<!-- =========================================================
ATLAS — PRECISION LIVING KNOWLEDGE GRAPH
STANDALONE APPLICATION
Version: 3.2.0

Self-contained Atlas app. Host this file (and only this file for Phase 1)
at a public URL, then embed it from Elementor via atlas/elementor-embed.html.

Changelog 3.2.0 (Denser published-graph render):
- Raises scene ceilings so every verified public entity can render (NODE_CAP 400,
  NODE_CAPACITY 420, EDGE_CAP 2400, MAX_DEGREE 22); no fabricated nodes/edges
- Type weights include material, failure_mode, warranty_term, maintenance_practice
  so trim/importance/labels prefer the concept layer when a future cap binds
- Slightly larger sphere + density-scaled constellation pull for even spread
- Featured labels scale with graph size (LOD); distant nodes stay points only
- Edge opacity floor retuned for denser real graphs
- Cache schema bumped to 4 so 180-node caches discard
- Hard density limit remains published verified entity count from the public API

Changelog 3.1.1 (Hotfix):
- Restored missing `knowledgeMentionsSubject` function declaration that broke
  ATLAS_QUERY parse (SyntaxError) and left the graph at GRAPH INITIALIZING
- No UI, ranking-logic, or API contract changes beyond that one-line restore

Changelog 3.1.0 (Concept-intent ontology awareness):
- Classifies question intent: concept / service / comparison / process / warranty
- Re-ranks reasoning paths and entities so definition questions prefer
  concept-like nodes (failure modes, systems, prep methods, standards)
  over service packages when published evidence supports it
- Concept answers lead with grounded definitional evidence, then Precision use
- Honest limitation when the published graph lacks a standalone definition
- No UI redesign; no fabricated definitions; Phase 1 grounding preserved

Changelog 3.0.0 (Queryable closed-loop reasoning):
- Natural-language query UI (Explore the Graph) with grounded public-API answers
- Uses /reasoning, /entities/search, /knowledge, /standards/search, /entity
- Real reasoning-path Thought travel; no fabricated edges or entities
- Temporary extraction of 3–8 relevant nodes + exact closed-loop return
- Subtle Web Audio lock click (user-gesture, muted preference persisted)
- Feature flag QUERY_REASONING_ENABLED / PKG.features.queryReasoning
- Camera, particles, constellations, HUD chrome, live adapter unchanged

Changelog 2.3.0 (Standalone extraction):
- Moved Atlas out of the Elementor HTML widget into a standalone document
- Visual system, graph adapter, live API, cache/fallback, Thoughts,
  constellations, labels, HUD, camera, particles, and motion unchanged
- Elementor embeds via lightweight iframe (see elementor-embed.html)
- Posts atlas:resize / atlas:ready to parent for iframe sizing

Changelog 2.2.0 (Knowledge graph edges):
- Reads /relationships (knowledge graph) alongside /entities/relationships and
  merges both into one governed edge set; neither source is discarded
- Knowledge edges are addressed by knowledge record, so each endpoint must
  resolve onto a published entity; edges that cannot resolve are dropped and
  counted as counts.unresolvedEdges rather than rendered as orphans
- Edge-level publication gate: only accepted/approved edges render; suggested,
  rejected, ignored and non-public edges are counted as counts.rejectedEdges
- Entity lookup widened (canonical id tail, type:slug, aliases, punctuation-
  insensitive match) so edges naming the same thing differently still resolve
- Density control for the larger edge set: per-node degree ceiling (16), global
  edge cap (1400), and edge opacity that eases down as the graph gets denser
- Edge awaken buffer only walks and uploads while something is lit
- Evidence read from the documented evidence field (string or array), falling
  back to applicability, rationale, then the older description shape
- Confidence accepts the 0-100 knowledge scale and the 0-1 scale, and falls
  back to weight before the derived score
- Cache schema bumped to 3 so pre-merge caches are discarded
- counts.entityRelationships / knowledgeRelationships / unresolvedEdges /
  rejectedEdges / edgesResolved / edgesRendered / edgesTrimmed exposed for auditing
- Public API, events, LIVE/CACHED/DEMO behaviour, camera, particles, HUD unchanged

Changelog 2.1.1 (Publication gate):
- Renders published knowledge only; draft/archived/deleted/withheld records
  never reach the scene
- Requests verification_status=verified so the API applies its own filter
- Honors public_visibility, verification_status, false_positive, and any
  status/state/lifecycle/visibility field the payload returns
- No exclusions by entity name — newly published records appear automatically
- Cache schema bumped to 2 so pre-gate caches are discarded
- counts.withheld exposed on PKG.graphData for auditing

Changelog 2.1.0 (Live public knowledge graph):
- ATLAS_DATA adapter reads the Precision public API (entities + relationships)
- LIVE / CACHED / DEMO modes; demo paints first, live swaps in without blanking
- Real relationship edges only in live/cached (no synthetic kNN), real pulse paths
- Deterministic layout + importance ranking from entity ids (same payload, same scene)
- 24h localStorage cache (atlas.graph.v1) with schema + age + checksum validation
- New public API: graphMode, graphData, entitiesById, adjacency, getEntity,
  getNeighbors, getRelationships, reloadGraph, graph:* events
- Hidden screen-reader graph summary
- Camera, particles, center identity, HUD layout, controls, Thoughts unchanged

Changelog 2.0.0 (Knowledge Constellations):
- Soft domain organization across 11 knowledge constellations
- Subtle spacing, edge density, and gold temperature variation (no hard clusters)
- Thoughts explore locally, then optionally bridge via connected domain edges
- Camera, particles, controls, HUD, labels, and public API unchanged

Changelog 1.5.0 (Thoughts — living reasoning travelers):
- Rare single Thought walks connected nodes (4–12 hops), never jumps
- Hesitation, eased edge travel, tiny trail, natural dissolve
- Optional quiet core acknowledgment when a Thought visits the center
- Reused meshes; paused when hidden / reduced-motion
- No changes to camera, particles, HUD, labels, layout, controls, or public API

Changelog 1.4.0 (Intelligent motion / thinking sequences):
- Coordinated thinking moments (begin → develop → resolve) every 14–28s
- Eased reasoning-path journeys with anticipation, handoff, and fade
- Core bubble + 3D shell react subtly; soft radial ripple
- Rare featured-node wake / neighbor signaling
- No new UI; camera, particles, center identity design, HUD, API unchanged

Changelog 1.3.0 (Center identity only):
- Replaced square P badge with centered circular energy bubble
- Optical centering: bubble locked to viewport/3D origin; caption out of flow
- Subtle rim breath + inner energy arc; reduced-motion safe
- Tiny 3D nucleus/glow cradle tweak only (no size increase)

Changelog 1.2.1 (Particle visibility repair only):
- Restored dust/particle readability (size, projection, alpha, depth fade)
- No other systems modified

Changelog 1.2.0 (Alive / cinematic pass — no new UI):
- Increased perceived depth + cinematic front lighting
- Reduced central glow opacity
- Graph scaled to fill ~85% of the viewport
- Subtle intelligence: path awakenings, reasoning pulses, cluster breath
- All Phase 1 interactions and PKG public API preserved
========================================================= -->

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
  <meta name="color-scheme" content="dark" />
  <meta name="robots" content="noindex, nofollow" />
  <title>Atlas — Precision Living Knowledge Graph</title>
  <style>
    /* Document chrome only — does not alter the Atlas visual system. */
    html, body {
      margin: 0;
      padding: 0;
      width: 100%;
      min-height: 100%;
      background: #010101;
      color: #f6f3ea;
      font-family: system-ui, -apple-system, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
      -webkit-font-smoothing: antialiased;
      -moz-osx-font-smoothing: grayscale;
    }

    body {
      overflow-x: hidden;
    }
  </style>
<script defer src="/~flock.js" data-proxy-url="/~api/analytics"></script><meta property="og:image" content="https://pub-bb2e103a32db4e198524a2e9ed8f35b4.r2.dev/405d03d2-b65f-4735-9360-0e7e2ef1e5d2/id-preview-12c7670f--9acfbbc7-8107-4461-acf7-f432d4489c52.lovable.app-1781842994853.png"><meta name="twitter:image" content="https://pub-bb2e103a32db4e198524a2e9ed8f35b4.r2.dev/405d03d2-b65f-4735-9360-0e7e2ef1e5d2/id-preview-12c7670f--9acfbbc7-8107-4461-acf7-f432d4489c52.lovable.app-1781842994853.png"></head>
<body>
<section class="pkg1" id="precision-knowledge-graph">
  <div class="pkg1__grid" aria-hidden="true"></div>
  <div class="pkg1__ambient pkg1__ambient--left" aria-hidden="true"></div>
  <div class="pkg1__ambient pkg1__ambient--right" aria-hidden="true"></div>

  <div class="pkg1__shell">
    <header class="pkg1__header">
      <div>
        <span class="pkg1__kicker">PRECISION OS</span>
        <h2>Living Knowledge Graph</h2>
        <p>Every fact. Every relationship. Always connected.</p>
      </div>

      <div class="pkg1__live" aria-live="polite">
        <span class="pkg1__live-dot" aria-hidden="true"></span>
        <strong id="pkg1-live-label">GRAPH INITIALIZING</strong>
      </div>
    </header>

    <div class="pkg1__viewport" id="pkg1-viewport">
      <canvas id="pkg1-canvas" aria-label="Interactive three-dimensional Precision Living Knowledge Graph"></canvas>

      <div class="pkg1__scan" aria-hidden="true"></div>
      <div class="pkg1__reticle pkg1__reticle--outer" aria-hidden="true"></div>
      <div class="pkg1__reticle pkg1__reticle--inner" aria-hidden="true"></div>
      <div class="pkg1__vignette" aria-hidden="true"></div>

      <div class="pkg1__labels" id="pkg1-labels" aria-hidden="true"></div>

      <div class="pkg1__core-copy" aria-hidden="true">
        <div class="pkg1__core-mark">
          <span class="pkg1__core-mark-energy"></span>
          <span class="pkg1__core-mark-shimmer"></span>
          <span class="pkg1__core-mark-letter">P</span>
        </div>
        <div class="pkg1__core-caption">
          <span>PRECISION</span>
          <small>CANONICAL SOURCE OF TRUTH</small>
        </div>
      </div>

      <div class="pkg1__hud pkg1__hud--top-left">
        <span>GRAPH MODE</span>
        <strong>3D ENTITY NETWORK</strong>
      </div>

      <div class="pkg1__hud pkg1__hud--top-right">
        <span>ROTATION</span>
        <strong id="pkg1-rotation-label">AUTONOMOUS</strong>
      </div>

      <div class="pkg1__hud pkg1__hud--bottom-left">
        <span>INTERACTION</span>
        <strong>DRAG TO ROTATE</strong>
      </div>

      <div class="pkg1__hud pkg1__hud--bottom-right">
        <span>NETWORK STATE</span>
        <strong id="pkg1-network-label">ASSEMBLING</strong>
      </div>

      <!-- Atlas v3.0 — Queryable closed-loop reasoning (feature-gated in JS) -->
      <div class="pkg1__query" id="pkg1-query" hidden>
        <div class="pkg1__query-bar">
          <label class="pkg1__query-label" for="pkg1-query-input">EXPLORE THE GRAPH</label>
          <div class="pkg1__query-row">
            <input
              id="pkg1-query-input"
              class="pkg1__query-input"
              type="text"
              maxlength="200"
              autocomplete="off"
              spellcheck="true"
              placeholder="Ask Atlas about Precision…"
            />
            <button type="button" class="pkg1__query-submit" id="pkg1-query-submit" aria-label="Ask Atlas">
              ASK
            </button>
            <button type="button" class="pkg1__query-sound" id="pkg1-query-sound" aria-pressed="false" aria-label="Toggle lock sound" title="Lock sound">
              SOUND
            </button>
          </div>
          <div class="pkg1__query-examples" id="pkg1-query-examples">
            <button type="button" data-example="Why does surface preparation matter?">Surface preparation</button>
            <button type="button" data-example="How do epoxy and polyaspartic work together?">Epoxy + polyaspartic</button>
            <button type="button" data-example="What standards guide moisture testing?">Moisture standards</button>
            <button type="button" data-example="What protects a garage floor from hot tires?">Hot tires</button>
            <button type="button" data-example="How does Precision handle cracked concrete?">Cracked concrete</button>
          </div>
          <p class="pkg1__query-status" id="pkg1-query-status" aria-live="polite"></p>
        </div>
      </div>

      <aside class="pkg1__answer" id="pkg1-answer" hidden aria-live="polite">
        <header class="pkg1__answer-head">
          <div>
            <span class="pkg1__answer-kicker">GROUNDED RESULT</span>
            <strong id="pkg1-answer-stage">READY</strong>
          </div>
          <button type="button" class="pkg1__answer-close" id="pkg1-answer-close" aria-label="Close result and return nodes">
            CLOSE
          </button>
        </header>
        <p class="pkg1__answer-question" id="pkg1-answer-question"></p>
        <p class="pkg1__answer-body" id="pkg1-answer-body"></p>
        <div class="pkg1__answer-meta" id="pkg1-answer-meta"></div>
        <div class="pkg1__answer-section" id="pkg1-answer-entities-wrap" hidden>
          <span>KEY ENTITIES</span>
          <ul id="pkg1-answer-entities"></ul>
        </div>
        <div class="pkg1__answer-section" id="pkg1-answer-path-wrap" hidden>
          <span>REASONING PATH</span>
          <ol id="pkg1-answer-path"></ol>
        </div>
        <div class="pkg1__answer-section" id="pkg1-answer-evidence-wrap" hidden>
          <span>EVIDENCE / PROVENANCE</span>
          <ul id="pkg1-answer-evidence"></ul>
        </div>
        <div class="pkg1__answer-section" id="pkg1-answer-standards-wrap" hidden>
          <span>RELATED STANDARDS</span>
          <ul id="pkg1-answer-standards"></ul>
        </div>
        <p class="pkg1__answer-note" id="pkg1-answer-note"></p>
      </aside>

      <div class="pkg1__fallback" id="pkg1-fallback" hidden>
        <strong>Knowledge graph visualization unavailable</strong>
        <span>The public Precision AI platform remains online.</span>
      </div>
    </div>

    <p class="pkg1__sr" id="pkg1-graph-summary" aria-live="polite"></p>

    <footer class="pkg1__footer">
      <div><span></span> CANONICAL ENTITY</div>
      <div><i></i> GOVERNED RELATIONSHIP</div>
      <div><b></b> ACTIVE DATA PATH</div>
    </footer>
  </div>
</section>

<style>
.pkg1,
.pkg1 * {
  box-sizing: border-box;
}

.pkg1 {
  --pkg-gold: #d6a84a;
  --pkg-gold-soft: #f2d58b;
  --pkg-gold-hot: #ffd76a;
  --pkg-green: #7ee99a;
  --pkg-bg: #020202;
  --pkg-panel: rgba(10, 10, 10, 0.82);
  --pkg-border: rgba(214, 168, 74, 0.23);
  --pkg-text: #f6f3ea;
  --pkg-muted: #908d85;

  position: relative;
  isolation: isolate;
  overflow: hidden;
  width: 100%;
  padding: clamp(70px, 8vw, 120px) 18px;
  color: var(--pkg-text);
  background:
    radial-gradient(circle at 50% 45%, rgba(214, 168, 74, 0.09), transparent 31%),
    radial-gradient(circle at 8% 25%, rgba(214, 168, 74, 0.05), transparent 24%),
    radial-gradient(circle at 92% 72%, rgba(214, 168, 74, 0.04), transparent 26%),
    linear-gradient(180deg, #010101 0%, #070604 48%, #010101 100%);
  font-family: inherit;
}

.pkg1__grid {
  position: absolute;
  inset: 0;
  opacity: 0.16;
  pointer-events: none;
  background-image:
    linear-gradient(rgba(255, 255, 255, 0.032) 1px, transparent 1px),
    linear-gradient(90deg, rgba(255, 255, 255, 0.032) 1px, transparent 1px);
  background-size: 52px 52px;
  mask-image: radial-gradient(circle at center, #000 18%, transparent 82%);
}

.pkg1__ambient {
  position: absolute;
  width: 620px;
  height: 620px;
  border-radius: 50%;
  filter: blur(190px);
  opacity: 0.08;
  pointer-events: none;
}

.pkg1__ambient--left {
  left: -460px;
  top: 10%;
  background: var(--pkg-gold);
}

.pkg1__ambient--right {
  right: -470px;
  bottom: 5%;
  background: var(--pkg-gold);
}

.pkg1__shell {
  position: relative;
  z-index: 2;
  width: min(1460px, 100%);
  margin: 0 auto;
  overflow: hidden;
  border: 1px solid var(--pkg-border);
  border-radius: 28px;
  background:
    linear-gradient(145deg, rgba(255, 255, 255, 0.045), rgba(255, 255, 255, 0.01)),
    rgba(0, 0, 0, 0.78);
  box-shadow:
    0 55px 145px rgba(0, 0, 0, 0.72),
    0 0 0 1px rgba(214, 168, 74, 0.06),
    inset 0 1px 0 rgba(255, 255, 255, 0.07),
    inset 0 -1px 0 rgba(214, 168, 74, 0.04);
  backdrop-filter: blur(20px);
}

.pkg1__header {
  position: relative;
  z-index: 5;
  display: flex;
  justify-content: space-between;
  align-items: flex-start;
  gap: 24px;
  padding: 28px 32px 24px;
  border-bottom: 1px solid rgba(255, 255, 255, 0.07);
  background:
    linear-gradient(90deg, rgba(214, 168, 74, 0.045), transparent 42%),
    rgba(0, 0, 0, 0.52);
}

.pkg1__kicker {
  display: block;
  margin-bottom: 8px;
  color: var(--pkg-gold-soft);
  font-size: 10px;
  font-weight: 900;
  letter-spacing: 0.22em;
}

.pkg1__header h2 {
  margin: 0;
  color: #fff;
  font-size: clamp(30px, 4vw, 54px);
  font-weight: 750;
  letter-spacing: -0.055em;
  line-height: 1;
  text-transform: uppercase;
}

.pkg1__header p {
  margin: 11px 0 0;
  color: #aaa69c;
  font-size: 13px;
  letter-spacing: 0.04em;
}

.pkg1__live {
  display: inline-flex;
  align-items: center;
  gap: 9px;
  flex: 0 0 auto;
  margin-top: 4px;
  padding: 9px 12px;
  border: 1px solid rgba(126, 233, 154, 0.22);
  border-radius: 999px;
  color: var(--pkg-green);
  background: rgba(126, 233, 154, 0.06);
  box-shadow: 0 0 24px rgba(126, 233, 154, 0.06);
  font-size: 8px;
  font-weight: 900;
  letter-spacing: 0.13em;
}

.pkg1__live-dot {
  position: relative;
  width: 7px;
  height: 7px;
  border-radius: 50%;
  background: currentColor;
  box-shadow: 0 0 12px currentColor;
  animation: pkg1Live 1.8s ease-in-out infinite;
}

@keyframes pkg1Live {
  50% {
    opacity: 0.42;
    transform: scale(0.72);
  }
}

.pkg1__viewport {
  position: relative;
  min-height: clamp(620px, 68vw, 940px);
  overflow: hidden;
  background:
    radial-gradient(circle at 50% 50%, rgba(214, 168, 74, 0.065), transparent 33%),
    radial-gradient(circle at 50% 42%, rgba(255, 215, 106, 0.03), transparent 22%),
    radial-gradient(circle at 50% 50%, rgba(255, 255, 255, 0.016), transparent 64%),
    #020202;
  cursor: grab;
  touch-action: pan-y;
}

.pkg1__viewport:active {
  cursor: grabbing;
}

#pkg1-canvas {
  position: absolute;
  inset: 0;
  width: 100%;
  height: 100%;
  display: block;
}

.pkg1__vignette {
  position: absolute;
  inset: 0;
  z-index: 3;
  pointer-events: none;
  background:
    radial-gradient(ellipse at center, transparent 52%, rgba(0, 0, 0, 0.42) 100%),
    linear-gradient(180deg, rgba(0, 0, 0, 0.16) 0%, transparent 16%, transparent 84%, rgba(0, 0, 0, 0.2) 100%);
}

.pkg1__scan {
  position: absolute;
  left: 8%;
  right: 8%;
  top: 50%;
  height: 1px;
  z-index: 2;
  pointer-events: none;
  background: linear-gradient(
    90deg,
    transparent,
    rgba(214, 168, 74, 0.1),
    rgba(255, 215, 106, 0.78),
    rgba(214, 168, 74, 0.1),
    transparent
  );
  box-shadow: 0 0 28px rgba(255, 215, 106, 0.28);
  animation: pkg1Scan 6.5s ease-in-out infinite;
}

@keyframes pkg1Scan {
  0%, 100% {
    transform: translateY(-270px);
    opacity: 0.14;
  }
  50% {
    transform: translateY(270px);
    opacity: 0.88;
  }
}

.pkg1__reticle {
  position: absolute;
  left: 50%;
  top: 50%;
  z-index: 2;
  border: 1px solid rgba(214, 168, 74, 0.1);
  border-radius: 50%;
  transform: translate(-50%, -50%);
  pointer-events: none;
}

.pkg1__reticle--outer {
  width: min(78vw, 900px);
  aspect-ratio: 1;
  box-shadow: inset 0 0 60px rgba(214, 168, 74, 0.03);
  animation: pkg1Reticle 22s linear infinite;
}

.pkg1__reticle--inner {
  width: min(48vw, 560px);
  aspect-ratio: 1;
  border-style: dashed;
  animation: pkg1ReticleReverse 18s linear infinite;
}

.pkg1__reticle::before,
.pkg1__reticle::after {
  position: absolute;
  left: 50%;
  top: 50%;
  content: "";
  background: rgba(214, 168, 74, 0.09);
  transform: translate(-50%, -50%);
}

.pkg1__reticle::before {
  width: 112%;
  height: 1px;
}

.pkg1__reticle::after {
  width: 1px;
  height: 112%;
}

@keyframes pkg1Reticle {
  to { transform: translate(-50%, -50%) rotate(360deg); }
}

@keyframes pkg1ReticleReverse {
  to { transform: translate(-50%, -50%) rotate(-360deg); }
}

.pkg1__labels {
  position: absolute;
  inset: 0;
  z-index: 4;
  pointer-events: none;
}

.pkg1__label {
  position: absolute;
  transform: translate(-50%, -50%);
  padding: 5px 8px;
  border: 1px solid rgba(214, 168, 74, 0.24);
  border-radius: 7px;
  color: #f4ead0;
  background: rgba(4, 4, 4, 0.78);
  box-shadow:
    0 7px 25px rgba(0, 0, 0, 0.42),
    inset 0 1px 0 rgba(255, 255, 255, 0.04);
  font-size: 9px;
  font-weight: 750;
  letter-spacing: 0.02em;
  white-space: nowrap;
  opacity: 0;
  transition:
    opacity 0.2s linear,
    border-color 0.25s ease,
    box-shadow 0.25s ease,
    background 0.25s ease;
  backdrop-filter: blur(10px);
  will-change: transform, opacity;
}

.pkg1__label.is-hot {
  border-color: rgba(255, 215, 106, 0.55);
  background: rgba(18, 14, 6, 0.88);
  box-shadow:
    0 0 22px rgba(255, 215, 106, 0.18),
    0 10px 28px rgba(0, 0, 0, 0.5),
    inset 0 1px 0 rgba(255, 215, 106, 0.12);
  color: #fff4d2;
}

.pkg1__label small {
  display: block;
  margin-top: 2px;
  color: #88847b;
  font-size: 6px;
  font-weight: 700;
  letter-spacing: 0.09em;
  text-transform: uppercase;
}

.pkg1__label.is-hot small {
  color: #c4b896;
}

.pkg1__label.is-thinking {
  border-color: rgba(255, 215, 106, 0.4);
  background: rgba(14, 12, 6, 0.84);
  box-shadow:
    0 0 16px rgba(214, 168, 74, 0.12),
    0 8px 22px rgba(0, 0, 0, 0.45),
    inset 0 1px 0 rgba(255, 215, 106, 0.08);
  color: #f7ecd0;
}

.pkg1__label.is-thinking small {
  color: #b9ae92;
}

.pkg1__core-copy {
  position: absolute;
  left: 50%;
  top: 50%;
  z-index: 5;
  width: 64px;
  height: 64px;
  margin: 0;
  padding: 0;
  pointer-events: none;
  transform: translate3d(-50%, -50%, 0);
  display: grid;
  place-items: center;
  line-height: 0;
}

.pkg1__core-mark {
  --pkg-rim-dur: 7.2s;
  --pkg-energy-dur: 22s;
  --pkg-rim-alpha: 0.42;
  position: relative;
  z-index: 1;
  display: grid;
  place-items: center;
  width: 58px;
  height: 58px;
  margin: 0;
  padding: 0;
  border-radius: 50%;
  overflow: hidden;
  isolation: isolate;
  color: #efd7a0;
  background:
    radial-gradient(circle at 50% 38%, rgba(214, 168, 74, 0.2) 0%, transparent 46%),
    radial-gradient(circle at 50% 58%, rgba(8, 7, 4, 0.55) 0%, transparent 62%),
    radial-gradient(circle at 50% 50%, rgba(18, 14, 8, 0.94) 0%, rgba(3, 2, 1, 0.98) 72%);
  border: 1px solid rgba(214, 168, 74, var(--pkg-rim-alpha));
  box-shadow:
    0 0 0 1px rgba(0, 0, 0, 0.55),
    0 0 16px rgba(214, 168, 74, 0.16),
    0 0 36px rgba(214, 168, 74, 0.07),
    inset 0 0 18px rgba(214, 168, 74, 0.07),
    inset 0 1px 0 rgba(255, 215, 106, 0.14),
    inset 0 -10px 18px rgba(0, 0, 0, 0.35);
  animation: pkg1CoreRimBreath var(--pkg-rim-dur) ease-in-out infinite;
  transition: border-color 0.6s ease, box-shadow 0.6s ease;
}

.pkg1__core-mark.is-thinking {
  --pkg-rim-dur: 3.6s;
  --pkg-energy-dur: 9.5s;
  --pkg-rim-alpha: 0.58;
}

.pkg1__core-mark.is-aware {
  --pkg-rim-dur: 4.8s;
  --pkg-energy-dur: 12s;
  --pkg-rim-alpha: 0.5;
}

.pkg1__core-mark-energy {
  position: absolute;
  inset: -35%;
  border-radius: 50%;
  background: conic-gradient(
    from 0deg,
    transparent 0deg,
    rgba(255, 215, 106, 0.0) 20deg,
    rgba(255, 215, 106, 0.14) 42deg,
    transparent 70deg,
    transparent 200deg,
    rgba(214, 168, 74, 0.1) 230deg,
    transparent 270deg
  );
  opacity: 0.55;
  mix-blend-mode: screen;
  animation: pkg1CoreEnergySpin var(--pkg-energy-dur) linear infinite;
  pointer-events: none;
}

.pkg1__core-mark-shimmer {
  position: absolute;
  inset: 0;
  border-radius: 50%;
  background: linear-gradient(
    115deg,
    transparent 30%,
    rgba(255, 215, 106, 0.07) 48%,
    transparent 62%
  );
  background-size: 220% 220%;
  animation: pkg1CoreShimmer 9.5s ease-in-out infinite;
  pointer-events: none;
}

.pkg1__core-mark-letter {
  position: relative;
  z-index: 2;
  display: block;
  margin: 0;
  padding: 0;
  color: #efd7a0;
  font-size: 25px;
  font-weight: 800;
  letter-spacing: 0;
  line-height: 1;
  transform: translate3d(0.02em, 0.05em, 0);
  text-shadow:
    0 0 10px rgba(214, 168, 74, 0.28),
    0 1px 2px rgba(0, 0, 0, 0.65);
}

.pkg1__core-caption {
  position: absolute;
  top: calc(100% + 14px);
  left: 50%;
  width: 220px;
  margin: 0;
  padding: 0;
  display: flex;
  flex-direction: column;
  align-items: center;
  gap: 6px;
  text-align: center;
  transform: translate3d(-50%, 0, 0);
  text-shadow: 0 4px 24px #000;
  line-height: 1.15;
}

.pkg1__core-caption > span {
  display: block;
  margin: 0;
  padding: 0;
  color: #f5ce6a;
  font-size: 22px;
  font-weight: 800;
  letter-spacing: 0.07em;
  line-height: 1;
}

.pkg1__core-caption small {
  display: block;
  margin: 0;
  padding: 0;
  color: #b1aa9b;
  font-size: 7px;
  font-weight: 800;
  letter-spacing: 0.14em;
  line-height: 1.2;
}

@keyframes pkg1CoreRimBreath {
  0%, 100% {
    box-shadow:
      0 0 0 1px rgba(0, 0, 0, 0.55),
      0 0 14px rgba(214, 168, 74, 0.14),
      0 0 32px rgba(214, 168, 74, 0.06),
      inset 0 0 18px rgba(214, 168, 74, 0.06),
      inset 0 1px 0 rgba(255, 215, 106, 0.12),
      inset 0 -10px 18px rgba(0, 0, 0, 0.35);
    border-color: rgba(214, 168, 74, 0.38);
  }
  50% {
    box-shadow:
      0 0 0 1px rgba(0, 0, 0, 0.55),
      0 0 20px rgba(214, 168, 74, 0.22),
      0 0 42px rgba(214, 168, 74, 0.1),
      inset 0 0 22px rgba(214, 168, 74, 0.1),
      inset 0 1px 0 rgba(255, 215, 106, 0.18),
      inset 0 -10px 18px rgba(0, 0, 0, 0.35);
    border-color: rgba(214, 168, 74, 0.52);
  }
}

@keyframes pkg1CoreEnergySpin {
  to { transform: rotate(360deg); }
}

@keyframes pkg1CoreShimmer {
  0%, 100% { background-position: 0% 50%; opacity: 0.35; }
  50% { background-position: 100% 50%; opacity: 0.7; }
}

.pkg1__hud {
  position: absolute;
  z-index: 6;
  min-width: 140px;
  padding: 11px 13px;
  border: 1px solid rgba(214, 168, 74, 0.15);
  background:
    linear-gradient(105deg, rgba(214, 168, 74, 0.06), rgba(0, 0, 0, 0.58) 55%),
    rgba(0, 0, 0, 0.35);
  backdrop-filter: blur(12px);
  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.04);
  pointer-events: none;
}

.pkg1__hud span {
  display: block;
  margin-bottom: 4px;
  color: #78746b;
  font-size: 6px;
  font-weight: 900;
  letter-spacing: 0.13em;
}

.pkg1__hud strong {
  color: #d8d2c5;
  font-size: 8px;
  letter-spacing: 0.08em;
}

.pkg1__hud--top-left {
  left: 24px;
  top: 22px;
  border-left-color: var(--pkg-gold);
}

.pkg1__hud--top-right {
  right: 24px;
  top: 22px;
  text-align: right;
  border-right-color: var(--pkg-gold);
}

.pkg1__hud--bottom-left {
  left: 24px;
  bottom: 22px;
  border-left-color: var(--pkg-gold);
}

.pkg1__hud--bottom-right {
  right: 24px;
  bottom: 22px;
  text-align: right;
  border-right-color: var(--pkg-gold);
}

.pkg1__fallback {
  position: absolute;
  left: 50%;
  top: 50%;
  z-index: 10;
  width: min(420px, calc(100% - 40px));
  padding: 24px;
  border: 1px solid rgba(214, 168, 74, 0.24);
  border-radius: 18px;
  text-align: center;
  background: rgba(5, 5, 5, 0.94);
  transform: translate(-50%, -50%);
}

.pkg1__fallback strong {
  display: block;
  margin-bottom: 8px;
  color: #fff;
}

.pkg1__fallback span {
  color: #99958c;
  font-size: 12px;
}

.pkg1__sr {
  position: absolute;
  width: 1px;
  height: 1px;
  margin: -1px;
  padding: 0;
  overflow: hidden;
  border: 0;
  clip-path: inset(50%);
  white-space: nowrap;
}

.pkg1__footer {
  position: relative;
  z-index: 5;
  display: flex;
  justify-content: center;
  flex-wrap: wrap;
  gap: 20px 30px;
  padding: 18px 26px;
  border-top: 1px solid rgba(255, 255, 255, 0.07);
  color: #817d73;
  background: rgba(0, 0, 0, 0.55);
  font-size: 7px;
  font-weight: 800;
  letter-spacing: 0.09em;
}

.pkg1__footer div {
  display: flex;
  align-items: center;
  gap: 8px;
}

.pkg1__footer span,
.pkg1__footer b {
  display: block;
  width: 7px;
  height: 7px;
  border-radius: 50%;
}

.pkg1__footer span {
  background: var(--pkg-gold-hot);
  box-shadow: 0 0 9px var(--pkg-gold-hot);
}

.pkg1__footer i {
  display: block;
  width: 28px;
  height: 1px;
  background: linear-gradient(90deg, transparent, var(--pkg-gold), transparent);
}

.pkg1__footer b {
  background: var(--pkg-green);
  box-shadow: 0 0 9px var(--pkg-green);
}

@media (max-width: 760px) {
  .pkg1 {
    padding: 70px 12px;
  }

  .pkg1__shell {
    border-radius: 20px;
  }

  .pkg1__header {
    align-items: flex-start;
    flex-direction: column;
    padding: 22px 18px;
  }

  .pkg1__viewport {
    min-height: 620px;
  }

  .pkg1__core-copy {
    width: 52px;
    height: 52px;
  }

  .pkg1__core-mark {
    width: 52px;
    height: 52px;
  }

  .pkg1__core-mark-letter {
    font-size: 22px;
  }

  .pkg1__core-caption {
    width: 180px;
    top: calc(100% + 12px);
    gap: 5px;
  }

  .pkg1__core-caption > span {
    font-size: 18px;
  }

  .pkg1__hud {
    min-width: 0;
    padding: 8px 9px;
  }

  .pkg1__hud--top-left,
  .pkg1__hud--bottom-left {
    left: 10px;
  }

  .pkg1__hud--top-right,
  .pkg1__hud--bottom-right {
    right: 10px;
  }

  .pkg1__hud--top-left,
  .pkg1__hud--top-right {
    top: 10px;
  }

  .pkg1__hud--bottom-left,
  .pkg1__hud--bottom-right {
    bottom: 10px;
  }

  .pkg1__label {
    font-size: 7px;
  }

  .pkg1__label small {
    display: none;
  }
}

@media (prefers-reduced-motion: reduce) {
  .pkg1__live-dot,
  .pkg1__scan,
  .pkg1__reticle,
  .pkg1__core-mark,
  .pkg1__core-mark-energy,
  .pkg1__core-mark-shimmer {
    animation: none !important;
  }
}

/* =========================================================
   Atlas v3.0 — Query / answer surface (restrained, non-chat)
   ========================================================= */
.pkg1__query {
  position: absolute;
  left: 50%;
  bottom: 18px;
  z-index: 8;
  width: min(560px, calc(100% - 28px));
  transform: translateX(-50%);
  pointer-events: none;
}

.pkg1__query-bar {
  pointer-events: auto;
  padding: 12px 14px 10px;
  border: 1px solid rgba(214, 168, 74, 0.22);
  border-radius: 16px;
  background:
    linear-gradient(180deg, rgba(18, 16, 12, 0.92), rgba(6, 6, 6, 0.9));
  box-shadow:
    0 18px 48px rgba(0, 0, 0, 0.45),
    inset 0 1px 0 rgba(255, 255, 255, 0.05);
  backdrop-filter: blur(14px);
}

.pkg1__query-label {
  display: block;
  margin-bottom: 8px;
  color: var(--pkg-gold-soft);
  font-size: 8px;
  font-weight: 900;
  letter-spacing: 0.2em;
}

.pkg1__query-row {
  display: flex;
  gap: 8px;
  align-items: stretch;
}

.pkg1__query-input {
  flex: 1 1 auto;
  min-width: 0;
  height: 38px;
  padding: 0 12px;
  border: 1px solid rgba(255, 255, 255, 0.1);
  border-radius: 10px;
  background: rgba(0, 0, 0, 0.45);
  color: var(--pkg-text);
  font: inherit;
  font-size: 13px;
  letter-spacing: 0.01em;
  outline: none;
  transition: border-color 160ms ease, box-shadow 160ms ease;
}

.pkg1__query-input::placeholder {
  color: rgba(246, 243, 234, 0.38);
}

.pkg1__query-input:focus {
  border-color: rgba(214, 168, 74, 0.55);
  box-shadow: 0 0 0 2px rgba(214, 168, 74, 0.12);
}

.pkg1__query-submit,
.pkg1__query-sound,
.pkg1__answer-close {
  flex: 0 0 auto;
  height: 38px;
  padding: 0 12px;
  border: 1px solid rgba(214, 168, 74, 0.35);
  border-radius: 10px;
  background: rgba(214, 168, 74, 0.1);
  color: var(--pkg-gold-soft);
  font: inherit;
  font-size: 9px;
  font-weight: 900;
  letter-spacing: 0.14em;
  cursor: pointer;
  transition: background 160ms ease, border-color 160ms ease, color 160ms ease;
}

.pkg1__query-sound {
  border-color: rgba(255, 255, 255, 0.12);
  background: rgba(255, 255, 255, 0.04);
  color: var(--pkg-muted);
}

.pkg1__query-sound[aria-pressed="true"] {
  border-color: rgba(126, 233, 154, 0.35);
  color: var(--pkg-green);
  background: rgba(126, 233, 154, 0.08);
}

.pkg1__query-submit:hover,
.pkg1__query-submit:focus-visible,
.pkg1__answer-close:hover,
.pkg1__answer-close:focus-visible {
  background: rgba(214, 168, 74, 0.18);
  border-color: rgba(214, 168, 74, 0.55);
}

.pkg1__query-submit:disabled {
  opacity: 0.45;
  cursor: wait;
}

.pkg1__query-examples {
  display: flex;
  flex-wrap: wrap;
  gap: 6px;
  margin-top: 9px;
}

.pkg1__query-examples button {
  padding: 5px 8px;
  border: 1px solid rgba(255, 255, 255, 0.08);
  border-radius: 999px;
  background: rgba(255, 255, 255, 0.03);
  color: #a7a39a;
  font: inherit;
  font-size: 9px;
  letter-spacing: 0.04em;
  cursor: pointer;
}

.pkg1__query-examples button:hover,
.pkg1__query-examples button:focus-visible {
  border-color: rgba(214, 168, 74, 0.35);
  color: var(--pkg-gold-soft);
}

.pkg1__query-status {
  min-height: 14px;
  margin: 8px 0 0;
  color: #8f8b82;
  font-size: 9px;
  letter-spacing: 0.08em;
  text-transform: uppercase;
}

.pkg1__answer {
  position: absolute;
  right: 14px;
  top: 14px;
  z-index: 9;
  width: min(340px, calc(100% - 28px));
  max-height: min(62%, 520px);
  overflow: auto;
  padding: 14px 14px 12px;
  border: 1px solid rgba(214, 168, 74, 0.24);
  border-radius: 16px;
  background:
    linear-gradient(165deg, rgba(20, 18, 14, 0.96), rgba(5, 5, 5, 0.94));
  box-shadow: 0 22px 60px rgba(0, 0, 0, 0.5);
  backdrop-filter: blur(16px);
  color: var(--pkg-text);
}

.pkg1__answer-head {
  display: flex;
  justify-content: space-between;
  gap: 12px;
  align-items: flex-start;
  margin-bottom: 10px;
}

.pkg1__answer-kicker {
  display: block;
  color: var(--pkg-gold-soft);
  font-size: 8px;
  font-weight: 900;
  letter-spacing: 0.18em;
}

.pkg1__answer-head strong {
  display: block;
  margin-top: 4px;
  color: #fff;
  font-size: 11px;
  letter-spacing: 0.12em;
}

.pkg1__answer-close {
  height: 30px;
  padding: 0 10px;
}

.pkg1__answer-question {
  margin: 0 0 8px;
  color: #d8d3c7;
  font-size: 12px;
  line-height: 1.35;
}

.pkg1__answer-body {
  margin: 0 0 10px;
  color: #f3efe4;
  font-size: 13px;
  line-height: 1.45;
}

.pkg1__answer-meta {
  display: flex;
  flex-wrap: wrap;
  gap: 6px;
  margin-bottom: 10px;
}

.pkg1__answer-meta span {
  padding: 4px 7px;
  border: 1px solid rgba(255, 255, 255, 0.08);
  border-radius: 999px;
  color: #b7b2a6;
  font-size: 8px;
  letter-spacing: 0.08em;
  text-transform: uppercase;
}

.pkg1__answer-section {
  margin-top: 10px;
}

.pkg1__answer-section > span {
  display: block;
  margin-bottom: 5px;
  color: var(--pkg-gold-soft);
  font-size: 8px;
  font-weight: 800;
  letter-spacing: 0.16em;
}

.pkg1__answer-section ul,
.pkg1__answer-section ol {
  margin: 0;
  padding-left: 16px;
  color: #cfc9bb;
  font-size: 11px;
  line-height: 1.4;
}

.pkg1__answer-section li + li {
  margin-top: 4px;
}

.pkg1__answer-note {
  margin: 12px 0 0;
  color: #8f8b82;
  font-size: 10px;
  line-height: 1.4;
}

.pkg1--querying .pkg1__hud--bottom-left strong {
  color: var(--pkg-gold-soft);
}

.pkg1__query-transition {
  position: absolute;
  left: 50%;
  top: 18%;
  z-index: 7;
  transform: translateX(-50%);
  padding: 6px 10px;
  border: 1px solid rgba(214, 168, 74, 0.28);
  border-radius: 999px;
  background: rgba(0, 0, 0, 0.55);
  color: var(--pkg-gold-soft);
  font-size: 9px;
  letter-spacing: 0.1em;
  text-transform: uppercase;
  pointer-events: none;
  opacity: 0;
  transition: opacity 180ms ease;
}

.pkg1__query-transition.is-on {
  opacity: 1;
}

@media (max-width: 720px) {
  .pkg1__query {
    bottom: 10px;
    width: calc(100% - 20px);
  }

  .pkg1__query-examples {
    display: none;
  }

  .pkg1__query-sound {
    display: none;
  }

  .pkg1__answer {
    left: 10px;
    right: 10px;
    top: auto;
    bottom: 78px;
    width: auto;
    max-height: 42%;
    border-radius: 14px 14px 12px 12px;
  }

  .pkg1__hud--bottom-left,
  .pkg1__hud--bottom-right {
    bottom: auto;
    top: 10px;
  }

  .pkg1__hud--bottom-left {
    left: 10px;
    top: auto;
    bottom: 10px;
    display: none;
  }
}

@media (prefers-reduced-motion: reduce) {
  .pkg1__query-input,
  .pkg1__query-submit,
  .pkg1__query-transition {
    transition: none !important;
  }
}

</style>

<script type="module">
(async function () {
  const root = document.getElementById("precision-knowledge-graph");
  const viewport = document.getElementById("pkg1-viewport");
  const canvas = document.getElementById("pkg1-canvas");
  const labelsLayer = document.getElementById("pkg1-labels");
  const fallback = document.getElementById("pkg1-fallback");

  if (!root || !viewport || !canvas || !labelsLayer) return;

  window.PrecisionKnowledgeGraph = window.PrecisionKnowledgeGraph || {};

  const PKG = window.PrecisionKnowledgeGraph;

  if (PKG.phases && PKG.phases.core) return;

  PKG.phases = {
    core: true,
    inspector: false,
    metrics: false,
    activity: false,
    askGraph: false,
    reasoning: false
  };

  PKG.codename = "Atlas";
  PKG.version = "3.2.0";
  PKG.root = root;
  PKG.viewport = viewport;
  PKG.canvas = canvas;
  PKG.labelsLayer = labelsLayer;
  PKG.selectedNode = null;
  PKG.hoveredNode = null;
  PKG.ready = false;
  PKG.events = new EventTarget();

  PKG.graphMode = "demo";
  PKG.graphData = null;
  PKG.entitiesById = new Map();
  PKG.adjacency = new Map();

  PKG.emit = function (name, detail) {
    PKG.events.dispatchEvent(new CustomEvent(name, { detail }));
  };

  PKG.on = function (name, listener) {
    PKG.events.addEventListener(name, listener);
  };

  const prefersReducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;

  function setText(id, value) {
    const el = document.getElementById(id);
    if (el) el.textContent = value;
  }

  // =========================================================
  // ATLAS_DATA — public knowledge graph adapter
  // Normalizes the Precision public API into a graph model the
  // scene can consume. Pure data: no Three.js, no DOM.
  // =========================================================
  const ATLAS_DATA = (function () {
    const API_ROOT = "https://app.precision-concretecoating.com/api/public/v1";
    const ENTITIES_URL = API_ROOT + "/entities";
    const RELATIONSHIPS_URL = API_ROOT + "/entities/relationships";
    // The knowledge graph proper. Far denser than the entity edge set, and
    // addressed by knowledge record rather than canonical entity id, so every
    // edge has to earn its place by resolving onto a rendered entity.
    const KNOWLEDGE_RELATIONSHIPS_URL = API_ROOT + "/relationships";

    const CACHE_KEY = "atlas.graph.v1";
    // Bumped to 4 so caches written before denser-graph ceilings discard.
    const CACHE_SCHEMA_VERSION = 4;
    const CACHE_MAX_AGE = 24 * 60 * 60 * 1000;

    const FETCH_TIMEOUT = 12000;
    const PAGE_LIMIT = 50;
    const MAX_FETCHED_ENTITIES = 500;
    const MAX_PAGES = 12;

    // The API documents verification_status as verified | needs_review |
    // unverified, and states that published entities are always "verified".
    // Ask it for published records rather than filtering after the fact.
    const PUBLISHED_STATUS = "verified";

    // Scene ceilings: show every published verified entity up to this headroom.
    // True 2–3× density beyond the live corpus requires publishing more entities.
    const NODE_CAP = 400;
    const LABEL_MIN = 24;
    const LABEL_MAX = 42;
    const PULSE_MAX = 12;
    const NAME_MAX_CHARS = 24;

    // Density guards for the merged edge set. The knowledge graph is hub-heavy,
    // so a per-node degree ceiling keeps the sphere legible instead of matting
    // a few hubs into a solid gold web.
    const EDGE_CAP = 2400;
    const MAX_DEGREE = 22;

    // Importance weighting per entity type (deterministic, no API field for this).
    // Ladder prefers concept / material / failure layers when a future trim binds.
    const TYPE_WEIGHTS = {
      organization: 1,
      person: 0.98,
      material: 0.96,
      failure_mode: 0.94,
      coating_system: 0.92,
      preparation_method: 0.9,
      service: 0.88,
      standard: 0.84,
      expertise: 0.8,
      trust_signal: 0.76,
      manufacturer: 0.74,
      product: 0.7,
      maintenance_practice: 0.68,
      service_area: 0.64,
      warranty_term: 0.58,
      community_involvement: 0.48,
      manufacturer_document: 0.36
    };

    const TYPE_LABELS = {
      service: "Service",
      service_area: "Service Area",
      coating_system: "Coating System",
      preparation_method: "Preparation",
      standard: "Standard",
      manufacturer: "Manufacturer",
      manufacturer_document: "Documents",
      product: "Product",
      trust_signal: "Trust Signal",
      expertise: "Expertise",
      community_involvement: "Community",
      organization: "Organization",
      person: "Person",
      material: "Material",
      failure_mode: "Failure Mode",
      warranty_term: "Warranty Term",
      maintenance_practice: "Maintenance"
    };

    const TYPE_PLURALS = {
      service: "services",
      service_area: "service areas",
      coating_system: "coating systems",
      preparation_method: "preparation methods",
      standard: "standards",
      manufacturer: "manufacturers",
      manufacturer_document: "manufacturer documents",
      product: "products",
      trust_signal: "trust signals",
      expertise: "expertise records",
      community_involvement: "community records",
      organization: "organizations",
      person: "people",
      material: "materials",
      failure_mode: "failure modes",
      warranty_term: "warranty terms",
      maintenance_practice: "maintenance practices"
    };

    // Constellation slots (must match the scene's 11 domains)
    const C_GARAGE = 0;
    const C_COMMERCIAL = 1;
    const C_PREP = 2;
    const C_POLY = 3;
    const C_EPOXY = 4;
    const C_REPAIR = 5;
    const C_STANDARDS = 6;
    const C_MANUFACTURERS = 7;
    const C_AREAS = 8;
    const C_MAINTENANCE = 9;
    const C_OS = 10;

    function clamp(value, min, max) {
      return value < min ? min : value > max ? max : value;
    }

    function hash32(value) {
      const text = String(value == null ? "" : value);
      let h = 0x811c9dc5;

      for (let i = 0; i < text.length; i++) {
        h ^= text.charCodeAt(i);
        h = Math.imul(h, 0x01000193) >>> 0;
      }

      return h >>> 0;
    }

    // Stable pseudo-random in [0, 1) from a hash + slot
    function hashUnit(hash, slot) {
      let h = (hash ^ Math.imul(slot + 1, 0x9e3779b9)) >>> 0;
      h ^= h >>> 16;
      h = Math.imul(h, 0x7feb352d) >>> 0;
      h ^= h >>> 15;
      h = Math.imul(h, 0x846ca68b) >>> 0;
      h ^= h >>> 16;
      return (h >>> 0) / 4294967296;
    }

    function text(value) {
      return typeof value === "string" ? value.trim() : "";
    }

    function truncate(value, max) {
      const clean = value.replace(/\s+/g, " ").trim();
      if (clean.length <= max) return clean;
      return clean.slice(0, Math.max(1, max - 1)).trimEnd() + "\u2026";
    }

    function titleize(value) {
      return String(value || "")
        .replace(/[_\-]+/g, " ")
        .replace(/\b\w/g, (c) => c.toUpperCase());
    }

    function typeLabel(type) {
      return TYPE_LABELS[type] || titleize(type) || "Entity";
    }

    function typePlural(type) {
      return TYPE_PLURALS[type] || (titleize(type).toLowerCase() + " records");
    }

    // -------------------------------------------------------
    // Network
    // -------------------------------------------------------
    async function fetchJSON(url) {
      const controller = new AbortController();
      const timer = window.setTimeout(() => controller.abort(), FETCH_TIMEOUT);

      try {
        const response = await fetch(url, {
          method: "GET",
          credentials: "omit",
          mode: "cors",
          cache: "no-store",
          redirect: "follow",
          headers: { Accept: "application/json" },
          signal: controller.signal
        });

        if (!response.ok) {
          throw new Error("HTTP " + response.status + " from " + url);
        }

        return await response.json();
      } finally {
        window.clearTimeout(timer);
      }
    }

    async function fetchEntities() {
      const collected = [];
      let envelope = null;
      let offset = 0;
      let complete = false;

      for (let page = 0; page < MAX_PAGES; page++) {
        const url =
          ENTITIES_URL +
          "?limit=" + PAGE_LIMIT +
          "&offset=" + offset +
          "&verification_status=" + encodeURIComponent(PUBLISHED_STATUS);
        let body;

        try {
          body = await fetchJSON(url);
        } catch (error) {
          // The first page is load-bearing; later pages may drop out and we
          // still render everything we did get (just without caching it).
          if (!collected.length) throw error;
          break;
        }

        if (!body || body.ok === false || !body.data) {
          if (!collected.length) throw new Error("Malformed entities payload");
          break;
        }

        if (!envelope) envelope = body;

        const list = Array.isArray(body.data.entities) ? body.data.entities : [];
        for (let i = 0; i < list.length; i++) collected.push(list[i]);

        const pagination = body.data.pagination || {};
        const nextOffset = Number.isFinite(pagination.next_offset)
          ? pagination.next_offset
          : offset + PAGE_LIMIT;

        if (!pagination.has_more || !list.length || nextOffset <= offset) {
          complete = true;
          break;
        }

        if (collected.length >= MAX_FETCHED_ENTITIES) break;

        offset = nextOffset;
      }

      if (!collected.length) throw new Error("No entities returned");

      return {
        raw: collected.slice(0, MAX_FETCHED_ENTITIES),
        envelope,
        complete
      };
    }

    async function fetchRelationships() {
      try {
        // This endpoint rejects a limit param — request it bare.
        const body = await fetchJSON(RELATIONSHIPS_URL);

        if (!body || body.ok === false || !body.data) {
          throw new Error("Malformed relationships payload");
        }

        return {
          raw: edgeList(body.data),
          envelope: body,
          ok: true
        };
      } catch (error) {
        // Real entities are still worth showing; we just draw no edges and
        // refuse to cache a payload that is missing its relationships.
        return { raw: [], envelope: null, ok: false, error };
      }
    }

    // Edge arrays have been served under a few key names across surfaces; take
    // the first array we recognize rather than assuming one shape.
    function edgeList(data) {
      if (!data || typeof data !== "object") return [];

      const candidates = [data.edges, data.relationships, data.results, data.items];

      for (let i = 0; i < candidates.length; i++) {
        if (Array.isArray(candidates[i])) return candidates[i];
      }

      return [];
    }

    async function fetchKnowledgeRelationships() {
      try {
        const body = await fetchJSON(KNOWLEDGE_RELATIONSHIPS_URL);

        if (!body || body.ok === false || !body.data) {
          throw new Error("Malformed knowledge relationships payload");
        }

        return { raw: edgeList(body.data), envelope: body, ok: true };
      } catch (error) {
        // Supplementary by design: the entity graph still renders without it.
        return { raw: [], envelope: null, ok: false, error };
      }
    }

    // -------------------------------------------------------
    // Publication gate
    //
    // Atlas renders published knowledge only. Every decision below reads a
    // status field the API itself returns — no entity is ever excluded by
    // name — so newly published records appear without a code change, and
    // anything the platform holds back stays out of the public graph.
    // -------------------------------------------------------
    const PUBLISHED_VERIFICATION = /^(verified|approved|published)$/;

    // Lifecycle values meaning "not public yet", "no longer public", or
    // "deliberately held back". Matched against any status-shaped field.
    const UNPUBLISHED_STATE = new RegExp(
      "^(" +
        "draft|pending|proposed|experimental|internal|private|hidden|unlisted|" +
        "unpublished|needs[_-]?review|unverified|in[_-]?review|withheld|withdrawn|" +
        "rejected|archived?|deleted|removed|retired|obsolete|superseded|" +
        "deprecated|inactive|disabled|suppressed|quarantined" +
      ")"
    );

    const STATUS_FIELD = /(^|_)(status|state|lifecycle|visibility|stage)$/;

    // Returns a reason string when the record must not be rendered, else null.
    function unpublishedReason(raw) {
      if (!raw || typeof raw !== "object") return "malformed";

      // Documented explicit boolean on the public entity schema.
      if (raw.public_visibility === false) return "public_visibility=false";

      const verification = text(raw.verification_status).toLowerCase();
      if (verification && !PUBLISHED_VERIFICATION.test(verification)) {
        return "verification_status=" + verification;
      }

      const meta =
        raw.public_metadata && typeof raw.public_metadata === "object" ? raw.public_metadata : {};

      if (meta.public_visibility === false) return "public_visibility=false";

      // The platform marks records it discovered but has not cleared, and
      // records it decided were misclassified. Both are status flags.
      if (meta.false_positive === true) return "false_positive";

      const scopes = [raw, meta];

      for (let s = 0; s < scopes.length; s++) {
        const scope = scopes[s];
        const keys = Object.keys(scope);

        for (let i = 0; i < keys.length; i++) {
          const key = keys[i];
          if (!STATUS_FIELD.test(key)) continue;

          const value = scope[key];
          if (typeof value !== "string") continue;

          const clean = value.trim().toLowerCase();
          if (clean && UNPUBLISHED_STATE.test(clean)) return key + "=" + clean;
        }
      }

      return null;
    }

    // Edges carry their own review lifecycle: the knowledge graph holds
    // suggested, rejected and ignored edges alongside accepted ones. Only an
    // explicitly accepted edge is allowed into the scene, and an edge with no
    // status field at all still has to survive the generic status scan.
    const ACCEPTED_EDGE_STATE = /^(accepted|approved|published|verified|active|confirmed)$/;

    function edgeRejectedReason(raw) {
      if (!raw || typeof raw !== "object") return "malformed";

      if (raw.public_visibility === false) return "public_visibility=false";

      const status = text(raw.status).toLowerCase();
      if (status) {
        return ACCEPTED_EDGE_STATE.test(status) ? null : "status=" + status;
      }

      const keys = Object.keys(raw);

      for (let i = 0; i < keys.length; i++) {
        const key = keys[i];
        if (!STATUS_FIELD.test(key)) continue;

        const value = raw[key];
        if (typeof value !== "string") continue;

        const clean = value.trim().toLowerCase();
        if (clean && UNPUBLISHED_STATE.test(clean)) return key + "=" + clean;
      }

      return null;
    }

    // -------------------------------------------------------
    // Normalization
    // -------------------------------------------------------
    function normalizeEntity(raw) {
      if (!raw || typeof raw !== "object") return null;

      const id = text(raw.public_id);
      const name = text(raw.name);
      if (!id || !name) return null;

      const type = text(raw.entity_type).toLowerCase() || "entity";
      const links = raw.links && typeof raw.links === "object" ? raw.links : {};
      const relationshipsCount = Number(links.relationships_count);
      const verificationStatus = text(raw.verification_status).toLowerCase();

      return {
        id,
        slug: text(raw.slug) || id,
        type,
        name,
        summary: text(raw.description),
        importance: 0,
        metadata: {
          aliases: Array.isArray(raw.aliases) ? raw.aliases.filter((a) => text(a)) : [],
          sameAs: Array.isArray(raw.same_as) ? raw.same_as.filter((a) => text(a)) : [],
          canonicalUri: text(raw.canonical_uri) || text(links.self),
          sourceUrl: text(raw.source_url),
          updatedAt: text(raw.updated_at),
          contentHash: text(raw.content_hash),
          schemaVersion: text(raw.schema_version),
          verificationStatus,
          verified: /^(verified|approved|published)$/.test(verificationStatus),
          relationshipsCount: Number.isFinite(relationshipsCount) ? relationshipsCount : 0,
          publicMetadata:
            raw.public_metadata && typeof raw.public_metadata === "object"
              ? raw.public_metadata
              : {},
          degree: 0,
          typeLabel: typeLabel(type)
        }
      };
    }

    // Evidence is documented as an array on graph edges and as a summary string
    // elsewhere. Take the first usable text from either, and keep the older
    // `description` shape working rather than swapping one guess for another.
    function firstText(value) {
      if (typeof value === "string") return value.trim();

      if (Array.isArray(value)) {
        for (let i = 0; i < value.length; i++) {
          const item = value[i];

          if (typeof item === "string" && item.trim()) return item.trim();

          if (item && typeof item === "object") {
            const nested =
              text(item.text) || text(item.summary) || text(item.quote) ||
              text(item.statement) || text(item.source);
            if (nested) return nested;
          }
        }
      }

      return "";
    }

    function edgeEvidence(raw) {
      return (
        firstText(raw.evidence) ||
        text(raw.applicability) ||
        text(raw.applicability_summary) ||
        text(raw.rationale) ||
        text(raw.description)
      );
    }

    // Confidence is published 0–100 on knowledge edges and 0–1 elsewhere;
    // weight is always 0–1. Accept either scale, prefer an explicit value, and
    // fall back to the derived score when the payload carries neither.
    function edgeConfidence(raw) {
      const candidates = [Number(raw.confidence), Number(raw.weight)];

      for (let i = 0; i < candidates.length; i++) {
        const value = candidates[i];
        if (!Number.isFinite(value) || value <= 0) continue;
        if (value <= 1) return value;
        if (value <= 100) return value / 100;
      }

      return null;
    }

    // Endpoints appear as plain strings, as nested objects, and as
    // module-qualified record ids. Offer every shape we can read to the
    // resolver and let it decide which one names a published entity.
    function endpointKeys(raw, primary, aliases) {
      const keys = [primary].concat(aliases);
      const out = [];

      function push(value) {
        const clean = text(value);
        if (clean) out.push(clean);
      }

      for (let i = 0; i < keys.length; i++) {
        const key = keys[i];
        const value = raw[key];

        if (typeof value === "string") {
          push(value);
        } else if (value && typeof value === "object") {
          push(value.public_id);
          push(value.id);
          push(value.entity_id);
          push(value.slug);
          push(value.name);
          push(value.title);

          const nestedModule = text(value.module);
          const nestedId = text(value.id) || text(value.record_id) || text(value.slug);
          if (nestedModule && nestedId) push(nestedModule + ":" + nestedId);
        }

        push(raw[key + "_public_id"]);
        push(raw[key + "_id"]);
        push(raw[key + "_slug"]);
        push(raw[key + "_name"]);
        push(raw[key + "_title"]);

        const flatModule = text(raw[key + "_module"]);
        const flatId = text(raw[key + "_id"]) || text(raw[key + "_slug"]);
        if (flatModule && flatId) push(flatModule + ":" + flatId);
      }

      return out;
    }

    function resolveEndpoint(raw, primary, aliases, resolve) {
      const candidates = endpointKeys(raw, primary, aliases);

      for (let i = 0; i < candidates.length; i++) {
        const match = resolve(candidates[i]);
        if (match) return match;
      }

      return null;
    }

    function normalizeRelationship(raw, resolve, origin) {
      if (!raw || typeof raw !== "object") return null;

      const from = resolveEndpoint(raw, "from", ["source", "subject"], resolve);
      const to = resolveEndpoint(raw, "to", ["target", "object"], resolve);
      if (!from || !to || from.id === to.id) return null;

      const predicate =
        text(raw.relationship) || text(raw.predicate) || text(raw.type) || "related_to";

      const evidence = edgeEvidence(raw);
      const apiConfidence = edgeConfidence(raw);
      const hasApiConfidence = apiConfidence !== null;

      const rawConfidence = hasApiConfidence
        ? apiConfidence
        : 0.75 +
          (evidence ? 0.1 : 0) +
          (from.metadata.verified ? 0.075 : 0) +
          (to.metadata.verified ? 0.075 : 0);

      const confidence = Math.round(clamp(rawConfidence, 0.75, 1) * 10000) / 10000;

      return {
        sourceId: from.id,
        targetId: to.id,
        predicate,
        confidence,
        evidence,
        origin: origin || "entity",
        metadata: {
          predicateLabel: titleize(predicate),
          derivedConfidence: !hasApiConfidence,
          sourceType: from.type,
          targetType: to.type
        }
      };
    }

    // -------------------------------------------------------
    // Constellation mapping
    // -------------------------------------------------------
    const RE_GARAGE = /(garage|residential|patio|pool|driveway|porch|basement|home)/;
    const RE_COMMERCIAL = /(commercial|industrial|warehouse|retail|restaurant|office|shop|showroom)/;
    const RE_REPAIR = /(repair|crack|spall|patch|joint|resurfac|level|overlay|removal)/;
    const RE_MAINTENANCE = /(maintain|maintenance|recoat|reseal|seal|clean|polish|cure|protect|care)/;
    const RE_POLY = /(polyaspartic|polyurea|urethane|thane|hybrid)/;
    const RE_EPOXY = /(epoxy|resin|flake|metallic|chip|quartz)/;
    const RE_PREP = /(prep|grind|shot ?blast|profile|moisture|diamond|abras)/;

    function constellationFor(entity) {
      const type = entity.type;
      const hay = (entity.name + " " + entity.slug + " " + entity.summary).toLowerCase();
      const systemType = String(
        (entity.metadata.publicMetadata && entity.metadata.publicMetadata.system_type) || ""
      ).toLowerCase();

      if (type === "service_area") return C_AREAS;
      if (type === "standard") return C_STANDARDS;

      if (type === "preparation_method") {
        if (RE_REPAIR.test(hay) && !RE_PREP.test(hay)) return C_REPAIR;
        return C_PREP;
      }

      if (type === "coating_system" || type === "product") {
        if (RE_POLY.test(systemType) || RE_POLY.test(hay)) return C_POLY;
        if (RE_EPOXY.test(systemType) || RE_EPOXY.test(hay)) return C_EPOXY;
        if (type === "coating_system") return C_EPOXY;
        if (RE_MAINTENANCE.test(hay)) return C_MAINTENANCE;
        if (RE_REPAIR.test(hay)) return C_REPAIR;
        return C_MANUFACTURERS;
      }

      if (type === "manufacturer" || type === "manufacturer_document") return C_MANUFACTURERS;

      if (type === "service" || type === "expertise") {
        if (RE_COMMERCIAL.test(hay)) return C_COMMERCIAL;
        if (RE_REPAIR.test(hay)) return C_REPAIR;
        if (RE_PREP.test(hay)) return C_PREP;
        if (RE_GARAGE.test(hay)) return C_GARAGE;
        if (RE_MAINTENANCE.test(hay)) return C_MAINTENANCE;
        if (RE_POLY.test(hay)) return C_POLY;
        if (RE_EPOXY.test(hay)) return C_EPOXY;
        return C_GARAGE;
      }

      return C_OS;
    }

    // -------------------------------------------------------
    // Importance + featured selection
    // -------------------------------------------------------
    function applyImportance(entities, relationships) {
      const degree = new Map();

      relationships.forEach((edge) => {
        degree.set(edge.sourceId, (degree.get(edge.sourceId) || 0) + 1);
        degree.set(edge.targetId, (degree.get(edge.targetId) || 0) + 1);
      });

      let maxDegree = 0;
      degree.forEach((value) => {
        if (value > maxDegree) maxDegree = value;
      });

      let maxRelCount = 0;
      entities.forEach((entity) => {
        if (entity.metadata.relationshipsCount > maxRelCount) {
          maxRelCount = entity.metadata.relationshipsCount;
        }
      });

      entities.forEach((entity) => {
        const own = degree.get(entity.id) || 0;
        const weight = TYPE_WEIGHTS[entity.type];
        const typeWeight = Number.isFinite(weight) ? weight : 0.5;
        const degreeScore = maxDegree > 0 ? own / maxDegree : 0;
        const relScore = maxRelCount > 0 ? entity.metadata.relationshipsCount / maxRelCount : 0;
        const verifiedScore = entity.metadata.verified ? 1 : 0;
        const jitter = hashUnit(hash32(entity.id), 7) * 0.02;

        entity.metadata.degree = own;
        entity.importance = clamp(
          typeWeight * 0.5 + degreeScore * 0.24 + relScore * 0.14 + verifiedScore * 0.1 + jitter,
          0,
          1
        );
      });

      return degree;
    }

    function pickFeatured(entities, constellationOf) {
      const total = entities.length;
      const target = Math.min(total, clamp(Math.round(total * 0.14), LABEL_MIN, LABEL_MAX));

      const order = entities.map((entity, index) => index).sort((a, b) => {
        const delta = entities[b].importance - entities[a].importance;
        if (delta !== 0) return delta;
        return entities[a].id < entities[b].id ? -1 : 1;
      });

      const perConstellation = new Map();
      const perType = new Map();
      const distinctTypes = new Set(entities.map((entity) => entity.type)).size;

      // First pass spreads labels across domains and types so the ring of
      // featured names reads as a whole graph, not one dense corner.
      const maxPerConstellation = Math.max(2, Math.ceil(target / 3.5));
      const maxPerType = Math.max(2, Math.ceil((target * 1.5) / Math.max(4, distinctTypes)));
      const chosen = [];
      const taken = new Set();

      for (let pass = 0; pass < 2 && chosen.length < target; pass++) {
        for (let i = 0; i < order.length && chosen.length < target; i++) {
          const index = order[i];
          if (taken.has(index)) continue;

          const constellation = constellationOf[index];
          const type = entities[index].type;

          if (pass === 0) {
            if ((perConstellation.get(constellation) || 0) >= maxPerConstellation) continue;
            if ((perType.get(type) || 0) >= maxPerType) continue;
          }

          taken.add(index);
          chosen.push(index);
          perConstellation.set(constellation, (perConstellation.get(constellation) || 0) + 1);
          perType.set(type, (perType.get(type) || 0) + 1);
        }
      }

      return chosen.sort((a, b) => a - b);
    }

    // -------------------------------------------------------
    // Deterministic layout — entity id hash + constellation anchors
    // -------------------------------------------------------
    function fibonacciDirection(index, count) {
      const total = Math.max(2, count);
      const y = 1 - (index / (total - 1)) * 2;
      const r = Math.sqrt(Math.max(0, 1 - y * y));
      const theta = Math.PI * (3 - Math.sqrt(5)) * index;

      return { x: Math.cos(theta) * r, y, z: Math.sin(theta) * r };
    }

    function normalizeVec(v) {
      const length = Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z) || 1;
      return { x: v.x / length, y: v.y / length, z: v.z / length };
    }

    function buildLayout(entities, constellationOf, featuredSet, options) {
      const radius = options.radius;
      const anchors = options.anchors.map(normalizeVec);
      const total = entities.length;

      const sizes = new Array(anchors.length).fill(0);
      for (let i = 0; i < total; i++) sizes[constellationOf[i]] += 1;

      const positions = [];

      for (let i = 0; i < total; i++) {
        const entity = entities[i];
        const constellation = constellationOf[i];
        const anchor = anchors[constellation] || anchors[0];
        const hash = hash32(entity.id);

        const base = fibonacciDirection(i, total);

        // Hash-derived tangential jitter so identical payloads land identically
        const up = Math.abs(base.y) < 0.9 ? { x: 0, y: 1, z: 0 } : { x: 1, y: 0, z: 0 };
        const u = normalizeVec({
          x: up.y * base.z - up.z * base.y,
          y: up.z * base.x - up.x * base.z,
          z: up.x * base.y - up.y * base.x
        });
        const v = {
          x: base.y * u.z - base.z * u.y,
          y: base.z * u.x - base.x * u.z,
          z: base.x * u.y - base.y * u.x
        };

        const angle = hashUnit(hash, 1) * Math.PI * 2;
        const amount = 0.03 + hashUnit(hash, 2) * 0.055;
        const jx = (u.x * Math.cos(angle) + v.x * Math.sin(angle)) * amount;
        const jy = (u.y * Math.cos(angle) + v.y * Math.sin(angle)) * amount;
        const jz = (u.z * Math.cos(angle) + v.z * Math.sin(angle)) * amount;

        const jittered = normalizeVec({ x: base.x + jx, y: base.y + jy, z: base.z + jz });

        // Soft pull toward the domain anchor — eased for crowded domains and
        // scaled down when the graph is dense so clusters stay soft, not piled.
        const share = total > 0 ? sizes[constellation] / total : 0;
        const densityScale = total > 140 ? clamp(140 / total, 0.55, 1) : 1;
        const pull = (share > 0.18 ? 0.15 : 0.24) * densityScale;

        const pulled = normalizeVec({
          x: jittered.x + (anchor.x - jittered.x) * pull,
          y: jittered.y + (anchor.y - jittered.y) * pull,
          z: jittered.z + (anchor.z - jittered.z) * pull
        });

        const radiusScale =
          0.965 + (constellation % 4) * 0.011 + (featuredSet.has(i) ? 0.008 : 0);
        const scaled = radius * radiusScale;

        positions.push({
          x: pulled.x * scaled,
          y: pulled.y * scaled,
          z: pulled.z * scaled
        });
      }

      return positions;
    }

    // -------------------------------------------------------
    // Payload assembly
    // -------------------------------------------------------
    function buildPayload(entityResult, relationshipResult, knowledgeResult) {
      const envelope = entityResult.envelope || {};
      const data = envelope.data || {};

      const entities = [];
      const byId = new Map();
      const lookup = new Map();
      const loose = new Map();

      function squash(value) {
        return String(value || "").toLowerCase().replace(/[^a-z0-9]+/g, "");
      }

      function register(key, entity) {
        const clean = text(key).toLowerCase();
        if (!clean) return;

        if (!lookup.has(clean)) lookup.set(clean, entity);

        // A loose key absorbs the punctuation differences between a canonical
        // id, a slug and a display name so a knowledge edge that names the same
        // thing a different way still lands on the right node.
        const squashed = squash(clean);
        if (squashed.length > 2 && !loose.has(squashed)) loose.set(squashed, entity);
      }

      let withheld = 0;

      entityResult.raw.forEach((raw) => {
        // Publication status decides visibility before anything is normalized.
        if (unpublishedReason(raw)) {
          withheld += 1;
          return;
        }

        const entity = normalizeEntity(raw);
        if (!entity || byId.has(entity.id)) return;

        byId.set(entity.id, entity);
        entities.push(entity);
        register(entity.id, entity);
        register(entity.slug, entity);
        register(entity.name, entity);

        // Canonical ids are published as pcc:{type}/{slug}; register the tail
        // and the type-qualified form so edges addressed either way resolve.
        const tail = entity.id.split("/").pop();
        register(tail, entity);
        register(entity.type + ":" + entity.slug, entity);

        (entity.metadata.aliases || []).forEach((alias) => register(alias, entity));
      });

      if (!entities.length) {
        throw new Error(
          "No published entities after normalization (" + withheld + " withheld)"
        );
      }

      // Deterministic canonical order
      entities.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));

      function resolve(key) {
        const clean = text(key);
        if (!clean) return null;

        const direct = byId.get(clean) || lookup.get(clean.toLowerCase());
        if (direct) return direct;

        const squashed = squash(clean);
        return (squashed.length > 2 && loose.get(squashed)) || null;
      }

      const relationships = [];
      const edgeSeen = new Set();

      let entityEdges = 0;
      let knowledgeEdges = 0;
      let unresolvedEdges = 0;
      let rejectedEdges = 0;

      function collect(list, origin) {
        let kept = 0;

        (list || []).forEach((raw) => {
          // The same lifecycle discipline the entity gate applies, applied to
          // edges: suggested, rejected and ignored links never reach the scene.
          if (edgeRejectedReason(raw)) {
            rejectedEdges += 1;
            return;
          }

          const edge = normalizeRelationship(raw, resolve, origin);

          if (!edge) {
            // Knowledge edges legitimately reference knowledge records that are
            // not part of the published entity set. Count them, never guess.
            unresolvedEdges += 1;
            return;
          }

          const key = edge.sourceId + "|" + edge.predicate + "|" + edge.targetId;
          if (edgeSeen.has(key)) return;

          edgeSeen.add(key);
          relationships.push(edge);
          kept += 1;
        });

        return kept;
      }

      entityEdges = collect(relationshipResult.raw, "entity");
      knowledgeEdges = collect(knowledgeResult && knowledgeResult.raw, "knowledge");

      relationships.sort((a, b) => {
        const key = (edge) => edge.sourceId + "|" + edge.predicate + "|" + edge.targetId;
        const ka = key(a);
        const kb = key(b);
        return ka < kb ? -1 : ka > kb ? 1 : 0;
      });

      applyImportance(entities, relationships);

      // Cap node count, but never drop an entity that carries a real relationship
      let kept = entities;

      if (entities.length > NODE_CAP) {
        const required = new Set();
        relationships.forEach((edge) => {
          required.add(edge.sourceId);
          required.add(edge.targetId);
        });

        const ranked = entities.slice().sort((a, b) => {
          const requiredDelta = (required.has(b.id) ? 1 : 0) - (required.has(a.id) ? 1 : 0);
          if (requiredDelta !== 0) return requiredDelta;
          const delta = b.importance - a.importance;
          if (delta !== 0) return delta;
          return a.id < b.id ? -1 : 1;
        });

        const keepIds = new Set(ranked.slice(0, NODE_CAP).map((entity) => entity.id));
        kept = entities.filter((entity) => keepIds.has(entity.id));
      }

      const keptIds = new Set(kept.map((entity) => entity.id));
      const keptRelationships = relationships.filter(
        (edge) => keptIds.has(edge.sourceId) && keptIds.has(edge.targetId)
      );

      const byType = {};
      kept.forEach((entity) => {
        byType[entity.type] = (byType[entity.type] || 0) + 1;
      });

      // Recount by origin after the node cap so the split describes what
      // survived, not what was parsed.
      let entityOrigin = 0;
      let knowledgeOrigin = 0;
      keptRelationships.forEach((edge) => {
        if (edge.origin === "knowledge") knowledgeOrigin += 1;
        else entityOrigin += 1;
      });

      const knowledgeOk = !knowledgeResult || knowledgeResult.ok !== false;

      return {
        schemaVersion: CACHE_SCHEMA_VERSION,
        complete:
          entityResult.complete !== false &&
          relationshipResult.ok !== false &&
          knowledgeOk,
        relationshipsAvailable: relationshipResult.ok !== false || knowledgeOk,
        apiSchemaVersion: text(data.schema_version) || text(envelope.schema_version),
        apiVersion: text(envelope.api_version),
        checksum: text(data.checksum),
        knowledgeLastUpdated: text(envelope.knowledge_last_updated),
        generatedAt: text(envelope.generated_at),
        knowledgeQuality: envelope.knowledge_quality || null,
        counts: {
          entities: kept.length,
          relationships: keptRelationships.length,
          entityRelationships: entityOrigin,
          knowledgeRelationships: knowledgeOrigin,
          parsedEntityRelationships: entityEdges,
          parsedKnowledgeRelationships: knowledgeEdges,
          unresolvedEdges,
          rejectedEdges,
          total: Number.isFinite(data.counts && data.counts.total) ? data.counts.total : kept.length,
          withheld,
          byType
        },
        entities: kept,
        relationships: keptRelationships
      };
    }

    // -------------------------------------------------------
    // Cache
    // -------------------------------------------------------
    function isValidPayload(payload) {
      if (!payload || typeof payload !== "object") return false;
      if (payload.schemaVersion !== CACHE_SCHEMA_VERSION) return false;
      if (!Array.isArray(payload.entities) || !payload.entities.length) return false;
      if (!Array.isArray(payload.relationships)) return false;

      return payload.entities.every(
        (entity) =>
          entity &&
          typeof entity.id === "string" &&
          entity.id &&
          typeof entity.name === "string" &&
          entity.name &&
          typeof entity.type === "string" &&
          entity.metadata &&
          typeof entity.metadata === "object"
      );
    }

    function writeCache(payload) {
      try {
        const record = {
          schemaVersion: CACHE_SCHEMA_VERSION,
          savedAt: Date.now(),
          maxAge: CACHE_MAX_AGE,
          checksum: payload.checksum || null,
          payload
        };

        window.localStorage.setItem(CACHE_KEY, JSON.stringify(record));
        return true;
      } catch (error) {
        return false;
      }
    }

    function readCache() {
      let record;

      try {
        const raw = window.localStorage.getItem(CACHE_KEY);
        if (!raw) return null;
        record = JSON.parse(raw);
      } catch (error) {
        clearCache();
        return null;
      }

      if (!record || record.schemaVersion !== CACHE_SCHEMA_VERSION) {
        clearCache();
        return null;
      }

      const savedAt = Number(record.savedAt);
      const maxAge = Number.isFinite(record.maxAge) ? record.maxAge : CACHE_MAX_AGE;

      if (!Number.isFinite(savedAt) || Date.now() - savedAt > maxAge) {
        clearCache();
        return null;
      }

      if (!isValidPayload(record.payload)) {
        clearCache();
        return null;
      }

      if (record.checksum && record.payload.checksum && record.checksum !== record.payload.checksum) {
        clearCache();
        return null;
      }

      record.payload.savedAt = savedAt;
      return record.payload;
    }

    function clearCache() {
      try {
        window.localStorage.removeItem(CACHE_KEY);
      } catch (error) {
        /* storage unavailable — nothing to clear */
      }
    }

    async function fetchLive() {
      const [entityResult, relationshipResult, knowledgeResult] = await Promise.all([
        fetchEntities(),
        fetchRelationships(),
        fetchKnowledgeRelationships()
      ]);

      const payload = buildPayload(entityResult, relationshipResult, knowledgeResult);

      // Never persist a partial fetch — a transient outage must not poison
      // the 24h cache with a graph that is missing entities or edges.
      if (payload.complete) writeCache(payload);

      return payload;
    }

    // -------------------------------------------------------
    // Model — what the scene consumes
    // -------------------------------------------------------
    function toModel(payload, mode, options) {
      const entities = payload.entities.slice(0, Math.min(NODE_CAP, options.nodeCap || NODE_CAP));
      const total = entities.length;

      const indexById = new Map();
      entities.forEach((entity, index) => indexById.set(entity.id, index));

      const resolved = payload.relationships.filter(
        (edge) => indexById.has(edge.sourceId) && indexById.has(edge.targetId)
      );

      // Strongest edges first, deterministic on ties, so the same payload always
      // produces the same scene.
      const ranked = resolved.slice().sort((a, b) => {
        if (b.confidence !== a.confidence) return b.confidence - a.confidence;

        const ka = a.sourceId + "|" + a.predicate + "|" + a.targetId;
        const kb = b.sourceId + "|" + b.predicate + "|" + b.targetId;
        return ka < kb ? -1 : ka > kb ? 1 : 0;
      });

      // Accept edges until either the global cap or a node's degree ceiling is
      // reached. Hubs keep their strongest links; nothing becomes a hairball.
      const acceptedPairs = new Set();
      const degree = new Map();
      let trimmed = 0;

      for (let i = 0; i < ranked.length; i++) {
        const edge = ranked[i];
        const a = indexById.get(edge.sourceId);
        const b = indexById.get(edge.targetId);
        if (a === b) continue;

        const key = a < b ? a + ":" + b : b + ":" + a;
        if (acceptedPairs.has(key)) continue;

        const da = degree.get(a) || 0;
        const db = degree.get(b) || 0;

        if (acceptedPairs.size >= EDGE_CAP || da >= MAX_DEGREE || db >= MAX_DEGREE) {
          trimmed += 1;
          continue;
        }

        acceptedPairs.add(key);
        degree.set(a, da + 1);
        degree.set(b, db + 1);
      }

      // Every predicate on a rendered pair stays available to the public API,
      // so getRelationships still describes the line the visitor can see.
      const relationships = resolved.filter((edge) => {
        const a = indexById.get(edge.sourceId);
        const b = indexById.get(edge.targetId);
        if (a === b) return false;

        return acceptedPairs.has(a < b ? a + ":" + b : b + ":" + a);
      });

      const constellationOf = new Uint8Array(total);
      entities.forEach((entity, index) => {
        constellationOf[index] = constellationFor(entity);
      });

      const featuredIndexes = pickFeatured(entities, constellationOf);
      const featuredSet = new Set(featuredIndexes);

      const positions = buildLayout(entities, constellationOf, featuredSet, options);

      const edgePairs = [];
      const edgeStrengths = [];
      const edgeRelationships = [];
      const pairSeen = new Set();

      relationships.forEach((edge) => {
        const a = indexById.get(edge.sourceId);
        const b = indexById.get(edge.targetId);
        if (a === b) return;

        const key = a < b ? a + ":" + b : b + ":" + a;
        if (pairSeen.has(key)) return;
        pairSeen.add(key);

        edgePairs.push([a, b]);
        edgeStrengths.push(clamp(0.42 + edge.confidence * 0.45, 0.35, 1));
        edgeRelationships.push(edge);
      });

      // Pulse paths ride real relationships only, strongest first, spread out
      const pulseOrder = edgePairs
        .map((pair, index) => index)
        .sort((a, b) => {
          const sa =
            edgeStrengths[a] +
            entities[edgePairs[a][0]].importance +
            entities[edgePairs[a][1]].importance;
          const sb =
            edgeStrengths[b] +
            entities[edgePairs[b][0]].importance +
            entities[edgePairs[b][1]].importance;
          if (sb !== sa) return sb - sa;
          return a - b;
        });

      const pulsePairs = [];
      const pulseUsed = new Set();

      for (let pass = 0; pass < 2 && pulsePairs.length < PULSE_MAX; pass++) {
        for (let i = 0; i < pulseOrder.length && pulsePairs.length < PULSE_MAX; i++) {
          const pair = edgePairs[pulseOrder[i]];
          const key = pair[0] + ":" + pair[1];
          if (pulseUsed.has(key)) continue;
          if (pass === 0 && (pulseUsed.has("n" + pair[0]) || pulseUsed.has("n" + pair[1]))) continue;

          pulseUsed.add(key);
          pulseUsed.add("n" + pair[0]);
          pulseUsed.add("n" + pair[1]);
          pulsePairs.push([pair[0], pair[1]]);
        }
      }

      const accentNodes = new Set();
      edgePairs.forEach(([a, b]) => {
        accentNodes.add(a);
        accentNodes.add(b);
      });

      const featuredLabels = featuredIndexes.map((index) => [
        truncate(entities[index].name, NAME_MAX_CHARS),
        typeLabel(entities[index].type)
      ]);

      return {
        mode,
        synthetic: false,
        count: total,
        entities,
        relationships,
        indexById,
        positions,
        constellationOf,
        featuredIndexes,
        featuredLabels,
        edgePairs,
        edgeStrengths,
        edgeRelationships,
        pulsePairs,
        accentNodes,
        seedKeys: entities.map((entity) => entity.id),
        meta: {
          complete: payload.complete !== false,
          relationshipsAvailable: payload.relationshipsAvailable !== false,
          checksum: payload.checksum || null,
          apiVersion: payload.apiVersion || null,
          apiSchemaVersion: payload.apiSchemaVersion || null,
          knowledgeLastUpdated: payload.knowledgeLastUpdated || null,
          generatedAt: payload.generatedAt || null,
          savedAt: payload.savedAt || null,
          counts: Object.assign({}, payload.counts || {}, {
            relationships: relationships.length,
            edgesResolved: resolved.length,
            edgesRendered: edgePairs.length,
            edgesTrimmed: trimmed
          })
        }
      };
    }

    function describeTypes(entities, limit) {
      const counts = new Map();
      entities.forEach((entity) => {
        counts.set(entity.type, (counts.get(entity.type) || 0) + 1);
      });

      return Array.from(counts.entries())
        .sort((a, b) => (b[1] - a[1]) || (a[0] < b[0] ? -1 : 1))
        .slice(0, limit || 5)
        .map(([type, count]) => count + " " + typePlural(type));
    }

    return {
      CACHE_KEY,
      CACHE_MAX_AGE,
      CACHE_SCHEMA_VERSION,
      FETCH_TIMEOUT,
      NODE_CAP,
      EDGE_CAP,
      MAX_DEGREE,
      PULSE_MAX,
      CONSTELLATION_COUNT: 11,
      hash32,
      hashUnit,
      fetchLive,
      readCache,
      writeCache,
      clearCache,
      isValidPayload,
      unpublishedReason,
      toModel,
      describeTypes,
      typeLabel,
      typePlural,
      constellationFor
    };
  })();

  PKG.data = ATLAS_DATA;

  // =========================================================
  // ATLAS_QUERY — public reasoning / search adapter (v3)
  // Pure data. No Three.js. No DOM.
  // =========================================================
  const ATLAS_QUERY = (function () {
    const API_ROOT = "https://app.precision-concretecoating.com/api/public/v1";
    const FETCH_TIMEOUT = 12000;

    function text(value) {
      return typeof value === "string" ? value.trim() : "";
    }

    function clamp(value, min, max) {
      return value < min ? min : value > max ? max : value;
    }

    async function fetchJSON(url, signal) {
      const controller = new AbortController();
      const timer = window.setTimeout(() => controller.abort(), FETCH_TIMEOUT);
      const onAbort = () => controller.abort();

      if (signal) {
        if (signal.aborted) {
          window.clearTimeout(timer);
          throw new DOMException("Aborted", "AbortError");
        }
        signal.addEventListener("abort", onAbort, { once: true });
      }

      try {
        const response = await fetch(url, {
          method: "GET",
          credentials: "omit",
          mode: "cors",
          cache: "no-store",
          headers: { Accept: "application/json" },
          signal: controller.signal
        });

        const body = await response.json().catch(() => null);

        if (!response.ok) {
          const message =
            (body && (body.error || body.message)) ||
            "HTTP " + response.status + " from " + url;
          const error = new Error(message);
          error.status = response.status;
          error.body = body;
          throw error;
        }

        if (!body || body.ok === false) {
          throw new Error((body && body.error) || "Malformed API response");
        }

        return body;
      } finally {
        window.clearTimeout(timer);
        if (signal) signal.removeEventListener("abort", onAbort);
      }
    }

    async function searchEntities(query, options) {
      const q = text(query);
      if (q.length < 2) return [];

      const params = new URLSearchParams({
        q: q.slice(0, 200),
        limit: String((options && options.limit) || 8)
      });

      if (options && options.entityType) {
        params.set("entity_type", options.entityType);
      }

      const body = await fetchJSON(
        API_ROOT + "/entities/search?" + params.toString(),
        options && options.signal
      );

      const results = Array.isArray(body.data && body.data.results)
        ? body.data.results
        : [];

      return results
        .map((raw) => {
          const id = text(raw.public_id);
          const name = text(raw.name);
          if (!id || !name) return null;
          return {
            id,
            name,
            type: text(raw.entity_type).toLowerCase(),
            summary: text(raw.description),
            relevance: Number(raw.relevance) || 0,
            verificationStatus: text(raw.verification_status).toLowerCase(),
            canonicalUri: text(raw.canonical_uri)
          };
        })
        .filter(Boolean);
    }

    async function fetchEntity(id, signal) {
      const key = text(id);
      if (!key) return null;

      const body = await fetchJSON(
        API_ROOT + "/entity?id=" + encodeURIComponent(key),
        signal
      );

      const entity = body.data && body.data.entity;
      if (!entity || !text(entity.public_id)) return null;

      return {
        id: text(entity.public_id),
        name: text(entity.name),
        type: text(entity.entity_type).toLowerCase(),
        summary: text(entity.description),
        slug: text(entity.slug),
        canonicalUri: text(entity.canonical_uri),
        verificationStatus: text(entity.verification_status).toLowerCase(),
        relationships: body.data.relationships || null
      };
    }

    async function fetchReasoning(question, options) {
      const q = text(question);
      if (!q) throw new Error("Question is required");

      const params = new URLSearchParams({
        question: q.slice(0, 400),
        max_depth: String((options && options.maxDepth) || 4),
        max_paths: String((options && options.maxPaths) || 5)
      });

      if (options && options.subject) params.set("subject", text(options.subject));
      if (options && options.goal) params.set("goal", text(options.goal));

      const body = await fetchJSON(
        API_ROOT + "/reasoning?" + params.toString(),
        options && options.signal
      );

      const data = body.data || {};
      const paths = Array.isArray(data.paths) ? data.paths : [];

      return {
        question: text(data.question) || q,
        subject: text(data.subject) || null,
        goal: text(data.goal) || null,
        note: text(data.note) || null,
        pathCount: Number(data.path_count) || paths.length,
        nodesIndexed: Number(data.nodes_indexed) || 0,
        relationshipsIndexed: Number(data.relationships_indexed) || 0,
        paths: paths.map(normalizePath).filter(Boolean)
      };
    }

    function normalizePath(raw) {
      if (!raw || typeof raw !== "object") return null;

      const steps = Array.isArray(raw.steps)
        ? raw.steps
            .map((step) => {
              const fromTitle = text(step.from && step.from.title);
              const toTitle = text(step.to && step.to.title);
              if (!fromTitle || !toTitle) return null;

              return {
                index: Number(step.index) || 0,
                from: {
                  title: fromTitle,
                  module: text(step.from.module),
                  conceptType: text(step.from.concept_type),
                  conceptTypeLabel: text(step.from.concept_type_label)
                },
                to: {
                  title: toTitle,
                  module: text(step.to.module),
                  conceptType: text(step.to.concept_type),
                  conceptTypeLabel: text(step.to.concept_type_label)
                },
                predicate: text(step.relationship) || "related_to",
                predicateLabel: text(step.relationship_label) || "Related To",
                inverse: Boolean(step.inverse),
                statement: text(step.statement),
                explanation: text(step.explanation),
                weight: Number(step.weight),
                evidenceStrength: Number(step.evidence_strength),
                evidence: Array.isArray(step.evidence) ? step.evidence : [],
                score: step.score && typeof step.score === "object" ? step.score : null
              };
            })
            .filter(Boolean)
        : [];

      return {
        summary: text(raw.summary),
        depth: Number(raw.depth) || steps.length,
        pathConfidence: Number(raw.path_confidence),
        pathScore: Number(raw.path_score),
        relationshipTypes: Array.isArray(raw.relationship_types)
          ? raw.relationship_types.map(text).filter(Boolean)
          : [],
        rankingReasons: Array.isArray(raw.ranking_reasons)
          ? raw.ranking_reasons.map(text).filter(Boolean)
          : [],
        supportingEvidence: Array.isArray(raw.supporting_evidence)
          ? raw.supporting_evidence
          : [],
        traversal: Array.isArray(raw.traversal)
          ? raw.traversal
              .map((node) => ({
                title: text(node.title),
                module: text(node.module),
                conceptType: text(node.concept_type)
              }))
              .filter((node) => node.title)
          : [],
        steps
      };
    }

    async function searchKnowledge(query, options) {
      const q = text(query);
      const params = new URLSearchParams({
        limit: String((options && options.limit) || 6)
      });
      if (q) params.set("q", q.slice(0, 200));
      if (options && options.module) params.set("module", options.module);

      const body = await fetchJSON(
        API_ROOT + "/knowledge?" + params.toString(),
        options && options.signal
      );

      const results = Array.isArray(body.data && body.data.results)
        ? body.data.results
        : [];

      return {
        query: text(body.data && body.data.query) || q,
        message: text(body.data && body.data.message),
        results: results
          .map((raw) => ({
            module: text(raw.module),
            section: text(raw.section),
            title: text(raw.title),
            body: text(raw.body),
            url: text(raw.url) || null,
            score: Number(raw.score) || 0
          }))
          .filter((item) => item.title || item.body)
      };
    }

    async function searchStandards(query, options) {
      const q = text(query);
      if (q.length < 2) return { results: [], usageNotice: "" };

      const params = new URLSearchParams({
        q: q.slice(0, 200),
        limit: String((options && options.limit) || 5)
      });

      const body = await fetchJSON(
        API_ROOT + "/standards/search?" + params.toString(),
        options && options.signal
      );

      const results = Array.isArray(body.data && body.data.results)
        ? body.data.results
        : [];

      return {
        usageNotice: text(body.data && body.data.usage_notice),
        results: results
          .map((raw) => ({
            id: text(raw.public_id),
            number: text(raw.standard_number),
            title: text(raw.official_title),
            issuer: text(raw.issuing_organization),
            lifecycle: text(raw.lifecycle),
            sourceUrl: text(raw.official_source_url),
            relevance: Number(raw.relevance) || 0
          }))
          .filter((item) => item.id || item.number)
      };
    }

    function titleKey(value) {
      return text(value)
        .toLowerCase()
        .replace(/[^a-z0-9]+/g, " ")
        .trim();
    }


    const STOP_TOKENS = new Set([
      "the", "and", "for", "with", "from", "does", "what", "why", "how", "will",
      "about", "that", "this", "into", "your", "our", "are", "can", "any", "you",
      "precision", "concrete", "coating", "coatings", "floor", "floors", "garage",
      "customer", "question", "questions", "concern", "concerns", "project",
      "installation", "approved", "method", "material", "serve", "handle",
      "matter", "guide", "guides", "protect", "protects", "resist", "together",
      "work", "works", "need", "before", "after", "their", "they", "have", "has"
    ]);

    const CONCEPT_ENTITY_TYPES = new Set([
      "failure_mode",
      "preparation_method",
      "coating_system",
      "standard",
      "product",
      "expertise",
      "maintenance_practice",
      "manufacturer",
      "material",
      "concept"
    ]);

    const SERVICE_ENTITY_TYPES = new Set([
      "service",
      "service_area",
      "trust_signal",
      "community_involvement",
      "organization",
      "person",
      "warranty_term"
    ]);

    function tokenize(value) {
      return text(value)
        .toLowerCase()
        .replace(/[^a-z0-9\s]/g, " ")
        .split(/\s+/)
        .filter((token) => token.length >= 3 && !STOP_TOKENS.has(token));
    }

    function extractDefinitionSubject(question) {
      const raw = text(question).replace(/[?!.,]+$/g, "").trim();
      const match = raw.match(
        /^(?:what(?:'s| is| are)|define|explain)\s+(?:a |an |the )?(.+)$/i
      );
      if (!match) return "";
      return text(match[1])
        .replace(/\b(mean|means|exactly|basically|really)\b/gi, " ")
        .replace(/\s+/g, " ")
        .trim();
    }

    function classifyQuestionIntent(question) {
      const q = text(question).toLowerCase().trim();
      if (!q) return "general";

      if (
        /\b(warranty|warranties)\b/.test(q) ||
        /\b(covered|coverage|exclu|void the warranty|what isn't covered|what is not covered)\b/.test(q)
      ) {
        return "warranty";
      }

      if (/\bvs\.?\b|versus|compared to|comparison|difference between\b/.test(q)) {
        return "comparison";
      }

      if (
        /\bwhat (?:polyaspartic|epoxy|polyurea|metallic).*(?:coating|system|service|offer|install|use|do you)\b/.test(q) ||
        /\bwhat (?:do you|does precision).*(?:install|offer|use|provide|sell)\b/.test(q) ||
        /\bwhich (?:system|service|coating)\b/.test(q)
      ) {
        return "service";
      }

      // Definition questions before broad process keywords (e.g. "What is crack repair?").
      if (/^(?:what(?:'s| is| are)\b|define\b|explain\b)/.test(q)) {
        return "concept";
      }

      if (
        /^(?:how (?:do|does|is|are|should|to)\b)/.test(q) ||
        /\bhow do you\b|\bhow does precision\b/.test(q)
      ) {
        return "process";
      }

      return "general";
    }

    function isServicePackageName(name) {
      return /\b(garage floor coating|floor coating|pool deck coating|warehouse|industrial coating|commercial floor|patio & outdoor|patio and outdoor|crack repair|control joint|moisture mitigation|recoating failed)\b/i.test(
        text(name)
      );
    }

    function subjectKeyMatch(candidate, subject) {
      const left = titleKey(candidate);
      const right = titleKey(subject);
      if (!left || !right) return 0;
      if (left === right) return 3;
      if (left.indexOf(right) !== -1 || right.indexOf(left) !== -1) return 2;
      const leftParts = left.split(" ").filter(Boolean);
      const rightParts = right.split(" ").filter(Boolean);
      const overlap = rightParts.filter((part) => leftParts.indexOf(part) !== -1).length;
      if (overlap && overlap === rightParts.length) return 2;
      if (overlap >= Math.max(1, Math.ceil(rightParts.length * 0.66))) return 1;
      return 0;
    }

    /** Prefer canonical concept titles over hybrids, kits, and packages. */
    function subjectCanonicalBoost(candidate, subject) {
      const left = titleKey(candidate);
      const right = titleKey(subject);
      if (!left || !right) return 0;
      if (left === right) return 18;
      if (
        left === right + " floor system" ||
        left === right + " coating systems" ||
        left === right + " coating system" ||
        left === right + " systems" ||
        left === right + " system"
      ) {
        return 16;
      }
      if (left.indexOf(right) === 0 && left.length <= right.length + 24) return 10;
      if (/\bhybrid\b/.test(left) && !/\bhybrid\b/.test(right)) return -12;
      if (/\b(cove kit|tabletop|casting resin)\b/.test(left)) return -14;
      return 0;
    }

    function pathTraversalNodes(path) {
      if (Array.isArray(path.traversal) && path.traversal.length) return path.traversal;
      const nodes = [];
      (path.steps || []).forEach((step) => {
        if (step && step.from) nodes.push(step.from);
        if (step && step.to) nodes.push(step.to);
      });
      return nodes;
    }

    function pathRelationshipBlob(path) {
      const types = path.relationship_types || path.relationshipTypes || [];
      if (types.length) return types.join(" ").toLowerCase();
      return (path.steps || [])
        .map((step) => text(step.predicate || step.relationship || step.predicateLabel).toLowerCase())
        .join(" ");
    }

    function rankPathsForIntent(paths, intent, question, subject) {
      const list = Array.isArray(paths) ? paths.slice() : [];
      if (!list.length) return list;

      return list
        .map((path, index) => {
          let score =
            (Number(path.pathScore) || 0) * 0.5 +
            (Number(path.pathConfidence) || 0) * 0.25 -
            index * 0.01;
          const nodes = pathTraversalNodes(path);
          const first = nodes[0] || {};
          const firstTitle = text(first.title);
          const firstType = text(first.concept_type || first.conceptType).toLowerCase();
          const rels = pathRelationshipBlob(path);
          const match = subjectKeyMatch(firstTitle, subject);

          const second = nodes[1] || {};
          const secondTitle = text(second.title);
          const secondType = text(second.concept_type || second.conceptType).toLowerCase();
          const anyServiceNode = nodes.some((node) => isServicePackageName(node && node.title));

          if (intent === "concept") {
            score += match * 28;
            score += subjectCanonicalBoost(firstTitle, subject);
            if (/failure|preparation|procedure|moisture|adhesion|material|concept/.test(firstType)) {
              score += 18;
            }
            if (/coating.?system|expertise|standard|material|concept/.test(firstType)) score += 20;
            if (/system$/i.test(firstTitle) || /\bcoating systems\b/i.test(firstTitle)) score += 12;
            if (isServicePackageName(firstTitle)) score -= 36;
            if (/^product$/i.test(firstType) && match < 3) score -= 18;
            if (/\bmanufactured_by\b/.test(rels)) score -= 24;
            if (/\b(mitigated_by|detected_via|measured_by|helps_detect|addressed_by|tested_by)\b/.test(rels)) {
              score += 14;
            }
            if (/\b(governed_by|manufactured_by)\b/.test(rels) && isServicePackageName(firstTitle)) {
              score -= 18;
            }
            if (/\bused_by\b/.test(rels) && /system$/i.test(firstTitle)) score += 8;
            // Failure documentation is related, but not a material definition.
            if (
              !/failure/.test(firstType) &&
              (/failure/.test(secondType) || /ambering|blister|yellow|soft or uncured/i.test(secondTitle))
            ) {
              score -= 10;
            }
          } else if (intent === "service") {
            if (isServicePackageName(firstTitle) || anyServiceNode) score += 34;
            if (/\b(uses|used_by|includes|applies_to)\b/.test(rels)) score += 16;
            if (/\bmanufactured_by\b/.test(rels) && !anyServiceNode) score -= 10;
            if (match) score += match * 8;
          } else if (intent === "warranty") {
            if (/warrant|exclu|cover|abuse|misuse|transfer/i.test(firstTitle)) score += 36;
            if (/\b(governed_by|excludes|excluded_by|covers|covered_by|applies_to)\b/.test(rels)) {
              score += 12;
            }
          } else if (intent === "process") {
            if (/prepar|grind|repair|install|inspect|moisture|profile|csp/i.test(firstTitle)) {
              score += 28;
            }
            if (/preparation|procedure|inspection/.test(firstType)) score += 12;
          } else if (intent === "comparison") {
            if (/system|coating systems|epoxy|polyaspartic|polyurea/i.test(firstTitle)) score += 14;
            if (/coating.?system|expertise|material|concept/.test(firstType)) score += 16;
            if (isServicePackageName(firstTitle)) score -= 12;
            if (/\bmanufactured_by\b/.test(rels)) score -= 14;
            score += match * 10;
            score += subjectCanonicalBoost(firstTitle, subject);
          }

          return { path, score };
        })
        .sort((a, b) => b.score - a.score)
        .map((row) => row.path);
    }

    function rankEntitiesForIntent(entities, intent, question, subject) {
      const list = Array.isArray(entities) ? entities.slice() : [];
      if (!list.length) return list;

      return list
        .map((entity, index) => {
          let score = (Number(entity.relevance) || 0) - index * 0.01;
          const name = text(entity.name);
          const type = text(entity.type).toLowerCase();
          const match = subjectKeyMatch(name, subject);
          score += match * 20;

          if (intent === "concept") {
            if (CONCEPT_ENTITY_TYPES.has(type)) score += 22;
            if (type === "failure_mode" || type === "preparation_method") score += 10;
            if (type === "coating_system" || type === "expertise" || type === "material" || type === "concept") {
              score += 10;
            }
            if (type === "product" && match < 3) score -= 12;
            if (SERVICE_ENTITY_TYPES.has(type) || isServicePackageName(name)) score -= 28;
            if (text(entity.summary).length > 80) score += 6;
            score += subjectCanonicalBoost(name, subject);
          } else if (intent === "service") {
            if (type === "service" || type === "coating_system") score += 24;
            if (isServicePackageName(name)) score += 12;
          } else if (intent === "warranty") {
            if (type === "warranty_term" || type === "trust_signal") score += 24;
          } else if (intent === "process") {
            if (type === "preparation_method" || type === "service" || type === "expertise") {
              score += 18;
            }
          } else if (intent === "comparison") {
            if (CONCEPT_ENTITY_TYPES.has(type)) score += 16;
            if (isServicePackageName(name)) score -= 10;
            score += subjectCanonicalBoost(name, subject);
          }

          return { entity, score };
        })
        .sort((a, b) => b.score - a.score)
        .map((row) => row.entity);
    }

    function isThinConceptSummary(summary) {
      const value = text(summary);
      if (!value) return true;
      if (value.length < 48) return true;
      if (/^installation of\b/i.test(value)) return true;
      if (/seeded from the official product index|awaiting document intake|discovered on the official product index/i.test(value)) {
        return true;
      }
      if (
        value.length < 80 &&
        /^(polyaspartic|epoxy|polyurea).*(coating system|floor system)\.?$/i.test(value)
      ) {
        return true;
      }
      return false;
    }

    function isConceptDefinitionEntity(entity, subject) {
      if (!entity) return false;
      const match = subjectKeyMatch(entity.name, subject);
      if (match < 1) return false;
      if (isThinConceptSummary(entity.summary)) return false;
      const type = text(entity.type).toLowerCase();
      const name = text(entity.name);
      if (/\bhybrid\b/i.test(name) && !/\bhybrid\b/i.test(subject)) return false;
      if (type === "product" && match < 3) return false;
      if (type === "expertise" && /^installation of\b/i.test(text(entity.summary))) return false;
      if (
        (type === "coating_system" || type === "expertise") &&
        subjectCanonicalBoost(name, subject) <= 0 &&
        match < 3
      ) {
        return false;
      }
      return true;
    }

    function knowledgeMentionsSubject(hit, subject) {
      if (!subject) return true;
      const title = text(hit.title);
      const body = text(hit.body);
      if (subjectKeyMatch(title, subject) >= 1) return true;
      const sk = titleKey(subject);
      if (!sk) return true;
      return titleKey(title + " " + body).indexOf(sk) !== -1;
    }

    function isDefinitionalKnowledge(hit, subject) {
      const title = text(hit.title);
      const body = text(hit.body);
      const moduleName = text(hit.module).toLowerCase();
      const mentions = knowledgeMentionsSubject(hit, subject);

      // Service package / warranty coverage copy is usage or coverage — not a concept definition.
      if (
        moduleName === "services" ||
        moduleName === "warranty" ||
        isServicePackageName(title)
      ) {
        return false;
      }

      if (/^what is\b|^what are\b|^define\b/i.test(title)) {
        return mentions;
      }
      if (/^what\b.+\bis\b/i.test(title) && mentions) return true;
      if (
        subject &&
        mentions &&
        new RegExp(
          "^\\s*" +
            text(subject).replace(/[.*+?^${}()|[\]\\]/g, "\\$&") +
            "\\s+(is|are|means|refers to)\\b",
          "i"
        ).test(body)
      ) {
        return true;
      }
      if (
        (moduleName === "inspection_standards") &&
        subject &&
        subjectKeyMatch(title, subject) >= 1 &&
        body.length > 50
      ) {
        return true;
      }
      if (
        (moduleName === "failure_analysis" || moduleName === "maintenance_care") &&
        subject &&
        subjectKeyMatch(title, subject) >= 2 &&
        body.length > 40
      ) {
        return true;
      }
      // Exact-title concept records only — avoid treating install checklist lines as definitions.
      if (subject && subjectKeyMatch(title, subject) >= 3 && body.length > 40) return true;
      return false;
    }

    function rankKnowledge(question, results, intent, subject) {
      const qTokens = Array.from(new Set(tokenize(question)));
      if (!qTokens.length) return [];
      const resolvedIntent = intent || classifyQuestionIntent(question);
      const resolvedSubject = subject || extractDefinitionSubject(question);

      return (results || [])
        .map((hit) => {
          const title = text(hit.title).toLowerCase();
          const body = text(hit.body).toLowerCase();
          const moduleName = text(hit.module).toLowerCase();
          let titleHits = 0;
          let bodyHits = 0;

          qTokens.forEach((token) => {
            if (title.indexOf(token) !== -1) titleHits += 1;
            else if (body.indexOf(token) !== -1) bodyHits += 1;
          });

          const overlap = titleHits + bodyHits;
          const isFaq = /frequently asked questions|^#\s*faq\b/i.test(
            text(hit.title) + "\n" + text(hit.body).slice(0, 80)
          );
          const isBoilerplate =
            /committed to delivering|customer experience on every project|company standards include/i.test(
              text(hit.body).slice(0, 220)
            );
          const definitional = isDefinitionalKnowledge(hit, resolvedSubject);

          let score =
            (Number(hit.score) || 0) * 0.35 +
            titleHits * 0.85 +
            bodyHits * 0.2 +
            (moduleName === "service_areas" && titleHits ? 0.4 : 0) +
            (moduleName === "warranty" && overlap ? 0.45 : 0) +
            (moduleName === "failure_analysis" && overlap ? 0.15 : 0) +
            (moduleName === "maintenance_care" && overlap ? 0.15 : 0) +
            (moduleName.indexOf("standard") !== -1 && overlap ? 0.2 : 0);

          if (resolvedIntent === "concept") {
            if (definitional) score += 2.4;
            if (moduleName === "services") score -= 1.35;
            if (moduleName.indexOf("standard") !== -1 && definitional) score += 0.8;
            if (moduleName === "failure_analysis" && definitional) score += 0.7;
            if (moduleName === "approved_knowledge" && overlap) score += 0.35;
          } else if (resolvedIntent === "service") {
            if (moduleName === "services") score += 1.1;
          } else if (resolvedIntent === "warranty") {
            if (moduleName === "warranty") score += 1.4;
          } else if (resolvedIntent === "process") {
            if (moduleName.indexOf("installation") !== -1 || moduleName.indexOf("inspection") !== -1) {
              score += 0.9;
            }
          }

          if (isFaq) score -= 1.2;
          if (isBoilerplate) score -= 0.8;
          if (!titleHits && bodyHits === 1 && qTokens.length > 1) score -= 0.35;

          return { hit, overlap, titleHits, score, isFaq, isBoilerplate, definitional };
        })
        .filter((row) => {
          if (row.isFaq || row.isBoilerplate) return false;
          if (resolvedIntent === "concept" && row.definitional) {
            return knowledgeMentionsSubject(row.hit, resolvedSubject);
          }
          return row.titleHits > 0;
        })
        .sort(
          (a, b) =>
            b.score - a.score ||
            Number(b.definitional) - Number(a.definitional) ||
            b.titleHits - a.titleHits ||
            b.overlap - a.overlap
        )
        .map((row) => row.hit);
    }

    function cleanSnippet(value) {
      return text(value)
        .replace(/^#+\s*/gm, "")
        .replace(/\s+/g, " ")
        .trim();
    }

    function clipSnippet(value, maxLen) {
      const snippet = cleanSnippet(value);
      if (!snippet) return "";
      if (snippet.length <= maxLen) return snippet;
      return snippet.slice(0, maxLen - 1).trimEnd() + "…";
    }

    function buildAnswer(payload) {
      const question = text(payload.question);
      const intent = payload.intent || classifyQuestionIntent(question);
      const subject = payload.subject || extractDefinitionSubject(question);
      const reasoning = payload.reasoning || { paths: [], note: null };
      const knowledge = payload.knowledge || { results: [] };
      const standards = payload.standards || { results: [], usageNotice: "" };
      const entities = Array.isArray(payload.entities) ? payload.entities : [];
      const mappedPath = payload.mappedPath || null;

      const topPath = reasoning.paths[0] || null;
      const knowledgeHits = rankKnowledge(
        question,
        knowledge.results || [],
        intent,
        subject
      ).slice(0, 6);
      const statements = [];

      const definitionHits = knowledgeHits.filter((hit) => isDefinitionalKnowledge(hit, subject));
      const usageHits = knowledgeHits.filter((hit) => {
        const moduleName = text(hit.module).toLowerCase();
        return moduleName === "services" || isServicePackageName(hit.title);
      });

      const conceptEntities = entities.filter((entity) => {
        const type = text(entity.type).toLowerCase();
        if (SERVICE_ENTITY_TYPES.has(type) || isServicePackageName(entity.name)) {
          return false;
        }
        if (intent === "concept") {
          return (
            CONCEPT_ENTITY_TYPES.has(type) &&
            (subjectKeyMatch(entity.name, subject) >= 1 || text(entity.summary).length > 48)
          );
        }
        return CONCEPT_ENTITY_TYPES.has(type) || subjectKeyMatch(entity.name, subject) >= 1;
      });

      const serviceEntities = entities.filter(
        (entity) =>
          text(entity.type).toLowerCase() === "service" || isServicePackageName(entity.name)
      );

      if (intent === "concept") {
        definitionHits.slice(0, 2).forEach((hit) => {
          if (!hit.body) return;
          const snippet = clipSnippet(hit.body, 320);
          if (snippet) statements.push(snippet);
        });

        if (!statements.length) {
          const definitionEntity = conceptEntities
            .filter((entity) => isConceptDefinitionEntity(entity, subject))
            .sort(
              (a, b) =>
                subjectKeyMatch(b.name, subject) - subjectKeyMatch(a.name, subject) ||
                text(b.summary).length - text(a.summary).length
            )[0];
          if (definitionEntity) {
            const typeLabel = text(definitionEntity.type).replace(/_/g, " ");
            statements.push(
              clipSnippet(
                definitionEntity.name +
                  (typeLabel ? " (" + typeLabel + ")" : "") +
                  ": " +
                  text(definitionEntity.summary),
                340
              )
            );
          }
        }

        if (statements.length && conceptEntities.length) {
          const matter = conceptEntities.find(
            (entity) =>
              text(entity.type) === "failure_mode" ||
              text(entity.type) === "maintenance_practice" ||
              text(entity.type) === "standard"
          );
          if (matter && text(matter.summary).length > 40 && subjectKeyMatch(matter.name, subject) < 3) {
            statements.push(clipSnippet(matter.name + " matters because " + matter.summary, 280));
          }
        }

        const usageParts = [];
        usageHits.slice(0, 1).forEach((hit) => {
          const snippet = clipSnippet(hit.body || hit.title, 240);
          if (snippet) usageParts.push(snippet);
        });
        if (!usageParts.length && serviceEntities[0] && text(serviceEntities[0].summary)) {
          usageParts.push(
            clipSnippet(
              "Precision’s published service record for this topic: " +
                serviceEntities[0].name +
                " — " +
                serviceEntities[0].summary,
              260
            )
          );
        } else if (usageParts.length) {
          usageParts[0] = "How Precision uses it in published services: " + usageParts[0];
        }
        usageParts.forEach((part) => statements.push(part));
      } else {
        knowledgeHits.forEach((hit) => {
          if (hit.body) {
            const snippet = clipSnippet(hit.body, 280);
            if (snippet) statements.push(snippet);
          } else if (hit.title) {
            statements.push(cleanSnippet(hit.title));
          }
        });
      }

      const standardLines = (standards.results || [])
        .slice(0, 3)
        .map((std) => {
          const label = text(std.number) || text(std.id);
          const title = text(std.title);
          return label + (title ? " — " + title : "");
        })
        .filter(Boolean);

      if (standardLines.length && /standard|moisture|astm|icri|test|csp|profile/i.test(question)) {
        statements.unshift(
          "Referenced standards in Precision’s published public layer: " +
            standardLines.join("; ") +
            "."
        );
      }

      const entitySupport = entities
        .filter((entity) => {
          const name = text(entity.name).toLowerCase();
          return tokenize(question).some((token) => name.indexOf(token) !== -1);
        })
        .slice(0, 3);

      if (!statements.length && entitySupport.length && /serve|service area|area/i.test(question)) {
        statements.push(
          "Published service-area entities matching this question: " +
            entitySupport.map((entity) => entity.name).join(", ") +
            "."
        );
      }

      let hasDefinitiveSupport = statements.length > 0;
      let body;
      let limited = false;

      if (intent === "concept") {
        const hasDefinition =
          definitionHits.length > 0 ||
          conceptEntities.some((entity) => isConceptDefinitionEntity(entity, subject));

        if (hasDefinition && statements.length) {
          body = statements.slice(0, 3).join(" ");
        } else if (statements.length) {
          limited = true;
          body =
            "Atlas found published Precision records related to " +
            (subject || "this topic") +
            ", but the public graph does not yet include a standalone concept definition. " +
            statements.slice(0, 2).join(" ");
        } else if (entities.length || (topPath && topPath.steps && topPath.steps.length)) {
          limited = true;
          body =
            "Atlas found related knowledge, but the published graph does not contain enough support for a definitive concept definition.";
        } else {
          limited = true;
          body =
            reasoning.note ||
            "Atlas could not find a published reasoning path for that question.";
        }
        hasDefinitiveSupport = hasDefinition;
      } else if (hasDefinitiveSupport) {
        body = statements.slice(0, 2).join(" ");
      } else if (entities.length || (topPath && topPath.steps && topPath.steps.length)) {
        limited = true;
        body =
          "Atlas found related knowledge, but the published graph does not contain enough support for a definitive answer.";
      } else {
        limited = true;
        body =
          reasoning.note ||
          "Atlas could not find a published reasoning path for that question.";
      }

      const pathSteps = (mappedPath && mappedPath.steps) || (topPath && topPath.steps) || [];
      const evidence = [];

      pathSteps.forEach((step) => {
        if (step.explanation) evidence.push(step.explanation);
        if (Array.isArray(step.evidence)) {
          step.evidence.forEach((item) => {
            const line =
              typeof item === "string"
                ? item
                : text(item && (item.text || item.title || item.statement));
            if (line) evidence.push(line);
          });
        }
      });

      knowledgeHits.forEach((hit) => {
        if (hit.title && hit.module) {
          evidence.push(hit.module.replace(/_/g, " ") + ": " + hit.title);
        }
      });

      const confidence =
        topPath && Number.isFinite(topPath.pathConfidence)
          ? clamp(Math.round(topPath.pathConfidence), 0, 100)
          : null;

      return {
        question,
        intent,
        subject,
        body,
        limited,
        confidence,
        pathSummary: topPath ? topPath.summary : "",
        entities: entities.slice(0, 8).map((entity) => ({
          id: entity.id,
          name: entity.name,
          type: entity.type
        })),
        pathSteps: pathSteps.slice(0, 8).map((step) => ({
          from: step.from && step.from.title ? step.from.title : step.fromTitle || "",
          to: step.to && step.to.title ? step.to.title : step.toTitle || "",
          predicateLabel: step.predicateLabel || step.relationship_label || "Related To",
          statement: step.statement || ""
        })),
        evidence: evidence.slice(0, 6),
        standards: (standards.results || []).slice(0, 5),
        standardsNotice: standards.usageNotice || "",
        note: limited
          ? "Informational only. On-site inspection may be required before any recommendation."
          : "Grounded in Precision’s published public knowledge. Field conditions can differ."
      };
    }

    return {
      API_ROOT,
      FETCH_TIMEOUT,
      searchEntities,
      fetchEntity,
      fetchReasoning,
      searchKnowledge,
      searchStandards,
      titleKey,
      rankKnowledge,
      rankPathsForIntent,
      rankEntitiesForIntent,
      classifyQuestionIntent,
      extractDefinitionSubject,
      cleanSnippet,
      tokenize,
      buildAnswer,
      text
    };
  })();

  PKG.queryAdapter = ATLAS_QUERY;


  async function importGraphics() {
    const loaders = [
      async () => {
        const THREE = await import("https://cdn.jsdelivr.net/npm/three@0.160.0/build/three.module.js/+esm");
        const { OrbitControls } = await import("https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/controls/OrbitControls.js/+esm");
        return { THREE, OrbitControls };
      },
      async () => {
        const THREE = await import("https://esm.sh/three@0.160.0");
        const { OrbitControls } = await import("https://esm.sh/three@0.160.0/examples/jsm/controls/OrbitControls");
        return { THREE, OrbitControls };
      }
    ];

    let lastError;

    for (const load of loaders) {
      try {
        return await load();
      } catch (error) {
        lastError = error;
      }
    }

    throw lastError || new Error("Failed to load Three.js");
  }

  try {
    const { THREE, OrbitControls } = await importGraphics();

    PKG.THREE = THREE;

    const renderer = new THREE.WebGLRenderer({
      canvas,
      antialias: true,
      alpha: true,
      powerPreference: "high-performance"
    });

    renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 1.8));
    renderer.setSize(viewport.clientWidth, viewport.clientHeight, false);
    renderer.outputColorSpace = THREE.SRGBColorSpace;
    renderer.toneMapping = THREE.ACESFilmicToneMapping;
    renderer.toneMappingExposure = 1.52;

    const scene = new THREE.Scene();
    scene.fog = new THREE.FogExp2(0x030201, 0.036);

    const camera = new THREE.PerspectiveCamera(
      40,
      viewport.clientWidth / viewport.clientHeight,
      0.1,
      100
    );

    camera.position.set(0, 0.12, 9.85);

    const controls = new OrbitControls(camera, canvas);
    controls.enableDamping = true;
    controls.dampingFactor = 0.048;
    controls.enablePan = false;
    controls.enableZoom = true;
    controls.minDistance = 7.35;
    controls.maxDistance = 13.2;
    controls.rotateSpeed = 0.4;
    controls.zoomSpeed = 0.55;
    controls.autoRotate = !prefersReducedMotion;
    controls.autoRotateSpeed = 0.16;

    const graphGroup = new THREE.Group();
    const GRAPH_SCALE = 1.18;
    graphGroup.scale.setScalar(GRAPH_SCALE);
    scene.add(graphGroup);

    const sphereRadius = 4.35;

    function fibonacciSphere(count, radius) {
      const points = [];
      const phi = Math.PI * (3 - Math.sqrt(5));

      for (let i = 0; i < count; i++) {
        const y = 1 - (i / (count - 1)) * 2;
        const r = Math.sqrt(1 - y * y);
        const theta = phi * i;

        points.push(
          new THREE.Vector3(
            Math.cos(theta) * r * radius,
            y * radius,
            Math.sin(theta) * r * radius
          )
        );
      }

      return points;
    }

    // Node/edge buffers are allocated once at capacity; live payloads reuse them.
    // Must stay ≥ ATLAS_DATA.NODE_CAP (400) with a little GPU headroom.
    const NODE_CAPACITY = 420;

    // Knowledge Constellations — soft domains, not hard clusters
    const CONSTELLATION_COUNT = ATLAS_DATA.CONSTELLATION_COUNT;
    const constellationNames = [
      "Garage Floor Coatings",
      "Commercial Flooring",
      "Surface Preparation",
      "Polyaspartic Systems",
      "Epoxy Systems",
      "Concrete Repair",
      "ASTM Standards",
      "Manufacturers",
      "Service Areas",
      "Maintenance",
      "Precision OS"
    ];

    const constellationAnchors = fibonacciSphere(CONSTELLATION_COUNT, sphereRadius);

    const baseGold = new THREE.Color("#d6a84a");
    const hotGold = new THREE.Color("#ffd76a");
    const green = new THREE.Color("#7ee99a");

    // Restrained gold-temperature variation within the existing palette
    const constellationTemps = [
      new THREE.Color("#e2b456"),
      new THREE.Color("#cba04a"),
      new THREE.Color("#d7a84a"),
      new THREE.Color("#e6c06a"),
      new THREE.Color("#c8963e"),
      new THREE.Color("#d0a35a"),
      new THREE.Color("#b89040"),
      new THREE.Color("#dbb25e"),
      new THREE.Color("#d4a84f"),
      new THREE.Color("#c9a055"),
      new THREE.Color("#e0bc6c")
    ];

    // -------------------------------------------------------
    // DEMO MODEL — the procedural constellation graph.
    // Always available, always the first thing painted.
    // -------------------------------------------------------
    function buildDemoModel() {
      const count = NODE_CAPACITY;
      const positions = fibonacciSphere(count, sphereRadius);

      const featuredLabels = [
        ["Garage Floors", "Service"],
        ["Commercial", "Service"],
        ["Conroe", "Service Area"],
        ["The Woodlands", "Service Area"],
        ["Polyaspartic", "Coating System"],
        ["Epoxy", "Coating System"],
        ["Surface Prep", "Preparation"],
        ["Grinding", "Preparation"],
        ["Moisture", "Condition"],
        ["Inspection", "Quality"],
        ["Installation", "Process"],
        ["Warranty", "Lifecycle"],
        ["Maintenance", "Lifecycle"],
        ["Failure Analysis", "Reasoning"],
        ["ASTM", "Standard"],
        ["ICRI", "Standard"],
        ["SIMIRON", "Manufacturer"],
        ["Products", "Product Layer"],
        ["SDS / TDS", "Documents"],
        ["Evidence", "Provenance"],
        ["Estimate", "Execution"],
        ["Appointment", "Execution"],
        ["JoJo", "Orchestration"],
        ["Photo Analysis", "Vision"],
        ["Trust Signals", "Entity Layer"],
        ["Expertise", "Entity Layer"]
      ];

      const featuredIndexes = [
        4, 11, 18, 26, 35, 44, 53, 63, 74, 84, 95, 106, 117,
        128, 139, 150, 161, 172, 183, 194, 204, 214, 224, 232, 236, 239
      ];

      const featuredSet = new Set(featuredIndexes);

      // Featured node → constellation id (aligned with labels above)
      const featuredConstellation = [
        0, 1, 8, 8, 3, 4, 2, 2, 2, 2, 2, 9, 9, 5, 6, 6, 7, 7, 7, 10, 10, 10, 10, 10, 10, 10
      ];

      const constellationOf = new Uint8Array(count);

      featuredIndexes.forEach((nodeIndex, i) => {
        constellationOf[nodeIndex] = featuredConstellation[i];
      });

      for (let i = 0; i < count; i++) {
        if (featuredSet.has(i)) continue;

        let best = 0;
        let bestD = Infinity;

        for (let c = 0; c < CONSTELLATION_COUNT; c++) {
          const d = positions[i].distanceTo(constellationAnchors[c]);
          if (d < bestD) {
            bestD = d;
            best = c;
          }
        }

        constellationOf[i] = best;
      }

      const centroids = Array.from({ length: CONSTELLATION_COUNT }, () => new THREE.Vector3());
      const centroidCounts = new Float32Array(CONSTELLATION_COUNT);

      for (let i = 0; i < count; i++) {
        const c = constellationOf[i];
        centroids[c].add(positions[i]);
        centroidCounts[c] += 1;
      }

      for (let c = 0; c < CONSTELLATION_COUNT; c++) {
        if (centroidCounts[c] > 0) {
          centroids[c]
            .multiplyScalar(1 / centroidCounts[c])
            .normalize()
            .multiplyScalar(sphereRadius);
        } else {
          centroids[c].copy(constellationAnchors[c]);
        }
      }

      // Soft pull + slight radial spacing variation (elegant, not obvious clusters).
      // Density-scale pull so large graphs do not pile into domain clumps.
      const densityScale = count > 140 ? Math.max(0.55, 140 / count) : 1;
      const constellationPull = 0.18 * densityScale;
      const scratchPull = new THREE.Vector3();

      for (let i = 0; i < count; i++) {
        const c = constellationOf[i];
        const radiusScale = 0.965 + (c % 4) * 0.011 + (featuredSet.has(i) ? 0.008 : 0);
        scratchPull.copy(positions[i]).lerp(centroids[c], constellationPull);
        scratchPull.normalize().multiplyScalar(sphereRadius * radiusScale);
        positions[i].copy(scratchPull);
      }

      // Decorative nearest-neighbour adjacency. Demo only — live data never
      // synthesizes edges, it only draws governed relationships.
      const edgePairs = [];
      const edgeStrengths = [];
      const maxDistance = 1.22;

      for (let i = 0; i < count; i++) {
        const nearest = [];
        const home = constellationOf[i];

        for (let j = 0; j < count; j++) {
          if (i === j) continue;

          const d = positions[i].distanceTo(positions[j]);
          const same = constellationOf[j] === home;
          const limit = same ? maxDistance : maxDistance * 0.9;

          if (d < limit) {
            // Same constellation reads closer → denser local edges; bridges stay sparser
            const effective = d * (same ? 0.78 : 1.12);
            nearest.push({ j, d, effective, same });
          }
        }

        nearest.sort((a, b) => a.effective - b.effective);

        const keep = 3;
        let sameKept = 0;
        let bridgeKept = 0;

        for (let n = 0; n < nearest.length && (sameKept + bridgeKept) < keep + 1; n++) {
          const { j, same } = nearest[n];
          if (same) {
            if (sameKept >= 3) continue;
            sameKept += 1;
          } else {
            if (bridgeKept >= 1) continue;
            bridgeKept += 1;
          }

          if (i < j) {
            let strength = same ? 0.72 : 0.42;
            if (featuredSet.has(i) || featuredSet.has(j)) {
              strength = Math.min(1, strength + 0.22);
            }
            edgePairs.push([i, j]);
            edgeStrengths.push(strength);
          }
        }
      }

      const accentNodes = new Set();
      const seedKeys = [];

      for (let i = 0; i < count; i++) {
        if (i % 29 === 0) accentNodes.add(i);
        seedKeys.push("atlas:demo:" + i);
      }

      return {
        mode: "demo",
        synthetic: true,
        count,
        entities: [],
        relationships: [],
        indexById: new Map(),
        positions,
        constellationOf,
        featuredIndexes,
        featuredLabels,
        edgePairs,
        edgeStrengths,
        edgeRelationships: [],
        pulsePairs: [
          [4, 95],
          [18, 139],
          [35, 161],
          [53, 194],
          [74, 128],
          [84, 183],
          [117, 204],
          [150, 224],
          [172, 232],
          [106, 214],
          [63, 236],
          [11, 239]
        ],
        accentNodes,
        seedKeys,
        meta: null
      };
    }

    const demoModel = buildDemoModel();

    // Live payloads are capped well below the demo edge count, so one allocation
    // comfortably covers every mode.
    const EDGE_CAPACITY = Math.max(demoModel.edgePairs.length, ATLAS_DATA.EDGE_CAP + 64);

    let activeModel = null;
    let graphMode = "demo";
    let nodeCount = demoModel.count;
    let edgeCount = 0;
    let edgeAwakenActive = false;

    const nodePositions = [];
    for (let i = 0; i < NODE_CAPACITY; i++) nodePositions.push(new THREE.Vector3());

    const featuredIndexes = [];
    const featuredSet = new Set();
    const constellationOf = new Uint8Array(NODE_CAPACITY);

    const nodeGeometry = new THREE.BufferGeometry();
    const positions = new Float32Array(NODE_CAPACITY * 3);
    const colors = new Float32Array(NODE_CAPACITY * 3);
    const sizes = new Float32Array(NODE_CAPACITY);
    const featuredFlags = new Float32Array(NODE_CAPACITY);
    const indices = new Float32Array(NODE_CAPACITY);
    const clusters = new Float32Array(NODE_CAPACITY);
    const nodeWake = new Float32Array(NODE_CAPACITY);

    for (let i = 0; i < NODE_CAPACITY; i++) indices[i] = i;

    nodeGeometry.setAttribute("position", new THREE.BufferAttribute(positions, 3));
    nodeGeometry.setAttribute("color", new THREE.BufferAttribute(colors, 3));
    nodeGeometry.setAttribute("aSize", new THREE.BufferAttribute(sizes, 1));
    nodeGeometry.setAttribute("aFeatured", new THREE.BufferAttribute(featuredFlags, 1));
    nodeGeometry.setAttribute("aIndex", new THREE.BufferAttribute(indices, 1));
    nodeGeometry.setAttribute("aCluster", new THREE.BufferAttribute(clusters, 1));
    nodeGeometry.setAttribute("aWake", new THREE.BufferAttribute(nodeWake, 1));

    const nodeMaterial = new THREE.ShaderMaterial({
      transparent: true,
      depthWrite: false,
      blending: THREE.AdditiveBlending,
      vertexColors: true,
      uniforms: {
        uPixelRatio: { value: renderer.getPixelRatio() },
        uTime: { value: 0 },
        uHoverIndex: { value: -1 },
        uThinkCluster: { value: -1 },
        uThinkClusterBoost: { value: 0 }
      },
      vertexShader: `
        attribute float aSize;
        attribute float aFeatured;
        attribute float aIndex;
        attribute float aCluster;
        attribute float aWake;
        varying vec3 vColor;
        varying float vFeatured;
        varying float vHover;
        varying float vWake;
        varying float vDepth;
        varying float vFront;
        uniform float uPixelRatio;
        uniform float uTime;
        uniform float uHoverIndex;
        uniform float uThinkCluster;
        uniform float uThinkClusterBoost;

        void main() {
          vColor = color;
          vFeatured = aFeatured;
          vWake = aWake;
          vHover = 1.0 - smoothstep(0.0, 0.55, abs(aIndex - uHoverIndex));

          float clusterBreath = 1.0 + sin(uTime * 0.48 + aCluster * 0.72) * (0.04 + aFeatured * 0.08);
          float thinkCluster = abs(aCluster - uThinkCluster) < 0.1 ? uThinkClusterBoost : 0.0;
          float living = 1.0 + sin(uTime * 0.33 + aIndex * 0.17) * 0.035;
          float wakeBoost = 1.0 + aWake * 0.65 + thinkCluster * 0.35;

          vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
          vDepth = -mvPosition.z;
          vFront = clamp((-normalize(mvPosition.xyz).z) * 0.5 + 0.5, 0.0, 1.0);

          float pulse = 0.9 + sin(uTime * 1.15 + position.x * 2.2 + position.y) * 0.12;
          float featuredBoost = 1.0 + aFeatured * 0.16;
          float hoverBoost = 1.0 + vHover * 0.5;

          gl_PointSize = aSize * pulse * featuredBoost * hoverBoost * clusterBreath * living * wakeBoost
            * uPixelRatio * (720.0 / -mvPosition.z);
          gl_Position = projectionMatrix * mvPosition;
        }
      `,
      fragmentShader: `
        varying vec3 vColor;
        varying float vFeatured;
        varying float vHover;
        varying float vWake;
        varying float vDepth;
        varying float vFront;

        void main() {
          vec2 p = gl_PointCoord - vec2(0.5);
          float d = length(p);
          if (d > 0.5) discard;

          float core = smoothstep(0.22, 0.0, d);
          float mid = smoothstep(0.38, 0.08, d);
          float glow = smoothstep(0.5, 0.12, d);
          float corona = smoothstep(0.5, 0.28, d) * (0.28 + vFeatured * 0.35 + vHover * 0.5 + vWake * 0.45);

          float depthDim = smoothstep(15.5, 7.2, vDepth);
          float key = mix(0.42, 1.18, vFront);
          float fill = mix(0.55, 1.0, depthDim);

          float alpha = (core * 1.0 + mid * 0.5 + glow * 0.28 + corona) * mix(0.38, 1.0, depthDim);
          alpha *= 1.0 + vWake * 0.35;
          vec3 tint = vColor * (1.08 + core * 0.45 + vHover * 0.3 + vWake * 0.25) * key * fill;
          tint += vec3(0.14, 0.09, 0.015) * vFeatured * glow * vFront;

          gl_FragColor = vec4(tint, min(1.0, alpha));
        }
      `
    });

    const nodes = new THREE.Points(nodeGeometry, nodeMaterial);
    graphGroup.add(nodes);

    // A near-empty graph keeps the original luminous line weight; a dense one
    // steps down so structure reads as depth instead of glare. The scene tunes
    // itself to whatever the payload actually resolves to.
    const EDGE_OPACITY_SPARSE = 0.175;
    // Dense floor raised so larger real edge sets stay readable (still eases down).
    const EDGE_OPACITY_DENSE = 0.085;
    // The demo graph is the reference for "sparse": it is the density the scene
    // was originally tuned against, so it and anything lighter render unchanged.
    const EDGE_DENSITY_FLOOR = Math.max(320, demoModel.edgePairs.length);
    const EDGE_DENSITY_CEILING = EDGE_DENSITY_FLOOR + 1400;

    function edgeOpacityFor(count) {
      if (count <= EDGE_DENSITY_FLOOR) return EDGE_OPACITY_SPARSE;
      if (count >= EDGE_DENSITY_CEILING) return EDGE_OPACITY_DENSE;

      const t =
        (count - EDGE_DENSITY_FLOOR) / (EDGE_DENSITY_CEILING - EDGE_DENSITY_FLOOR);

      // Ease out: the first few hundred edges cost the most visual headroom.
      const eased = 1 - Math.pow(1 - t, 2);
      return EDGE_OPACITY_SPARSE + (EDGE_OPACITY_DENSE - EDGE_OPACITY_SPARSE) * eased;
    }

    const edgePairs = [];
    const edgePositions = new Float32Array(EDGE_CAPACITY * 6);
    const edgeBaseStrength = new Float32Array(EDGE_CAPACITY * 2);
    const edgeAwaken = new Float32Array(EDGE_CAPACITY * 2);

    const edgeGeometry = new THREE.BufferGeometry();
    edgeGeometry.setAttribute(
      "position",
      new THREE.BufferAttribute(edgePositions, 3)
    );
    edgeGeometry.setAttribute(
      "aStrength",
      new THREE.BufferAttribute(edgeBaseStrength, 1)
    );
    edgeGeometry.setAttribute(
      "aAwaken",
      new THREE.BufferAttribute(edgeAwaken, 1)
    );

    const edgeMaterial = new THREE.ShaderMaterial({
      transparent: true,
      depthWrite: false,
      blending: THREE.AdditiveBlending,
      uniforms: {
        uTime: { value: 0 },
        uOpacity: { value: EDGE_OPACITY_SPARSE }
      },
      vertexShader: `
        attribute float aStrength;
        attribute float aAwaken;
        varying float vStrength;
        varying float vAwaken;
        varying float vDepth;
        varying float vFront;

        void main() {
          vStrength = aStrength;
          vAwaken = aAwaken;
          vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
          vDepth = -mvPosition.z;
          vFront = clamp((-normalize(mvPosition.xyz).z) * 0.5 + 0.5, 0.0, 1.0);
          gl_Position = projectionMatrix * mvPosition;
        }
      `,
      fragmentShader: `
        uniform float uTime;
        uniform float uOpacity;
        varying float vStrength;
        varying float vAwaken;
        varying float vDepth;
        varying float vFront;

        void main() {
          float depthFade = smoothstep(15.0, 7.0, vDepth);
          float key = mix(0.45, 1.15, vFront);
          float shimmer = 0.94 + sin(uTime * 0.45 + vDepth * 0.28) * 0.06;
          float awaken = 1.0 + vAwaken * 1.65;
          float alpha = uOpacity * vStrength * depthFade * shimmer * awaken * mix(0.55, 1.0, vFront);
          vec3 gold = vec3(0.84, 0.66, 0.29);
          vec3 hot = vec3(1.0, 0.86, 0.46);
          vec3 color = mix(gold, hot, max((vStrength - 0.55) * 1.5, vAwaken * 0.85));

          gl_FragColor = vec4(color * key * (0.8 + depthFade * 0.35), alpha);
        }
      `
    });

    const edges = new THREE.LineSegments(edgeGeometry, edgeMaterial);
    graphGroup.add(edges);

    const awakenTargets = new Float32Array(EDGE_CAPACITY);
    const neighbors = Array.from({ length: NODE_CAPACITY }, () => []);
    const edgeIndexByPair = new Map();
    const thoughtSeeds = [];
    const featuredThoughtSeeds = [];

    const orbitalGroup = new THREE.Group();
    graphGroup.add(orbitalGroup);

    function createOrbit(radiusX, radiusY, rotationX, rotationY, opacity) {
      const points = [];
      const segments = 260;

      for (let i = 0; i <= segments; i++) {
        const t = (i / segments) * Math.PI * 2;
        points.push(new THREE.Vector3(
          Math.cos(t) * radiusX,
          Math.sin(t) * radiusY,
          0
        ));
      }

      const geometry = new THREE.BufferGeometry().setFromPoints(points);

      const halo = new THREE.LineLoop(
        geometry,
        new THREE.LineBasicMaterial({
          color: 0xd6a84a,
          transparent: true,
          opacity: opacity * 0.35,
          blending: THREE.AdditiveBlending,
          depthWrite: false
        })
      );
      halo.rotation.x = rotationX;
      halo.rotation.y = rotationY;
      halo.scale.setScalar(1.012);
      orbitalGroup.add(halo);

      const line = new THREE.LineLoop(
        geometry.clone(),
        new THREE.LineBasicMaterial({
          color: 0xffd76a,
          transparent: true,
          opacity,
          blending: THREE.AdditiveBlending,
          depthWrite: false
        })
      );
      line.rotation.x = rotationX;
      line.rotation.y = rotationY;
      orbitalGroup.add(line);
    }

    createOrbit(4.85, 2.2, 0.25, 0.0, 0.26);
    createOrbit(4.7, 2.65, -0.55, 0.45, 0.19);
    createOrbit(4.55, 3.1, 0.72, -0.28, 0.14);
    createOrbit(4.35, 3.55, -0.18, 0.88, 0.12);

    const coreFresnelMaterial = new THREE.ShaderMaterial({
      transparent: true,
      depthWrite: false,
      blending: THREE.AdditiveBlending,
      uniforms: {
        uTime: { value: 0 },
        uThink: { value: 0 }
      },
      vertexShader: `
        varying vec3 vNormal;
        varying vec3 vView;

        void main() {
          vec4 worldPosition = modelMatrix * vec4(position, 1.0);
          vNormal = normalize(normalMatrix * normal);
          vView = normalize(cameraPosition - worldPosition.xyz);
          gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
        }
      `,
      fragmentShader: `
        uniform float uTime;
        uniform float uThink;
        varying vec3 vNormal;
        varying vec3 vView;

        void main() {
          float fresnel = pow(1.0 - max(dot(normalize(vNormal), normalize(vView)), 0.0), 2.55);
          float breath = 0.88 + sin(uTime * 0.85) * 0.12;
          float think = 1.0 + uThink * 0.55;
          vec3 gold = vec3(0.84, 0.66, 0.29);
          vec3 hot = vec3(1.0, 0.85, 0.45);
          vec3 color = mix(gold, hot, fresnel) * (0.4 + fresnel * 1.05) * breath * think;
          float alpha = (fresnel * 0.28 + 0.02) * (1.0 + uThink * 0.45);
          gl_FragColor = vec4(color, alpha);
        }
      `
    });

    const innerSphere = new THREE.Mesh(
      new THREE.SphereGeometry(1.08, 64, 64),
      coreFresnelMaterial
    );
    graphGroup.add(innerSphere);

    const coreGlow = new THREE.Mesh(
      new THREE.SphereGeometry(0.62, 48, 48),
      new THREE.MeshBasicMaterial({
        color: 0xffd76a,
        transparent: true,
        opacity: 0.07,
        blending: THREE.AdditiveBlending,
        depthWrite: false
      })
    );
    graphGroup.add(coreGlow);

    const coreNucleus = new THREE.Mesh(
      new THREE.SphereGeometry(0.28, 32, 32),
      new THREE.MeshBasicMaterial({
        color: 0xe8c56a,
        transparent: true,
        opacity: 0.12,
        blending: THREE.AdditiveBlending,
        depthWrite: false
      })
    );
    graphGroup.add(coreNucleus);

    const coreRingPoints = [];
    for (let i = 0; i <= 180; i++) {
      const t = (i / 180) * Math.PI * 2;
      coreRingPoints.push(new THREE.Vector3(Math.cos(t) * 1.42, 0, Math.sin(t) * 1.42));
    }

    const coreRing = new THREE.LineLoop(
      new THREE.BufferGeometry().setFromPoints(coreRingPoints),
      new THREE.LineBasicMaterial({
        color: 0xffd76a,
        transparent: true,
        opacity: 0.16,
        blending: THREE.AdditiveBlending,
        depthWrite: false
      })
    );
    coreRing.rotation.x = 0.4;
    graphGroup.add(coreRing);

    const rippleMesh = new THREE.Mesh(
      new THREE.SphereGeometry(1, 48, 24),
      new THREE.MeshBasicMaterial({
        color: 0xd6a84a,
        transparent: true,
        opacity: 0,
        blending: THREE.AdditiveBlending,
        depthWrite: false
      })
    );
    rippleMesh.visible = false;
    rippleMesh.scale.setScalar(0.85);
    graphGroup.add(rippleMesh);

    const particleCount = 750;
    const particlePositions = new Float32Array(particleCount * 3);
    const particleSizes = new Float32Array(particleCount);

    for (let i = 0; i < particleCount; i++) {
      const radius = 4.7 + Math.random() * 3.4;
      const theta = Math.random() * Math.PI * 2;
      const phi = Math.acos(2 * Math.random() - 1);

      particlePositions[i * 3] = radius * Math.sin(phi) * Math.cos(theta);
      particlePositions[i * 3 + 1] = radius * Math.cos(phi);
      particlePositions[i * 3 + 2] = radius * Math.sin(phi) * Math.sin(theta);
      particleSizes[i] = 0.035 + Math.random() * 0.05;
    }

    const particleGeometry = new THREE.BufferGeometry();
    particleGeometry.setAttribute(
      "position",
      new THREE.BufferAttribute(particlePositions, 3)
    );
    particleGeometry.setAttribute(
      "aSize",
      new THREE.BufferAttribute(particleSizes, 1)
    );

    const particleMaterial = new THREE.ShaderMaterial({
      transparent: true,
      depthWrite: false,
      blending: THREE.AdditiveBlending,
      uniforms: {
        uPixelRatio: { value: renderer.getPixelRatio() },
        uTime: { value: 0 }
      },
      vertexShader: `
        attribute float aSize;
        uniform float uPixelRatio;
        uniform float uTime;
        varying float vAlpha;

        void main() {
          vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
          float twinkle = 0.85 + sin(uTime * 0.9 + position.x * 3.0 + position.z) * 0.15;
          vAlpha = mix(0.42, 1.0, smoothstep(20.0, 6.5, -mvPosition.z)) * twinkle;
          gl_PointSize = aSize * twinkle * uPixelRatio * (840.0 / -mvPosition.z);
          gl_Position = projectionMatrix * mvPosition;
        }
      `,
      fragmentShader: `
        varying float vAlpha;

        void main() {
          vec2 p = gl_PointCoord - vec2(0.5);
          float d = length(p);
          if (d > 0.5) discard;
          float glow = smoothstep(0.5, 0.0, d);
          gl_FragColor = vec4(vec3(0.84, 0.68, 0.32) * glow, glow * 0.5 * vAlpha);
        }
      `
    });

    const particles = new THREE.Points(particleGeometry, particleMaterial);
    scene.add(particles);

    const pulseCurves = [];
    const pulseMeshes = [];
    const pulseTrails = [];
    const pulseRibbons = [];
    const pulsePoint = new THREE.Vector3();
    const trailPoint = new THREE.Vector3();

    function easeInOutCubic(t) {
      return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
    }

    function easeOutQuad(t) {
      return 1 - (1 - t) * (1 - t);
    }

    // Pulse slots are allocated once. Each mode re-points them at its own paths:
    // decorative long-range arcs in demo, governed relationships when live.
    const PULSE_SLOTS = ATLAS_DATA.PULSE_MAX;

    function makePulseSlot() {
      const curve = new THREE.QuadraticBezierCurve3(
        new THREE.Vector3(),
        new THREE.Vector3(),
        new THREE.Vector3()
      );
      pulseCurves.push(curve);

      const ribbon = new THREE.Line(
        new THREE.BufferGeometry().setFromPoints(curve.getPoints(64)),
        new THREE.LineBasicMaterial({
          color: 0xffd76a,
          transparent: true,
          opacity: 0.03,
          blending: THREE.AdditiveBlending,
          depthWrite: false
        })
      );
      pulseRibbons.push(ribbon);
      graphGroup.add(ribbon);

      const pulse = new THREE.Mesh(
        new THREE.SphereGeometry(0.055, 16, 16),
        new THREE.MeshBasicMaterial({
          color: 0xffd76a,
          transparent: true,
          opacity: 0,
          blending: THREE.AdditiveBlending,
          depthWrite: false
        })
      );

      pulse.userData.startIndex = -1;
      pulse.userData.endIndex = -1;
      pulse.userData.enabled = false;
      pulse.userData.phase = "idle";
      pulse.userData.phaseT = 0;
      pulse.userData.progress = 0;
      pulse.userData.hero = false;
      pulse.userData.anticipateDur = 0.5;
      pulse.userData.travelDur = 2.7;
      pulse.userData.fadeDur = 0.85;
      pulse.userData.handoffFired = false;
      pulseMeshes.push(pulse);
      graphGroup.add(pulse);

      const trails = [];
      for (let t = 0; t < 2; t++) {
        const ghost = new THREE.Mesh(
          new THREE.SphereGeometry(0.04, 12, 12),
          new THREE.MeshBasicMaterial({
            color: 0xd6a84a,
            transparent: true,
            opacity: 0,
            blending: THREE.AdditiveBlending,
            depthWrite: false
          })
        );
        ghost.userData.lag = 0.055 + t * 0.05;
        trails.push(ghost);
        graphGroup.add(ghost);
      }
      pulseTrails.push(trails);
    }

    for (let i = 0; i < PULSE_SLOTS; i++) makePulseSlot();

    function assignPulsePaths(pairs) {
      const list = Array.isArray(pairs) ? pairs : [];

      for (let i = 0; i < pulseMeshes.length; i++) {
        const pulse = pulseMeshes[i];
        const data = pulse.userData;
        const curve = pulseCurves[i];
        const ribbon = pulseRibbons[i];

        data.phase = "idle";
        data.phaseT = 0;
        data.progress = 0;
        data.hero = false;
        data.handoffFired = false;
        pulse.visible = false;
        pulse.material.opacity = 0;

        pulseTrails[i].forEach((ghost) => {
          ghost.visible = false;
          ghost.material.opacity = 0;
        });

        const pair = list[i];
        const a = pair ? pair[0] : -1;
        const b = pair ? pair[1] : -1;
        const usable = a >= 0 && b >= 0 && a < nodeCount && b < nodeCount && a !== b;

        if (!usable) {
          data.enabled = false;
          data.startIndex = -1;
          data.endIndex = -1;
          ribbon.visible = false;
          ribbon.material.opacity = 0;
          continue;
        }

        data.enabled = true;
        data.startIndex = a;
        data.endIndex = b;

        curve.v0.copy(nodePositions[a]);
        curve.v2.copy(nodePositions[b]);
        curve.v1
          .copy(nodePositions[a])
          .add(nodePositions[b])
          .multiplyScalar(0.5)
          .normalize()
          .multiplyScalar(sphereRadius + 0.6);

        ribbon.geometry.setFromPoints(curve.getPoints(64));
        ribbon.visible = true;
        ribbon.material.opacity = 0.03;
      }
    }

    function startPulseJourney(index, hero) {
      const pulse = pulseMeshes[index];
      if (!pulse || !pulse.userData.enabled || pulse.userData.phase !== "idle") return false;

      pulse.userData.phase = "anticipate";
      pulse.userData.phaseT = 0;
      pulse.userData.progress = 0;
      pulse.userData.hero = Boolean(hero);
      pulse.userData.handoffFired = false;
      pulse.userData.anticipateDur = hero ? 0.65 : 0.42 + Math.random() * 0.18;
      pulse.userData.travelDur = hero ? 3.1 + Math.random() * 0.5 : 2.4 + Math.random() * 0.7;
      pulse.userData.fadeDur = hero ? 1.0 : 0.7 + Math.random() * 0.25;
      return true;
    }

    function boostNode(index, amount) {
      if (index < 0 || index >= nodeCount) return;
      nodeWake[index] = Math.min(1, Math.max(nodeWake[index], amount));
    }

    function boostEdge(edgeIndex, amount) {
      if (edgeIndex < 0 || edgeIndex >= edgeCount) return;
      awakenTargets[edgeIndex] = Math.min(1, Math.max(awakenTargets[edgeIndex], amount));
      edgeAwakenActive = true;
    }

    function boostEdgeBetween(a, b, amount) {
      const key = a < b ? `${a}:${b}` : `${b}:${a}`;
      const edgeIndex = edgeIndexByPair.get(key);
      if (edgeIndex !== undefined) boostEdge(edgeIndex, amount);
    }

    function signalNeighbors(nodeIndex, strength, count) {
      const list = neighbors[nodeIndex];
      if (!list || !list.length) return;

      const picks = Math.min(count, list.length);
      for (let i = 0; i < picks; i++) {
        const entry = list[i];
        boostNode(entry.node, strength * (0.7 - i * 0.15));
        boostEdge(entry.edge, strength * (0.75 - i * 0.12));
      }
    }

    // -------------------------------------------------------
    // THOUGHT SYSTEM — one living idea at a time
    // -------------------------------------------------------
    const thoughtMesh = new THREE.Mesh(
      new THREE.SphereGeometry(0.07, 20, 20),
      new THREE.MeshBasicMaterial({
        color: 0xffe08a,
        transparent: true,
        opacity: 0,
        blending: THREE.AdditiveBlending,
        depthWrite: false
      })
    );
    thoughtMesh.visible = false;
    graphGroup.add(thoughtMesh);

    const thoughtTrails = [];
    for (let t = 0; t < 3; t++) {
      const ghost = new THREE.Mesh(
        new THREE.SphereGeometry(0.045 - t * 0.008, 12, 12),
        new THREE.MeshBasicMaterial({
          color: 0xd6a84a,
          transparent: true,
          opacity: 0,
          blending: THREE.AdditiveBlending,
          depthWrite: false
        })
      );
      ghost.visible = false;
      ghost.userData.lag = 0.04 + t * 0.035;
      thoughtTrails.push(ghost);
      graphGroup.add(ghost);
    }

    const thoughtCurve = new THREE.QuadraticBezierCurve3(
      new THREE.Vector3(),
      new THREE.Vector3(),
      new THREE.Vector3()
    );
    const thoughtPos = new THREE.Vector3();
    const thoughtTrailPos = new THREE.Vector3();
    const thoughtDir = new THREE.Vector3();
    const thoughtTmp = new THREE.Vector3();

    const thought = {
      active: false,
      phase: "idle",
      phaseT: 0,
      progress: 0,
      currentNode: -1,
      prevNode: -1,
      nextNode: -1,
      hopsDone: 0,
      localHops: 0,
      hopsTarget: 6,
      homeConstellation: 0,
      bridgeMode: false,
      willVisitCore: false,
      coreVisited: false,
      fromCore: false,
      coreBoost: 0,
      opacity: 0,
      pauseDur: 0.65,
      nextAt: prefersReducedMotion ? Number.POSITIVE_INFINITY : 6 + Math.random() * 6,
      visited: new Set()
    };

    function hideThoughtVisuals() {
      thoughtMesh.visible = false;
      thoughtMesh.material.opacity = 0;
      thoughtTrails.forEach((ghost) => {
        ghost.visible = false;
        ghost.material.opacity = 0;
      });
    }

    function setThoughtCurve(fromIndex, toIndex) {
      const start = nodePositions[fromIndex];
      const end = nodePositions[toIndex];
      thoughtCurve.v0.copy(start);
      thoughtCurve.v2.copy(end);
      thoughtCurve.v1.copy(start).add(end).multiplyScalar(0.5);
      thoughtCurve.v1.normalize().multiplyScalar(sphereRadius + 0.35);
    }

    function setThoughtCurveToCore(fromIndex) {
      const start = nodePositions[fromIndex];
      thoughtCurve.v0.copy(start);
      thoughtCurve.v2.set(0, 0, 0);
      thoughtCurve.v1.copy(start).multiplyScalar(0.45);
    }

    function setThoughtCurveFromCore(toIndex) {
      const end = nodePositions[toIndex];
      thoughtCurve.v0.set(0, 0, 0);
      thoughtCurve.v2.copy(end);
      thoughtCurve.v1.copy(end).multiplyScalar(0.45);
    }

    function chooseThoughtNext(fromIndex, prevIndex) {
      if (typeof query !== "undefined" && query && query.thoughtGuided && Array.isArray(thought.guidedIndexes)) {
        const cursor = thought.guidedCursor || 0;
        const next = thought.guidedIndexes[cursor + 1];
        if (Number.isInteger(next) && next >= 0) {
          thought.guidedCursor = cursor + 1;
          const step = thought.guidedSteps && thought.guidedSteps[cursor];
          if (step && step.hasRenderedEdge) {
            boostEdgeBetween(fromIndex, next, 0.75);
          }
          if (step && typeof showTransition === "function") {
            showTransition(
              (step.fromTitle || "") + " · " + (step.predicateLabel || "") + " · " + (step.toTitle || ""),
              0.9
            );
          }
          return next;
        }
        return -1;
      }

      const list = neighbors[fromIndex];
      if (!list || !list.length) return -1;

      const home = thought.homeConstellation;
      const localHops = thought.localHops || 0;
      const preferBridge =
        thought.bridgeMode &&
        localHops >= 2 &&
        (localHops >= 4 || Math.random() < 0.28);

      let best = -1;
      let bestScore = -Infinity;

      for (let i = 0; i < list.length; i++) {
        const candidate = list[i].node;
        if (candidate === prevIndex && list.length > 1) continue;

        const same = constellationOf[candidate] === home;
        let score = Math.random() * 0.3;

        if (!thought.visited.has(candidate)) score += 1.15;
        if (featuredSet.has(candidate)) score += 0.4;
        if (candidate === prevIndex) score -= 1.5;

        if (same) {
          score += preferBridge ? 0.35 : 1.85;
        } else {
          score += preferBridge ? 1.55 : -1.25;
        }

        if (prevIndex >= 0) {
          thoughtDir.copy(nodePositions[fromIndex]).sub(nodePositions[prevIndex]).normalize();
          thoughtTmp.copy(nodePositions[candidate]).sub(nodePositions[fromIndex]).normalize();
          score += Math.max(0, thoughtDir.dot(thoughtTmp)) * 0.55;
        }

        if (score > bestScore) {
          bestScore = score;
          best = candidate;
        }
      }

      if (best < 0) best = list[Math.floor(Math.random() * list.length)].node;
      return best;
    }

    function beginThought(elapsed) {
      if (thought.active || think.active) {
        thought.nextAt = elapsed + 2 + Math.random() * 3;
        return;
      }

      // Only ever start on a node that actually has somewhere to go. In live mode
      // that means a node carrying a real governed relationship.
      if (!thoughtSeeds.length) {
        thought.nextAt = elapsed + 6 + Math.random() * 4;
        return;
      }

      let start = thoughtSeeds[Math.floor(Math.random() * thoughtSeeds.length)];
      if (featuredThoughtSeeds.length && Math.random() < 0.62) {
        start = featuredThoughtSeeds[Math.floor(Math.random() * featuredThoughtSeeds.length)];
      }

      const list = neighbors[start];
      if (!list || !list.length) {
        thought.nextAt = elapsed + 3;
        return;
      }

      thought.active = true;
      thought.phase = "form";
      thought.phaseT = 0;
      thought.progress = 0;
      thought.currentNode = start;
      thought.prevNode = -1;
      thought.nextNode = -1;
      thought.hopsDone = 0;
      thought.localHops = 0;
      thought.hopsTarget = 4 + Math.floor(Math.random() * 9);
      thought.homeConstellation = constellationOf[start];
      thought.bridgeMode = Math.random() < 0.4;
      thought.willVisitCore = constellationOf[start] === 10
        ? Math.random() < 0.55
        : Math.random() < 0.22;
      thought.coreVisited = false;
      thought.fromCore = false;
      thought.coreBoost = 0;
      thought.opacity = 0;
      thought.visited = new Set([start]);

      thoughtMesh.position.copy(nodePositions[start]);
      thoughtMesh.visible = true;
      thoughtMesh.scale.setScalar(0.35);
      boostNode(start, 0.5);
      PKG.emit("thought", {
        phase: "form",
        node: start,
        constellation: constellationNames[thought.homeConstellation]
      });
    }

    function acknowledgeCoreFromThought() {
      thought.coreBoost = 1;
      if (coreMark && !coreMark.classList.contains("is-thinking")) {
        coreMark.classList.add("is-aware");
      }
      if (!think.active && rippleMesh) {
        rippleMesh.visible = true;
        rippleMesh.scale.setScalar(0.95);
        rippleMesh.material.opacity = 0.055;
        rippleMesh.userData.thoughtRipple = 1;
      }
      PKG.emit("thought", { phase: "core" });
    }

    function updateThought(delta, elapsed, motion) {
      if (!motion) {
        if (thought.active) {
          thought.active = false;
          thought.phase = "idle";
          hideThoughtVisuals();
          if (coreMark) coreMark.classList.remove("is-aware");
        }
        return;
      }

      if (!thought.active) {
        if (elapsed >= thought.nextAt && !think.active) {
          beginThought(elapsed);
        }
        if (thought.coreBoost > 0) {
          thought.coreBoost = Math.max(0, thought.coreBoost - delta * 0.85);
          if (thought.coreBoost < 0.05 && coreMark) {
            coreMark.classList.remove("is-aware");
          }
        }
        if (rippleMesh && rippleMesh.userData.thoughtRipple) {
          rippleMesh.userData.thoughtRipple = Math.max(0, rippleMesh.userData.thoughtRipple - delta * 0.55);
          const rt = rippleMesh.userData.thoughtRipple;
          if (rt > 0.01 && !think.active) {
            rippleMesh.visible = true;
            rippleMesh.scale.setScalar(0.95 + (1 - rt) * 2.8);
            rippleMesh.material.opacity = rt * 0.05;
          } else if (!think.active) {
            rippleMesh.userData.thoughtRipple = 0;
            if (!think.active) {
              rippleMesh.visible = false;
              rippleMesh.material.opacity = 0;
            }
          }
        }
        return;
      }

      thought.phaseT += delta;
      const phase = thought.phase;

      if (phase === "form") {
        const t = Math.min(1, thought.phaseT / 0.85);
        const e = easeOutQuad(t);
        thought.opacity = e;
        thoughtMesh.scale.setScalar(0.35 + e * 0.75);
        thoughtMesh.material.opacity = 0.15 + e * 0.75;
        thoughtMesh.position.copy(nodePositions[thought.currentNode]);
        boostNode(thought.currentNode, 0.35 + e * 0.3);

        if (t >= 1) {
          thought.phase = "hesitate";
          thought.phaseT = 0;
        }
      } else if (phase === "hesitate") {
        const hold = 0.55 + Math.random() * 0.05;
        const pulse = 0.9 + Math.sin(thought.phaseT * 3.2) * 0.08;
        thoughtMesh.scale.setScalar(pulse);
        thoughtMesh.material.opacity = 0.82 + Math.sin(thought.phaseT * 2.4) * 0.08;
        thoughtMesh.position.copy(nodePositions[thought.currentNode]);

        if (thought.phaseT >= 0.7 + (thought.hopsDone === 0 ? 0.35 : 0)) {
          const shouldCore =
            thought.willVisitCore &&
            !thought.coreVisited &&
            thought.hopsDone >= 2 &&
            thought.hopsDone <= thought.hopsTarget - 2 &&
            Math.random() < 0.42;

          if (shouldCore) {
            thought.phase = "coreIn";
            thought.phaseT = 0;
            thought.progress = 0;
            setThoughtCurveToCore(thought.currentNode);
            thought.fromCore = false;
          } else if (thought.hopsDone >= thought.hopsTarget) {
            thought.phase = "dissolve";
            thought.phaseT = 0;
          } else {
            const next = chooseThoughtNext(thought.currentNode, thought.prevNode);
            if (next < 0) {
              thought.phase = "dissolve";
              thought.phaseT = 0;
            } else {
              thought.nextNode = next;
              setThoughtCurve(thought.currentNode, next);
              boostEdgeBetween(thought.currentNode, next, 0.4);
              thought.phase = "travel";
              thought.phaseT = 0;
              thought.progress = 0;
            }
          }
        }
      } else if (phase === "travel" || phase === "coreIn" || phase === "coreOut") {
        const dur = phase === "travel" ? 1.55 + Math.random() * 0.05 : 1.85;
        const t = Math.min(1, thought.phaseT / (phase === "coreIn" || phase === "coreOut" ? 1.9 : 1.65));
        thought.progress = easeInOutCubic(t);
        thoughtCurve.getPoint(thought.progress, thoughtPos);
        thoughtMesh.position.copy(thoughtPos);

        const swell = 0.85 + Math.sin(thought.progress * Math.PI) * 0.2;
        thoughtMesh.scale.setScalar(swell);
        thoughtMesh.material.opacity = 0.75 + swell * 0.15;

        thoughtTrails.forEach((ghost, g) => {
          const tp = Math.max(0, thought.progress - ghost.userData.lag * (1 + g * 0.25));
          thoughtCurve.getPoint(tp, thoughtTrailPos);
          ghost.position.copy(thoughtTrailPos);
          ghost.visible = tp > 0.01;
          ghost.scale.setScalar(0.55 - g * 0.08);
          ghost.material.opacity = thoughtMesh.material.opacity * (0.28 - g * 0.07);
        });

        if (phase === "travel" && thought.progress > 0.2 && thought.progress < 0.35) {
          boostEdgeBetween(thought.currentNode, thought.nextNode, 0.55);
        }

        if (t >= 1) {
          if (phase === "coreIn") {
            thought.coreVisited = true;
            acknowledgeCoreFromThought();
            thought.phase = "coreHold";
            thought.phaseT = 0;
          } else if (phase === "coreOut") {
            thought.prevNode = thought.currentNode;
            thought.currentNode = thought.nextNode;
            thought.visited.add(thought.currentNode);
            thought.hopsDone += 1;
            if (constellationOf[thought.currentNode] === thought.homeConstellation) {
              thought.localHops += 1;
            } else {
              thought.homeConstellation = constellationOf[thought.currentNode];
              thought.localHops = 1;
              thought.bridgeMode = Math.random() < 0.35;
            }
            boostNode(thought.currentNode, 0.7);
            signalNeighbors(thought.currentNode, 0.35, 2);
            thought.phase = Math.random() < 0.4 ? "pause" : "hesitate";
            thought.phaseT = 0;
            thought.pauseDur = 0.5 + Math.random() * 0.45;
            thought.fromCore = false;
          } else {
            thought.prevNode = thought.currentNode;
            thought.currentNode = thought.nextNode;
            thought.visited.add(thought.currentNode);
            thought.hopsDone += 1;
            if (constellationOf[thought.currentNode] === thought.homeConstellation) {
              thought.localHops += 1;
            } else {
              thought.homeConstellation = constellationOf[thought.currentNode];
              thought.localHops = 1;
              thought.bridgeMode = Math.random() < 0.35;
            }
            boostNode(thought.currentNode, 0.72);
            signalNeighbors(thought.currentNode, 0.4, 2);
            boostEdgeBetween(thought.prevNode, thought.currentNode, 0.65);
            thought.phase = Math.random() < 0.45 ? "pause" : "hesitate";
            thought.phaseT = 0;
            thought.pauseDur = 0.5 + Math.random() * 0.55;
          }
        }
      } else if (phase === "coreHold") {
        thoughtMesh.position.set(0, 0, 0);
        thoughtMesh.scale.setScalar(0.7 + Math.sin(thought.phaseT * 2.5) * 0.06);
        thoughtMesh.material.opacity = 0.7;
        thought.coreBoost = Math.max(thought.coreBoost, 0.85 - thought.phaseT * 0.15);

        if (thought.phaseT >= 0.85) {
          const next = chooseThoughtNext(thought.currentNode, thought.prevNode);
          if (next < 0) {
            thought.phase = "dissolve";
            thought.phaseT = 0;
          } else {
            thought.nextNode = next;
            setThoughtCurveFromCore(next);
            thought.phase = "coreOut";
            thought.phaseT = 0;
            thought.progress = 0;
            thought.fromCore = true;
          }
        }
      } else if (phase === "pause") {
        thoughtMesh.position.copy(nodePositions[thought.currentNode]);
        thoughtMesh.scale.setScalar(0.88 + Math.sin(thought.phaseT * 2.8) * 0.05);
        thoughtMesh.material.opacity = 0.78;
        thoughtTrails.forEach((ghost) => {
          ghost.material.opacity *= Math.max(0, 1 - delta * 2.2);
          if (ghost.material.opacity < 0.02) ghost.visible = false;
        });

        if (thought.phaseT >= (thought.pauseDur || 0.65)) {
          thought.phase = "hesitate";
          thought.phaseT = 0;
        }
      } else if (phase === "dissolve") {
        const t = Math.min(1, thought.phaseT / 1.4);
        const fade = 1 - easeInOutCubic(t);
        thoughtMesh.position.copy(nodePositions[thought.currentNode]);
        thoughtMesh.scale.setScalar(0.75 * fade);
        thoughtMesh.material.opacity = 0.7 * fade;
        thoughtTrails.forEach((ghost) => {
          ghost.material.opacity *= Math.max(0, 1 - delta * 2.5);
          if (ghost.material.opacity < 0.02) ghost.visible = false;
        });

        if (t >= 1) {
          thought.active = false;
          thought.phase = "idle";
          hideThoughtVisuals();
          thought.nextAt = elapsed + 8 + Math.random() * 12;
          if (coreMark) coreMark.classList.remove("is-aware");
          PKG.emit("thought", { phase: "idle" });
        }
      }

      if (thought.coreBoost > 0 && phase !== "coreHold" && phase !== "coreIn") {
        thought.coreBoost = Math.max(0, thought.coreBoost - delta * 0.65);
        if (thought.coreBoost < 0.08 && coreMark && !think.active) {
          coreMark.classList.remove("is-aware");
        }
      }
    }

    const labels = [];
    const labelByIndex = new Map();

    function rebuildLabels(model) {
      labels.length = 0;
      labelByIndex.clear();
      labelsLayer.textContent = "";

      model.featuredIndexes.forEach((nodeIndex, i) => {
        if (nodeIndex < 0 || nodeIndex >= nodeCount) return;

        const pair = model.featuredLabels[i] || [];
        const name = pair[0] || "";
        const type = pair[1] || "";
        if (!name) return;

        const element = document.createElement("div");
        element.className = "pkg1__label";

        const nameElement = document.createElement("span");
        nameElement.textContent = name;

        const typeElement = document.createElement("small");
        typeElement.textContent = type;

        element.appendChild(nameElement);
        element.appendChild(typeElement);
        labelsLayer.appendChild(element);

        const entity = model.entities[nodeIndex] || null;

        const label = {
          index: nodeIndex,
          element,
          name,
          type,
          entityId: entity ? entity.id : null
        };

        labels.push(label);
        labelByIndex.set(nodeIndex, label);
      });
    }

    const raycaster = new THREE.Raycaster();
    raycaster.params.Points.threshold = 0.18;
    const pointer = new THREE.Vector2(999, 999);

    function getPointer(event) {
      const rect = canvas.getBoundingClientRect();

      pointer.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;
      pointer.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
    }

    canvas.addEventListener("pointermove", getPointer, { passive: true });

    canvas.addEventListener("pointerleave", () => {
      pointer.set(999, 999);
      nodeMaterial.uniforms.uHoverIndex.value = -1;
      PKG.hoveredNode = null;
      labels.forEach(({ element }) => element.classList.remove("is-hot"));
    }, { passive: true });

    controls.addEventListener("start", () => {
      controls.autoRotate = false;
      setText("pkg1-rotation-label", "MANUAL");
    });

    let autoResumeTimer;

    controls.addEventListener("end", () => {
      window.clearTimeout(autoResumeTimer);

      autoResumeTimer = window.setTimeout(() => {
        if (!prefersReducedMotion) {
          controls.autoRotate = true;
          setText("pkg1-rotation-label", "AUTONOMOUS");
        }
      }, 4200);
    });

    let contextLost = false;

    canvas.addEventListener("webglcontextlost", (event) => {
      event.preventDefault();
      contextLost = true;
      setText("pkg1-network-label", "CONTEXT RECOVERING");
    }, false);

    canvas.addEventListener("webglcontextrestored", () => {
      contextLost = false;
      resize();
      setText("pkg1-network-label", NETWORK_LABELS[graphMode] || NETWORK_LABELS.demo);
    }, false);

    const clock = new THREE.Clock();
    const projected = new THREE.Vector3();
    let frameId = 0;
    let resizeTimer = 0;

    function updateLabels() {
      labels.forEach(({ index, element }) => {
        projected.copy(nodePositions[index]);
        projected.applyMatrix4(graphGroup.matrixWorld);
        projected.project(camera);

        const x = (projected.x * 0.5 + 0.5) * viewport.clientWidth;
        const y = (-projected.y * 0.5 + 0.5) * viewport.clientHeight;

        const distanceFromCenter = Math.sqrt(projected.x ** 2 + projected.y ** 2);
        const frontFactor = 1 - Math.min(1, Math.abs(projected.z));
        const visible = projected.z < 1 && distanceFromCenter < 0.92;
        const isHot = PKG.hoveredNode === index;
        const thinkBoost = thinkLabelBoost[index] || 0;
        const isThinking = thinkBoost > 0.18;

        element.classList.toggle("is-thinking", isThinking && !isHot);

        element.style.left = `${x}px`;
        element.style.top = `${y}px`;
        element.style.opacity = visible
          ? String(Math.max(
            isHot ? 0.72 : 0.18,
            frontFactor + (isHot ? 0.25 : 0) + thinkBoost * 0.45
          ))
          : "0";
        element.style.transform = `translate(-50%, -50%) scale(${0.78 + frontFactor * 0.26 + (isHot ? 0.08 : 0) + thinkBoost * 0.06})`;
      });
    }

    const coreMark = root.querySelector(".pkg1__core-mark");
    const thinkLabelBoost = new Float32Array(NODE_CAPACITY);
    const thinkFocusNodes = [];

    const think = {
      active: false,
      phase: "idle",
      age: 0,
      pulseIndex: -1,
      clusterId: -1,
      coreBoost: 0,
      rippleT: 0,
      nextAt: prefersReducedMotion ? Number.POSITIVE_INFINITY : 10 + Math.random() * 6
    };

    let nextAmbientJourneyAt = prefersReducedMotion ? Number.POSITIVE_INFINITY : 2.5;
    let nextNodeSignalAt = prefersReducedMotion ? Number.POSITIVE_INFINITY : 6 + Math.random() * 4;
    let nextSoftEdgeAt = prefersReducedMotion ? Number.POSITIVE_INFINITY : 3.5;

    function beginThinkingMoment(elapsed) {
      const idlePulses = [];
      for (let i = 0; i < pulseMeshes.length; i++) {
        const data = pulseMeshes[i].userData;
        if (data.enabled && data.phase === "idle") idlePulses.push(i);
      }
      if (!idlePulses.length) {
        think.nextAt = elapsed + 4 + Math.random() * 3;
        return;
      }

      const pulseIndex = idlePulses[Math.floor(Math.random() * idlePulses.length)];
      const pulse = pulseMeshes[pulseIndex];
      const start = pulse.userData.startIndex;
      const end = pulse.userData.endIndex;

      think.active = true;
      think.phase = "begin";
      think.age = 0;
      think.pulseIndex = pulseIndex;
      think.clusterId = clusters[start];
      think.coreBoost = 0;
      think.rippleT = 0;
      thinkFocusNodes.length = 0;
      thinkFocusNodes.push(start, end);

      (neighbors[start] || []).slice(0, 3).forEach(({ node }) => {
        if (thinkFocusNodes.indexOf(node) === -1) thinkFocusNodes.push(node);
      });

      startPulseJourney(pulseIndex, true);
      boostNode(start, 0.55);
      boostEdgeBetween(start, end, 0.35);

      if (coreMark) coreMark.classList.add("is-thinking");
      PKG.emit("thinking", { phase: "begin", pulseIndex, start, end });
    }

    function updateThinkingMoment(delta) {
      if (!think.active) return;

      think.age += delta;
      const age = think.age;
      const pulse = pulseMeshes[think.pulseIndex];

      if (age < 1.15) {
        think.phase = "begin";
        think.coreBoost = easeOutQuad(Math.min(1, age / 1.15)) * 0.7;
        think.rippleT = 0;
        nodeMaterial.uniforms.uThinkClusterBoost.value = think.coreBoost * 0.55;
      } else if (age < 5.6) {
        think.phase = "develop";
        const developT = (age - 1.15) / 4.45;
        think.coreBoost = 0.7 + Math.sin(developT * Math.PI) * 0.18;
        think.rippleT = easeOutQuad(Math.min(1, (age - 1.15) / 3.4));

        if (age > 1.35 && age < 1.35 + delta) {
          signalNeighbors(pulse.userData.startIndex, 0.7, 2);
        }
        if (age > 2.1 && age < 2.1 + delta) {
          boostNode(pulse.userData.startIndex, 0.45);
          (neighbors[pulse.userData.startIndex] || []).slice(0, 2).forEach(({ node, edge }, i) => {
            boostNode(node, 0.55 - i * 0.12);
            boostEdge(edge, 0.6 - i * 0.1);
            thinkLabelBoost[node] = Math.max(thinkLabelBoost[node], 0.7);
          });
        }
        if (age > 3.2 && age < 3.2 + delta) {
          boostNode(pulse.userData.endIndex, 0.5);
          signalNeighbors(pulse.userData.endIndex, 0.55, 2);
        }

        thinkFocusNodes.forEach((nodeIndex) => {
          thinkLabelBoost[nodeIndex] = Math.max(thinkLabelBoost[nodeIndex], 0.55 + developT * 0.35);
        });

        nodeMaterial.uniforms.uThinkClusterBoost.value = 0.35 + developT * 0.45;
      } else if (age < 8.2) {
        think.phase = "resolve";
        const resolveT = (age - 5.6) / 2.6;
        const fade = 1 - easeInOutCubic(Math.min(1, resolveT));
        think.coreBoost = 0.55 * fade;
        think.rippleT = Math.min(1, think.rippleT + delta * 0.15);
        nodeMaterial.uniforms.uThinkClusterBoost.value = 0.45 * fade;

        for (let i = 0; i < nodeCount; i++) {
          thinkLabelBoost[i] *= Math.max(0, 1 - delta * 1.4);
        }
      } else {
        think.active = false;
        think.phase = "idle";
        think.coreBoost = 0;
        think.rippleT = 0;
        think.clusterId = -1;
        think.pulseIndex = -1;
        think.nextAt = clock.elapsedTime + 14 + Math.random() * 14;
        nodeMaterial.uniforms.uThinkCluster.value = -1;
        nodeMaterial.uniforms.uThinkClusterBoost.value = 0;
        if (coreMark) coreMark.classList.remove("is-thinking");
        rippleMesh.visible = false;
        rippleMesh.material.opacity = 0;
        PKG.emit("thinking", { phase: "idle" });
        return;
      }

      nodeMaterial.uniforms.uThinkCluster.value = think.clusterId;
      coreFresnelMaterial.uniforms.uThink.value = think.coreBoost;

      if (think.rippleT > 0.02 && think.rippleT < 0.98) {
        rippleMesh.visible = true;
        const rippleScale = 0.9 + think.rippleT * 3.8;
        rippleMesh.scale.setScalar(rippleScale);
        rippleMesh.material.opacity = (1 - think.rippleT) * 0.07 * (0.55 + think.coreBoost * 0.45);
        rippleMesh.rotation.y += delta * 0.15;
      } else if (think.phase === "resolve" && think.rippleT >= 0.98) {
        rippleMesh.material.opacity *= Math.max(0, 1 - delta * 2.5);
        if (rippleMesh.material.opacity < 0.01) {
          rippleMesh.visible = false;
          rippleMesh.material.opacity = 0;
        }
      }
    }

    function updatePulseJourneys(delta, motion) {
      for (let i = 0; i < pulseMeshes.length; i++) {
        const pulse = pulseMeshes[i];
        const data = pulse.userData;
        const curve = pulseCurves[i];
        const ribbon = pulseRibbons[i];
        const trails = pulseTrails[i];
        const heroMul = data.hero ? 1.15 : 1;

        if (!data.enabled || data.phase === "idle" || !motion) {
          pulse.visible = false;
          pulse.material.opacity = 0;
          ribbon.material.opacity = Math.max(0.02, ribbon.material.opacity - delta * 0.08);
          trails.forEach((ghost) => {
            ghost.visible = false;
            ghost.material.opacity = 0;
          });
          continue;
        }

        data.phaseT += delta;

        if (data.phase === "anticipate") {
          const t = Math.min(1, data.phaseT / data.anticipateDur);
          const ant = easeOutQuad(t);
          data.progress = 0;
          curve.getPoint(0, pulsePoint);
          pulse.position.copy(pulsePoint);
          pulse.visible = true;
          pulse.scale.setScalar(0.35 + ant * 0.35);
          pulse.material.opacity = ant * 0.35 * heroMul;
          ribbon.material.opacity = 0.03 + ant * 0.1 * heroMul;
          boostNode(data.startIndex, 0.25 + ant * 0.35);
          boostEdgeBetween(data.startIndex, data.endIndex, 0.2 + ant * 0.25);

          if (t >= 1) {
            data.phase = "travel";
            data.phaseT = 0;
          }
        } else if (data.phase === "travel") {
          const t = Math.min(1, data.phaseT / data.travelDur);
          data.progress = easeInOutCubic(t);
          curve.getPoint(data.progress, pulsePoint);
          pulse.position.copy(pulsePoint);

          const swell = 0.55 + Math.sin(data.progress * Math.PI) * 0.35;
          pulse.visible = true;
          pulse.scale.setScalar(swell * heroMul);
          pulse.material.opacity = (0.5 + swell * 0.35) * heroMul * 0.85;
          ribbon.material.opacity = 0.05 + (1 - Math.abs(data.progress - 0.5) * 2) * 0.08 * heroMul;

          if (!data.handoffFired && data.progress > 0.82) {
            data.handoffFired = true;
            boostNode(data.endIndex, 0.75);
            signalNeighbors(data.endIndex, 0.45, 2);
            boostEdgeBetween(data.startIndex, data.endIndex, 0.7);
          }

          if (data.progress > 0.15 && data.progress < 0.2) {
            signalNeighbors(data.startIndex, 0.3, 1);
          }

          trails.forEach((ghost, g) => {
            const trailProgress = Math.max(0, data.progress - ghost.userData.lag * (0.9 + g * 0.35));
            curve.getPoint(trailProgress, trailPoint);
            ghost.position.copy(trailPoint);
            ghost.visible = trailProgress > 0.01;
            ghost.scale.setScalar(swell * 0.55);
            ghost.material.opacity = pulse.material.opacity * (0.45 - g * 0.14);
          });

          if (t >= 1) {
            data.phase = "fade";
            data.phaseT = 0;
          }
        } else if (data.phase === "fade") {
          const t = Math.min(1, data.phaseT / data.fadeDur);
          const fade = 1 - easeInOutCubic(t);
          curve.getPoint(1, pulsePoint);
          pulse.position.copy(pulsePoint);
          pulse.visible = fade > 0.02;
          pulse.scale.setScalar(0.45 * fade);
          pulse.material.opacity = 0.4 * fade;
          ribbon.material.opacity = 0.03 + 0.05 * fade;

          trails.forEach((ghost) => {
            ghost.material.opacity *= Math.max(0, 1 - delta * 2.8);
            if (ghost.material.opacity < 0.02) ghost.visible = false;
          });

          if (t >= 1) {
            data.phase = "idle";
            data.phaseT = 0;
            data.progress = 0;
            data.hero = false;
            pulse.visible = false;
            pulse.material.opacity = 0;
            trails.forEach((ghost) => {
              ghost.visible = false;
              ghost.material.opacity = 0;
            });
          }
        }
      }
    }

    // -------------------------------------------------------
    // MODEL BINDING — demo, cached, and live all land here.
    // Buffers, adjacency, labels, and pulse paths are re-pointed
    // in place so the scene never blanks between modes.
    // -------------------------------------------------------
    const NETWORK_LABELS = {
      live: "LIVE KNOWLEDGE GRAPH",
      cached: "CACHED KNOWLEDGE GRAPH",
      demo: "DEMO VISUALIZATION"
    };

    const LIVE_LABELS = {
      live: "GRAPH LIVE",
      cached: "GRAPH CACHED",
      demo: "GRAPH ACTIVE"
    };

    function resetLivingState() {
      nodeWake.fill(0);
      thinkLabelBoost.fill(0);
      awakenTargets.fill(0);
      edgeAwaken.fill(0);
      edgeAwakenActive = false;
      nodeGeometry.attributes.aWake.needsUpdate = true;
      edgeGeometry.attributes.aAwaken.needsUpdate = true;

      thought.active = false;
      thought.phase = "idle";
      thought.currentNode = -1;
      thought.prevNode = -1;
      thought.nextNode = -1;
      thought.coreBoost = 0;
      thought.visited = new Set();
      hideThoughtVisuals();

      think.active = false;
      think.phase = "idle";
      think.coreBoost = 0;
      think.rippleT = 0;
      think.clusterId = -1;
      think.pulseIndex = -1;
      thinkFocusNodes.length = 0;

      nodeMaterial.uniforms.uThinkCluster.value = -1;
      nodeMaterial.uniforms.uThinkClusterBoost.value = 0;
      nodeMaterial.uniforms.uHoverIndex.value = -1;
      coreFresnelMaterial.uniforms.uThink.value = 0;

      rippleMesh.visible = false;
      rippleMesh.material.opacity = 0;
      rippleMesh.userData.thoughtRipple = 0;

      if (coreMark) {
        coreMark.classList.remove("is-thinking");
        coreMark.classList.remove("is-aware");
      }

      PKG.hoveredNode = null;

      const now = clock.elapsedTime;

      thought.nextAt = prefersReducedMotion ? Number.POSITIVE_INFINITY : now + 5 + Math.random() * 5;
      think.nextAt = prefersReducedMotion ? Number.POSITIVE_INFINITY : now + 9 + Math.random() * 6;
      nextAmbientJourneyAt = prefersReducedMotion ? Number.POSITIVE_INFINITY : now + 2;
      nextNodeSignalAt = prefersReducedMotion ? Number.POSITIVE_INFINITY : now + 6 + Math.random() * 4;
      nextSoftEdgeAt = prefersReducedMotion ? Number.POSITIVE_INFINITY : now + 3.5;
    }

    function applyModel(model) {
      activeModel = model;
      graphMode = model.mode;
      nodeCount = Math.max(0, Math.min(model.count, NODE_CAPACITY));

      featuredIndexes.length = 0;
      featuredSet.clear();

      model.featuredIndexes.forEach((index) => {
        if (index >= 0 && index < nodeCount && !featuredSet.has(index)) {
          featuredIndexes.push(index);
          featuredSet.add(index);
        }
      });

      const accents = model.accentNodes || new Set();

      for (let i = 0; i < NODE_CAPACITY; i++) {
        if (i >= nodeCount) {
          nodePositions[i].set(0, 0, 0);
          positions[i * 3] = 0;
          positions[i * 3 + 1] = 0;
          positions[i * 3 + 2] = 0;
          colors[i * 3] = 0;
          colors[i * 3 + 1] = 0;
          colors[i * 3 + 2] = 0;
          sizes[i] = 0;
          featuredFlags[i] = 0;
          clusters[i] = 0;
          constellationOf[i] = 0;
          continue;
        }

        const point = model.positions[i];
        nodePositions[i].set(point.x, point.y, point.z);
        positions[i * 3] = point.x;
        positions[i * 3 + 1] = point.y;
        positions[i * 3 + 2] = point.z;

        const c = Math.min(CONSTELLATION_COUNT - 1, model.constellationOf[i] || 0);
        constellationOf[i] = c;
        clusters[i] = c;

        // Deterministic size jitter so a payload always renders identically
        const seed = ATLAS_DATA.hash32(
          model.seedKeys && model.seedKeys[i] ? model.seedKeys[i] : "atlas:node:" + i
        );

        let color = baseGold.clone().lerp(constellationTemps[c], 0.42);
        let size = 0.052 + ATLAS_DATA.hashUnit(seed, 1) * 0.05;
        let featured = 0;

        if (featuredSet.has(i)) {
          color = hotGold.clone().lerp(constellationTemps[c], 0.28);
          size = 0.12 + ATLAS_DATA.hashUnit(seed, 2) * 0.035;
          featured = 1;
        } else if (accents.has(i)) {
          color = green.clone();
          size = 0.075;
        }

        colors[i * 3] = color.r;
        colors[i * 3 + 1] = color.g;
        colors[i * 3 + 2] = color.b;
        sizes[i] = size;
        featuredFlags[i] = featured;
      }

      nodeGeometry.setDrawRange(0, nodeCount);
      nodeGeometry.attributes.position.needsUpdate = true;
      nodeGeometry.attributes.color.needsUpdate = true;
      nodeGeometry.attributes.aSize.needsUpdate = true;
      nodeGeometry.attributes.aFeatured.needsUpdate = true;
      nodeGeometry.attributes.aCluster.needsUpdate = true;
      nodeGeometry.computeBoundingSphere();

      edgePairs.length = 0;
      edgeIndexByPair.clear();

      const sourcePairs = model.edgePairs || [];
      const sourceStrengths = model.edgeStrengths || [];
      const seenPairs = new Set();
      let written = 0;

      for (let i = 0; i < sourcePairs.length && written < EDGE_CAPACITY; i++) {
        const pair = sourcePairs[i];
        if (!pair) continue;

        const a = pair[0];
        const b = pair[1];
        if (!(a >= 0 && b >= 0 && a < nodeCount && b < nodeCount) || a === b) continue;

        const key = a < b ? `${a}:${b}` : `${b}:${a}`;
        if (seenPairs.has(key)) continue;
        seenPairs.add(key);

        const p1 = nodePositions[a];
        const p2 = nodePositions[b];
        const base = written * 6;

        edgePositions[base] = p1.x;
        edgePositions[base + 1] = p1.y;
        edgePositions[base + 2] = p1.z;
        edgePositions[base + 3] = p2.x;
        edgePositions[base + 4] = p2.y;
        edgePositions[base + 5] = p2.z;

        const strength = Number.isFinite(sourceStrengths[i]) ? sourceStrengths[i] : 0.6;
        edgeBaseStrength[written * 2] = strength;
        edgeBaseStrength[written * 2 + 1] = strength;
        edgeAwaken[written * 2] = 0;
        edgeAwaken[written * 2 + 1] = 0;
        awakenTargets[written] = 0;

        edgePairs.push([a, b]);
        edgeIndexByPair.set(key, written);
        written += 1;
      }

      edgeCount = written;

      for (let e = edgeCount; e < EDGE_CAPACITY; e++) {
        const base = e * 6;
        for (let k = 0; k < 6; k++) edgePositions[base + k] = 0;
        edgeBaseStrength[e * 2] = 0;
        edgeBaseStrength[e * 2 + 1] = 0;
        edgeAwaken[e * 2] = 0;
        edgeAwaken[e * 2 + 1] = 0;
        awakenTargets[e] = 0;
      }

      edgeGeometry.setDrawRange(0, edgeCount * 2);
      edgeGeometry.attributes.position.needsUpdate = true;
      edgeGeometry.attributes.aStrength.needsUpdate = true;
      edgeGeometry.attributes.aAwaken.needsUpdate = true;
      edgeGeometry.computeBoundingSphere();
      edges.visible = edgeCount > 0;
      edgeMaterial.uniforms.uOpacity.value = edgeOpacityFor(edgeCount);

      for (let i = 0; i < NODE_CAPACITY; i++) neighbors[i].length = 0;

      edgePairs.forEach(([a, b], edgeIndex) => {
        neighbors[a].push({ node: b, edge: edgeIndex });
        neighbors[b].push({ node: a, edge: edgeIndex });
      });

      thoughtSeeds.length = 0;
      featuredThoughtSeeds.length = 0;

      for (let i = 0; i < nodeCount; i++) {
        if (!neighbors[i].length) continue;
        thoughtSeeds.push(i);
        if (featuredSet.has(i)) featuredThoughtSeeds.push(i);
      }

      rebuildLabels(model);
      assignPulsePaths(model.pulsePairs);
      resetLivingState();
      publishModel(model);
    }

    function updateAccessibleSummary(model) {
      const element = document.getElementById("pkg1-graph-summary");
      if (!element) return;

      const stateText =
        model.mode === "live"
          ? "Live knowledge graph"
          : model.mode === "cached"
            ? "Cached knowledge graph"
            : "Demo visualization";

      const parts = [stateText + "."];
      const entities = model.entities || [];

      if (entities.length) {
        const relationshipCount = model.relationships ? model.relationships.length : 0;
        parts.push(
          entities.length + " published entities, " + relationshipCount + " governed relationships."
        );

        const major = ATLAS_DATA.describeTypes(entities, 5);
        if (major.length) parts.push("Major types: " + major.join(", ") + ".");
      } else {
        parts.push(
          nodeCount + " illustrative nodes, " + edgeCount + " illustrative connections."
        );
        parts.push("Major domains: " + constellationNames.slice(0, 5).join(", ") + ".");
      }

      if (model.meta && model.meta.relationshipsAvailable === false) {
        parts.push("Relationship data is temporarily unavailable.");
      }

      if (model.meta && model.meta.knowledgeLastUpdated) {
        parts.push("Knowledge last updated " + model.meta.knowledgeLastUpdated + ".");
      }

      element.textContent = parts.join(" ");
    }

    function publishModel(model) {
      const entities = model.entities || [];
      const relationships = model.relationships || [];

      PKG.graphMode = model.mode;
      PKG.entitiesById = new Map(entities.map((entity) => [entity.id, entity]));

      const adjacency = new Map();

      function link(fromId, toId, edge, direction) {
        if (!adjacency.has(fromId)) adjacency.set(fromId, []);
        adjacency.get(fromId).push({
          id: toId,
          predicate: edge.predicate,
          confidence: edge.confidence,
          evidence: edge.evidence,
          direction
        });
      }

      relationships.forEach((edge) => {
        link(edge.sourceId, edge.targetId, edge, "out");
        link(edge.targetId, edge.sourceId, edge, "in");
      });

      PKG.adjacency = adjacency;
      PKG.nodeCount = nodeCount;
      PKG.edgeCount = edgeCount;
      PKG.constellationOf = constellationOf;
      PKG.constellationNames = constellationNames;

      PKG.graphData = {
        mode: model.mode,
        synthetic: Boolean(model.synthetic),
        entities,
        relationships,
        counts: {
          entities: entities.length,
          relationships: relationships.length,
          nodes: nodeCount,
          edges: edgeCount,
          labels: labels.length
        },
        meta: model.meta || null
      };

      setText("pkg1-network-label", NETWORK_LABELS[model.mode] || NETWORK_LABELS.demo);
      setText("pkg1-live-label", LIVE_LABELS[model.mode] || LIVE_LABELS.demo);
      updateAccessibleSummary(model);
    }

    function graphSnapshot() {
      return {
        mode: graphMode,
        nodes: nodeCount,
        edges: edgeCount,
        entities: PKG.graphData ? PKG.graphData.counts.entities : 0,
        relationships: PKG.graphData ? PKG.graphData.counts.relationships : 0,
        meta: PKG.graphData ? PKG.graphData.meta : null
      };
    }

    function buildLiveModel(payload, mode) {
      return ATLAS_DATA.toModel(payload, mode, {
        radius: sphereRadius,
        anchors: constellationAnchors.map((point) => ({ x: point.x, y: point.y, z: point.z })),
        constellationCount: CONSTELLATION_COUNT,
        nodeCap: Math.min(ATLAS_DATA.NODE_CAP, NODE_CAPACITY)
      });
    }

    async function loadGraphData(options) {
      const force = Boolean(options && options.force);

      PKG.emit("graph:loading", { mode: graphMode, force });
      setText("pkg1-live-label", "GRAPH SYNCING");

      let upgraded = false;

      if (!force) {
        try {
          const cached = ATLAS_DATA.readCache();
          if (cached) {
            applyModel(buildLiveModel(cached, "cached"));
            upgraded = true;
            PKG.emit("graph:cached", graphSnapshot());
            PKG.emit("graph:updated", graphSnapshot());
          }
        } catch (error) {
          ATLAS_DATA.clearCache();
        }
      }

      try {
        const payload = await ATLAS_DATA.fetchLive();
        applyModel(buildLiveModel(payload, "live"));
        PKG.emit("graph:live", graphSnapshot());
        PKG.emit("graph:updated", graphSnapshot());
      } catch (error) {
        console.warn("Atlas could not load the live knowledge graph.", error);

        setText("pkg1-network-label", NETWORK_LABELS[graphMode] || NETWORK_LABELS.demo);
        setText("pkg1-live-label", LIVE_LABELS[graphMode] || LIVE_LABELS.demo);

        if (!upgraded && graphMode === "demo") {
          PKG.emit("graph:demo", graphSnapshot());
        }

        PKG.emit("graph:error", {
          mode: graphMode,
          message: error && error.message ? error.message : String(error)
        });
      }

      return PKG.graphData;
    }

    // Demo paints first so the scene is never empty.
    applyModel(demoModel);
    PKG.emit("graph:demo", graphSnapshot());

    if (!prefersReducedMotion) {
      startPulseJourney(0, false);
      startPulseJourney(3, false);
    }

    function animate() {
      frameId = requestAnimationFrame(animate);

      if (document.hidden || contextLost) return;

      const delta = Math.min(clock.getDelta(), 0.05);
      const elapsed = clock.elapsedTime;
      const motion = prefersReducedMotion ? 0 : 1;

      nodeMaterial.uniforms.uTime.value = elapsed;
      edgeMaterial.uniforms.uTime.value = elapsed;
      particleMaterial.uniforms.uTime.value = elapsed;
      coreFresnelMaterial.uniforms.uTime.value = elapsed;

      const driftY = 0.00022 * motion;
      const thinkX = Math.sin(elapsed * 0.11) * 0.028 + Math.sin(elapsed * 0.29) * 0.01;
      const thinkZ = Math.sin(elapsed * 0.09) * 0.012;
      const breathScale = GRAPH_SCALE * (1 + Math.sin(elapsed * 0.41) * 0.007 * motion);

      graphGroup.rotation.y += driftY;
      graphGroup.rotation.x = thinkX;
      graphGroup.rotation.z = thinkZ * motion;
      graphGroup.scale.setScalar(breathScale);

      orbitalGroup.rotation.y += 0.00045 * motion;
      particles.rotation.y -= 0.00014 * motion;
      particles.rotation.x = Math.sin(elapsed * 0.07) * 0.03;
      coreRing.rotation.z += 0.0007 * motion;
      coreRing.rotation.y = Math.sin(elapsed * 0.17) * 0.12;

      const corePulse = (think.active ? think.coreBoost : 0) + thought.coreBoost * 0.55;
      coreGlow.scale.setScalar(1 + Math.sin(elapsed * 0.95) * 0.035 + corePulse * 0.04);
      coreGlow.material.opacity = 0.055 + Math.sin(elapsed * 0.95) * 0.02 + corePulse * 0.04;
      coreNucleus.scale.setScalar(1 + Math.sin(elapsed * 1.15) * 0.04 + corePulse * 0.03);
      coreNucleus.material.opacity = 0.1 + Math.sin(elapsed * 1.15) * 0.025 + corePulse * 0.05;

      if (!think.active) {
        const thinkTarget = thought.coreBoost * 0.55;
        coreFresnelMaterial.uniforms.uThink.value += (thinkTarget - coreFresnelMaterial.uniforms.uThink.value) * Math.min(1, delta * 2.2);
      }

      if (motion && !think.active && elapsed >= think.nextAt) {
        beginThinkingMoment(elapsed);
      }

      if (motion && think.active) {
        updateThinkingMoment(delta);
      }

      if (typeof updateQuerySystem === "function") {
        updateQuerySystem(delta, elapsed);
      }

      const queryBusy =
        typeof query !== "undefined" &&
        query &&
        query.state &&
        query.state !== "IDLE" &&
        query.state !== "CANCELLED" &&
        query.state !== "ERROR";

      updateThought(delta, elapsed, motion);
      if (motion && !think.active && !queryBusy && elapsed >= nextAmbientJourneyAt) {
        const idle = [];
        for (let i = 0; i < pulseMeshes.length; i++) {
          const data = pulseMeshes[i].userData;
          if (data.enabled && data.phase === "idle") idle.push(i);
        }
        if (idle.length) {
          startPulseJourney(idle[Math.floor(Math.random() * idle.length)], false);
        }
        nextAmbientJourneyAt = elapsed + 4.5 + Math.random() * 3.8;
      }

      if (motion && !queryBusy && elapsed >= nextNodeSignalAt && featuredIndexes.length) {
        const featured = featuredIndexes[Math.floor(Math.random() * featuredIndexes.length)];
        boostNode(featured, 0.55 + Math.random() * 0.25);
        signalNeighbors(featured, 0.4 + Math.random() * 0.2, 1 + Math.floor(Math.random() * 2));
        thinkLabelBoost[featured] = Math.max(thinkLabelBoost[featured], 0.45);
        nextNodeSignalAt = elapsed + 8 + Math.random() * 7;
      }

      if (motion && !queryBusy && elapsed >= nextSoftEdgeAt && edgeCount > 0) {
        const count = 3 + Math.floor(Math.random() * 4);
        for (let n = 0; n < count; n++) {
          boostEdge(Math.floor(Math.random() * edgeCount), 0.35 + Math.random() * 0.25);
        }
        nextSoftEdgeAt = elapsed + 5.5 + Math.random() * 4.5;
      }

      // Only walk and re-upload the awaken buffer while something is actually
      // lit. At a dozen edges this was free; across a full knowledge graph it is
      // the difference between a quiet idle frame and a constant buffer upload.
      if (edgeAwakenActive) {
        let stillActive = false;

        for (let e = 0; e < edgeCount; e++) {
          const value = Math.max(0, awakenTargets[e] - delta * 0.42);
          awakenTargets[e] = value;
          edgeAwaken[e * 2] = value;
          edgeAwaken[e * 2 + 1] = value;
          if (value > 0.001) stillActive = true;
        }

        edgeGeometry.attributes.aAwaken.needsUpdate = true;
        edgeAwakenActive = stillActive;
      }

      let wakeDirty = false;
      for (let n = 0; n < nodeCount; n++) {
        if (nodeWake[n] > 0) {
          nodeWake[n] = Math.max(0, nodeWake[n] - delta * 0.55);
          wakeDirty = true;
        }
        if (thinkLabelBoost[n] > 0 && !(think.active && think.phase !== "resolve")) {
          thinkLabelBoost[n] = Math.max(0, thinkLabelBoost[n] - delta * 0.35);
        }
      }

      updatePulseJourneys(delta, motion);

      for (let n = 0; n < nodeCount; n++) {
        if (nodeWake[n] > 0.001) {
          wakeDirty = true;
          break;
        }
      }

      if (wakeDirty || think.active) {
        nodeGeometry.attributes.aWake.needsUpdate = true;
      }

      raycaster.setFromCamera(pointer, camera);
      const intersections = raycaster.intersectObject(nodes);

      if (intersections.length > 0) {
        const hitIndex = intersections[0].index;
        canvas.style.cursor = "pointer";
        nodeMaterial.uniforms.uHoverIndex.value = hitIndex;
        PKG.hoveredNode = hitIndex;

        labels.forEach(({ index, element }) => {
          element.classList.toggle("is-hot", index === hitIndex);
        });
      } else {
        canvas.style.cursor = controls.state === -1 ? "grab" : "grabbing";
        nodeMaterial.uniforms.uHoverIndex.value = -1;
        if (PKG.hoveredNode !== null) {
          PKG.hoveredNode = null;
          labels.forEach(({ element }) => element.classList.remove("is-hot"));
        }
      }

      controls.update();
      updateLabels();
      renderer.render(scene, camera);
    }

    function resize() {
      const width = viewport.clientWidth;
      const height = viewport.clientHeight;

      if (width < 2 || height < 2) return;

      renderer.setSize(width, height, false);
      renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 1.8));

      camera.aspect = width / height;
      camera.updateProjectionMatrix();

      nodeMaterial.uniforms.uPixelRatio.value = renderer.getPixelRatio();
      particleMaterial.uniforms.uPixelRatio.value = renderer.getPixelRatio();
    }

    function scheduleResize() {
      window.clearTimeout(resizeTimer);
      resizeTimer = window.setTimeout(resize, 80);
    }

    const resizeObserver = new ResizeObserver(scheduleResize);
    resizeObserver.observe(viewport);

    PKG.renderer = renderer;
    PKG.scene = scene;
    PKG.camera = camera;
    PKG.controls = controls;
    PKG.graphGroup = graphGroup;
    PKG.nodes = nodes;
    PKG.edges = edges;
    PKG.nodePositions = nodePositions;
    PKG.featuredIndexes = featuredIndexes;
    PKG.labels = labels;
    PKG.labelByIndex = labelByIndex;
    PKG.pulseMeshes = pulseMeshes;
    PKG.pulseCurves = pulseCurves;
    PKG.resize = resize;
    PKG.resizeObserver = resizeObserver;

    PKG.setAutoRotate = function (enabled) {
      controls.autoRotate = Boolean(enabled);
      setText(
        "pkg1-rotation-label",
        controls.autoRotate ? "AUTONOMOUS" : "MANUAL"
      );
    };

    PKG.focusNode = function (index) {
      const point = nodePositions[index];

      if (!point) return;

      const worldPoint = point.clone().multiplyScalar(GRAPH_SCALE);
      const direction = worldPoint.clone().normalize();
      const destination = direction.multiplyScalar(8.35);

      camera.position.lerp(destination, 0.35);
      controls.target.copy(worldPoint.clone().multiplyScalar(0.14));
      controls.update();
    };

    function resolveEntity(key) {
      if (!activeModel) return null;

      const entities = activeModel.entities || [];

      if (typeof key === "number") {
        return entities[key] || null;
      }

      const id = typeof key === "string" ? key.trim() : "";
      if (!id) return null;

      const direct = PKG.entitiesById.get(id);
      if (direct) return direct;

      const lower = id.toLowerCase();

      return (
        entities.find(
          (entity) => entity.slug.toLowerCase() === lower || entity.name.toLowerCase() === lower
        ) || null
      );
    }

    PKG.getEntity = function (key) {
      return resolveEntity(key);
    };

    PKG.getNeighbors = function (key) {
      const entity = resolveEntity(key);
      if (!entity) return [];

      const links = PKG.adjacency.get(entity.id) || [];

      return links.map((link) => ({
        entity: PKG.entitiesById.get(link.id) || null,
        id: link.id,
        predicate: link.predicate,
        confidence: link.confidence,
        evidence: link.evidence,
        direction: link.direction
      }));
    };

    PKG.getRelationships = function (key) {
      if (!activeModel) return [];

      const relationships = activeModel.relationships || [];
      if (key === undefined || key === null) return relationships.slice();

      const entity = resolveEntity(key);
      if (!entity) return [];

      return relationships.filter(
        (edge) => edge.sourceId === entity.id || edge.targetId === entity.id
      );
    };

    PKG.getMode = function () {
      return graphMode;
    };

    let graphLoadInFlight = null;

    PKG.reloadGraph = function (options) {
      if (graphLoadInFlight) return graphLoadInFlight;

      graphLoadInFlight = loadGraphData(options).then(
        (result) => {
          graphLoadInFlight = null;
          return result;
        },
        (error) => {
          graphLoadInFlight = null;
          throw error;
        }
      );

      return graphLoadInFlight;
    };

    // =========================================================
    // ATLAS v3.0 — Queryable closed-loop reasoning runtime
    // =========================================================
    const QUERY_REASONING_ENABLED = true;
    PKG.features = PKG.features || {};
    PKG.features.queryReasoning = QUERY_REASONING_ENABLED;
    PKG.phases.askGraph = QUERY_REASONING_ENABLED;
    PKG.phases.reasoning = QUERY_REASONING_ENABLED;

    const QUERY_STATES = {
      IDLE: "IDLE",
      RESOLVING: "RESOLVING",
      REASONING: "REASONING",
      EXTRACTING: "EXTRACTING",
      PRESENTING: "PRESENTING",
      RETURNING: "RETURNING",
      ERROR: "ERROR",
      CANCELLED: "CANCELLED"
    };

    const SOUND_KEY = "atlas.query.sound";
    const queryUi = {
      root: document.getElementById("pkg1-query"),
      input: document.getElementById("pkg1-query-input"),
      submit: document.getElementById("pkg1-query-submit"),
      soundBtn: document.getElementById("pkg1-query-sound"),
      examples: document.getElementById("pkg1-query-examples"),
      status: document.getElementById("pkg1-query-status"),
      answer: document.getElementById("pkg1-answer"),
      answerStage: document.getElementById("pkg1-answer-stage"),
      answerClose: document.getElementById("pkg1-answer-close"),
      answerQuestion: document.getElementById("pkg1-answer-question"),
      answerBody: document.getElementById("pkg1-answer-body"),
      answerMeta: document.getElementById("pkg1-answer-meta"),
      answerEntitiesWrap: document.getElementById("pkg1-answer-entities-wrap"),
      answerEntities: document.getElementById("pkg1-answer-entities"),
      answerPathWrap: document.getElementById("pkg1-answer-path-wrap"),
      answerPath: document.getElementById("pkg1-answer-path"),
      answerEvidenceWrap: document.getElementById("pkg1-answer-evidence-wrap"),
      answerEvidence: document.getElementById("pkg1-answer-evidence"),
      answerStandardsWrap: document.getElementById("pkg1-answer-standards-wrap"),
      answerStandards: document.getElementById("pkg1-answer-standards"),
      answerNote: document.getElementById("pkg1-answer-note"),
      transition: null
    };

    const query = {
      state: QUERY_STATES.IDLE,
      generation: 0,
      controller: null,
      question: "",
      stageLabel: "",
      activePath: null,
      mappedPath: null,
      answer: null,
      focus: new Set(),
      extracted: [],
      savedColors: null,
      savedSizes: null,
      edgeSnapshot: null,
      dimmed: false,
      returnQueue: [],
      lockCount: 0,
      thoughtGuided: false,
      ambientPaused: false,
      previousThoughtNextAt: 0,
      transitionUntil: 0,
      presentUntil: 0,
      autoReturn: false
    };

    const extractScratch = {
      home: new THREE.Vector3(),
      target: new THREE.Vector3(),
      cur: new THREE.Vector3(),
      mid: new THREE.Vector3()
    };

    let audioCtx = null;
    let soundEnabled = false;

    try {
      soundEnabled = window.localStorage.getItem(SOUND_KEY) === "1";
    } catch (error) {
      soundEnabled = false;
    }

    function setQueryState(next, detail) {
      query.state = next;
      PKG.queryState = next;
      if (queryUi.status) {
        const labels = {
          IDLE: "",
          RESOLVING: "RESOLVING ENTITIES",
          REASONING: "TRAVERSING RELATIONSHIPS",
          EXTRACTING: "EVALUATING EVIDENCE",
          PRESENTING: "BUILDING GROUNDED ANSWER",
          RETURNING: "RETURNING TO GRAPH",
          ERROR: "QUERY ERROR",
          CANCELLED: "CANCELLED"
        };
        queryUi.status.textContent = query.stageLabel || labels[next] || next;
      }
      if (queryUi.answerStage) {
        queryUi.answerStage.textContent = query.stageLabel || next;
      }
      root.classList.toggle("pkg1--querying", next !== QUERY_STATES.IDLE && next !== QUERY_STATES.CANCELLED);
      if (detail && detail.event) PKG.emit(detail.event, detail.payload || {});
    }

    function ensureTransitionLabel() {
      if (queryUi.transition || !viewport) return;
      const el = document.createElement("div");
      el.className = "pkg1__query-transition";
      el.id = "pkg1-query-transition";
      el.setAttribute("aria-hidden", "true");
      viewport.appendChild(el);
      queryUi.transition = el;
    }

    function showTransition(label, dwell) {
      ensureTransitionLabel();
      if (!queryUi.transition) return;
      queryUi.transition.textContent = label || "";
      queryUi.transition.classList.toggle("is-on", Boolean(label));
      query.transitionUntil = clock.elapsedTime + (dwell || 0.35);
    }

    function clearTransition() {
      if (queryUi.transition) {
        queryUi.transition.classList.remove("is-on");
        queryUi.transition.textContent = "";
      }
      query.transitionUntil = 0;
    }

    function ensureAudio() {
      if (audioCtx) return audioCtx;
      const Ctx = window.AudioContext || window.webkitAudioContext;
      if (!Ctx) return null;
      audioCtx = new Ctx();
      return audioCtx;
    }

    function playLockClick(finalLock) {
      if (!soundEnabled || prefersReducedMotion) return;
      const ctx = ensureAudio();
      if (!ctx) return;

      const now = ctx.currentTime;
      const dur = finalLock ? 0.08 : 0.055 + Math.random() * 0.02;

      try {
        if (ctx.state === "suspended") ctx.resume();
      } catch (error) {
        return;
      }

      const master = ctx.createGain();
      master.gain.value = finalLock ? 0.045 : 0.028;
      master.connect(ctx.destination);

      const osc = ctx.createOscillator();
      const gain = ctx.createGain();
      const filter = ctx.createBiquadFilter();

      osc.type = "triangle";
      osc.frequency.setValueAtTime(finalLock ? 195 : 240 + Math.random() * 40, now);
      osc.frequency.exponentialRampToValueAtTime(90, now + dur);

      filter.type = "lowpass";
      filter.frequency.value = finalLock ? 900 : 1200;

      gain.gain.setValueAtTime(0.0001, now);
      gain.gain.exponentialRampToValueAtTime(finalLock ? 0.9 : 0.65, now + 0.008);
      gain.gain.exponentialRampToValueAtTime(0.0001, now + dur);

      osc.connect(filter);
      filter.connect(gain);
      gain.connect(master);
      osc.start(now);
      osc.stop(now + dur + 0.01);

      const tick = ctx.createOscillator();
      const tickGain = ctx.createGain();
      tick.type = "sine";
      tick.frequency.value = finalLock ? 1800 : 2100 + Math.random() * 200;
      tickGain.gain.setValueAtTime(0.0001, now);
      tickGain.gain.exponentialRampToValueAtTime(0.18, now + 0.004);
      tickGain.gain.exponentialRampToValueAtTime(0.0001, now + 0.03);
      tick.connect(tickGain);
      tickGain.connect(master);
      tick.start(now);
      tick.stop(now + 0.035);
    }

    function syncSoundButton() {
      if (!queryUi.soundBtn) return;
      queryUi.soundBtn.setAttribute("aria-pressed", soundEnabled ? "true" : "false");
      queryUi.soundBtn.textContent = soundEnabled ? "SOUND ON" : "SOUND";
    }

    function pauseAmbientForQuery() {
      if (query.ambientPaused) return;
      query.ambientPaused = true;
      query.previousThoughtNextAt = thought.nextAt;
      thought.nextAt = Number.POSITIVE_INFINITY;
      if (typeof think !== "undefined" && think) {
        think.nextAt = Number.POSITIVE_INFINITY;
        think.active = false;
        think.phase = "idle";
      }
      if (thought.active) {
        thought.active = false;
        thought.phase = "idle";
        hideThoughtVisuals();
      }
      think.active = false;
      think.phase = "idle";
    }

    function resumeAmbientAfterQuery() {
      if (!query.ambientPaused) return;
      query.ambientPaused = false;
      if (!prefersReducedMotion) {
        thought.nextAt = clock.elapsedTime + 4 + Math.random() * 4;
      } else {
        thought.nextAt = Number.POSITIVE_INFINITY;
      }
      query.thoughtGuided = false;
    }

    function findRenderedIndexById(id) {
      if (!id || !activeModel || !activeModel.indexById) return -1;
      const index = activeModel.indexById.get(id);
      return Number.isInteger(index) ? index : -1;
    }

    function findRenderedIndexByTitle(title) {
      if (!activeModel || !activeModel.entities) return -1;
      const key = ATLAS_QUERY.titleKey(title);
      if (!key) return -1;

      for (let i = 0; i < activeModel.entities.length; i++) {
        const entity = activeModel.entities[i];
        if (ATLAS_QUERY.titleKey(entity.name) === key) return i;
        if (ATLAS_QUERY.titleKey(entity.slug) === key) return i;
        const aliases = entity.metadata && entity.metadata.aliases;
        if (Array.isArray(aliases)) {
          for (let a = 0; a < aliases.length; a++) {
            if (ATLAS_QUERY.titleKey(aliases[a]) === key) return i;
          }
        }
      }
      return -1;
    }

    function edgeExists(a, b) {
      if (a < 0 || b < 0 || a === b) return false;
      const key = a < b ? a + ":" + b : b + ":" + a;
      return edgeIndexByPair.has(key);
    }

    async function resolveTitle(title, cache, signal) {
      const key = ATLAS_QUERY.titleKey(title);
      if (!key) return null;
      if (cache.has(key)) return cache.get(key);

      const localIndex = findRenderedIndexByTitle(title);
      if (localIndex >= 0) {
        const entity = activeModel.entities[localIndex];
        const resolved = {
          id: entity.id,
          name: entity.name,
          type: entity.type,
          summary: entity.summary,
          index: localIndex,
          rendered: true
        };
        cache.set(key, resolved);
        return resolved;
      }

      try {
        const hits = await ATLAS_QUERY.searchEntities(title, { limit: 5, signal });
        const exact = hits.find((hit) => ATLAS_QUERY.titleKey(hit.name) === key) || hits[0];
        if (!exact) {
          cache.set(key, null);
          return null;
        }

        const index = findRenderedIndexById(exact.id);
        const resolved = {
          id: exact.id,
          name: exact.name,
          type: exact.type,
          summary: exact.summary,
          index,
          rendered: index >= 0
        };
        cache.set(key, resolved);
        return resolved;
      } catch (error) {
        if (error && error.name === "AbortError") throw error;
        cache.set(key, null);
        return null;
      }
    }

    async function mapReasoningPath(path, signal) {
      const cache = new Map();
      const steps = [];
      const nodeIndexes = [];
      const seen = new Set();
      const entities = [];

      for (let i = 0; i < path.steps.length; i++) {
        const step = path.steps[i];
        const from = await resolveTitle(step.from.title, cache, signal);
        const to = await resolveTitle(step.to.title, cache, signal);

        const mapped = {
          fromTitle: step.from.title,
          toTitle: step.to.title,
          from,
          to,
          predicate: step.predicate,
          predicateLabel: step.predicateLabel,
          statement: step.statement,
          explanation: step.explanation,
          evidence: step.evidence,
          hasRenderedEdge: false,
          fromIndex: from && from.rendered ? from.index : -1,
          toIndex: to && to.rendered ? to.index : -1
        };

        if (mapped.fromIndex >= 0 && mapped.toIndex >= 0) {
          mapped.hasRenderedEdge = edgeExists(mapped.fromIndex, mapped.toIndex);
        }

        steps.push(mapped);

        [from, to].forEach((entity) => {
          if (!entity || !entity.id || seen.has(entity.id)) return;
          seen.add(entity.id);
          entities.push(entity);
          if (entity.rendered && entity.index >= 0) nodeIndexes.push(entity.index);
        });
      }

      return {
        summary: path.summary,
        pathConfidence: path.pathConfidence,
        pathScore: path.pathScore,
        steps,
        nodeIndexes: nodeIndexes.slice(0, 10),
        entities
      };
    }

    function saveVisualSnapshot(focusSet) {
      if (!query.savedColors) {
        query.savedColors = new Float32Array(colors);
        query.savedSizes = new Float32Array(sizes);
      }

      query.focus = new Set(focusSet);
      query.dimmed = true;

      for (let i = 0; i < nodeCount; i++) {
        if (query.focus.has(i)) continue;
        colors[i * 3] *= 0.42;
        colors[i * 3 + 1] *= 0.42;
        colors[i * 3 + 2] *= 0.42;
        sizes[i] *= 0.78;
      }

      nodeGeometry.attributes.color.needsUpdate = true;
      nodeGeometry.attributes.aSize.needsUpdate = true;
    }

    function restoreVisualSnapshot() {
      if (query.savedColors) {
        colors.set(query.savedColors);
        nodeGeometry.attributes.color.needsUpdate = true;
      }
      if (query.savedSizes) {
        sizes.set(query.savedSizes);
        nodeGeometry.attributes.aSize.needsUpdate = true;
      }
      query.savedColors = null;
      query.savedSizes = null;
      query.dimmed = false;
      query.focus.clear();
    }

    function syncNodeBuffer(index) {
      positions[index * 3] = nodePositions[index].x;
      positions[index * 3 + 1] = nodePositions[index].y;
      positions[index * 3 + 2] = nodePositions[index].z;
    }

    function syncEdgesForIndexes(indexSet) {
      for (let e = 0; e < edgeCount; e++) {
        const pair = edgePairs[e];
        if (!pair) continue;
        if (!indexSet.has(pair[0]) && !indexSet.has(pair[1])) continue;
        const p1 = nodePositions[pair[0]];
        const p2 = nodePositions[pair[1]];
        const base = e * 6;
        edgePositions[base] = p1.x;
        edgePositions[base + 1] = p1.y;
        edgePositions[base + 2] = p1.z;
        edgePositions[base + 3] = p2.x;
        edgePositions[base + 4] = p2.y;
        edgePositions[base + 5] = p2.z;
      }
      edgeGeometry.attributes.position.needsUpdate = true;
    }

    function buildExtractionTargets(indexes) {
      const count = Math.min(indexes.length, prefersReducedMotion ? 6 : 8);
      const picked = indexes.slice(0, count);
      const mobile = viewport.clientWidth < 720;
      const radius = mobile ? 1.35 : 1.7;
      const lift = mobile ? 0.55 : 0.85;
      const items = [];

      for (let i = 0; i < picked.length; i++) {
        const index = picked[i];
        const home = nodePositions[index].clone();
        const angle = (Math.PI * 2 * i) / Math.max(1, picked.length) - Math.PI / 2;
        const target = new THREE.Vector3(
          Math.cos(angle) * radius,
          lift + Math.sin(angle * 2) * 0.12,
          Math.sin(angle) * radius * 0.42
        );

        items.push({
          index,
          home,
          target,
          homeSize: sizes[index],
          t: 0,
          phase: "extract",
          locked: false
        });
      }

      return items;
    }

    function hardRestoreExtracted() {
      const touched = new Set();
      query.extracted.forEach((item) => {
        nodePositions[item.index].copy(item.home);
        sizes[item.index] = item.homeSize;
        syncNodeBuffer(item.index);
        touched.add(item.index);
      });
      if (touched.size) {
        nodeGeometry.attributes.position.needsUpdate = true;
        nodeGeometry.attributes.aSize.needsUpdate = true;
        syncEdgesForIndexes(touched);
      }
      query.extracted = [];
      query.returnQueue = [];
    }

    function fillList(element, items, mapper) {
      if (!element) return;
      element.textContent = "";
      items.forEach((item) => {
        const li = document.createElement("li");
        li.textContent = mapper(item);
        element.appendChild(li);
      });
    }

    function presentAnswer(answer) {
      query.answer = answer;
      if (!queryUi.answer) return;

      queryUi.answer.hidden = false;
      if (queryUi.answerQuestion) queryUi.answerQuestion.textContent = answer.question;
      if (queryUi.answerBody) queryUi.answerBody.textContent = answer.body;
      if (queryUi.answerNote) queryUi.answerNote.textContent = answer.note || "";

      if (queryUi.answerMeta) {
        queryUi.answerMeta.textContent = "";
        if (answer.confidence != null) {
          const chip = document.createElement("span");
          chip.textContent = "Path confidence " + answer.confidence + "%";
          queryUi.answerMeta.appendChild(chip);
        }
        if (answer.limited) {
          const chip = document.createElement("span");
          chip.textContent = "Limited support";
          queryUi.answerMeta.appendChild(chip);
        }
        const chip2 = document.createElement("span");
        chip2.textContent = graphMode === "live" ? "Live graph" : graphMode;
        queryUi.answerMeta.appendChild(chip2);
      }

      const hasEntities = answer.entities && answer.entities.length;
      if (queryUi.answerEntitiesWrap) queryUi.answerEntitiesWrap.hidden = !hasEntities;
      fillList(
        queryUi.answerEntities,
        hasEntities ? answer.entities : [],
        (entity) => entity.name + (entity.type ? " · " + entity.type.replace(/_/g, " ") : "")
      );

      const hasPath = answer.pathSteps && answer.pathSteps.length;
      if (queryUi.answerPathWrap) queryUi.answerPathWrap.hidden = !hasPath;
      fillList(
        queryUi.answerPath,
        hasPath ? answer.pathSteps : [],
        (step) => step.from + " → " + step.predicateLabel + " → " + step.to
      );

      const hasEvidence = answer.evidence && answer.evidence.length;
      if (queryUi.answerEvidenceWrap) queryUi.answerEvidenceWrap.hidden = !hasEvidence;
      fillList(queryUi.answerEvidence, hasEvidence ? answer.evidence : [], (line) => line);

      const hasStandards = answer.standards && answer.standards.length;
      if (queryUi.answerStandardsWrap) queryUi.answerStandardsWrap.hidden = !hasStandards;
      fillList(
        queryUi.answerStandards,
        hasStandards ? answer.standards : [],
        (std) => (std.number || std.id) + (std.title ? " — " + std.title : "")
      );
      if (hasStandards && answer.standardsNotice && queryUi.answerNote) {
        queryUi.answerNote.textContent =
          (queryUi.answerNote.textContent ? queryUi.answerNote.textContent + " " : "") +
          answer.standardsNotice;
      }

      PKG.emit("atlas:answer-ready", { question: answer.question, limited: answer.limited });
      if (typeof window !== "undefined" && window.parent !== window) {
        window.parent.postMessage(
          { source: "precision-atlas", type: "atlas:resize", reason: "answer-open", height: 0 },
          "*"
        );
        window.setTimeout(function () {
          window.parent.postMessage(
            { source: "precision-atlas", type: "atlas:ping" },
            "*"
          );
        }, 40);
      }
    }

    function hideAnswer() {
      if (queryUi.answer) queryUi.answer.hidden = true;
    }

    function beginGuidedThought(nodeIndexes, steps) {
      if (prefersReducedMotion || !nodeIndexes.length) return;

      const start = nodeIndexes[0];
      query.thoughtGuided = true;
      thought.active = true;
      thought.phase = "form";
      thought.phaseT = 0;
      thought.progress = 0;
      thought.currentNode = start;
      thought.prevNode = -1;
      thought.nextNode = -1;
      thought.hopsDone = 0;
      thought.hopsTarget = Math.max(1, nodeIndexes.length - 1);
      thought.homeConstellation = constellationOf[start];
      thought.bridgeMode = false;
      thought.willVisitCore = false;
      thought.coreVisited = false;
      thought.fromCore = false;
      thought.opacity = 0;
      thought.visited = new Set([start]);
      thought.guidedIndexes = nodeIndexes.slice();
      thought.guidedSteps = steps || [];
      thought.guidedCursor = 0;
      thoughtMesh.position.copy(nodePositions[start]);
      thoughtMesh.visible = true;
      thoughtMesh.material.opacity = 0;
      boostNode(start, 0.7);
    }


    function dwell(ms, signal) {
      return new Promise((resolve, reject) => {
        const timer = window.setTimeout(resolve, ms);
        if (!signal) return;
        const onAbort = () => {
          window.clearTimeout(timer);
          reject(new DOMException("Aborted", "AbortError"));
        };
        if (signal.aborted) return onAbort();
        signal.addEventListener("abort", onAbort, { once: true });
      });
    }

    async function runQueryPipeline(question, generation, signal) {
      query.question = question;
      PKG.activeQuery = { question, generation, startedAt: Date.now() };
      pauseAmbientForQuery();
      hideAnswer();

      const intent = ATLAS_QUERY.classifyQuestionIntent(question);
      const subject = ATLAS_QUERY.extractDefinitionSubject(question);

      setQueryState(QUERY_STATES.RESOLVING, {
        event: "atlas:query-start",
        payload: { question, intent, subject }
      });
      query.stageLabel = "RESOLVING ENTITIES";
      showTransition("RESOLVING ENTITIES", 0.35);
      await dwell(prefersReducedMotion ? 80 : 280, signal);

      let entityHits = await ATLAS_QUERY.searchEntities(question, {
        limit: 8,
        signal
      });

      // Full "What is X?" strings often return 0 entity hits; also search the subject/keywords.
      if ((intent === "concept" || intent === "service" || intent === "comparison") && subject) {
        const subjectHits = await ATLAS_QUERY.searchEntities(subject, {
          limit: 8,
          signal
        }).catch(() => []);
        const keywordHits = await ATLAS_QUERY.searchEntities(
          ATLAS_QUERY.tokenize(subject).slice(0, 4).join(" ") || subject,
          { limit: 6, signal }
        ).catch(() => []);
        const merged = [];
        const seen = new Set();
        []
          .concat(entityHits || [], subjectHits || [], keywordHits || [])
          .forEach((entity) => {
            if (!entity || !entity.id || seen.has(entity.id)) return;
            seen.add(entity.id);
            merged.push(entity);
          });
        entityHits = merged;
      } else if (intent === "service" || intent === "comparison") {
        const materialMatch = question.match(
          /\b(polyaspartic|epoxy|polyurea|metallic|urethane|polyurethane)\b/i
        );
        if (materialMatch) {
          const materialHits = await ATLAS_QUERY.searchEntities(materialMatch[1], {
            limit: 8,
            signal
          }).catch(() => []);
          const merged = [];
          const seen = new Set();
          [].concat(entityHits || [], materialHits || []).forEach((entity) => {
            if (!entity || !entity.id || seen.has(entity.id)) return;
            seen.add(entity.id);
            merged.push(entity);
          });
          entityHits = merged;
        }
      }

      entityHits = ATLAS_QUERY.rankEntitiesForIntent(entityHits, intent, question, subject);

      if (intent === "concept" && subject && entityHits[0]) {
        try {
          const hydrated = await ATLAS_QUERY.fetchEntity(entityHits[0].id, signal);
          if (hydrated && hydrated.summary) {
            entityHits = [
              hydrated,
              ...entityHits.filter((entity) => entity.id !== hydrated.id)
            ];
          }
        } catch (error) {
          if (error && error.name === "AbortError") throw error;
        }
      }

      PKG.emit("atlas:query-resolved", {
        question,
        intent,
        entities: entityHits.map((entity) => entity.id)
      });

      setQueryState(QUERY_STATES.REASONING, {
        event: "atlas:reasoning-start",
        payload: { question, intent }
      });
      query.stageLabel = "TRAVERSING RELATIONSHIPS";
      showTransition("TRAVERSING RELATIONSHIPS", 0.35);

      const tokens = ATLAS_QUERY.tokenize(question);
      const keywordSeed = tokens.slice(0, 5).join(" ");
      const topicalTokens = tokens.filter((token) => token.length >= 5).slice(0, 3);

      const knowledgeJobs = [
        ATLAS_QUERY.searchKnowledge(question, { limit: 8, signal }).catch(() => ({ results: [] })),
        keywordSeed
          ? ATLAS_QUERY.searchKnowledge(keywordSeed, { limit: 8, signal }).catch(() => ({
              results: []
            }))
          : Promise.resolve({ results: [] })
      ];

      if (intent === "concept" && subject) {
        knowledgeJobs.push(
          ATLAS_QUERY.searchKnowledge("What is " + subject, { limit: 6, signal }).catch(() => ({
            results: []
          }))
        );
      }

      topicalTokens.forEach((token) => {
        knowledgeJobs.push(
          ATLAS_QUERY.searchKnowledge(token, { limit: 5, signal }).catch(() => ({ results: [] }))
        );
      });

      entityHits.slice(0, 3).forEach((hit) => {
        if (hit && hit.name) {
          knowledgeJobs.push(
            ATLAS_QUERY.searchKnowledge(hit.name, { limit: 4, signal }).catch(() => ({
              results: []
            }))
          );
        }
      });

      const reasoningOptions = {
        maxDepth: 4,
        maxPaths: 5,
        signal
      };
      if (intent === "concept" && subject) {
        reasoningOptions.subject = subject.slice(0, 120);
      }

      const [reasoningRaw, standards, ...knowledgeBatches] = await Promise.all([
        ATLAS_QUERY.fetchReasoning(question, reasoningOptions),
        /standard|moisture|astm|icri|test|csp|profile/i.test(question)
          ? ATLAS_QUERY.searchStandards(
              tokens.find((token) =>
                /moisture|astm|icri|humidity|vapor|profile|csp|rh/.test(token)
              ) ||
                topicalTokens.find((token) => token !== "standards" && token !== "standard") ||
                subject ||
                "moisture",
              { limit: 5, signal }
            ).catch(() => ({
              results: [],
              usageNotice: ""
            }))
          : Promise.resolve({ results: [], usageNotice: "" }),
        ...knowledgeJobs
      ]);

      const reasoning = reasoningRaw || { paths: [], note: null };
      reasoning.paths = ATLAS_QUERY.rankPathsForIntent(
        reasoning.paths || [],
        intent,
        question,
        subject
      );

      const knowledgeMerged = {
        query: question,
        results: []
      };
      const seenKnowledge = new Set();
      knowledgeBatches.forEach((batch) => {
        (batch.results || []).forEach((hit) => {
          const key =
            (hit.module || "") + "|" + (hit.title || "") + "|" + (hit.body || "").slice(0, 80);
          if (seenKnowledge.has(key)) return;
          seenKnowledge.add(key);
          knowledgeMerged.results.push(hit);
        });
      });
      const knowledge = knowledgeMerged;

      if (!reasoning.paths.length) {
        const answer = ATLAS_QUERY.buildAnswer({
          question,
          intent,
          subject,
          reasoning,
          knowledge,
          standards,
          entities: entityHits,
          mappedPath: null
        });
        presentAnswer(answer);
        setQueryState(QUERY_STATES.PRESENTING);
        query.stageLabel = "COMPLETE";
        clearTransition();
        resumeAmbientAfterQuery();
        PKG.activeReasoningPath = null;
        PKG.emit("atlas:query-complete", {
          question,
          intent,
          limited: true,
          emptyPath: true
        });
        return;
      }

      const topPath = reasoning.paths[0];
      const mapped = await mapReasoningPath(topPath, signal);
      query.activePath = topPath;
      query.mappedPath = mapped;
      PKG.activeReasoningPath = mapped;

      PKG.emit("atlas:reasoning-path", {
        question,
        intent,
        steps: mapped.steps.length,
        renderedNodes: mapped.nodeIndexes.length
      });

      const focus = mapped.nodeIndexes.slice();
      entityHits.forEach((hit) => {
        const index = findRenderedIndexById(hit.id);
        if (index >= 0 && focus.indexOf(index) === -1) focus.push(index);
      });

      saveVisualSnapshot(focus);

      const travelIndexes = [];
      mapped.steps.forEach((step) => {
        if (step.fromIndex >= 0 && travelIndexes.indexOf(step.fromIndex) === -1) {
          travelIndexes.push(step.fromIndex);
        }
        if (step.toIndex >= 0 && travelIndexes.indexOf(step.toIndex) === -1) {
          travelIndexes.push(step.toIndex);
        }
        if (step.fromIndex >= 0) boostNode(step.fromIndex, 0.8);
        if (step.toIndex >= 0) boostNode(step.toIndex, 0.8);
        if (step.hasRenderedEdge) boostEdgeBetween(step.fromIndex, step.toIndex, 0.85);
      });

      if (travelIndexes.length) beginGuidedThought(travelIndexes, mapped.steps);
      await dwell(prefersReducedMotion ? 120 : 900, signal);

      setQueryState(QUERY_STATES.EXTRACTING);
      query.stageLabel = "EVALUATING EVIDENCE";
      showTransition("EVALUATING EVIDENCE", 0.4);

      const extractIndexes = (mapped.nodeIndexes.length ? mapped.nodeIndexes : focus).slice(
        0,
        viewport.clientWidth < 720 ? 5 : 8
      );

      if (prefersReducedMotion) {
        extractIndexes.forEach((index) => boostNode(index, 1));
      } else {
        query.extracted = buildExtractionTargets(extractIndexes);
      }

      await dwell(prefersReducedMotion ? 160 : 1100, signal);

      setQueryState(QUERY_STATES.PRESENTING);
      query.stageLabel = "BUILDING GROUNDED ANSWER";
      showTransition("BUILDING GROUNDED ANSWER", 0.35);

      const answerEntities = [];
      const seenAnswerEntities = new Set();
      (mapped.entities || []).concat(entityHits).forEach((entity) => {
        if (!entity || !entity.id || seenAnswerEntities.has(entity.id)) return;
        seenAnswerEntities.add(entity.id);
        answerEntities.push(entity);
      });

      const answer = ATLAS_QUERY.buildAnswer({
        question,
        intent,
        subject,
        reasoning,
        knowledge,
        standards,
        entities: ATLAS_QUERY.rankEntitiesForIntent(
          answerEntities,
          intent,
          question,
          subject
        ),
        mappedPath: mapped
      });

      await dwell(prefersReducedMotion ? 80 : 280, signal);
      presentAnswer(answer);
      query.stageLabel = "COMPLETE";
      showTransition("COMPLETE", 0.5);
      PKG.emit("atlas:query-complete", {
        question,
        intent,
        limited: answer.limited,
        nodes: extractIndexes.length
      });
    }

    function cancelQuery(reason) {
      if (query.controller) {
        try {
          query.controller.abort();
        } catch (error) {
          /* ignore */
        }
      }
      query.generation += 1;
      hardRestoreExtracted();
      restoreVisualSnapshot();
      hideAnswer();
      clearTransition();
      if (thought.active && query.thoughtGuided) {
        thought.active = false;
        thought.phase = "idle";
        hideThoughtVisuals();
      }
      resumeAmbientAfterQuery();
      query.mappedPath = null;
      query.activePath = null;
      PKG.activeReasoningPath = null;
      PKG.activeQuery = null;
      setQueryState(QUERY_STATES.CANCELLED, {
        event: "atlas:query-cancelled",
        payload: { reason: reason || "cancelled" }
      });
      window.setTimeout(() => {
        if (query.state === QUERY_STATES.CANCELLED) setQueryState(QUERY_STATES.IDLE);
      }, 200);
    }

    function startReturn() {
      if (query.state === QUERY_STATES.RETURNING) return;
      PKG.emit("atlas:return-start", {
        nodes: query.extracted.map((item) => item.index)
      });

      hideAnswer();
      clearTransition();
      query.stageLabel = "RETURNING TO GRAPH";
      setQueryState(QUERY_STATES.RETURNING);

      if (prefersReducedMotion || !query.extracted.length) {
        hardRestoreExtracted();
        restoreVisualSnapshot();
        resumeAmbientAfterQuery();
        query.mappedPath = null;
        PKG.activeReasoningPath = null;
        PKG.activeQuery = null;
        if (coreMark) {
          coreMark.classList.add("is-aware");
          window.setTimeout(() => coreMark && coreMark.classList.remove("is-aware"), 700);
        }
        setQueryState(QUERY_STATES.IDLE);
        PKG.emit("atlas:query-complete", { returned: true });
        return;
      }

      query.returnQueue = query.extracted
        .slice()
        .reverse()
        .map((item, order) => {
          item.phase = "return";
          item.t = -order * 0.08;
          item.locked = false;
          return item;
        });
      query.lockCount = 0;
    }

    function updateExtraction(delta) {
      if (!query.extracted.length) return;

      const touched = new Set();
      let allLocked = true;
      const returning = query.state === QUERY_STATES.RETURNING;

      for (let i = 0; i < query.extracted.length; i++) {
        const item = query.extracted[i];
        touched.add(item.index);

        if (item.phase === "extract" && !returning) {
          item.t = Math.min(1, item.t + delta * 0.85);
          const e = easeInOutCubic(item.t);
          extractScratch.cur.copy(item.home).lerp(item.target, e);
          extractScratch.mid.copy(item.home).add(item.target).multiplyScalar(0.5);
          extractScratch.mid.normalize().multiplyScalar(sphereRadius * 0.2);
          extractScratch.cur.addScaledVector(extractScratch.mid, Math.sin(e * Math.PI) * 0.35);
          nodePositions[item.index].copy(extractScratch.cur);
          sizes[item.index] = item.homeSize * (1 + e * 0.18);
          boostNode(item.index, 0.35);
          if (item.t < 1) allLocked = false;
        } else if (item.phase === "return") {
          item.t = Math.min(1.2, item.t + delta * 0.95);
          const raw = Math.max(0, item.t);
          let e = easeInOutCubic(Math.min(1, raw));
          if (raw > 0.82 && raw < 1.05) {
            const over = Math.sin(((raw - 0.82) / 0.23) * Math.PI) * 0.045;
            e = Math.min(1, e + over);
          }
          extractScratch.cur.copy(item.target).lerp(item.home, Math.min(1, e));
          nodePositions[item.index].copy(extractScratch.cur);
          sizes[item.index] = item.homeSize * (1.18 - Math.min(1, e) * 0.18);

          if (raw >= 1 && !item.locked) {
            nodePositions[item.index].copy(item.home);
            sizes[item.index] = item.homeSize;
            item.locked = true;
            query.lockCount += 1;
            const finalLock = query.lockCount >= query.extracted.length;
            playLockClick(finalLock);
            boostNode(item.index, finalLock ? 0.9 : 0.55);
          }

          if (!item.locked) allLocked = false;
        } else {
          allLocked = allLocked && item.locked;
        }

        syncNodeBuffer(item.index);
      }

      nodeGeometry.attributes.position.needsUpdate = true;
      nodeGeometry.attributes.aSize.needsUpdate = true;
      syncEdgesForIndexes(touched);

      if (returning && allLocked) {
        hardRestoreExtracted();
        restoreVisualSnapshot();
        resumeAmbientAfterQuery();
        query.mappedPath = null;
        query.activePath = null;
        PKG.activeReasoningPath = null;
        PKG.activeQuery = null;
        if (coreMark) {
          coreMark.classList.add("is-aware");
          window.setTimeout(() => coreMark && coreMark.classList.remove("is-aware"), 700);
        }
        setQueryState(QUERY_STATES.IDLE);
        PKG.emit("atlas:query-complete", { returned: true, locked: true });
      }
    }

    async function runQuery(question) {
      if (!QUERY_REASONING_ENABLED) {
        return Promise.reject(new Error("Query reasoning disabled"));
      }

      const clean = ATLAS_QUERY.text(question);
      if (clean.length < 2) return;

      if (
        query.state !== QUERY_STATES.IDLE &&
        query.state !== QUERY_STATES.PRESENTING &&
        query.state !== QUERY_STATES.ERROR &&
        query.state !== QUERY_STATES.CANCELLED
      ) {
        cancelQuery("superseded");
      } else if (query.state === QUERY_STATES.PRESENTING) {
        hardRestoreExtracted();
        restoreVisualSnapshot();
        hideAnswer();
      }

      ensureAudio();
      if (!soundEnabled) {
        // First gesture may enable sound preference only when user has opted in via toggle.
      }

      const generation = ++query.generation;
      query.controller = new AbortController();
      const signal = query.controller.signal;

      if (queryUi.submit) queryUi.submit.disabled = true;
      if (queryUi.input) queryUi.input.value = clean;

      try {
        await runQueryPipeline(clean, generation, signal);
      } catch (error) {
        if (generation !== query.generation) return;
        if (error && error.name === "AbortError") {
          return;
        }

        console.warn("Atlas query failed.", error);
        hardRestoreExtracted();
        restoreVisualSnapshot();
        resumeAmbientAfterQuery();
        clearTransition();

        presentAnswer({
          question: clean,
          body:
            "Atlas could not complete that request. The graph is unchanged. " +
            (error && error.message ? error.message : "Please try again."),
          limited: true,
          confidence: null,
          entities: [],
          pathSteps: [],
          evidence: [],
          standards: [],
          standardsNotice: "",
          note: "No private data was exposed. You can ask another question."
        });

        setQueryState(QUERY_STATES.ERROR, {
          event: "atlas:query-error",
          payload: {
            question: clean,
            message: error && error.message ? error.message : String(error)
          }
        });
      } finally {
        if (generation === query.generation && queryUi.submit) {
          queryUi.submit.disabled = false;
        }
      }
    }

    function resetQuery() {
      if (query.state === QUERY_STATES.IDLE && (!query.extracted || !query.extracted.length)) {
        hideAnswer();
        return;
      }

      if (
        query.state === QUERY_STATES.RESOLVING ||
        query.state === QUERY_STATES.REASONING ||
        query.state === QUERY_STATES.EXTRACTING
      ) {
        cancelQuery("reset");
        return;
      }

      startReturn();
    }

    function mountQueryUi() {
      if (!QUERY_REASONING_ENABLED) return;
      if (!queryUi.root) return;

      queryUi.root.hidden = false;
      syncSoundButton();

      if (queryUi.submit) {
        queryUi.submit.addEventListener("click", function () {
          runQuery(queryUi.input ? queryUi.input.value : "");
        });
      }

      if (queryUi.input) {
        queryUi.input.addEventListener("keydown", function (event) {
          if (event.key === "Enter") {
            event.preventDefault();
            runQuery(queryUi.input.value);
          }
        });
      }

      if (queryUi.examples) {
        queryUi.examples.addEventListener("click", function (event) {
          const button = event.target.closest("button[data-example]");
          if (!button || !queryUi.input) return;
          queryUi.input.value = button.getAttribute("data-example") || "";
          queryUi.input.focus();
        });
      }

      if (queryUi.answerClose) {
        queryUi.answerClose.addEventListener("click", function () {
          resetQuery();
        });
      }

      if (queryUi.soundBtn) {
        queryUi.soundBtn.addEventListener("click", function () {
          ensureAudio();
          soundEnabled = !soundEnabled;
          try {
            window.localStorage.setItem(SOUND_KEY, soundEnabled ? "1" : "0");
          } catch (error) {
            /* ignore */
          }
          syncSoundButton();
          if (soundEnabled) playLockClick(false);
        });
      }

      window.addEventListener("keydown", function (event) {
        if (event.key === "Escape") resetQuery();
      });
    }

    function updateQuerySystem(delta, elapsed) {
      if (!QUERY_REASONING_ENABLED) return;

      if (query.transitionUntil && elapsed > query.transitionUntil) {
        if (query.state === QUERY_STATES.PRESENTING || query.state === QUERY_STATES.IDLE) {
          clearTransition();
        }
      }

      if (
        query.state === QUERY_STATES.EXTRACTING ||
        query.state === QUERY_STATES.PRESENTING ||
        query.state === QUERY_STATES.RETURNING
      ) {
        updateExtraction(delta);
      }
    }

    PKG.queryState = QUERY_STATES.IDLE;
    PKG.activeQuery = null;
    PKG.activeReasoningPath = null;
    PKG.runQuery = runQuery;
    PKG.cancelQuery = function () {
      cancelQuery("api");
    };
    PKG.resetQuery = resetQuery;

    mountQueryUi();

    PKG.ready = true;
    PKG.emit("ready", { version: PKG.version, codename: PKG.codename });

    resize();
    animate();

    PKG._raf = frameId;

    // Live data arrives after first paint — the demo scene is already on screen.
    PKG.reloadGraph();

  } catch (error) {
    console.warn("Precision Knowledge Graph could not initialize.", error);

    if (fallback) fallback.hidden = false;

    setText("pkg1-live-label", "VISUALIZATION UNAVAILABLE");
    setText("pkg1-network-label", "PUBLIC PLATFORM ONLINE");

    root.classList.add("pkg1--degraded");
  }
})();
</script>

<script>
  // Lightweight iframe bridge — reports natural height to the Elementor embed.
  (function () {
    var MESSAGE_SOURCE = "precision-atlas";

    function measure() {
      var root = document.getElementById("precision-knowledge-graph");
      var height = 0;

      if (root) {
        var rect = root.getBoundingClientRect();
        height = Math.ceil(Math.max(root.scrollHeight, root.offsetHeight, rect.height));
      }

      height = Math.max(
        height,
        Math.ceil(document.documentElement.scrollHeight),
        Math.ceil(document.body.scrollHeight)
      );

      return height;
    }

    function report(reason) {
      if (window.parent === window) return;

      var height = measure();
      if (!height) return;

      window.parent.postMessage(
        {
          source: MESSAGE_SOURCE,
          type: "atlas:resize",
          height: height,
          reason: reason || "resize"
        },
        "*"
      );
    }

    function ready() {
      report("ready");
      if (window.parent !== window) {
        window.parent.postMessage(
          {
            source: MESSAGE_SOURCE,
            type: "atlas:ready",
            height: measure()
          },
          "*"
        );
      }
    }

    window.addEventListener("load", function () {
      ready();
      window.setTimeout(function () { report("load+250"); }, 250);
      window.setTimeout(function () { report("load+1000"); }, 1000);
      window.setTimeout(function () { report("load+2500"); }, 2500);
    });

    window.addEventListener("resize", function () {
      report("window-resize");
    });

    if (typeof ResizeObserver !== "undefined") {
      var root = document.getElementById("precision-knowledge-graph");
      if (root) {
        var ro = new ResizeObserver(function () {
          report("root-resize");
        });
        ro.observe(root);
      }
    }

    window.addEventListener("message", function (event) {
      var data = event.data;
      if (!data || data.source !== MESSAGE_SOURCE) return;
      if (data.type === "atlas:ping") report("ping");
    });
  })();
</script>
</body>
</html>