easter-egg-quest 1.0.0

package/dist/easter-egg-quest.es.js

@@ -0,0 +1,4997 @@
+const DEFAULT_SCRIPT = {
+  // ── Stage 0: Hidden entry hints (shown in escalating order) ───────────
+  hiddenEntryHints: [
+    "hey, it's not a bug — there's a hidden game on this page",
+    "look carefully — two words are hiding among the text",
+    "it blends in with everything else, but it’s clickable"
+  ],
+  // ── Entry confirmation ────────────────────────────────────────────────
+  entryConfirmation: [
+    "...",
+    "you noticed",
+    "then we can begin"
+  ],
+  // ── Stage 1: Stillness ────────────────────────────────────────────────
+  stage1Intro: [
+    "three eggs are hidden here",
+    "each one asks something different",
+    "the first riddle:",
+    "I am a cat that comes only to those who ignore it. Open your hand — and I leave. Close it — and I was never there."
+  ],
+  stage1Reactions: [
+    "the cat is watching",
+    "it doesn’t trust you yet",
+    "you’re trying too hard",
+    "what does a cat want?",
+    "the hand is still clenched",
+    "have you tried not trying?",
+    "forget the egg exists",
+    "it won’t come if you’re waiting",
+    "some things can’t be taken",
+    "only given"
+  ],
+  stage1Success: [
+    "you understood",
+    "stillness was the answer",
+    "the first egg reveals itself",
+    "to those who can stop",
+    "hold it to collect"
+  ],
+  // ── Stage 2: Motion ───────────────────────────────────────────────────
+  stage2Intro: [
+    "you solved the first one",
+    "the second riddle:",
+    "I am a river that needs you to flow. Without you, I dry up. But you can’t carry me — only become me.",
+    "what am I?"
+  ],
+  stage2Reactions: [
+    "the river is dry",
+    "nothing flows",
+    "what does a river need?",
+    "you are the current",
+    "without you, there’s no river",
+    "the answer isn’t in your head",
+    "it’s in your hands",
+    "be the water"
+  ],
+  stage2Success: [
+    "movement was the answer",
+    "the second egg appears",
+    "for those who never stop",
+    "not stillness this time",
+    "but life in motion"
+  ],
+  // ── Stage 3: Rhythm ───────────────────────────────────────────────────
+  stage3Intro: [
+    "two truths that shouldn’t exist together",
+    "the final riddle:",
+    "I am the conversation between opposites. Every living thing knows me. You’ve been doing me your whole life without thinking."
+  ],
+  stage3Reactions: [
+    "one truth alone isn’t enough",
+    "the other alone isn’t either",
+    "what do all living things share?",
+    "you already know the answer",
+    "you’ve been doing it since birth",
+    "listen to yourself",
+    "closer...",
+    "can you feel it?",
+    "the body remembers",
+    "in",
+    "out"
+  ],
+  stage3Success: [
+    "rhythm was the answer",
+    "not stopping, not rushing",
+    "but the dance between them",
+    "the third egg appears",
+    "for those who breathe"
+  ],
+  // ── Finale ────────────────────────────────────────────────────────────
+  finale: [
+    "you were looking for three eggs",
+    "but you found something else",
+    "stillness",
+    "motion",
+    "rhythm",
+    "this is where life appears"
+  ],
+  // ── Results / Share ───────────────────────────────────────────────────
+  results: [
+    "begin again",
+    "challenge someone"
+  ]
+};
+const THEME_DEFAULTS = {
+  overlayBg: "rgba(0,0,0,0.25)",
+  textColor: "rgba(255,255,255,0.92)",
+  textSecondary: "rgba(255,255,255,0.55)",
+  accent: "#D4A574",
+  accentGlow: "rgba(212,165,116,0.4)",
+  hudBg: "rgba(0,0,0,0.45)",
+  hudText: "rgba(255,255,255,0.85)"
+};
+const DANGEROUS_KEYWORDS = [
+  "buy",
+  "purchase",
+  "checkout",
+  "pay",
+  "delete",
+  "remove",
+  "submit",
+  "confirm",
+  "order",
+  "sign out",
+  "log out",
+  "logout",
+  "signout",
+  "unsubscribe",
+  "cancel",
+  "close account"
+];
+const DEFAULT_EXCLUDE_SELECTORS = [
+  'form [type="submit"]',
+  "[data-no-easter]"
+];
+function resolveConfig(raw = {}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
+  const prefersReduced = typeof window !== "undefined" && ((_a = window.matchMedia) == null ? void 0 : _a.call(window, "(prefers-reduced-motion: reduce)").matches);
+  const theme = resolveTheme(raw.theme);
+  return {
+    theme,
+    hiddenEntry: {
+      mode: ((_b = raw.hiddenEntry) == null ? void 0 : _b.mode) ?? "auto",
+      selector: (_c = raw.hiddenEntry) == null ? void 0 : _c.selector,
+      excludeSelectors: [
+        ...DEFAULT_EXCLUDE_SELECTORS,
+        ...((_d = raw.hiddenEntry) == null ? void 0 : _d.excludeSelectors) ?? []
+      ]
+    },
+    hud: typeof raw.hud === "boolean" ? { enabled: raw.hud, position: "top-left" } : { enabled: ((_e = raw.hud) == null ? void 0 : _e.enabled) ?? true, position: ((_f = raw.hud) == null ? void 0 : _f.position) ?? "top-left" },
+    shrine: typeof raw.shrine === "boolean" ? { enabled: raw.shrine, position: "bottom-right" } : { enabled: ((_g = raw.shrine) == null ? void 0 : _g.enabled) ?? true, position: ((_h = raw.shrine) == null ? void 0 : _h.position) ?? "bottom-right" },
+    sounds: raw.sounds ?? false,
+    stageDurations: {
+      stillnessMs: ((_i = raw.stageDurations) == null ? void 0 : _i.stillnessMs) ?? 2e4,
+      motionMs: ((_j = raw.stageDurations) == null ? void 0 : _j.motionMs) ?? 2e4,
+      rhythmCycles: ((_k = raw.stageDurations) == null ? void 0 : _k.rhythmCycles) ?? 6
+    },
+    renderer: raw.renderer ?? "auto",
+    scoring: {
+      enableLocal: ((_l = raw.scoring) == null ? void 0 : _l.enableLocal) ?? true,
+      leaderboardAdapter: (_m = raw.scoring) == null ? void 0 : _m.leaderboardAdapter
+    },
+    accessibility: {
+      reducedMotion: ((_n = raw.accessibility) == null ? void 0 : _n.reducedMotion) === "auto" ? prefersReduced : ((_o = raw.accessibility) == null ? void 0 : _o.reducedMotion) ?? prefersReduced,
+      highContrast: ((_p = raw.accessibility) == null ? void 0 : _p.highContrast) ?? false,
+      disableHiddenEntry: ((_q = raw.accessibility) == null ? void 0 : _q.disableHiddenEntry) ?? false,
+      subtitlesLog: ((_r = raw.accessibility) == null ? void 0 : _r.subtitlesLog) ?? false
+    },
+    callbacks: raw.callbacks ?? {}
+  };
+}
+function resolveTheme(input) {
+  if (!input || input === "auto" || input === "light" || input === "dark") {
+    return { ...THEME_DEFAULTS };
+  }
+  return { ...THEME_DEFAULTS, ...input };
+}
+function resolveNarrative(overrides) {
+  if (!overrides) return { ...DEFAULT_SCRIPT };
+  return { ...DEFAULT_SCRIPT, ...overrides };
+}
+class EventBus {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(event, fn) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(fn);
+  }
+  off(event, fn) {
+    var _a;
+    (_a = this.listeners.get(event)) == null ? void 0 : _a.delete(fn);
+  }
+  emit(event, ...args) {
+    var _a;
+    (_a = this.listeners.get(event)) == null ? void 0 : _a.forEach((fn) => {
+      try {
+        fn(...args);
+      } catch {
+      }
+    });
+  }
+  clear() {
+    this.listeners.clear();
+  }
+}
+const VALID_TRANSITIONS = {
+  "idle": ["entry"],
+  "entry": ["stage1-intro"],
+  "stage1-intro": ["stage1-active"],
+  "stage1-active": ["stage1-success"],
+  "stage1-success": ["stage2-intro"],
+  "stage2-intro": ["stage2-active"],
+  "stage2-active": ["stage2-success"],
+  "stage2-success": ["stage3-intro"],
+  "stage3-intro": ["stage3-active"],
+  "stage3-active": ["stage3-success"],
+  "stage3-success": ["finale"],
+  "finale": ["results"],
+  "results": ["complete", "idle"],
+  "complete": ["idle"]
+};
+class StateMachine {
+  constructor() {
+    this._state = "idle";
+    this._onTransition = null;
+  }
+  get state() {
+    return this._state;
+  }
+  /** Register a callback invoked on every valid transition. */
+  onTransition(cb) {
+    this._onTransition = cb;
+  }
+  /** Attempt a transition. Returns true if valid, false otherwise. */
+  transitionTo(next) {
+    var _a;
+    const allowed = VALID_TRANSITIONS[this._state];
+    if (!allowed || !allowed.includes(next)) {
+      console.warn(`[EasterEggQuest] Invalid transition: ${this._state} → ${next}`);
+      return false;
+    }
+    const prev = this._state;
+    this._state = next;
+    (_a = this._onTransition) == null ? void 0 : _a.call(this, prev, next);
+    return true;
+  }
+  /** Force-reset to idle (used for restart / destroy). */
+  reset() {
+    this._state = "idle";
+  }
+  /** Force state to a specific value (used for resuming from checkpoint). */
+  forceState(state) {
+    this._state = state;
+  }
+  /** Human-readable label for the current stage. */
+  get label() {
+    return STAGE_LABELS[this._state] ?? "";
+  }
+}
+const STAGE_LABELS = {
+  "idle": "",
+  "entry": "Searching",
+  "stage1-intro": "Stillness",
+  "stage1-active": "Stillness",
+  "stage1-success": "Stillness",
+  "stage2-intro": "Motion",
+  "stage2-active": "Motion",
+  "stage2-success": "Motion",
+  "stage3-intro": "Rhythm",
+  "stage3-active": "Rhythm",
+  "stage3-success": "Rhythm",
+  "finale": "Finale",
+  "results": "Results",
+  "complete": "Complete"
+};
+class InputTracker {
+  constructor() {
+    this._snapshot = {
+      isMoving: false,
+      lastMoveTime: 0,
+      lastStillTime: Date.now(),
+      mouseX: 0,
+      mouseY: 0,
+      velocity: 0,
+      totalClicks: 0,
+      totalScrolls: 0,
+      totalKeyPresses: 0,
+      totalDistance: 0,
+      maxVelocity: 0
+    };
+    this._phases = [];
+    this._currentPhaseType = "still";
+    this._currentPhaseStart = Date.now();
+    this._prevX = 0;
+    this._prevY = 0;
+    this._prevMoveTs = 0;
+    this.STILL_THRESHOLD_MS = 400;
+    this.MIN_PHASE_MS = 300;
+    this._stillTimer = null;
+    this._handlers = [];
+    this._active = false;
+    this._onVisibilityChange = () => {
+      if (document.hidden) {
+        this._snapshot.isMoving = true;
+      } else {
+        const now = Date.now();
+        this._snapshot.isMoving = false;
+        this._snapshot.lastStillTime = now;
+        this._snapshot.velocity = 0;
+        this._currentPhaseType = "still";
+        this._currentPhaseStart = now;
+      }
+    };
+    this._onWindowBlur = () => {
+      this._snapshot.isMoving = true;
+    };
+    this._onPointerMove = (e) => {
+      const now = Date.now();
+      const dx = e.clientX - this._prevX;
+      const dy = e.clientY - this._prevY;
+      const dt = now - this._prevMoveTs || 1;
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      if (dist < 2) return;
+      this._snapshot.mouseX = e.clientX;
+      this._snapshot.mouseY = e.clientY;
+      this._snapshot.velocity = dist / dt * 1e3;
+      this._snapshot.totalDistance += dist;
+      if (this._snapshot.velocity > this._snapshot.maxVelocity) {
+        this._snapshot.maxVelocity = this._snapshot.velocity;
+      }
+      this._prevX = e.clientX;
+      this._prevY = e.clientY;
+      this._prevMoveTs = now;
+      this._registerMove(now);
+    };
+    this._onTouchMove = (e) => {
+      const t = e.touches[0];
+      if (!t) return;
+      const now = Date.now();
+      const dx = t.clientX - this._prevX;
+      const dy = t.clientY - this._prevY;
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      if (dist < 2) return;
+      this._snapshot.mouseX = t.clientX;
+      this._snapshot.mouseY = t.clientY;
+      this._prevX = t.clientX;
+      this._prevY = t.clientY;
+      this._prevMoveTs = now;
+      this._registerMove(now);
+    };
+    this._onClick = () => {
+      this._snapshot.totalClicks++;
+      this._registerMove(Date.now());
+    };
+    this._onActivity = () => {
+      this._registerMove(Date.now());
+    };
+    this._onScroll = () => {
+      this._snapshot.totalScrolls++;
+      this._registerMove(Date.now());
+    };
+    this._onKeyDown = () => {
+      this._snapshot.totalKeyPresses++;
+      this._registerMove(Date.now());
+    };
+  }
+  get snapshot() {
+    return { ...this._snapshot };
+  }
+  get phases() {
+    return this._phases.slice();
+  }
+  /** How long the user has been continuously still (ms). Returns 0 if moving. */
+  get stillDuration() {
+    if (this._snapshot.isMoving) return 0;
+    return Date.now() - this._snapshot.lastStillTime;
+  }
+  /** How long the user has been continuously moving (ms). Returns 0 if still. */
+  get moveDuration() {
+    if (!this._snapshot.isMoving) return 0;
+    return Date.now() - this._snapshot.lastMoveTime;
+  }
+  /** Time since any recorded activity. */
+  get timeSinceLastActivity() {
+    return Date.now() - Math.max(this._snapshot.lastMoveTime, this._snapshot.lastStillTime);
+  }
+  start() {
+    if (this._active) return;
+    this._active = true;
+    this._snapshot.lastStillTime = Date.now();
+    const listen = (event, fn, options) => {
+      window.addEventListener(event, fn, { passive: true, ...options });
+      this._handlers.push({ event, fn });
+    };
+    listen("mousemove", this._onPointerMove);
+    listen("touchmove", this._onTouchMove);
+    listen("click", this._onClick);
+    listen("mousedown", this._onActivity);
+    listen("touchstart", this._onActivity);
+    listen("scroll", this._onScroll, { capture: true });
+    listen("keydown", this._onKeyDown);
+    listen("wheel", this._onScroll);
+    const visHandler = this._onVisibilityChange;
+    document.addEventListener("visibilitychange", visHandler);
+    this._handlers.push({ event: "visibilitychange", fn: visHandler });
+    window.addEventListener("blur", this._onWindowBlur);
+    this._handlers.push({ event: "blur", fn: this._onWindowBlur });
+  }
+  stop() {
+    this._active = false;
+    for (const { event, fn } of this._handlers) {
+      window.removeEventListener(event, fn);
+      document.removeEventListener(event, fn);
+    }
+    this._handlers = [];
+    if (this._stillTimer) clearTimeout(this._stillTimer);
+  }
+  /** Reset phase history (e.g., between stages). */
+  resetPhases() {
+    this._phases = [];
+    this._currentPhaseType = "still";
+    this._currentPhaseStart = Date.now();
+  }
+  resetCounts() {
+    this._snapshot.totalClicks = 0;
+    this._snapshot.totalScrolls = 0;
+    this._snapshot.totalKeyPresses = 0;
+    this._snapshot.totalDistance = 0;
+    this._snapshot.maxVelocity = 0;
+  }
+  // ─── Movement / Stillness transition logic ─────────────────────────────
+  _registerMove(now) {
+    this._snapshot.lastMoveTime = now;
+    if (!this._snapshot.isMoving) {
+      this._snapshot.isMoving = true;
+      this._completePhase("still", now);
+      this._currentPhaseType = "move";
+      this._currentPhaseStart = now;
+    }
+    if (this._stillTimer) clearTimeout(this._stillTimer);
+    this._stillTimer = setTimeout(() => {
+      this._becomeStill();
+    }, this.STILL_THRESHOLD_MS);
+  }
+  _becomeStill() {
+    if (!this._snapshot.isMoving) return;
+    const now = Date.now();
+    this._snapshot.isMoving = false;
+    this._snapshot.lastStillTime = now;
+    this._snapshot.velocity = 0;
+    this._completePhase("move", now);
+    this._currentPhaseType = "still";
+    this._currentPhaseStart = now;
+  }
+  _completePhase(type, endTime) {
+    const duration = endTime - this._currentPhaseStart;
+    if (duration >= this.MIN_PHASE_MS) {
+      this._phases.push({
+        type,
+        startTime: this._currentPhaseStart,
+        endTime,
+        duration
+      });
+    }
+    if (this._phases.length > 200) {
+      this._phases = this._phases.slice(-100);
+    }
+  }
+}
+function isElementVisible(el) {
+  const rect = el.getBoundingClientRect();
+  if (rect.width === 0 || rect.height === 0) return false;
+  const style = getComputedStyle(el);
+  if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") return false;
+  return rect.top < window.innerHeight && rect.bottom > 0 && rect.left < window.innerWidth && rect.right > 0;
+}
+function isDangerousElement(el) {
+  const text = (el.textContent ?? "").toLowerCase().trim();
+  const ariaLabel = (el.getAttribute("aria-label") ?? "").toLowerCase();
+  const combined = `${text} ${ariaLabel}`;
+  return DANGEROUS_KEYWORDS.some((kw) => combined.includes(kw));
+}
+function findEligibleEntryElements(containerSelector, excludeSelectors = []) {
+  const container = containerSelector ? document.querySelector(containerSelector) ?? document.body : document.body;
+  const candidates = container.querySelectorAll(
+    'a, button, [role="button"], nav a, nav button, .cta, [data-easter-entry]'
+  );
+  const excludeSet = /* @__PURE__ */ new Set();
+  for (const sel of excludeSelectors) {
+    document.querySelectorAll(sel).forEach((el) => excludeSet.add(el));
+  }
+  const eligible = [];
+  candidates.forEach((el) => {
+    if (excludeSet.has(el)) return;
+    if (!isElementVisible(el)) return;
+    if (isDangerousElement(el)) return;
+    const rect = el.getBoundingClientRect();
+    if (rect.width < 30 || rect.height < 20) return;
+    eligible.push(el);
+  });
+  return eligible;
+}
+function pickRandom(arr) {
+  if (arr.length === 0) return void 0;
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function formatTime(ms) {
+  const totalSec = Math.floor(ms / 1e3);
+  const min = Math.floor(totalSec / 60);
+  const sec = totalSec % 60;
+  return `${String(min).padStart(2, "0")}:${String(sec).padStart(2, "0")}`;
+}
+class HiddenEntry {
+  constructor(config, script, onFound) {
+    this.targetElement = null;
+    this.hintTimers = [];
+    this.hintIndex = 0;
+    this.hintContainer = null;
+    this.shimmerStyle = null;
+    this.clickHandler = null;
+    this.fallbackButton = null;
+    this._injectedElement = null;
+    this._destroyed = false;
+    this.config = config;
+    this.script = script;
+    this.onFound = onFound;
+  }
+  start() {
+    if (this.config.accessibility.disableHiddenEntry) {
+      this._createFallbackEntry();
+      return;
+    }
+    const eligible = findEligibleEntryElements(
+      this.config.hiddenEntry.selector,
+      this.config.hiddenEntry.excludeSelectors
+    );
+    if (eligible.length === 0) {
+      this._createFallbackEntry();
+      return;
+    }
+    this._injectIntoExisting(eligible);
+    this._startHintEscalation();
+  }
+  cleanup() {
+    var _a, _b, _c, _d;
+    this._destroyed = true;
+    for (const t of this.hintTimers) clearTimeout(t);
+    this.hintTimers = [];
+    if (this.clickHandler && this.targetElement) {
+      this.targetElement.removeEventListener("click", this.clickHandler);
+    }
+    if (this.targetElement) {
+      this.targetElement.style.removeProperty("animation");
+      this.targetElement.classList.remove("eeq-entry-target");
+    }
+    (_a = this._injectedElement) == null ? void 0 : _a.remove();
+    this._injectedElement = null;
+    (_b = this.hintContainer) == null ? void 0 : _b.remove();
+    (_c = this.shimmerStyle) == null ? void 0 : _c.remove();
+    (_d = this.fallbackButton) == null ? void 0 : _d.remove();
+  }
+  // ─── Strategy 1: possess an existing element ──────────────────────────
+  _possessElement(eligible) {
+    this.targetElement = pickRandom(eligible);
+    this._attachToElement(this.targetElement);
+  }
+  // ─── Inject trigger text inside an existing element ─────────────────
+  _injectIntoExisting(_eligible) {
+    const candidates = Array.from(
+      document.querySelectorAll(
+        "p, li, figcaption, blockquote, h4, h3, h2, h1, header a, nav a, nav button"
+      )
+    ).filter((el) => {
+      var _a;
+      const text = ((_a = el.textContent) == null ? void 0 : _a.trim()) ?? "";
+      const rect = el.getBoundingClientRect();
+      return text.length >= 2 && rect.width > 0 && rect.height > 0 && !el.closest("[data-eeq]");
+    });
+    const sorted = candidates.sort((a, b) => {
+      const aNav = a.closest("nav") !== null || a.closest("header") !== null ? 1 : 0;
+      const bNav = b.closest("nav") !== null || b.closest("header") !== null ? 1 : 0;
+      if (aNav !== bNav) return aNav - bNav;
+      const aSize = parseFloat(getComputedStyle(a).fontSize);
+      const bSize = parseFloat(getComputedStyle(b).fontSize);
+      return aSize - bSize;
+    });
+    const prints = sorted.map(
+      (el) => {
+        var _a;
+        return `${el.tagName}:${(((_a = el.textContent) == null ? void 0 : _a.trim()) ?? "").slice(0, 30)}`;
+      }
+    );
+    const HISTORY_KEY = "eeq_trigger_history";
+    let usedList = [];
+    try {
+      const raw = localStorage.getItem(HISTORY_KEY);
+      if (raw) usedList = JSON.parse(raw);
+    } catch {
+    }
+    let usedSet = new Set(usedList);
+    const VISIT_KEY = "eeq_visit";
+    let visitCount = 0;
+    try {
+      visitCount = parseInt(localStorage.getItem(VISIT_KEY) || "0", 10) || 0;
+      localStorage.setItem(VISIT_KEY, String(visitCount + 1));
+    } catch {
+    }
+    const bodyEls = sorted.filter(
+      (el) => !el.closest("nav") && !el.closest("header")
+    );
+    const navEls = sorted.filter(
+      (el) => el.closest("nav") !== null || el.closest("header") !== null
+    );
+    const offset = bodyEls.length > 1 ? visitCount % bodyEls.length : 0;
+    const rotated = [
+      ...bodyEls.slice(offset),
+      ...bodyEls.slice(0, offset),
+      ...navEls
+    ];
+    const rotatedPrints = rotated.map(
+      (el) => {
+        var _a;
+        return `${el.tagName}:${(((_a = el.textContent) == null ? void 0 : _a.trim()) ?? "").slice(0, 30)}`;
+      }
+    );
+    const unused = rotated.filter((_, i) => !usedSet.has(rotatedPrints[i]));
+    if (unused.length === 0) {
+      usedSet.clear();
+      usedList = [];
+    }
+    const ordered = unused.length > 0 ? [...unused, ...rotated.filter((_, i) => usedSet.has(rotatedPrints[i]))] : rotated;
+    for (const candidate of ordered) {
+      const host = candidate;
+      const isInline = host.tagName === "A" || host.tagName === "BUTTON" || host.tagName === "LI" || host.closest("nav") !== null;
+      const span = document.createElement("span");
+      span.textContent = isInline ? " · start hunt" : " start hunt";
+      span.style.cssText = `
+        font: inherit;
+        color: inherit;
+        letter-spacing: inherit;
+        cursor: pointer;
+      `;
+      const inserted = !isInline && this._tryInsertBetweenWords(host, span);
+      if (!inserted) {
+        const heightBefore = host.getBoundingClientRect().height;
+        host.appendChild(span);
+        const heightAfter = host.getBoundingClientRect().height;
+        if (Math.abs(heightAfter - heightBefore) > 2) {
+          host.removeChild(span);
+          continue;
+        }
+      }
+      const idx = sorted.indexOf(candidate);
+      if (idx >= 0) {
+        usedSet.add(prints[idx]);
+        try {
+          localStorage.setItem(HISTORY_KEY, JSON.stringify([...usedSet].slice(-20)));
+        } catch {
+        }
+      }
+      this._injectedElement = span;
+      this.targetElement = span;
+      this._attachToElement(span);
+      return;
+    }
+    this._createFallbackEntry();
+  }
+  /**
+   * Try to insert the trigger span between words inside a text node.
+   * Picks a random word boundary in the element's first direct text node.
+   * Returns true if inserted without layout shift.
+   */
+  _tryInsertBetweenWords(host, span) {
+    var _a;
+    const textNodes = [];
+    for (const node of host.childNodes) {
+      if (node.nodeType === Node.TEXT_NODE && (((_a = node.textContent) == null ? void 0 : _a.trim().length) ?? 0) > 5) {
+        textNodes.push(node);
+      }
+    }
+    if (!textNodes.length) return false;
+    const slotSeed = Math.floor(Date.now() / (1e3 * 60 * 2));
+    const textNode = textNodes[slotSeed % textNodes.length];
+    const text = textNode.textContent ?? "";
+    const spacePositions = [];
+    for (let i = 1; i < text.length - 1; i++) {
+      if (text[i] === " ") spacePositions.push(i);
+    }
+    if (spacePositions.length < 2) return false;
+    const start = Math.floor(spacePositions.length * 0.25);
+    const end = Math.floor(spacePositions.length * 0.75);
+    const idx = start + slotSeed % Math.max(1, end - start);
+    const splitAt = spacePositions[Math.min(idx, spacePositions.length - 1)];
+    const before = text.slice(0, splitAt);
+    const after = text.slice(splitAt);
+    const heightBefore = host.getBoundingClientRect().height;
+    const afterNode = document.createTextNode(after);
+    textNode.textContent = before;
+    host.insertBefore(afterNode, textNode.nextSibling);
+    host.insertBefore(span, afterNode);
+    const heightAfter = host.getBoundingClientRect().height;
+    if (Math.abs(heightAfter - heightBefore) > 2) {
+      host.removeChild(span);
+      host.removeChild(afterNode);
+      textNode.textContent = text;
+      return false;
+    }
+    return true;
+  }
+  // ─── Shared ───────────────────────────────────────────────────────────
+  _attachToElement(el) {
+    this.clickHandler = (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      if (this._destroyed) return;
+      this.cleanup();
+      this.onFound();
+    };
+    el.addEventListener("click", this.clickHandler, {
+      capture: true,
+      once: true
+    });
+  }
+  _startHintEscalation() {
+    this._injectShimmerStyles();
+    this._createHintContainer();
+    const hints = this.script.hiddenEntryHints;
+    const FIRST_HINT_DELAY = 5e3;
+    const HINT_INTERVAL = 3e3;
+    for (let i = 0; i < hints.length; i++) {
+      const delay = FIRST_HINT_DELAY + i * HINT_INTERVAL;
+      const timer = setTimeout(() => {
+        if (this._destroyed) return;
+        this._showHint(hints[i]);
+      }, delay);
+      this.hintTimers.push(timer);
+    }
+    const shimmerDelay = 12e3;
+    const shimmerTimer = setTimeout(() => {
+      if (this._destroyed || !this.targetElement) return;
+      this.targetElement.classList.add("eeq-entry-target");
+    }, shimmerDelay);
+    this.hintTimers.push(shimmerTimer);
+  }
+  _showHint(text) {
+    if (!this.hintContainer) return;
+    const snack = document.createElement("div");
+    snack.className = "eeq-snackbar";
+    const msg = document.createElement("span");
+    msg.textContent = text;
+    snack.appendChild(msg);
+    const btn = document.createElement("button");
+    btn.className = "eeq-snackbar-btn";
+    btn.textContent = "Not interested";
+    btn.addEventListener("click", () => {
+      try {
+        localStorage.setItem("eeq_optout", "1");
+      } catch {
+      }
+      this.cleanup();
+    });
+    snack.appendChild(btn);
+    this.hintContainer.appendChild(snack);
+    const dismiss = () => {
+      snack.style.transform = "translateY(20px)";
+      snack.style.opacity = "0";
+      setTimeout(() => snack.remove(), 400);
+    };
+    requestAnimationFrame(() => {
+      snack.style.transform = "translateY(0)";
+      snack.style.opacity = "1";
+    });
+    setTimeout(() => {
+      if (snack.parentNode) dismiss();
+    }, 8e3);
+  }
+  _createHintContainer() {
+    this.hintContainer = document.createElement("div");
+    Object.assign(this.hintContainer.style, {
+      position: "fixed",
+      bottom: "24px",
+      left: "50%",
+      transform: "translateX(-50%)",
+      zIndex: "999980",
+      pointerEvents: "none",
+      display: "flex",
+      flexDirection: "column",
+      alignItems: "center",
+      gap: "8px"
+    });
+    document.body.appendChild(this.hintContainer);
+  }
+  _injectShimmerStyles() {
+    this.shimmerStyle = document.createElement("style");
+    this.shimmerStyle.textContent = `
+      .eeq-entry-target {
+        animation: eeq-shimmer 3s ease-in-out infinite !important;
+      }
+      @keyframes eeq-shimmer {
+        0%, 100% { opacity: 1; }
+        50% { opacity: 0.55; }
+      }
+      .eeq-snackbar {
+        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+        font-size: 14px;
+        line-height: 20px;
+        letter-spacing: 0.01em;
+        color: #fff;
+        background: #323232;
+        padding: 14px 24px;
+        border-radius: 4px;
+        box-shadow: 0 3px 5px -1px rgba(0,0,0,0.2), 0 6px 10px rgba(0,0,0,0.14), 0 1px 18px rgba(0,0,0,0.12);
+        min-width: 288px;
+        max-width: 568px;
+        opacity: 0;
+        transform: translateY(20px);
+        transition: transform 0.3s cubic-bezier(0.4, 0, 0.2, 1), opacity 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+        pointer-events: auto;
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 24px;
+      }
+      .eeq-snackbar-btn {
+        font-family: inherit;
+        font-size: 14px;
+        font-weight: 500;
+        letter-spacing: 0.04em;
+        text-transform: none;
+        color: #fff;
+        background: none;
+        border: none;
+        padding: 0;
+        margin: 0;
+        cursor: pointer;
+        white-space: nowrap;
+        flex-shrink: 0;
+      }
+      .eeq-snackbar-btn:hover {
+        opacity: 0.8;
+      }
+    `;
+    document.head.appendChild(this.shimmerStyle);
+  }
+  _createFallbackEntry() {
+    this.fallbackButton = document.createElement("button");
+    this.fallbackButton.textContent = "·";
+    this.fallbackButton.setAttribute("aria-label", "Hidden game entry");
+    Object.assign(this.fallbackButton.style, {
+      position: "fixed",
+      bottom: "16px",
+      right: "16px",
+      width: "28px",
+      height: "28px",
+      borderRadius: "50%",
+      border: `1px solid ${this.config.theme.accent}`,
+      background: "transparent",
+      color: this.config.theme.accent,
+      fontSize: "16px",
+      cursor: "pointer",
+      zIndex: "999980",
+      opacity: "0.4",
+      transition: "opacity 0.6s",
+      fontFamily: "serif",
+      lineHeight: "1",
+      padding: "0"
+    });
+    this.fallbackButton.addEventListener("mouseenter", () => {
+      if (this.fallbackButton) this.fallbackButton.style.opacity = "0.8";
+    });
+    this.fallbackButton.addEventListener("mouseleave", () => {
+      if (this.fallbackButton) this.fallbackButton.style.opacity = "0.4";
+    });
+    this.fallbackButton.addEventListener("click", () => {
+      if (this._destroyed) return;
+      this.cleanup();
+      this.onFound();
+    });
+    document.body.appendChild(this.fallbackButton);
+    this._createHintContainer();
+    this._injectShimmerStyles();
+    const hints = this.script.hiddenEntryHints;
+    for (let i = 0; i < hints.length; i++) {
+      const timer = setTimeout(
+        () => {
+          if (this._destroyed) return;
+          this._showHint(hints[i]);
+        },
+        6e3 + i * 1e4
+      );
+      this.hintTimers.push(timer);
+    }
+  }
+}
+class NarrativeRenderer {
+  constructor(config) {
+    this.host = null;
+    this.shadow = null;
+    this.container = null;
+    this.currentLine = null;
+    this.clearTimer = null;
+    this.config = config;
+  }
+  mount() {
+    this.host = document.createElement("div");
+    this.host.id = "eeq-narrative-host";
+    Object.assign(this.host.style, {
+      position: "fixed",
+      top: "0",
+      left: "0",
+      width: "100%",
+      height: "100%",
+      pointerEvents: "none",
+      zIndex: "999990"
+    });
+    document.body.appendChild(this.host);
+    this.shadow = this.host.attachShadow({ mode: "closed" });
+    const style = document.createElement("style");
+    style.textContent = this._getStyles();
+    this.shadow.appendChild(style);
+    this.container = document.createElement("div");
+    this.container.className = "eeq-narrative";
+    this.shadow.appendChild(this.container);
+  }
+  /** Show a single narrative line. Fades in, replaces any previous line. */
+  showLine(text, className = "eeq-line") {
+    if (!this.container) return;
+    if (this.currentLine) {
+      const prev = this.currentLine;
+      prev.classList.add("eeq-narrative-exit");
+      setTimeout(() => prev.remove(), 750);
+    }
+    if (this.clearTimer) {
+      clearTimeout(this.clearTimer);
+      this.clearTimer = null;
+    }
+    const line = document.createElement("div");
+    line.className = className;
+    line.textContent = text;
+    this.container.appendChild(line);
+    requestAnimationFrame(() => {
+      requestAnimationFrame(() => {
+        line.classList.add("eeq-line-visible");
+      });
+    });
+    this.currentLine = line;
+    this.clearTimer = setTimeout(() => {
+      this.clear();
+    }, 5e3);
+  }
+  /** Show a sequence of lines with pauses. */
+  async showSequence(lines, pauseMs = 1500) {
+    for (const line of lines) {
+      this.showLine(line);
+      await new Promise((r) => setTimeout(r, pauseMs));
+    }
+  }
+  /** Show a celebratory line with golden styling. */
+  showCelebration(text) {
+    this.showLine(text, "eeq-line eeq-celebration");
+  }
+  /** Clear current narrative text. */
+  clear() {
+    if (this.clearTimer) {
+      clearTimeout(this.clearTimer);
+      this.clearTimer = null;
+    }
+    if (this.currentLine) {
+      this.currentLine.classList.add("eeq-narrative-exit");
+      const ref = this.currentLine;
+      setTimeout(() => ref.remove(), 750);
+      this.currentLine = null;
+    }
+  }
+  /** Remove all DOM. */
+  destroy() {
+    var _a;
+    this.clear();
+    (_a = this.host) == null ? void 0 : _a.remove();
+    this.host = null;
+    this.shadow = null;
+    this.container = null;
+  }
+  _getStyles() {
+    const t = this.config.theme;
+    return `
+      .eeq-narrative {
+        position: fixed;
+        bottom: 0;
+        left: 0;
+        width: 100%;
+        height: auto;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        padding-bottom: 48px;
+        pointer-events: none;
+        font-family: 'Georgia', 'Times New Roman', 'Noto Serif', serif;
+      }
+
+      .eeq-line {
+        position: absolute;
+        bottom: 48px;
+        left: 50%;
+        transform: translateX(-50%);
+        color: ${t.textColor};
+        font-size: clamp(13px, 1.8vw, 19px);
+        letter-spacing: 0.04em;
+        text-align: center;
+        max-width: 440px;
+        padding: 12px 24px;
+        opacity: 0;
+        filter: blur(12px);
+        transition: opacity 0.8s ease, filter 0.9s cubic-bezier(0.22, 1, 0.36, 1);
+        line-height: 1.6;
+
+        /* Frosted glass dialogue card */
+        background: rgba(10, 10, 14, 0.55);
+        backdrop-filter: blur(18px) saturate(1.4);
+        -webkit-backdrop-filter: blur(18px) saturate(1.4);
+        border: 1px solid rgba(255, 255, 255, 0.08);
+        border-radius: 16px;
+        box-shadow:
+          0 4px 24px rgba(0, 0, 0, 0.25),
+          0 0 0 0.5px rgba(255, 255, 255, 0.04) inset;
+      }
+
+      .eeq-line-visible {
+        opacity: 1;
+        filter: blur(0px);
+      }
+
+      .eeq-narrative-exit {
+        opacity: 0 !important;
+        filter: blur(14px) !important;
+        transition: opacity 0.6s ease, filter 0.7s cubic-bezier(0.22, 1, 0.36, 1) !important;
+      }
+
+      .eeq-celebration {
+        /* Override positioning: center of viewport via fixed */
+        position: fixed !important;
+        bottom: auto !important;
+        top: 50%;
+        left: 50%;
+        transform: translate(-50%, -50%) scale(0.8);
+        max-width: 90vw;
+        padding: 20px 40px;
+
+        color: #ffe8a0;
+        font-size: clamp(18px, 3.5vw, 28px);
+        font-weight: bold;
+        letter-spacing: 0.1em;
+        text-transform: uppercase;
+
+        background: linear-gradient(135deg, rgba(50,35,10,0.85), rgba(25,18,8,0.9));
+        border: 2px solid rgba(255, 215, 80, 0.35);
+        border-radius: 20px;
+        box-shadow:
+          0 0 60px rgba(255, 200, 60, 0.25),
+          0 8px 40px rgba(0, 0, 0, 0.5),
+          inset 0 1px 0 rgba(255, 230, 140, 0.15);
+        text-shadow:
+          0 0 20px rgba(255, 200, 60, 0.6),
+          0 0 40px rgba(255, 180, 40, 0.3);
+      }
+
+      .eeq-celebration.eeq-line-visible {
+        transform: translate(-50%, -50%) scale(1);
+        transition: opacity 0.6s ease, filter 0.8s ease, transform 0.6s cubic-bezier(0.17, 0.67, 0.29, 1.2);
+      }
+
+      .eeq-celebration.eeq-narrative-exit {
+        transform: translate(-50%, -50%) scale(1.1) !important;
+      }
+    `;
+  }
+}
+class ShrineRenderer {
+  constructor(config) {
+    this.host = null;
+    this.shadow = null;
+    this.slots = [];
+    this._activeSlot = null;
+    this._onEggClick = null;
+    this.config = config;
+  }
+  mount(onEggClick) {
+    if (!this.config.shrine.enabled) return;
+    this._onEggClick = onEggClick;
+    this.host = document.createElement("div");
+    this.host.id = "eeq-shrine-host";
+    const pos = this.config.shrine.position;
+    const posStyles = {
+      "bottom-right": { bottom: "16px", right: "16px" },
+      "bottom-left": { bottom: "16px", left: "16px" },
+      "bottom-center": { bottom: "16px", left: "50%", transform: "translateX(-50%)" }
+    };
+    Object.assign(this.host.style, {
+      position: "fixed",
+      zIndex: "999994",
+      opacity: "0",
+      transform: "translateY(20px)",
+      transition: "opacity 0.8s ease, transform 0.8s ease",
+      ...posStyles[pos] ?? posStyles["bottom-right"]
+    });
+    document.body.appendChild(this.host);
+    this.shadow = this.host.attachShadow({ mode: "closed" });
+    const style = document.createElement("style");
+    style.textContent = this._getStyles();
+    this.shadow.appendChild(style);
+    const container = document.createElement("div");
+    container.className = "eeq-shrine";
+    for (let i = 0; i < 3; i++) {
+      const slot = document.createElement("div");
+      slot.className = "eeq-slot eeq-slot-empty";
+      slot.setAttribute("data-egg", String(i));
+      slot.setAttribute("aria-label", `Egg ${i + 1} slot`);
+      slot.setAttribute("role", "button");
+      slot.setAttribute("tabindex", "0");
+      const inner = document.createElement("div");
+      inner.className = "eeq-egg-inner";
+      slot.appendChild(inner);
+      slot.addEventListener("click", () => {
+        var _a;
+        if (this._activeSlot === i) {
+          (_a = this._onEggClick) == null ? void 0 : _a.call(this, i);
+        }
+      });
+      slot.addEventListener("keydown", (e) => {
+        var _a;
+        if (e.key === "Enter" && this._activeSlot === i) {
+          (_a = this._onEggClick) == null ? void 0 : _a.call(this, i);
+        }
+      });
+      container.appendChild(slot);
+      this.slots.push(slot);
+    }
+    this.shadow.appendChild(container);
+  }
+  /** Fade in the shrine. Call after entry is found. */
+  show() {
+    if (!this.host) return;
+    requestAnimationFrame(() => {
+      if (!this.host) return;
+      this.host.style.opacity = "1";
+      this.host.style.transform = "translateY(0)";
+    });
+  }
+  /** Mark an egg slot as found (filled). */
+  fillSlot(index) {
+    const slot = this.slots[index];
+    if (!slot) return;
+    slot.classList.remove("eeq-slot-empty");
+    slot.classList.add("eeq-slot-filled");
+  }
+  /** Activate a slot for click-to-continue (pulsing). */
+  activateSlot(index) {
+    this._activeSlot = index;
+    const slot = this.slots[index];
+    if (!slot) return;
+    slot.classList.add("eeq-slot-active");
+    slot.style.cursor = "pointer";
+    slot.style.pointerEvents = "auto";
+  }
+  /** Deactivate the active slot. */
+  deactivateSlot(index) {
+    this._activeSlot = null;
+    const slot = this.slots[index];
+    if (!slot) return;
+    slot.classList.remove("eeq-slot-active");
+    slot.style.cursor = "default";
+    slot.style.pointerEvents = "none";
+  }
+  /** Animate all eggs leaving the shrine (for finale). */
+  hideAll() {
+    for (const slot of this.slots) {
+      slot.classList.add("eeq-slot-finale-exit");
+    }
+  }
+  /** Show all slots again (for reset). */
+  reset() {
+    this._activeSlot = null;
+    for (const slot of this.slots) {
+      slot.className = "eeq-slot eeq-slot-empty";
+      slot.style.cursor = "default";
+      slot.style.pointerEvents = "none";
+    }
+  }
+  destroy() {
+    var _a;
+    (_a = this.host) == null ? void 0 : _a.remove();
+    this.host = null;
+    this.shadow = null;
+    this.slots = [];
+  }
+  _getStyles() {
+    const t = this.config.theme;
+    return `
+      .eeq-shrine {
+        display: flex;
+        gap: 14px;
+        padding: 12px 16px;
+        background: ${t.hudBg};
+        backdrop-filter: blur(12px);
+        -webkit-backdrop-filter: blur(12px);
+        border: 1px solid rgba(255,255,255,0.08);
+        border-radius: 12px;
+      }
+
+      .eeq-slot {
+        width: 36px;
+        height: 44px;
+        border-radius: 50% 50% 50% 50% / 60% 60% 40% 40%;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        transition: all 0.6s ease;
+        pointer-events: none;
+        position: relative;
+      }
+
+      .eeq-slot-empty {
+        border: 1.5px dashed rgba(255,255,255,0.2);
+        background: transparent;
+      }
+
+      .eeq-slot-filled {
+        border: 1.5px solid ${t.accent};
+        background: radial-gradient(ellipse at 40% 30%, rgba(255,255,255,0.15), transparent);
+      }
+
+      .eeq-slot-filled .eeq-egg-inner {
+        width: 60%;
+        height: 70%;
+        border-radius: 50% 50% 50% 50% / 60% 60% 40% 40%;
+        background: linear-gradient(135deg, ${t.accent}, rgba(255,255,255,0.3));
+        opacity: 0.8;
+      }
+
+      .eeq-slot-active {
+        animation: eeq-slot-pulse 2s ease-in-out infinite;
+        border-color: ${t.accent} !important;
+        box-shadow: 0 0 16px ${t.accentGlow};
+      }
+
+      .eeq-slot-finale-exit {
+        opacity: 0;
+        transform: translateY(-20px) scale(0.6);
+        transition: all 1s ease;
+      }
+
+      .eeq-egg-inner {
+        transition: all 0.4s ease;
+      }
+
+      @keyframes eeq-slot-pulse {
+        0%, 100% { transform: scale(1); opacity: 0.8; }
+        50% { transform: scale(1.08); opacity: 1; }
+      }
+    `;
+  }
+}
+class ThreeRenderer {
+  constructor(config) {
+    this.canvas = null;
+    this.THREE = null;
+    this.renderer = null;
+    this.scene = null;
+    this.camera = null;
+    this.eggs = [];
+    this.eggBodies = [];
+    this.lights = [];
+    this._raf = 0;
+    this._running = false;
+    this._clock = null;
+    this._eggStates = [
+      { visible: false, phase: "hidden", t: 0, targetPos: [0, 0, 0] },
+      { visible: false, phase: "hidden", t: 0, targetPos: [0, 0, 0] },
+      { visible: false, phase: "hidden", t: 0, targetPos: [0, 0, 0] }
+    ];
+    this._finaleActive = false;
+    this._finaleT = 0;
+    this._greetingOverlay = null;
+    this._trailParticles = [];
+    this._ambientParticles = [];
+    this._revealParticles = [];
+    this._disposed = false;
+    this._interactiveEgg = null;
+    this._isDragging = false;
+    this._dragStartX = 0;
+    this._dragStartY = 0;
+    this._dragRotX = 0;
+    this._dragRotY = 0;
+    this._dragMoved = false;
+    this._longPressStartTime = 0;
+    this._longPressActive = false;
+    this._holdProgress = 0;
+    this._holdRing = null;
+    this._holdShockwave = null;
+    this._miniEggs = [];
+    this._collectLight = null;
+    this._onCollectEgg = null;
+    this._vortexParticles = [];
+    this._emberParticles = [];
+    this._collectFlashOpacity = 0;
+    this._collectShake = 0;
+    this._collectCamBaseZ = 5;
+    this._onPointerDown = (e) => {
+      if (this._interactiveEgg === null || this._disposed) return;
+      const egg = this.eggs[this._interactiveEgg];
+      if (!egg || !egg.visible) return;
+      const eggScreen = this._worldToScreen(egg.position);
+      const dx = e.clientX - eggScreen.x;
+      const dy = e.clientY - eggScreen.y;
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      if (dist > 120) return;
+      e.preventDefault();
+      e.stopPropagation();
+      if (this.canvas) document.body.style.cursor = "grabbing";
+      this._isDragging = true;
+      this._dragMoved = false;
+      this._dragStartX = e.clientX;
+      this._dragStartY = e.clientY;
+      this._dragRotX = egg.rotation.x;
+      this._dragRotY = egg.rotation.y;
+      this._longPressStartTime = Date.now();
+      this._longPressActive = true;
+      this._holdProgress = 0;
+    };
+    this._onPointerMove = (e) => {
+      if (!this._isDragging || this._interactiveEgg === null) return;
+      e.preventDefault();
+      e.stopPropagation();
+      const egg = this.eggs[this._interactiveEgg];
+      if (!egg) return;
+      const dx = e.clientX - this._dragStartX;
+      const dy = e.clientY - this._dragStartY;
+      egg.rotation.y = this._dragRotY + dx * 8e-3;
+      egg.rotation.x = this._dragRotX + dy * 5e-3;
+      if (Math.abs(dx) > 15 || Math.abs(dy) > 15) {
+        this._dragMoved = true;
+        this._cancelLongPress();
+      }
+    };
+    this._onPointerUp = (e) => {
+      if (this._isDragging) {
+        e.preventDefault();
+        e.stopPropagation();
+      }
+      this._isDragging = false;
+      this._cancelLongPress();
+      if (this._interactiveEgg !== null) {
+        document.body.style.cursor = "grab";
+      }
+    };
+    this._onWheel = (e) => {
+      if (this._interactiveEgg === null || this._disposed) return;
+      const egg = this.eggs[this._interactiveEgg];
+      if (!egg || !egg.visible) return;
+      const eggScreen = this._worldToScreen(egg.position);
+      const dx = e.clientX - eggScreen.x;
+      const dy = e.clientY - eggScreen.y;
+      if (Math.sqrt(dx * dx + dy * dy) <= 120) {
+        e.preventDefault();
+        e.stopPropagation();
+      }
+    };
+    this._onClickCapture = (e) => {
+      if (this._interactiveEgg === null || this._disposed) return;
+      const egg = this.eggs[this._interactiveEgg];
+      if (!egg || !egg.visible) return;
+      const eggScreen = this._worldToScreen(egg.position);
+      const dx = e.clientX - eggScreen.x;
+      const dy = e.clientY - eggScreen.y;
+      if (Math.sqrt(dx * dx + dy * dy) <= 120) {
+        e.preventDefault();
+        e.stopPropagation();
+      }
+    };
+    this._onMouseDownCapture = (e) => {
+      if (this._interactiveEgg === null || this._disposed) return;
+      const egg = this.eggs[this._interactiveEgg];
+      if (!egg || !egg.visible) return;
+      const eggScreen = this._worldToScreen(egg.position);
+      const dx = e.clientX - eggScreen.x;
+      const dy = e.clientY - eggScreen.y;
+      if (Math.sqrt(dx * dx + dy * dy) <= 120) {
+        e.preventDefault();
+        e.stopPropagation();
+      }
+    };
+    this._onMouseUpCapture = (e) => {
+      if (this._isDragging) {
+        e.preventDefault();
+        e.stopPropagation();
+      }
+    };
+    this._onTouchStartCapture = (e) => {
+      if (this._interactiveEgg === null || this._disposed) return;
+      const egg = this.eggs[this._interactiveEgg];
+      if (!egg || !egg.visible) return;
+      const touch = e.touches[0];
+      if (!touch) return;
+      const eggScreen = this._worldToScreen(egg.position);
+      const dx = touch.clientX - eggScreen.x;
+      const dy = touch.clientY - eggScreen.y;
+      if (Math.sqrt(dx * dx + dy * dy) <= 120) {
+        e.preventDefault();
+        e.stopPropagation();
+      }
+    };
+    this._onTouchMoveCapture = (e) => {
+      if (this._isDragging) {
+        e.preventDefault();
+        e.stopPropagation();
+      }
+    };
+    this._animate = () => {
+      if (!this._running || this._disposed) return;
+      this._raf = requestAnimationFrame(this._animate);
+      const dt = Math.min(this._clock.getDelta(), 0.05);
+      this._updateEggs(dt);
+      this._updateHoldRing();
+      this._updateMiniEggs(dt);
+      this._updateTrails(dt);
+      this._updateAmbientParticles(dt);
+      this._updateRevealParticles(dt);
+      this._updateFinale(dt);
+      this.renderer.render(this.scene, this.camera);
+    };
+    this._onResize = () => {
+      if (!this.camera || !this.renderer || !this.canvas) return;
+      this.camera.aspect = window.innerWidth / window.innerHeight;
+      this.camera.updateProjectionMatrix();
+      this.renderer.setSize(window.innerWidth, window.innerHeight);
+    };
+    this.config = config;
+    this._reducedMotion = config.accessibility.reducedMotion;
+  }
+  /** Set callback for when user completes long-press collect. */
+  onCollectEgg(cb) {
+    this._onCollectEgg = cb;
+  }
+  async init() {
+    try {
+      const globalThree = typeof window !== "undefined" && window.THREE;
+      if (globalThree) {
+        this.THREE = globalThree;
+      } else {
+        this.THREE = await import("./three.module-BYIS7JD4.mjs");
+      }
+    } catch {
+      return false;
+    }
+    const T = this.THREE;
+    this.canvas = document.createElement("canvas");
+    this.canvas.id = "eeq-three-canvas";
+    Object.assign(this.canvas.style, {
+      position: "fixed",
+      top: "0",
+      left: "0",
+      width: "100%",
+      height: "100%",
+      pointerEvents: "none",
+      zIndex: "999992"
+    });
+    document.body.appendChild(this.canvas);
+    this.renderer = new T.WebGLRenderer({
+      canvas: this.canvas,
+      alpha: true,
+      antialias: true,
+      powerPreference: "high-performance"
+    });
+    this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+    this.renderer.setSize(window.innerWidth, window.innerHeight);
+    this.renderer.toneMapping = T.ACESFilmicToneMapping;
+    this.renderer.toneMappingExposure = 1.1;
+    this.scene = new T.Scene();
+    this.camera = new T.PerspectiveCamera(
+      45,
+      window.innerWidth / window.innerHeight,
+      0.1,
+      100
+    );
+    this.camera.position.set(0, 0, 5);
+    this._setupLights(T);
+    this._setupEnvironment(T);
+    this._createEggs(T);
+    this._createHoldRing(T);
+    this._clock = new T.Clock();
+    window.addEventListener("resize", this._onResize);
+    document.addEventListener("pointerdown", this._onPointerDown, { capture: true });
+    document.addEventListener("pointermove", this._onPointerMove, { capture: true });
+    document.addEventListener("pointerup", this._onPointerUp, { capture: true });
+    document.addEventListener("wheel", this._onWheel, { capture: true, passive: false });
+    document.addEventListener("click", this._onClickCapture, { capture: true });
+    document.addEventListener("mousedown", this._onMouseDownCapture, { capture: true });
+    document.addEventListener("mouseup", this._onMouseUpCapture, { capture: true });
+    document.addEventListener("touchstart", this._onTouchStartCapture, { capture: true, passive: false });
+    document.addEventListener("touchmove", this._onTouchMoveCapture, { capture: true, passive: false });
+    return true;
+  }
+  startRenderLoop() {
+    if (this._running) return;
+    this._running = true;
+    this._animate();
+  }
+  stopRenderLoop() {
+    this._running = false;
+    if (this._raf) cancelAnimationFrame(this._raf);
+  }
+  /** Make an egg interactively draggable. */
+  enableInteraction(index) {
+    this._interactiveEgg = index;
+    document.body.style.cursor = "grab";
+  }
+  /** Disable drag interaction. */
+  disableInteraction() {
+    this._interactiveEgg = null;
+    this._isDragging = false;
+    this._cancelLongPress();
+    document.body.style.cursor = "";
+  }
+  /** Trigger spectacular egg reveal. */
+  revealEgg(index) {
+    const state = this._eggStates[index];
+    if (!state) return;
+    state.visible = true;
+    state.phase = "reveal";
+    state.t = 0;
+    const group = this.eggs[index];
+    if (group) {
+      group.visible = true;
+      group.scale.set(0.01, 0.01, 0.01);
+      group.position.set(0, 0, 0);
+    }
+    this._spawnRevealBurst(index);
+    this.enableInteraction(index);
+  }
+  /** Collect egg — hide immediately (mini-egg burst already happened during hold). */
+  collectEgg(index) {
+    const state = this._eggStates[index];
+    if (!state) return;
+    const group = this.eggs[index];
+    if (group) group.visible = false;
+    const body = this.eggBodies[index];
+    if (body == null ? void 0 : body.material) {
+      body.material.emissiveIntensity = 0.05;
+      body.material.opacity = 1;
+      body.material.transparent = false;
+    }
+    this.disableInteraction();
+    state.phase = "shrine";
+    state.t = 0;
+  }
+  /** Reset renderer state for game restart (preserves WebGL context). */
+  resetForRestart() {
+    var _a, _b, _c, _d, _e, _f, _g;
+    (_a = this._greetingOverlay) == null ? void 0 : _a.remove();
+    this._greetingOverlay = null;
+    this.stopRenderLoop();
+    for (let i = 0; i < 3; i++) {
+      this._eggStates[i] = { visible: false, phase: "hidden", t: 0, targetPos: [0, 0, 0] };
+      if (this.eggs[i]) {
+        this.eggs[i].visible = false;
+        this.eggs[i].scale.set(1, 1, 1);
+        this.eggs[i].position.set(0, 0, 0);
+        this.eggs[i].rotation.set(0, 0, 0);
+      }
+      const body = this.eggBodies[i];
+      if (body == null ? void 0 : body.material) {
+        body.material.emissiveIntensity = 0.05;
+        body.material.opacity = 1;
+        body.material.transparent = false;
+      }
+    }
+    this._finaleActive = false;
+    this._finaleT = 0;
+    this.disableInteraction();
+    for (const p of [...this._trailParticles, ...this._ambientParticles, ...this._revealParticles, ...this._vortexParticles, ...this._emberParticles]) {
+      (_b = this.scene) == null ? void 0 : _b.remove(p.mesh);
+      (_c = p.mesh.geometry) == null ? void 0 : _c.dispose();
+      (_d = p.mesh.material) == null ? void 0 : _d.dispose();
+    }
+    this._trailParticles = [];
+    this._ambientParticles = [];
+    this._revealParticles = [];
+    this._vortexParticles = [];
+    this._emberParticles = [];
+    for (const p of this._miniEggs) {
+      (_e = this.scene) == null ? void 0 : _e.remove(p.mesh);
+      (_f = p.mesh.geometry) == null ? void 0 : _f.dispose();
+      (_g = p.mesh.material) == null ? void 0 : _g.dispose();
+    }
+    this._miniEggs = [];
+  }
+  /** Add a luminous motion trail at screen coordinates. */
+  addTrail(x, y, velocity) {
+    if (!this.THREE || !this.scene) return;
+    const T = this.THREE;
+    const worldPos = this._screenToWorld(x, y);
+    const size = Math.min(0.05, velocity * 3e-5);
+    const geo = this._createMiniEggGeo(T, size);
+    const mat = this._createMiniEggMat(T, 0.65);
+    const particle = new T.Mesh(geo, mat);
+    particle.position.copy(worldPos);
+    particle.rotation.set(
+      Math.random() * Math.PI,
+      Math.random() * Math.PI,
+      Math.random() * Math.PI
+    );
+    this.scene.add(particle);
+    this._trailParticles.push({ mesh: particle, life: 1 });
+    if (this._trailParticles.length > 100) {
+      const old = this._trailParticles.shift();
+      if (old) {
+        this.scene.remove(old.mesh);
+        old.mesh.geometry.dispose();
+        old.mesh.material.dispose();
+      }
+    }
+  }
+  /** Spawn gentle ambient particles to show stage progress. */
+  showProgressParticles(progress) {
+    if (!this.THREE || !this.scene || progress < 0.05) return;
+    const T = this.THREE;
+    if (Math.random() > progress * 0.3) return;
+    const angle = Math.random() * Math.PI * 2;
+    const radius = 2 + Math.random() * 2;
+    const x = Math.cos(angle) * radius;
+    const y = -2 + Math.random() * 4;
+    const size = 0.02 + Math.random() * 0.025;
+    const geo = this._createMiniEggGeo(T, size);
+    const mat = this._createMiniEggMat(T, 0);
+    const p = new T.Mesh(geo, mat);
+    p.position.set(x, y, -1 + Math.random() * 0.5);
+    p.rotation.set(
+      Math.random() * Math.PI,
+      Math.random() * Math.PI,
+      Math.random() * Math.PI
+    );
+    this.scene.add(p);
+    this._ambientParticles.push({
+      mesh: p,
+      life: 1,
+      vy: 0.2 + Math.random() * 0.3,
+      fadeIn: true
+    });
+    if (this._ambientParticles.length > 60) {
+      const old = this._ambientParticles.shift();
+      if (old) {
+        this.scene.remove(old.mesh);
+        old.mesh.geometry.dispose();
+        old.mesh.material.dispose();
+      }
+    }
+  }
+  /** Start the finale composition. */
+  startFinale() {
+    this._finaleActive = true;
+    this._finaleT = 0;
+    this.disableInteraction();
+    for (let i = 0; i < 3; i++) {
+      const state = this._eggStates[i];
+      state.phase = "finale";
+      state.t = 0;
+      if (this.eggs[i]) this.eggs[i].visible = true;
+    }
+    this._greetingOverlay = document.createElement("div");
+    Object.assign(this._greetingOverlay.style, {
+      position: "fixed",
+      bottom: "12%",
+      left: "0",
+      width: "100%",
+      display: "flex",
+      flexDirection: "column",
+      alignItems: "center",
+      justifyContent: "center",
+      zIndex: "999997",
+      pointerEvents: "none",
+      opacity: "0",
+      transition: "opacity 2s ease",
+      fontFamily: "'Georgia', 'Times New Roman', serif",
+      textAlign: "center"
+    });
+    this._greetingOverlay.innerHTML = `
+      <div style="font-size: 48px; color: #fff8e8; text-shadow: 0 0 60px rgba(212,165,80,0.7), 0 0 20px rgba(212,165,80,0.4), 0 2px 8px rgba(0,0,0,0.6); margin-bottom: 10px; letter-spacing: 0.03em; font-weight: bold;">
+        Happy Easter! 🐰🥚
+      </div>
+      <div style="font-size: 17px; color: rgba(245,240,230,0.85); font-style: italic; text-shadow: 0 0 12px rgba(212,165,80,0.3), 0 1px 6px rgba(0,0,0,0.4);">
+        Wishing you joy, peace, and light
+      </div>
+    `;
+    document.body.appendChild(this._greetingOverlay);
+    requestAnimationFrame(() => {
+      requestAnimationFrame(() => {
+        if (this._greetingOverlay) this._greetingOverlay.style.opacity = "1";
+      });
+    });
+  }
+  /** Re-draw the festive (3rd) egg texture with a specific seed for uniqueness. */
+  setFestiveEggSeed(seed) {
+    var _a;
+    const body = this.eggBodies[2];
+    if (!body || !this.THREE) return;
+    const T = this.THREE;
+    const newTex = new T.CanvasTexture(this._drawFestivePattern(seed));
+    newTex.colorSpace = T.SRGBColorSpace;
+    newTex.wrapS = T.RepeatWrapping;
+    (_a = body.material.map) == null ? void 0 : _a.dispose();
+    body.material.map = newTex;
+    body.material.needsUpdate = true;
+  }
+  setBreathIntensity(intensity) {
+    if (!this.camera) return;
+    const breathScale = 0.04 * intensity;
+    const time = Date.now() * 1e-3;
+    this.camera.position.z = 5 + Math.sin(time * 0.8) * breathScale;
+  }
+  setOverlayIntensity(_progress) {
+  }
+  destroy() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u;
+    this._disposed = true;
+    this.stopRenderLoop();
+    this.disableInteraction();
+    window.removeEventListener("resize", this._onResize);
+    document.removeEventListener("pointerdown", this._onPointerDown, { capture: true });
+    document.removeEventListener("pointermove", this._onPointerMove, { capture: true });
+    document.removeEventListener("pointerup", this._onPointerUp, { capture: true });
+    document.removeEventListener("wheel", this._onWheel, { capture: true });
+    document.removeEventListener("click", this._onClickCapture, { capture: true });
+    document.removeEventListener("mousedown", this._onMouseDownCapture, { capture: true });
+    document.removeEventListener("mouseup", this._onMouseUpCapture, { capture: true });
+    document.removeEventListener("touchstart", this._onTouchStartCapture, { capture: true });
+    document.removeEventListener("touchmove", this._onTouchMoveCapture, { capture: true });
+    document.body.style.cursor = "";
+    const disposeList = [
+      ...this._trailParticles,
+      ...this._ambientParticles,
+      ...this._revealParticles,
+      ...this._vortexParticles,
+      ...this._emberParticles
+    ];
+    for (const p of disposeList) {
+      (_a = this.scene) == null ? void 0 : _a.remove(p.mesh);
+      (_b = p.mesh.geometry) == null ? void 0 : _b.dispose();
+      (_c = p.mesh.material) == null ? void 0 : _c.dispose();
+    }
+    this._trailParticles = [];
+    this._ambientParticles = [];
+    this._revealParticles = [];
+    this._vortexParticles = [];
+    this._emberParticles = [];
+    for (const group of this.eggs) {
+      group == null ? void 0 : group.traverse((child) => {
+        if (child.geometry) child.geometry.dispose();
+        if (child.material) {
+          if (Array.isArray(child.material)) {
+            child.material.forEach((m) => m.dispose());
+          } else {
+            child.material.dispose();
+          }
+        }
+      });
+      (_d = this.scene) == null ? void 0 : _d.remove(group);
+    }
+    this.eggs = [];
+    this.eggBodies = [];
+    if (this._holdRing) {
+      (_e = this.scene) == null ? void 0 : _e.remove(this._holdRing);
+      (_f = this._holdRing.geometry) == null ? void 0 : _f.dispose();
+      (_g = this._holdRing.material) == null ? void 0 : _g.dispose();
+    }
+    if (this._holdShockwave) {
+      (_h = this.scene) == null ? void 0 : _h.remove(this._holdShockwave);
+      (_i = this._holdShockwave.geometry) == null ? void 0 : _i.dispose();
+      (_j = this._holdShockwave.material) == null ? void 0 : _j.dispose();
+    }
+    for (const p of this._miniEggs) {
+      (_k = this.scene) == null ? void 0 : _k.remove(p.mesh);
+      (_l = p.mesh.geometry) == null ? void 0 : _l.dispose();
+      (_m = p.mesh.material) == null ? void 0 : _m.dispose();
+    }
+    this._miniEggs = [];
+    if (this._collectLight) {
+      (_n = this.scene) == null ? void 0 : _n.remove(this._collectLight);
+      (_p = (_o = this._collectLight).dispose) == null ? void 0 : _p.call(_o);
+      this._collectLight = null;
+    }
+    for (const l of this.lights) {
+      (_q = this.scene) == null ? void 0 : _q.remove(l);
+    }
+    this.lights = [];
+    if ((_r = this.scene) == null ? void 0 : _r.environment) {
+      this.scene.environment.dispose();
+      this.scene.environment = null;
+    }
+    (_s = this.renderer) == null ? void 0 : _s.dispose();
+    (_t = this.canvas) == null ? void 0 : _t.remove();
+    (_u = this._greetingOverlay) == null ? void 0 : _u.remove();
+    this._greetingOverlay = null;
+    this.canvas = null;
+    this.renderer = null;
+    this.scene = null;
+    this.camera = null;
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // LIGHTING
+  // ═══════════════════════════════════════════════════════════════════════
+  _setupLights(T) {
+    const ambient = new T.AmbientLight(16775408, 0.6);
+    this.scene.add(ambient);
+    this.lights.push(ambient);
+    const key = new T.DirectionalLight(16772306, 1);
+    key.position.set(3, 5, 4);
+    this.scene.add(key);
+    this.lights.push(key);
+    const fill = new T.DirectionalLight(13687024, 0.35);
+    fill.position.set(-4, 3, 2);
+    this.scene.add(fill);
+    this.lights.push(fill);
+    const rim = new T.PointLight(16763016, 0.5, 12);
+    rim.position.set(0, -3, 3);
+    this.scene.add(rim);
+    this.lights.push(rim);
+    const top = new T.PointLight(16777215, 0.3, 10);
+    top.position.set(0, 4, 2);
+    this.scene.add(top);
+    this.lights.push(top);
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // ENVIRONMENT MAP — procedural studio HDRI for metallic reflections
+  // ═══════════════════════════════════════════════════════════════════════
+  _setupEnvironment(T) {
+    const pmrem = new T.PMREMGenerator(this.renderer);
+    pmrem.compileCubemapShader();
+    const envScene = new T.Scene();
+    const skyGeo = new T.SphereGeometry(50, 32, 16);
+    const skyMat = new T.ShaderMaterial({
+      side: T.BackSide,
+      uniforms: {},
+      vertexShader: `
+        varying vec3 vWorldPos;
+        void main() {
+          vWorldPos = (modelMatrix * vec4(position, 1.0)).xyz;
+          gl_Position = projectionMatrix * viewMatrix * vec4(vWorldPos, 1.0);
+        }
+      `,
+      fragmentShader: `
+        varying vec3 vWorldPos;
+        void main() {
+          float y = normalize(vWorldPos).y;
+          // Top: warm bright sky
+          vec3 top = vec3(0.85, 0.88, 0.95);
+          // Horizon: bright neutral white
+          vec3 mid = vec3(0.95, 0.93, 0.90);
+          // Bottom: warm ground bounce
+          vec3 bot = vec3(0.75, 0.68, 0.62);
+          vec3 color;
+          if (y > 0.0) {
+            color = mix(mid, top, y);
+          } else {
+            color = mix(mid, bot, -y);
+          }
+          // Bright highlight (simulates studio softbox)
+          float sun = max(0.0, dot(normalize(vWorldPos), normalize(vec3(2.0, 5.0, 3.0))));
+          color += vec3(1.0, 0.97, 0.92) * pow(sun, 16.0) * 0.8;
+          // Fill light opposite side
+          float fill = max(0.0, dot(normalize(vWorldPos), normalize(vec3(-3.0, 2.0, 1.0))));
+          color += vec3(0.7, 0.8, 0.95) * pow(fill, 8.0) * 0.3;
+          gl_FragColor = vec4(color, 1.0);
+        }
+      `
+    });
+    const skyMesh = new T.Mesh(skyGeo, skyMat);
+    envScene.add(skyMesh);
+    const envMap = pmrem.fromScene(envScene, 0.04).texture;
+    this.scene.environment = envMap;
+    skyGeo.dispose();
+    skyMat.dispose();
+    envScene.clear();
+    pmrem.dispose();
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // EASTER EGG CREATION — Silver, Gold, and Royal Fabergé
+  // ═══════════════════════════════════════════════════════════════════════
+  _createEggs(T) {
+    const baseGeo = this._createEggGeometry(T);
+    const group1 = new T.Group();
+    const silverTex = new T.CanvasTexture(this._drawSilverPolkaDots());
+    silverTex.colorSpace = T.SRGBColorSpace;
+    silverTex.wrapS = T.RepeatWrapping;
+    const silverRoughTex = new T.CanvasTexture(this._drawSilverRoughness());
+    silverRoughTex.wrapS = T.RepeatWrapping;
+    const body1 = new T.Mesh(baseGeo.clone(), new T.MeshPhysicalMaterial({
+      map: silverTex,
+      roughness: 0.15,
+      roughnessMap: silverRoughTex,
+      metalness: 0.92,
+      clearcoat: 0.3,
+      clearcoatRoughness: 0.1,
+      emissive: 2236979,
+      emissiveIntensity: 0.02,
+      envMapIntensity: 1
+    }));
+    group1.add(body1);
+    group1.visible = false;
+    this.scene.add(group1);
+    this.eggs.push(group1);
+    this.eggBodies.push(body1);
+    const group2 = new T.Group();
+    const goldTex = new T.CanvasTexture(this._drawGoldPattern());
+    goldTex.colorSpace = T.SRGBColorSpace;
+    goldTex.wrapS = T.RepeatWrapping;
+    const goldRoughTex = new T.CanvasTexture(this._drawGoldRoughness());
+    goldRoughTex.wrapS = T.RepeatWrapping;
+    const body2 = new T.Mesh(baseGeo.clone(), new T.MeshPhysicalMaterial({
+      map: goldTex,
+      roughness: 0.2,
+      roughnessMap: goldRoughTex,
+      metalness: 0.95,
+      clearcoat: 0.2,
+      clearcoatRoughness: 0.15,
+      emissive: 3811848,
+      emissiveIntensity: 0.06,
+      envMapIntensity: 1
+    }));
+    group2.add(body2);
+    group2.visible = false;
+    this.scene.add(group2);
+    this.eggs.push(group2);
+    this.eggBodies.push(body2);
+    const group3 = new T.Group();
+    const festiveTex = new T.CanvasTexture(this._drawFestivePattern());
+    festiveTex.colorSpace = T.SRGBColorSpace;
+    festiveTex.wrapS = T.RepeatWrapping;
+    const festiveRoughTex = new T.CanvasTexture(this._drawFestiveRoughness());
+    festiveRoughTex.wrapS = T.RepeatWrapping;
+    const body3 = new T.Mesh(baseGeo.clone(), new T.MeshPhysicalMaterial({
+      map: festiveTex,
+      roughness: 0.22,
+      roughnessMap: festiveRoughTex,
+      metalness: 0.35,
+      clearcoat: 0.8,
+      clearcoatRoughness: 0.05,
+      emissive: 1708064,
+      emissiveIntensity: 0.04,
+      envMapIntensity: 0.8,
+      sheen: 0.4,
+      sheenColor: new T.Color(16765088),
+      sheenRoughness: 0.3
+    }));
+    group3.add(body3);
+    group3.visible = false;
+    this.scene.add(group3);
+    this.eggs.push(group3);
+    this.eggBodies.push(body3);
+  }
+  // ── Mini egg helpers for particles ─────────────────────────────────────
+  /** Create a tiny egg-shaped geometry (same squash as main eggs, lower poly). */
+  _createMiniEggGeo(T, radius) {
+    const geo = new T.SphereGeometry(radius, 8, 8);
+    const pos = geo.attributes.position;
+    for (let i = 0; i < pos.count; i++) {
+      let y = pos.getY(i);
+      const x = pos.getX(i);
+      const z = pos.getZ(i);
+      const topSquash = y > 0 ? 0.92 : 1;
+      y = y * 1.15 * topSquash;
+      const narrowing = 1 - Math.abs(y) * 0.06;
+      pos.setX(i, x * narrowing);
+      pos.setY(i, y);
+      pos.setZ(i, z * narrowing);
+    }
+    geo.computeVertexNormals();
+    return geo;
+  }
+  /** Create a minimalist randomly-decorated mini egg material. */
+  /** Create a decorated mini egg material — pastel base with visible patterns. */
+  _createMiniEggMat(T, opacity) {
+    const c = document.createElement("canvas");
+    c.width = 64;
+    c.height = 64;
+    const ctx = c.getContext("2d");
+    const hue = Math.random() * 360;
+    const sat = 45 + Math.random() * 30;
+    const light = 65 + Math.random() * 15;
+    ctx.fillStyle = `hsl(${hue}, ${sat}%, ${light}%)`;
+    ctx.fillRect(0, 0, 64, 64);
+    const accentHue = (hue + 80 + Math.random() * 100) % 360;
+    const accentSat = sat + 10;
+    const accentLight = Math.max(35, light - 30);
+    ctx.lineWidth = 2;
+    const layers = 1 + Math.floor(Math.random() * 2);
+    for (let layer = 0; layer < layers; layer++) {
+      const layerHue = layer === 0 ? accentHue : (accentHue + 120) % 360;
+      ctx.strokeStyle = `hsla(${layerHue}, ${accentSat}%, ${accentLight}%, 0.7)`;
+      ctx.fillStyle = `hsla(${layerHue}, ${accentSat}%, ${accentLight + 10}%, 0.5)`;
+      const pattern = Math.floor(Math.random() * 6);
+      const yOff = layer * 16 - 8;
+      switch (pattern) {
+        case 0:
+          ctx.beginPath();
+          ctx.moveTo(0, 24 + yOff);
+          ctx.lineTo(64, 24 + yOff);
+          ctx.moveTo(0, 40 + yOff);
+          ctx.lineTo(64, 40 + yOff);
+          ctx.stroke();
+          break;
+        case 1:
+          for (let d = 0; d < 6; d++) {
+            ctx.beginPath();
+            ctx.arc(
+              8 + Math.random() * 48,
+              8 + Math.random() * 48,
+              2.5 + Math.random() * 2.5,
+              0,
+              Math.PI * 2
+            );
+            ctx.fill();
+          }
+          break;
+        case 2:
+          ctx.beginPath();
+          ctx.moveTo(0, 32 + yOff);
+          for (let zx = 6; zx <= 64; zx += 6) {
+            ctx.lineTo(zx, 32 + yOff + (zx / 6 % 2 === 0 ? -7 : 7));
+          }
+          ctx.stroke();
+          break;
+        case 3:
+          ctx.fillRect(0, 24 + yOff, 64, 16);
+          break;
+        case 4:
+          ctx.beginPath();
+          for (let lx = 0; lx < 64; lx += 12) {
+            ctx.moveTo(lx, 0);
+            ctx.lineTo(lx + 32, 64);
+            ctx.moveTo(lx + 32, 0);
+            ctx.lineTo(lx, 64);
+          }
+          ctx.stroke();
+          break;
+        default:
+          ctx.beginPath();
+          ctx.moveTo(0, 32 + yOff);
+          for (let wx = 0; wx <= 64; wx += 2) {
+            ctx.lineTo(wx, 32 + yOff + Math.sin(wx * 0.3) * 5);
+          }
+          ctx.stroke();
+          break;
+      }
+    }
+    const tex = new T.CanvasTexture(c);
+    return new T.MeshBasicMaterial({
+      map: tex,
+      transparent: true,
+      opacity
+    });
+  }
+  _createEggGeometry(T) {
+    const geo = new T.SphereGeometry(0.42, 48, 48);
+    const pos = geo.attributes.position;
+    for (let i = 0; i < pos.count; i++) {
+      let y = pos.getY(i);
+      const x = pos.getX(i);
+      const z = pos.getZ(i);
+      const topSquash = y > 0 ? 0.82 : 1;
+      y = y * 1.45 * topSquash;
+      const narrowing = 1 - Math.abs(y) * 0.12;
+      pos.setX(i, x * narrowing);
+      pos.setY(i, y);
+      pos.setZ(i, z * narrowing);
+    }
+    geo.computeVertexNormals();
+    return geo;
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // CANVAS TEXTURE GENERATORS — procedural PBR textures
+  // ═══════════════════════════════════════════════════════════════════════
+  /** Silver polka-dot color map */
+  _drawSilverPolkaDots() {
+    const size = 512;
+    const c = document.createElement("canvas");
+    c.width = size;
+    c.height = size;
+    const ctx = c.getContext("2d");
+    const bg = ctx.createLinearGradient(0, 0, 0, size);
+    bg.addColorStop(0, "#e0e4ea");
+    bg.addColorStop(0.4, "#d5d9e0");
+    bg.addColorStop(0.6, "#cdd1d8");
+    bg.addColorStop(1, "#c8c4c0");
+    ctx.fillStyle = bg;
+    ctx.fillRect(0, 0, size, size);
+    const dotR = 22;
+    const spacingX = 64;
+    const spacingY = 52;
+    ctx.fillStyle = "#f4f4f6";
+    ctx.shadowColor = "rgba(255,255,255,0.5)";
+    ctx.shadowBlur = 6;
+    for (let row = 0; row < size / spacingY + 1; row++) {
+      const offsetX = row % 2 * (spacingX / 2);
+      for (let col = -1; col < size / spacingX + 1; col++) {
+        const cx = col * spacingX + offsetX;
+        const cy = row * spacingY;
+        ctx.beginPath();
+        ctx.arc(cx, cy, dotR, 0, Math.PI * 2);
+        ctx.fill();
+      }
+    }
+    ctx.shadowBlur = 0;
+    return c;
+  }
+  /** Silver roughness map (dots are more rough = less shiny) */
+  _drawSilverRoughness() {
+    const size = 512;
+    const c = document.createElement("canvas");
+    c.width = size;
+    c.height = size;
+    const ctx = c.getContext("2d");
+    ctx.fillStyle = "#333";
+    ctx.fillRect(0, 0, size, size);
+    const dotR = 22;
+    const spacingX = 64;
+    const spacingY = 52;
+    ctx.fillStyle = "#999";
+    for (let row = 0; row < size / spacingY + 1; row++) {
+      const offsetX = row % 2 * (spacingX / 2);
+      for (let col = -1; col < size / spacingX + 1; col++) {
+        const cx = col * spacingX + offsetX;
+        const cy = row * spacingY;
+        ctx.beginPath();
+        ctx.arc(cx, cy, dotR, 0, Math.PI * 2);
+        ctx.fill();
+      }
+    }
+    return c;
+  }
+  /** Gold color map with ornamental scrollwork */
+  _drawGoldPattern() {
+    const size = 512;
+    const c = document.createElement("canvas");
+    c.width = size;
+    c.height = size;
+    const ctx = c.getContext("2d");
+    const bg = ctx.createLinearGradient(0, 0, 0, size);
+    bg.addColorStop(0, "#c8960a");
+    bg.addColorStop(0.3, "#daa520");
+    bg.addColorStop(0.5, "#e6b422");
+    bg.addColorStop(0.7, "#c89618");
+    bg.addColorStop(1, "#b8860b");
+    ctx.fillStyle = bg;
+    ctx.fillRect(0, 0, size, size);
+    ctx.globalAlpha = 0.2;
+    for (const yRatio of [0.25, 0.5, 0.75]) {
+      const y = yRatio * size;
+      const bandH = 30;
+      const bg2 = ctx.createLinearGradient(0, y - bandH, 0, y + bandH);
+      bg2.addColorStop(0, "#b8860b");
+      bg2.addColorStop(0.5, "#f0d060");
+      bg2.addColorStop(1, "#b8860b");
+      ctx.fillStyle = bg2;
+      ctx.fillRect(0, y - bandH, size, bandH * 2);
+    }
+    ctx.globalAlpha = 1;
+    ctx.strokeStyle = "#a07008";
+    ctx.lineWidth = 1.2;
+    ctx.globalAlpha = 0.15;
+    const step = 32;
+    for (let x = -size; x < size * 2; x += step) {
+      ctx.beginPath();
+      ctx.moveTo(x, 0);
+      ctx.lineTo(x + size, size);
+      ctx.stroke();
+      ctx.beginPath();
+      ctx.moveTo(x + size, 0);
+      ctx.lineTo(x, size);
+      ctx.stroke();
+    }
+    ctx.globalAlpha = 1;
+    ctx.strokeStyle = "#d4a510";
+    ctx.lineWidth = 2;
+    ctx.globalAlpha = 0.3;
+    for (const yRatio of [0.22, 0.28, 0.47, 0.53, 0.72, 0.78]) {
+      const y = yRatio * size;
+      ctx.beginPath();
+      ctx.moveTo(0, y);
+      ctx.lineTo(size, y);
+      ctx.stroke();
+    }
+    ctx.globalAlpha = 1;
+    return c;
+  }
+  /** Gold roughness map */
+  _drawGoldRoughness() {
+    const size = 512;
+    const c = document.createElement("canvas");
+    c.width = size;
+    c.height = size;
+    const ctx = c.getContext("2d");
+    ctx.fillStyle = "#444";
+    ctx.fillRect(0, 0, size, size);
+    for (const yRatio of [0.25, 0.5, 0.75]) {
+      const y = yRatio * size;
+      ctx.fillStyle = "#666";
+      ctx.fillRect(0, y - 30, size, 60);
+    }
+    return c;
+  }
+  /** Festive Fabergé color map — randomized enamel bands + golden dividers */
+  _drawFestivePattern(seed) {
+    const size = 512;
+    const c = document.createElement("canvas");
+    c.width = size;
+    c.height = size;
+    const ctx = c.getContext("2d");
+    let s = seed ?? Date.now() ^ 25214903917;
+    const rand = () => {
+      s = s + 1831565813 | 0;
+      let t = Math.imul(s ^ s >>> 15, 1 | s);
+      t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+      return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    };
+    const hueBase = rand() * 360;
+    const enamelHues = [];
+    for (let i = 0; i < 5; i++) {
+      enamelHues.push((hueBase + i * (50 + rand() * 30)) % 360);
+    }
+    const bandCount = 9;
+    const bandH = size / bandCount;
+    for (let i = 0; i < bandCount; i++) {
+      const isGold = i % 2 === 1;
+      const y = i * bandH;
+      if (isGold) {
+        const goldLight = 52 + rand() * 10;
+        const bg = ctx.createLinearGradient(0, y, 0, y + bandH);
+        bg.addColorStop(0, `hsl(43, 80%, ${goldLight}%)`);
+        bg.addColorStop(1, `hsl(43, 75%, ${goldLight - 6}%)`);
+        ctx.fillStyle = bg;
+      } else {
+        const eIdx = Math.floor(i / 2);
+        const hue = enamelHues[eIdx % enamelHues.length];
+        const sat = 55 + rand() * 30;
+        const light = 35 + rand() * 15;
+        const bg = ctx.createLinearGradient(0, y, 0, y + bandH);
+        bg.addColorStop(0, `hsl(${hue}, ${sat}%, ${light}%)`);
+        bg.addColorStop(1, `hsl(${hue}, ${sat}%, ${light - 8}%)`);
+        ctx.fillStyle = bg;
+      }
+      ctx.fillRect(0, y, size, bandH + 1);
+    }
+    const overlayType = Math.floor(rand() * 4);
+    ctx.strokeStyle = `hsla(43, 70%, 60%, 0.2)`;
+    ctx.lineWidth = 1.5;
+    if (overlayType === 0) {
+      const step = rand() < 0.5 ? 32 : 64;
+      for (let x = -size; x < size * 2; x += step) {
+        ctx.beginPath();
+        ctx.moveTo(x, 0);
+        ctx.lineTo(x + size, size);
+        ctx.stroke();
+        ctx.beginPath();
+        ctx.moveTo(x + size, 0);
+        ctx.lineTo(x, size);
+        ctx.stroke();
+      }
+    } else if (overlayType === 1) {
+      const scW = 32;
+      for (let bi = 0; bi < bandCount; bi += 2) {
+        const cy = (bi + 0.5) * bandH;
+        for (let sx = scW / 2; sx < size; sx += scW) {
+          ctx.beginPath();
+          ctx.arc(sx, cy, scW * 0.38, 0, Math.PI * 2);
+          ctx.stroke();
+        }
+      }
+    } else if (overlayType === 2) {
+      const amp = 8 + rand() * 8;
+      const freq = [16, 32, 64][Math.floor(rand() * 3)];
+      for (let bi = 0; bi < bandCount; bi += 2) {
+        const cy = (bi + 0.5) * bandH;
+        ctx.beginPath();
+        ctx.moveTo(0, cy);
+        for (let x = 0; x <= size; x += freq) {
+          ctx.lineTo(x, cy + (x / freq % 2 === 0 ? -amp : amp));
+        }
+        ctx.stroke();
+      }
+    } else {
+      for (let bi = 0; bi < bandCount; bi += 2) {
+        const yCenter = (bi + 0.5) * bandH;
+        for (const off of [-bandH * 0.2, bandH * 0.2]) {
+          ctx.beginPath();
+          for (let x = 0; x <= size; x += 2) {
+            ctx.lineTo(x, yCenter + off + Math.sin(x * (Math.PI * 8 / size) + rand() * 0.5) * 4);
+          }
+          ctx.stroke();
+        }
+      }
+    }
+    const gemCount = 10 + Math.floor(rand() * 10);
+    for (let di = 1; di < bandCount; di += 2) {
+      const cy = (di + 0.5) * bandH;
+      for (let j = 0; j < gemCount; j++) {
+        const cx = (j + 0.5) * (size / gemCount);
+        const gh = enamelHues[Math.floor(rand() * enamelHues.length)];
+        ctx.fillStyle = `hsl(${gh}, 70%, 55%)`;
+        ctx.beginPath();
+        const gemPick = rand();
+        if (gemPick < 0.5) {
+          ctx.arc(cx, cy, 3 + rand() * 3, 0, Math.PI * 2);
+        } else {
+          const r = 3 + rand() * 3;
+          ctx.moveTo(cx, cy - r);
+          ctx.lineTo(cx + r, cy);
+          ctx.lineTo(cx, cy + r);
+          ctx.lineTo(cx - r, cy);
+        }
+        ctx.fill();
+      }
+    }
+    return c;
+  }
+  /** Festive roughness map */
+  _drawFestiveRoughness() {
+    const size = 512;
+    const c = document.createElement("canvas");
+    c.width = size;
+    c.height = size;
+    const ctx = c.getContext("2d");
+    ctx.fillStyle = "#555";
+    ctx.fillRect(0, 0, size, size);
+    const bands = 9;
+    const bandH = size / bands;
+    const dividerYs = [1, 3, 5, 7];
+    for (const dIdx of dividerYs) {
+      ctx.fillStyle = "#333";
+      ctx.fillRect(0, dIdx * bandH, size, bandH);
+    }
+    return c;
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // HOLD RING (visual feedback for long-press)
+  // ═══════════════════════════════════════════════════════════════════════
+  _createHoldRing(_T) {
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // REVEAL BURST — particle explosion when egg appears
+  // ═══════════════════════════════════════════════════════════════════════
+  _spawnRevealBurst(eggIndex) {
+    if (!this.THREE || !this.scene) return;
+    const T = this.THREE;
+    const burstColors = [
+      [12632264, 14540270, 16777215],
+      [16766720, 13145600, 16769152],
+      [13369376, 17612, 43568, 16766720, 8913066]
+    ];
+    const colors = burstColors[eggIndex] ?? burstColors[0];
+    const count = 40 + eggIndex * 20;
+    for (let i = 0; i < count; i++) {
+      const size = 0.015 + Math.random() * 0.03;
+      const geo = new T.SphereGeometry(size, 5, 5);
+      const c = colors[Math.floor(Math.random() * colors.length)];
+      const mat = new T.MeshBasicMaterial({
+        color: c,
+        transparent: true,
+        opacity: 0.8
+      });
+      const p = new T.Mesh(geo, mat);
+      const theta = Math.random() * Math.PI * 2;
+      const phi = Math.random() * Math.PI;
+      const speed = 1.5 + Math.random() * 2.5;
+      const vx = Math.sin(phi) * Math.cos(theta) * speed;
+      const vy = Math.sin(phi) * Math.sin(theta) * speed;
+      const vz = Math.cos(phi) * speed;
+      p.position.set(0, 0, 0);
+      this.scene.add(p);
+      this._revealParticles.push({ mesh: p, life: 1, vx, vy, vz });
+    }
+  }
+  /** Spawn golden energy vortex particles that orbit and spiral inward. */
+  _spawnVortex(eggIndex) {
+    if (!this.THREE || !this.scene) return;
+    const T = this.THREE;
+    const egg = this.eggs[eggIndex];
+    const origin = egg ? egg.position.clone() : new T.Vector3(0, 0, 0);
+    const count = 60;
+    for (let n = 0; n < count; n++) {
+      const size = 8e-3 + Math.random() * 0.015;
+      const geo = new T.SphereGeometry(size, 6, 6);
+      const hue = 0.1 + Math.random() * 0.06;
+      const col = new T.Color().setHSL(hue, 0.8, 0.6 + Math.random() * 0.3);
+      const mat = new T.MeshBasicMaterial({
+        color: col,
+        transparent: true,
+        opacity: 0
+      });
+      const p = new T.Mesh(geo, mat);
+      const angle = n / count * Math.PI * 2 + Math.random() * 0.3;
+      const radius = 1.2 + Math.random() * 0.8;
+      const yOff = (Math.random() - 0.5) * 1;
+      p.position.set(
+        origin.x + Math.cos(angle) * radius,
+        origin.y + yOff,
+        origin.z + Math.sin(angle) * radius
+      );
+      this.scene.add(p);
+      this._vortexParticles.push({
+        mesh: p,
+        life: 1,
+        angle,
+        radius,
+        yOff,
+        originX: origin.x,
+        originY: origin.y,
+        originZ: origin.z,
+        speed: 1.5 + Math.random() * 1.5,
+        delay: n * 8e-3 + Math.random() * 0.15
+      });
+    }
+  }
+  /** Spawn upward-drifting golden ember particles after implosion. */
+  _spawnEmbers(eggIndex) {
+    if (!this.THREE || !this.scene) return;
+    const T = this.THREE;
+    const egg = this.eggs[eggIndex];
+    const origin = egg ? egg.position.clone() : new T.Vector3(0, 0, 0);
+    const count = 35;
+    for (let n = 0; n < count; n++) {
+      const size = 6e-3 + Math.random() * 0.012;
+      const geo = new T.SphereGeometry(size, 4, 4);
+      const hue = 0.08 + Math.random() * 0.1;
+      const col = new T.Color().setHSL(hue, 0.7, 0.5 + Math.random() * 0.4);
+      const mat = new T.MeshBasicMaterial({
+        color: col,
+        transparent: true,
+        opacity: 0.9
+      });
+      const p = new T.Mesh(geo, mat);
+      const spread = 0.3;
+      p.position.set(
+        origin.x + (Math.random() - 0.5) * spread,
+        origin.y + (Math.random() - 0.5) * spread,
+        origin.z + (Math.random() - 0.5) * spread * 0.3
+      );
+      this.scene.add(p);
+      this._emberParticles.push({
+        mesh: p,
+        life: 1,
+        vx: (Math.random() - 0.5) * 0.3,
+        vy: 0.4 + Math.random() * 0.6,
+        vz: (Math.random() - 0.5) * 0.1,
+        flicker: Math.random() * Math.PI * 2
+      });
+    }
+  }
+  /** Update vortex particles — orbit, spiral inward, fade in then out. */
+  _updateVortexParticles(dt, collectProgress) {
+    var _a;
+    for (let i = this._vortexParticles.length - 1; i >= 0; i--) {
+      const p = this._vortexParticles[i];
+      if (collectProgress < p.delay) continue;
+      const localP = Math.min(1, (collectProgress - p.delay) / (0.55 - p.delay));
+      const currentRadius = p.radius * (1 - localP * localP * 0.95);
+      p.angle += dt * p.speed * (1 + localP * 4);
+      const yDrift = p.yOff * (1 - localP);
+      p.mesh.position.x = p.originX + Math.cos(p.angle) * currentRadius;
+      p.mesh.position.y = p.originY + yDrift;
+      p.mesh.position.z = p.originZ + Math.sin(p.angle) * currentRadius;
+      if (localP < 0.2) {
+        p.mesh.material.opacity = localP / 0.2 * 0.85;
+      } else if (localP > 0.85) {
+        p.mesh.material.opacity = (1 - localP) / 0.15 * 0.85;
+      } else {
+        p.mesh.material.opacity = 0.85;
+      }
+      p.mesh.scale.setScalar(0.8 + Math.sin(p.angle * 3) * 0.3);
+      if (localP >= 1) {
+        (_a = this.scene) == null ? void 0 : _a.remove(p.mesh);
+        p.mesh.geometry.dispose();
+        p.mesh.material.dispose();
+        this._vortexParticles.splice(i, 1);
+      }
+    }
+  }
+  /** Update ember particles — drift up, sway, flicker, fade. */
+  _updateEmberParticles(dt) {
+    var _a;
+    for (let i = this._emberParticles.length - 1; i >= 0; i--) {
+      const p = this._emberParticles[i];
+      p.life -= dt * 0.4;
+      p.mesh.position.x += p.vx * dt;
+      p.mesh.position.y += p.vy * dt;
+      p.mesh.position.z += p.vz * dt;
+      p.flicker += dt * 3;
+      p.mesh.position.x += Math.sin(p.flicker) * dt * 0.15;
+      p.vx *= 0.995;
+      p.vz *= 0.995;
+      const flick = 0.7 + Math.sin(p.flicker * 4) * 0.3;
+      p.mesh.material.opacity = Math.max(0, p.life * flick);
+      p.mesh.scale.setScalar(0.5 + p.life * 0.5);
+      if (p.life <= 0) {
+        (_a = this.scene) == null ? void 0 : _a.remove(p.mesh);
+        p.mesh.geometry.dispose();
+        p.mesh.material.dispose();
+        this._emberParticles.splice(i, 1);
+      }
+    }
+  }
+  _cancelLongPress() {
+    var _a;
+    this._longPressActive = false;
+    this._holdProgress = 0;
+    if (this._interactiveEgg !== null) {
+      const egg = this.eggs[this._interactiveEgg];
+      if (egg) {
+        egg.scale.setScalar(0.9);
+        egg.rotation.z = 0;
+      }
+      const body = this.eggBodies[this._interactiveEgg];
+      if (((_a = body == null ? void 0 : body.material) == null ? void 0 : _a.emissiveIntensity) !== void 0) {
+        body.material.emissiveIntensity = 0.05;
+      }
+    }
+  }
+  _worldToScreen(pos) {
+    if (!this.THREE || !this.camera) return { x: 0, y: 0 };
+    const T = this.THREE;
+    const v = new T.Vector3().copy(pos);
+    v.project(this.camera);
+    return {
+      x: (v.x * 0.5 + 0.5) * window.innerWidth,
+      y: (-v.y * 0.5 + 0.5) * window.innerHeight
+    };
+  }
+  _screenToWorld(sx, sy) {
+    const T = this.THREE;
+    const ndcX = sx / window.innerWidth * 2 - 1;
+    const ndcY = -(sy / window.innerHeight) * 2 + 1;
+    const vec = new T.Vector3(ndcX, ndcY, 0.5);
+    vec.unproject(this.camera);
+    const dir = vec.sub(this.camera.position).normalize();
+    const dist = -this.camera.position.z / dir.z;
+    return this.camera.position.clone().add(dir.multiplyScalar(dist));
+  }
+  _updateEggs(dt) {
+    var _a, _b;
+    if (!this.THREE) return;
+    for (let i = 0; i < 3; i++) {
+      const group = this.eggs[i];
+      const state = this._eggStates[i];
+      if (!state.visible || !group) continue;
+      state.t += dt;
+      switch (state.phase) {
+        case "reveal": {
+          const dur = 3;
+          const p = Math.min(1, state.t / dur);
+          const c4 = 2 * Math.PI / 3;
+          const ease = p === 0 ? 0 : p === 1 ? 1 : Math.pow(2, -10 * p) * Math.sin((p * 10 - 0.75) * c4) + 1;
+          group.scale.setScalar(ease * 0.9);
+          group.rotation.y = state.t * 1.2;
+          group.position.y = Math.sin(state.t * 2) * 0.06 * (1 - p);
+          const body = this.eggBodies[i];
+          if (((_a = body == null ? void 0 : body.material) == null ? void 0 : _a.emissiveIntensity) !== void 0) {
+            body.material.emissiveIntensity = 0.15 + Math.sin(state.t * 4) * 0.1;
+          }
+          if (p >= 1) {
+            state.phase = "interactive";
+            state.t = 0;
+          }
+          break;
+        }
+        case "interactive": {
+          if (!this._isDragging || this._interactiveEgg !== i) {
+            group.rotation.y += dt * 0.25;
+          }
+          group.position.y = Math.sin(state.t * 0.7) * 0.04;
+          const body = this.eggBodies[i];
+          if (((_b = body == null ? void 0 : body.material) == null ? void 0 : _b.emissiveIntensity) !== void 0) {
+            body.material.emissiveIntensity = 0.05 + Math.sin(state.t * 1.5) * 0.04;
+          }
+          break;
+        }
+        case "collecting": {
+          group.visible = false;
+          state.phase = "shrine";
+          state.t = 0;
+          break;
+        }
+        case "shrine": {
+          group.rotation.y += dt * 0.15;
+          const scale = 0.32 + Math.sin(state.t * 1) * 0.01;
+          group.scale.setScalar(scale);
+          break;
+        }
+      }
+    }
+  }
+  _updateHoldRing() {
+    var _a;
+    if (!this._longPressActive || this._interactiveEgg === null) return;
+    const elapsed = Date.now() - this._longPressStartTime;
+    const holdDuration = 1200;
+    this._holdProgress = Math.min(1, elapsed / holdDuration);
+    const p = this._holdProgress;
+    const time = elapsed * 1e-3;
+    const egg = this.eggs[this._interactiveEgg];
+    if (!egg) return;
+    const baseScale = 0.9;
+    const growScale = baseScale * (1 + p * 0.35);
+    egg.scale.setScalar(growScale);
+    if (p > 0.4) {
+      const wobble = (p - 0.4) * 0.03;
+      egg.rotation.z = Math.sin(time * 12) * wobble;
+      egg.rotation.x = Math.cos(time * 10) * wobble * 0.5;
+    }
+    if (p >= 1) {
+      const idx = this._interactiveEgg;
+      this._spawnMiniEggBurst(idx);
+      this._cancelLongPress();
+      (_a = this._onCollectEgg) == null ? void 0 : _a.call(this, idx);
+    }
+  }
+  /** Spawn a burst of shards flying outward from the collected egg, in the egg's own colour. */
+  _spawnMiniEggBurst(eggIndex) {
+    if (!this.THREE || !this.scene) return;
+    const T = this.THREE;
+    const egg = this.eggs[eggIndex];
+    if (!egg) return;
+    const origin = egg.position.clone();
+    const eggPalettes = [
+      { main: 12634328, accent: 8425648 },
+      // Egg 1: Silver
+      { main: 15253568, accent: 13934624 },
+      // Egg 2: Gold
+      { main: 13647968, accent: 8401056 }
+      // Egg 3: Fabergé (ruby/amethyst)
+    ];
+    const palette = eggPalettes[eggIndex] ?? eggPalettes[0];
+    const count = 18;
+    const miniGeo = new T.SphereGeometry(0.06, 12, 12);
+    const pos = miniGeo.attributes.position;
+    for (let vi = 0; vi < pos.count; vi++) {
+      let y = pos.getY(vi);
+      const topSquash = y > 0 ? 0.82 : 1;
+      y = y * 1.4 * topSquash;
+      pos.setY(vi, y);
+    }
+    miniGeo.computeVertexNormals();
+    for (let i = 0; i < count; i++) {
+      const color = Math.random() > 0.35 ? palette.main : palette.accent;
+      const mat = new T.MeshStandardMaterial({
+        color,
+        roughness: 0.3,
+        metalness: 0.5,
+        emissive: color,
+        emissiveIntensity: 0.15,
+        transparent: true,
+        opacity: 1
+      });
+      const mini = new T.Mesh(miniGeo, mat);
+      mini.position.copy(origin);
+      const s = 0.5 + Math.random() * 0.8;
+      mini.scale.setScalar(s);
+      mini.rotation.set(Math.random() * Math.PI, Math.random() * Math.PI, Math.random() * Math.PI);
+      const theta = Math.random() * Math.PI * 2;
+      const phi = Math.acos(2 * Math.random() - 1);
+      const speed = 2 + Math.random() * 3;
+      const vx = Math.sin(phi) * Math.cos(theta) * speed;
+      const vy = Math.sin(phi) * Math.sin(theta) * speed * 0.8 + 1;
+      const vz = Math.cos(phi) * speed;
+      this.scene.add(mini);
+      this._miniEggs.push({
+        mesh: mini,
+        vx,
+        vy,
+        vz,
+        life: 1,
+        spin: (Math.random() - 0.5) * 8
+      });
+    }
+  }
+  _updateMiniEggs(dt) {
+    var _a, _b;
+    for (let i = this._miniEggs.length - 1; i >= 0; i--) {
+      const p = this._miniEggs[i];
+      p.life -= dt * 1.2;
+      p.vy -= dt * 5;
+      p.mesh.position.x += p.vx * dt;
+      p.mesh.position.y += p.vy * dt;
+      p.mesh.position.z += p.vz * dt;
+      p.mesh.rotation.y += p.spin * dt;
+      p.mesh.rotation.x += p.spin * dt * 0.5;
+      const fade = Math.max(0, p.life);
+      p.mesh.material.opacity = fade;
+      p.mesh.scale.multiplyScalar(1 - dt * 0.5);
+      if (p.life <= 0) {
+        (_a = this.scene) == null ? void 0 : _a.remove(p.mesh);
+        (_b = p.mesh.material) == null ? void 0 : _b.dispose();
+        this._miniEggs.splice(i, 1);
+      }
+    }
+  }
+  _updateFinale(dt) {
+    var _a;
+    if (!this._finaleActive || !this.THREE) return;
+    this._finaleT += dt;
+    const angle = this._finaleT * 0.35;
+    const radius = 1.4;
+    const eggScale = 0.55;
+    for (let i = 0; i < 3; i++) {
+      const group = this.eggs[i];
+      if (!group) continue;
+      group.visible = true;
+      const eggAngle = angle + i * (Math.PI * 2 / 3);
+      const tx = Math.sin(eggAngle) * radius;
+      const ty = -0.1 + Math.sin(this._finaleT * 0.6 + i * 1.2) * 0.05;
+      const tz = Math.cos(eggAngle) * radius * 0.3;
+      group.position.x += (tx - group.position.x) * 0.06;
+      group.position.y += (ty - group.position.y) * 0.06;
+      group.position.z += (tz - group.position.z) * 0.06;
+      group.rotation.y = this._finaleT * 0.4 + i * (Math.PI * 2 / 3);
+      group.scale.setScalar(
+        group.scale.x + (eggScale - group.scale.x) * 0.04
+      );
+      const body = this.eggBodies[i];
+      if (((_a = body == null ? void 0 : body.material) == null ? void 0 : _a.emissiveIntensity) !== void 0) {
+        const glow = 0.15 + Math.sin(this._finaleT * 2 + i * 1.5) * 0.08;
+        body.material.emissiveIntensity += (glow - body.material.emissiveIntensity) * 0.05;
+      }
+    }
+    if (this._finaleT > 5 && this._finaleT < 5.1 && this.renderer) {
+      this.renderer.toneMappingExposure = 2.8;
+    }
+    if (this._finaleT > 5.1 && this._finaleT < 8 && this.renderer) {
+      this.renderer.toneMappingExposure = Math.max(
+        1.1,
+        2.8 - (this._finaleT - 5.1) * 0.55
+      );
+    }
+  }
+  _updateTrails(dt) {
+    for (let i = this._trailParticles.length - 1; i >= 0; i--) {
+      const p = this._trailParticles[i];
+      p.life -= dt * 0.5;
+      if (p.life <= 0) {
+        this.scene.remove(p.mesh);
+        p.mesh.geometry.dispose();
+        p.mesh.material.dispose();
+        this._trailParticles.splice(i, 1);
+      } else {
+        p.mesh.material.opacity = p.life * 0.65;
+        p.mesh.position.y += dt * 0.15;
+        p.mesh.scale.setScalar(p.life);
+        p.mesh.rotation.z += dt * 0.8;
+      }
+    }
+  }
+  _updateAmbientParticles(dt) {
+    for (let i = this._ambientParticles.length - 1; i >= 0; i--) {
+      const p = this._ambientParticles[i];
+      p.life -= dt * 0.25;
+      p.mesh.position.y += p.vy * dt;
+      p.mesh.rotation.z += dt * 0.5;
+      if (p.fadeIn && p.life > 0.7) {
+        p.mesh.material.opacity = Math.min(
+          0.55,
+          p.mesh.material.opacity + dt * 0.6
+        );
+        if (p.mesh.material.opacity >= 0.5) p.fadeIn = false;
+      } else {
+        p.mesh.material.opacity = Math.max(0, p.life * 0.55);
+      }
+      if (p.life <= 0) {
+        this.scene.remove(p.mesh);
+        p.mesh.geometry.dispose();
+        p.mesh.material.dispose();
+        this._ambientParticles.splice(i, 1);
+      }
+    }
+  }
+  _updateRevealParticles(dt) {
+    for (let i = this._revealParticles.length - 1; i >= 0; i--) {
+      const p = this._revealParticles[i];
+      p.life -= dt * 0.6;
+      p.mesh.position.x += p.vx * dt;
+      p.mesh.position.y += p.vy * dt;
+      p.mesh.position.z += p.vz * dt;
+      p.vy -= dt * 1.5;
+      p.mesh.material.opacity = Math.max(0, p.life * 0.8);
+      p.mesh.scale.setScalar(Math.max(0.01, p.life));
+      if (p.life <= 0) {
+        this.scene.remove(p.mesh);
+        p.mesh.geometry.dispose();
+        p.mesh.material.dispose();
+        this._revealParticles.splice(i, 1);
+      }
+    }
+  }
+}
+class FallbackRenderer {
+  constructor(config) {
+    this.host = null;
+    this.shadow = null;
+    this.container = null;
+    this.eggs = [];
+    this._finaleActive = false;
+    this.config = config;
+  }
+  async init() {
+    this.host = document.createElement("div");
+    this.host.id = "eeq-fallback-host";
+    Object.assign(this.host.style, {
+      position: "fixed",
+      top: "0",
+      left: "0",
+      width: "100%",
+      height: "100%",
+      pointerEvents: "none",
+      zIndex: "999992"
+    });
+    document.body.appendChild(this.host);
+    this.shadow = this.host.attachShadow({ mode: "closed" });
+    const style = document.createElement("style");
+    style.textContent = this._getStyles();
+    this.shadow.appendChild(style);
+    this.container = document.createElement("div");
+    this.container.className = "eeq-f-container";
+    this.shadow.appendChild(this.container);
+    for (let i = 0; i < 3; i++) {
+      const egg = document.createElement("div");
+      egg.className = `eeq-f-egg eeq-f-egg-${i + 1} eeq-f-hidden`;
+      const inner = document.createElement("div");
+      inner.className = "eeq-f-egg-inner";
+      const shine = document.createElement("div");
+      shine.className = "eeq-f-egg-shine";
+      inner.appendChild(shine);
+      egg.appendChild(inner);
+      this.container.appendChild(egg);
+      this.eggs.push(egg);
+    }
+    return true;
+  }
+  startRenderLoop() {
+  }
+  stopRenderLoop() {
+  }
+  revealEgg(index) {
+    const egg = this.eggs[index];
+    if (!egg) return;
+    egg.classList.remove("eeq-f-hidden");
+    egg.classList.add("eeq-f-reveal");
+  }
+  collectEgg(index) {
+    const egg = this.eggs[index];
+    if (!egg) return;
+    egg.classList.remove("eeq-f-reveal");
+    egg.classList.add("eeq-f-collected");
+  }
+  addTrail(x, y, _velocity) {
+    if (!this.container) return;
+    const dot = document.createElement("div");
+    dot.className = "eeq-f-trail";
+    const hue = Math.random() * 360;
+    dot.style.background = `hsl(${hue}, 50%, 78%)`;
+    dot.style.left = `${x}px`;
+    dot.style.top = `${y}px`;
+    this.container.appendChild(dot);
+    setTimeout(() => dot.remove(), 1200);
+  }
+  startFinale() {
+    this._finaleActive = true;
+    for (const egg of this.eggs) {
+      egg.classList.remove("eeq-f-collected", "eeq-f-hidden");
+      egg.classList.add("eeq-f-finale");
+    }
+    if (this.container) {
+      this.container.classList.add("eeq-f-finale-active");
+    }
+  }
+  setBreathIntensity(_intensity) {
+  }
+  setOverlayIntensity(_progress) {
+  }
+  destroy() {
+    var _a;
+    (_a = this.host) == null ? void 0 : _a.remove();
+    this.host = null;
+    this.shadow = null;
+    this.container = null;
+    this.eggs = [];
+  }
+  _getStyles() {
+    const t = this.config.theme;
+    return `
+      .eeq-f-container {
+        position: fixed;
+        top: 0; left: 0;
+        width: 100%; height: 100%;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        gap: 32px;
+        pointer-events: none;
+      }
+
+      .eeq-f-egg {
+        width: 60px;
+        height: 80px;
+        border-radius: 50% 50% 50% 50% / 60% 60% 40% 40%;
+        position: relative;
+        transition: all 1.5s cubic-bezier(0.22, 1, 0.36, 1);
+      }
+
+      .eeq-f-hidden {
+        opacity: 0;
+        transform: scale(0.1);
+      }
+
+      .eeq-f-reveal {
+        opacity: 1;
+        transform: scale(1);
+        animation: eeq-f-float 3s ease-in-out infinite;
+      }
+
+      .eeq-f-collected {
+        opacity: 0.6;
+        transform: scale(0.5) translateY(200px);
+        position: fixed;
+        bottom: 30px;
+      }
+
+      .eeq-f-finale {
+        opacity: 1;
+        transform: scale(1);
+        animation: eeq-f-finale-spin 3s linear infinite;
+      }
+
+      .eeq-f-finale-active {
+        animation: eeq-f-glow-bg 2s ease-in-out forwards;
+      }
+
+      .eeq-f-egg-inner {
+        width: 100%;
+        height: 100%;
+        border-radius: inherit;
+        position: relative;
+        overflow: hidden;
+      }
+
+      .eeq-f-egg-shine {
+        position: absolute;
+        top: 15%;
+        left: 20%;
+        width: 30%;
+        height: 25%;
+        border-radius: 50%;
+        background: rgba(255,255,255,0.4);
+        filter: blur(4px);
+      }
+
+      /* Egg 1: Porcelain */
+      .eeq-f-egg-1 .eeq-f-egg-inner {
+        background: linear-gradient(145deg, #f5f0eb 0%, #e8e0d8 50%, #d8d0c8 100%);
+        box-shadow: 0 4px 24px rgba(212,165,116,0.2), inset 0 2px 8px rgba(255,255,255,0.3);
+      }
+
+      /* Egg 2: Luminous pearl */
+      .eeq-f-egg-2 .eeq-f-egg-inner {
+        background: linear-gradient(145deg, #faf5f0 0%, #f0e8e0 40%, #e5ddd5 100%);
+        box-shadow: 0 4px 28px rgba(212,165,116,0.3), inset 0 2px 12px rgba(255,255,255,0.4);
+      }
+
+      /* Egg 3: Golden core */
+      .eeq-f-egg-3 .eeq-f-egg-inner {
+        background: linear-gradient(145deg, #fff8f0 0%, #f5e8d5 40%, ${t.accent} 100%);
+        box-shadow: 0 4px 32px ${t.accentGlow}, inset 0 2px 16px rgba(255,255,255,0.4);
+      }
+
+      .eeq-f-trail {
+        position: fixed;
+        width: 8px;
+        height: 11px;
+        border-radius: 50% 50% 50% 50% / 60% 60% 40% 40%;
+        background: ${t.accent};
+        opacity: 0.4;
+        pointer-events: none;
+        animation: eeq-f-trail-fade 1.2s ease-out forwards;
+      }
+
+      @keyframes eeq-f-float {
+        0%, 100% { transform: scale(1) translateY(0); }
+        50% { transform: scale(1) translateY(-8px); }
+      }
+
+      @keyframes eeq-f-finale-spin {
+        from { transform: scale(1) rotate(0deg); }
+        to { transform: scale(1) rotate(360deg); }
+      }
+
+      @keyframes eeq-f-trail-fade {
+        0% { opacity: 0.5; transform: scale(1); }
+        100% { opacity: 0; transform: scale(0.2) translateY(-10px); }
+      }
+
+      @keyframes eeq-f-glow-bg {
+        0% { background: transparent; }
+        50% { background: rgba(212,165,116,0.08); }
+        100% { background: transparent; }
+      }
+    `;
+  }
+}
+class OverlayManager {
+  constructor(config) {
+    this.overlay = null;
+    this._visible = false;
+    this.config = config;
+  }
+  mount() {
+    this.overlay = document.createElement("div");
+    this.overlay.id = "eeq-overlay";
+    Object.assign(this.overlay.style, {
+      position: "fixed",
+      top: "0",
+      left: "0",
+      width: "100%",
+      height: "100%",
+      background: "transparent",
+      backdropFilter: "none",
+      WebkitBackdropFilter: "none",
+      zIndex: "999985",
+      pointerEvents: "none",
+      transition: "background 1.5s ease, backdrop-filter 1.5s ease",
+      opacity: "0"
+    });
+    document.body.appendChild(this.overlay);
+  }
+  /** Fade in the overlay. */
+  show() {
+    if (!this.overlay || this._visible) return;
+    this._visible = true;
+    requestAnimationFrame(() => {
+      if (!this.overlay) return;
+      this.overlay.style.opacity = "1";
+      this.overlay.style.background = this.config.theme.overlayBg;
+      this.overlay.style.backdropFilter = "blur(2px)";
+      this.overlay.style.WebkitBackdropFilter = "blur(2px)";
+    });
+  }
+  /** Adjust overlay intensity for visual softening (0–1). */
+  setIntensity(progress) {
+    if (!this.overlay) return;
+    const baseAlpha = 0.25;
+    const maxAlpha = 0.5;
+    const alpha = baseAlpha + progress * (maxAlpha - baseAlpha);
+    this.overlay.style.background = `rgba(0,0,0,${alpha})`;
+    const blur = 2 + progress * 4;
+    this.overlay.style.backdropFilter = `blur(${blur}px)`;
+    this.overlay.style.WebkitBackdropFilter = `blur(${blur}px)`;
+  }
+  /** Fade out the overlay. */
+  hide() {
+    if (!this.overlay) return;
+    this._visible = false;
+    this.overlay.style.opacity = "0";
+    this.overlay.style.background = "transparent";
+    this.overlay.style.backdropFilter = "none";
+    this.overlay.style.WebkitBackdropFilter = "none";
+  }
+  destroy() {
+    var _a;
+    (_a = this.overlay) == null ? void 0 : _a.remove();
+    this.overlay = null;
+  }
+}
+const _ResultsRenderer = class _ResultsRenderer {
+  constructor(config) {
+    this.host = null;
+    this.shadow = null;
+    this._onFinish = null;
+    this.config = config;
+  }
+  show(score, onFinish) {
+    var _a, _b;
+    this._onFinish = onFinish;
+    this.host = document.createElement("div");
+    this.host.id = "eeq-results-host";
+    Object.assign(this.host.style, {
+      position: "fixed",
+      top: "0",
+      left: "0",
+      width: "100%",
+      height: "100%",
+      zIndex: "999998",
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "center",
+      pointerEvents: "none"
+    });
+    document.body.appendChild(this.host);
+    this.shadow = this.host.attachShadow({ mode: "closed" });
+    const style = document.createElement("style");
+    style.textContent = this._getStyles();
+    this.shadow.appendChild(style);
+    const panel = document.createElement("div");
+    panel.className = "eeq-results";
+    panel.innerHTML = this._buildContent(score);
+    this.shadow.appendChild(panel);
+    requestAnimationFrame(() => {
+      requestAnimationFrame(() => {
+        panel.classList.add("eeq-results-visible");
+      });
+    });
+    (_a = this.shadow.querySelector(".eeq-btn-finish")) == null ? void 0 : _a.addEventListener("click", () => {
+      var _a2;
+      return (_a2 = this._onFinish) == null ? void 0 : _a2.call(this);
+    });
+    (_b = this.shadow.querySelector(".eeq-btn-share")) == null ? void 0 : _b.addEventListener("click", () => this._copyShareImage(score));
+  }
+  destroy() {
+    var _a;
+    (_a = this.host) == null ? void 0 : _a.remove();
+    this.host = null;
+    this.shadow = null;
+  }
+  // ─── Content ───────────────────────────────────────────────────────────
+  _buildContent(s) {
+    const bp = s.behaviorProfile;
+    const actionIcons = {
+      clicker: "🖱",
+      scroller: "📜",
+      typist: "⌨",
+      minimalist: "🧘",
+      mover: "🖱"
+    };
+    const mouseIcons = {
+      tornado: "🌪",
+      conductor: "🎼",
+      surgeon: "🎯",
+      ghost: "👻"
+    };
+    const paceIcons = {
+      speedster: "⚡",
+      steady: "🚶",
+      explorer: "🧭",
+      philosopher: "🕊"
+    };
+    const badges = [];
+    const ai = actionIcons[bp.dominantAction] ?? "";
+    const mi = mouseIcons[bp.mousePersonality] ?? "";
+    const pi = paceIcons[bp.pace] ?? "";
+    if (ai) badges.push(`<span class="eeq-badge" title="${bp.dominantAction}">${ai}</span>`);
+    if (mi) badges.push(`<span class="eeq-badge" title="${bp.mousePersonality}">${mi}</span>`);
+    if (pi) badges.push(`<span class="eeq-badge" title="${bp.pace}">${pi}</span>`);
+    return `
+      <div class="eeq-results-inner">
+        <div class="eeq-results-title">« ${this._escapeHtml(bp.title)} »</div>
+        <div class="eeq-time">${formatTime(s.totalTime)}</div>
+        <div class="eeq-badges">${badges.join("")}</div>
+        <div class="eeq-share-invite">share your result with friends 🥚</div>
+        <div class="eeq-results-actions">
+          <button class="eeq-btn eeq-btn-share" title="share result">
+            <svg width="16" height="16" viewBox="0 0 16 16" fill="none"><path d="M4.5 10.5a2 2 0 1 1 0-4 2 2 0 0 1 0 4zm7-4a2 2 0 1 1 0-4 2 2 0 0 1 0 4zm0 8a2 2 0 1 1 0-4 2 2 0 0 1 0 4z" stroke="currentColor" stroke-width="1.2"/><path d="M6.3 9.2l3.4 1.6M6.3 7.8l3.4-1.6" stroke="currentColor" stroke-width="1.2"/></svg>
+            <span>share</span>
+          </button>
+          <button class="eeq-btn eeq-btn-finish" title="finish">
+            <svg width="16" height="16" viewBox="0 0 16 16" fill="none"><path d="M4 8.5l3 3 5-6.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>
+            <span>finish</span>
+          </button>
+        </div>
+      </div>
+    `;
+  }
+  // ─── 2D Egg Drawing (type-accurate) ─────────────────────────────────
+  _makeRand(seed) {
+    let s = seed;
+    return () => {
+      s = s + 1831565813 | 0;
+      let t = Math.imul(s ^ s >>> 15, 1 | s);
+      t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+      return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    };
+  }
+  /** Draw a type-accurate egg on canvas. eggIdx: 0=silver, 1=gold, 2=festive. */
+  _drawTypedEgg2D(canvas, eggIdx, found, seed) {
+    const w = 72;
+    const h = 96;
+    const dpr = Math.min(window.devicePixelRatio || 1, 3);
+    canvas.width = w * dpr;
+    canvas.height = h * dpr;
+    canvas.style.width = `${w}px`;
+    canvas.style.height = `${h}px`;
+    const ctx = canvas.getContext("2d");
+    ctx.scale(dpr, dpr);
+    const cx = w / 2;
+    const cy = h / 2;
+    const rx = w * 0.42;
+    const ry = h * 0.46;
+    if (!found) {
+      this._drawEggOutline(ctx, cx, cy, rx, ry, true);
+      return;
+    }
+    if (eggIdx === 0) this._paintSilverEgg(ctx, cx, cy, rx, ry);
+    else if (eggIdx === 1) this._paintGoldEgg(ctx, cx, cy, rx, ry);
+    else this._paintFestiveEgg(ctx, cx, cy, rx, ry, seed);
+  }
+  /** Egg path helper — builds egg-shaped path. */
+  _eggPath(ctx, cx, cy, rx, ry) {
+    ctx.beginPath();
+    for (let a = 0; a <= Math.PI * 2; a += 0.02) {
+      const r = 1 - 0.15 * Math.sin(a);
+      const x = cx + Math.cos(a) * rx * r;
+      const y = cy - Math.sin(a) * ry;
+      if (a === 0) ctx.moveTo(x, y);
+      else ctx.lineTo(x, y);
+    }
+    ctx.closePath();
+  }
+  /** Dashed or solid egg outline. */
+  _drawEggOutline(ctx, cx, cy, rx, ry, dashed) {
+    ctx.save();
+    if (dashed) ctx.setLineDash([5, 4]);
+    this._eggPath(ctx, cx, cy, rx, ry);
+    ctx.strokeStyle = "rgba(255,255,255,0.15)";
+    ctx.lineWidth = 1.5;
+    ctx.stroke();
+    ctx.restore();
+  }
+  /** Specular highlight on top-left of egg. */
+  _drawSpecular(ctx, cx, cy, rx, ry) {
+    const hl = ctx.createRadialGradient(cx - rx * 0.25, cy - ry * 0.4, 0, cx - rx * 0.25, cy - ry * 0.4, rx * 0.7);
+    hl.addColorStop(0, "rgba(255,255,255,0.4)");
+    hl.addColorStop(1, "rgba(255,255,255,0)");
+    ctx.fillStyle = hl;
+    ctx.fillRect(cx - rx - 2, cy - ry - 2, rx * 2 + 4, ry * 2 + 4);
+  }
+  /** Silver egg — cool chrome gradient with white polka dots and metallic sheen. */
+  _paintSilverEgg(ctx, cx, cy, rx, ry) {
+    ctx.save();
+    this._eggPath(ctx, cx, cy, rx, ry);
+    ctx.clip();
+    const bg = ctx.createLinearGradient(cx, cy - ry, cx, cy + ry);
+    bg.addColorStop(0, "#e8ecf2");
+    bg.addColorStop(0.3, "#dde1e8");
+    bg.addColorStop(0.6, "#d0d4dc");
+    bg.addColorStop(1, "#c4c0bc");
+    ctx.fillStyle = bg;
+    ctx.fillRect(cx - rx - 2, cy - ry - 2, rx * 2 + 4, ry * 2 + 4);
+    const dotR = 3.5;
+    const spX = 12;
+    const spY = 10;
+    ctx.fillStyle = "rgba(255,255,255,0.55)";
+    for (let row = -1; row < ry * 2 / spY + 2; row++) {
+      const offX = row % 2 * (spX / 2);
+      for (let col = -1; col < rx * 2 / spX + 2; col++) {
+        const dx = cx - rx + col * spX + offX;
+        const dy = cy - ry + row * spY;
+        ctx.beginPath();
+        ctx.arc(dx, dy, dotR, 0, Math.PI * 2);
+        ctx.fill();
+      }
+    }
+    const sheen = ctx.createLinearGradient(cx - rx, cy - ry * 0.2, cx + rx, cy + ry * 0.2);
+    sheen.addColorStop(0, "rgba(255,255,255,0)");
+    sheen.addColorStop(0.4, "rgba(255,255,255,0.12)");
+    sheen.addColorStop(0.6, "rgba(255,255,255,0.12)");
+    sheen.addColorStop(1, "rgba(255,255,255,0)");
+    ctx.fillStyle = sheen;
+    ctx.fillRect(cx - rx - 2, cy - ry - 2, rx * 2 + 4, ry * 2 + 4);
+    this._drawSpecular(ctx, cx, cy, rx, ry);
+    ctx.restore();
+    ctx.save();
+    this._eggPath(ctx, cx, cy, rx, ry);
+    ctx.strokeStyle = "rgba(200,205,215,0.5)";
+    ctx.lineWidth = 1.2;
+    ctx.stroke();
+    ctx.restore();
+  }
+  /** Gold egg — warm yellow gradient, horizontal ornate bands, diamond lattice. */
+  _paintGoldEgg(ctx, cx, cy, rx, ry) {
+    ctx.save();
+    this._eggPath(ctx, cx, cy, rx, ry);
+    ctx.clip();
+    const bg = ctx.createLinearGradient(cx, cy - ry, cx, cy + ry);
+    bg.addColorStop(0, "#d4a520");
+    bg.addColorStop(0.25, "#e6c040");
+    bg.addColorStop(0.5, "#daa520");
+    bg.addColorStop(0.75, "#c89618");
+    bg.addColorStop(1, "#b8860b");
+    ctx.fillStyle = bg;
+    ctx.fillRect(cx - rx - 2, cy - ry - 2, rx * 2 + 4, ry * 2 + 4);
+    ctx.globalAlpha = 0.25;
+    for (const yRatio of [0.28, 0.5, 0.72]) {
+      const y = cy - ry + yRatio * ry * 2;
+      const bandH = 5;
+      const bg2 = ctx.createLinearGradient(cx, y - bandH, cx, y + bandH);
+      bg2.addColorStop(0, "#b8860b");
+      bg2.addColorStop(0.5, "#f0d060");
+      bg2.addColorStop(1, "#b8860b");
+      ctx.fillStyle = bg2;
+      ctx.fillRect(cx - rx - 2, y - bandH, rx * 2 + 4, bandH * 2);
+    }
+    ctx.globalAlpha = 1;
+    ctx.strokeStyle = "rgba(160,112,8,0.18)";
+    ctx.lineWidth = 0.8;
+    const step = 8;
+    for (let x = cx - rx * 2; x < cx + rx * 2; x += step) {
+      ctx.beginPath();
+      ctx.moveTo(x, cy - ry);
+      ctx.lineTo(x + ry * 2, cy + ry);
+      ctx.stroke();
+      ctx.beginPath();
+      ctx.moveTo(x + ry * 2, cy - ry);
+      ctx.lineTo(x, cy + ry);
+      ctx.stroke();
+    }
+    ctx.strokeStyle = "rgba(212,165,16,0.35)";
+    ctx.lineWidth = 0.7;
+    for (const yRatio of [0.24, 0.32, 0.46, 0.54, 0.68, 0.76]) {
+      const y = cy - ry + yRatio * ry * 2;
+      ctx.beginPath();
+      ctx.moveTo(cx - rx, y);
+      ctx.lineTo(cx + rx, y);
+      ctx.stroke();
+    }
+    this._drawSpecular(ctx, cx, cy, rx, ry);
+    ctx.restore();
+    ctx.save();
+    this._eggPath(ctx, cx, cy, rx, ry);
+    ctx.strokeStyle = "rgba(200,165,30,0.5)";
+    ctx.lineWidth = 1.2;
+    ctx.stroke();
+    ctx.restore();
+  }
+  /** Festive Fabergé egg — seeded enamel bands + golden dividers + gem dots. */
+  _paintFestiveEgg(ctx, cx, cy, rx, ry, seed) {
+    const rand = this._makeRand(seed);
+    ctx.save();
+    this._eggPath(ctx, cx, cy, rx, ry);
+    ctx.clip();
+    const hueBase = rand() * 360;
+    const enamelHues = [];
+    for (let i = 0; i < 5; i++) enamelHues.push((hueBase + i * (50 + rand() * 30)) % 360);
+    const bandCount = 9;
+    const fullH = ry * 2;
+    const bandH = fullH / bandCount;
+    const top = cy - ry;
+    for (let i = 0; i < bandCount; i++) {
+      const isGold = i % 2 === 1;
+      const y = top + i * bandH;
+      if (isGold) {
+        const gl = 52 + rand() * 10;
+        const gb = ctx.createLinearGradient(cx, y, cx, y + bandH);
+        gb.addColorStop(0, `hsl(43, 80%, ${gl}%)`);
+        gb.addColorStop(1, `hsl(43, 75%, ${gl - 6}%)`);
+        ctx.fillStyle = gb;
+      } else {
+        const eIdx = Math.floor(i / 2);
+        const hue = enamelHues[eIdx % enamelHues.length];
+        const sat = 55 + rand() * 30;
+        const light = 35 + rand() * 15;
+        const eb = ctx.createLinearGradient(cx, y, cx, y + bandH);
+        eb.addColorStop(0, `hsl(${hue}, ${sat}%, ${light}%)`);
+        eb.addColorStop(1, `hsl(${hue}, ${sat}%, ${light - 8}%)`);
+        ctx.fillStyle = eb;
+      }
+      ctx.fillRect(cx - rx - 2, y, rx * 2 + 4, bandH + 1);
+    }
+    const gemCount = 5 + Math.floor(rand() * 4);
+    for (let di = 1; di < bandCount; di += 2) {
+      const gemY = top + (di + 0.5) * bandH;
+      for (let j = 0; j < gemCount; j++) {
+        const gx = cx - rx * 0.7 + (j + 0.5) * (rx * 1.4 / gemCount);
+        const gh = enamelHues[Math.floor(rand() * enamelHues.length)];
+        ctx.fillStyle = `hsl(${gh}, 70%, 55%)`;
+        ctx.beginPath();
+        ctx.arc(gx, gemY, 1.5 + rand(), 0, Math.PI * 2);
+        ctx.fill();
+      }
+    }
+    this._drawSpecular(ctx, cx, cy, rx, ry);
+    ctx.restore();
+    ctx.save();
+    this._eggPath(ctx, cx, cy, rx, ry);
+    ctx.strokeStyle = "rgba(200,150,100,0.45)";
+    ctx.lineWidth = 1.2;
+    ctx.stroke();
+    ctx.restore();
+  }
+  // ─── Combined copy & share ──────────────────────────────────────────
+  _copyShareImage(s) {
+    const canvas = this._renderCard(s);
+    canvas.toBlob((blob) => {
+      var _a;
+      if (!blob) return;
+      const isMobile = /Android|iPhone|iPad|iPod/i.test(navigator.userAgent) && window.innerWidth < 768;
+      if (isMobile && navigator.share) {
+        const file = new File([blob], "easter-egg-quest.png", { type: "image/png" });
+        if ((_a = navigator.canShare) == null ? void 0 : _a.call(navigator, { files: [file] })) {
+          navigator.share({
+            files: [file],
+            title: "Easter Egg Quest",
+            text: `«${s.behaviorProfile.title}»`
+          }).catch(() => {
+          });
+          return;
+        }
+      }
+      if (navigator.clipboard && typeof ClipboardItem !== "undefined") {
+        navigator.clipboard.write([
+          new ClipboardItem({ "image/png": blob })
+        ]).then(() => {
+          this._flashButton(".eeq-btn-share", "copied!");
+        }).catch(() => {
+          this._downloadBlob(blob);
+        });
+        return;
+      }
+      this._downloadBlob(blob);
+    }, "image/png");
+  }
+  _downloadBlob(blob) {
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = "easter-egg-quest.png";
+    a.click();
+    setTimeout(() => URL.revokeObjectURL(url), 5e3);
+    this._flashButton(".eeq-btn-share", "saved!");
+  }
+  _renderCard(s) {
+    const W = 480;
+    const H = 400;
+    const dpr = Math.min(window.devicePixelRatio || 1, 3);
+    const c = document.createElement("canvas");
+    c.width = W * dpr;
+    c.height = H * dpr;
+    const ctx = c.getContext("2d");
+    ctx.scale(dpr, dpr);
+    const grad = ctx.createLinearGradient(0, 0, 0, H);
+    grad.addColorStop(0, "#1e1815");
+    grad.addColorStop(0.5, "#14110e");
+    grad.addColorStop(1, "#0d0b09");
+    ctx.fillStyle = grad;
+    this._roundRect(ctx, 0, 0, W, H, 16);
+    ctx.fill();
+    ctx.strokeStyle = "rgba(212,165,80,0.18)";
+    ctx.lineWidth = 1;
+    this._roundRect(ctx, 0.5, 0.5, W - 1, H - 1, 16);
+    ctx.stroke();
+    ctx.textAlign = "center";
+    ctx.font = "11px Georgia, serif";
+    ctx.fillStyle = "rgba(232,224,214,0.3)";
+    ctx.fillText("🥚 Easter Egg Quest", W / 2, 28);
+    const eggW = 48;
+    const eggH = 64;
+    const eggRx = eggW * 0.42;
+    const eggRy = eggH * 0.46;
+    const eggY = 72;
+    const gap = 16;
+    const totalRow = eggW * 3 + gap * 2;
+    const startX = (W - totalRow) / 2 + eggW / 2;
+    for (let i = 0; i < 3; i++) {
+      const ecx = startX + i * (eggW + gap);
+      const found = i < s.eggsFound;
+      if (found) {
+        if (i === 0) this._paintSilverEgg(ctx, ecx, eggY, eggRx, eggRy);
+        else if (i === 1) this._paintGoldEgg(ctx, ecx, eggY, eggRx, eggRy);
+        else this._paintFestiveEgg(ctx, ecx, eggY, eggRx, eggRy, s.eggSeed);
+      } else {
+        this._drawEggOutline(ctx, ecx, eggY, eggRx, eggRy, true);
+      }
+    }
+    const countText = s.eggsFound === 3 ? "All eggs collected!" : `${s.eggsFound} of 3 eggs collected`;
+    ctx.font = "10px Georgia, serif";
+    ctx.fillStyle = "rgba(232,224,214,0.35)";
+    ctx.fillText(countText, W / 2, eggY + eggRy + 18);
+    const divY = eggY + eggRy + 30;
+    ctx.strokeStyle = "rgba(212,165,80,0.12)";
+    ctx.lineWidth = 0.5;
+    ctx.beginPath();
+    ctx.moveTo(W * 0.2, divY);
+    ctx.lineTo(W * 0.8, divY);
+    ctx.stroke();
+    ctx.font = "italic 18px Georgia, serif";
+    ctx.fillStyle = this.config.theme.accent;
+    ctx.fillText(`« ${s.behaviorProfile.title} »`, W / 2, divY + 28);
+    ctx.font = '32px "SF Mono", "Fira Code", Consolas, monospace';
+    ctx.fillStyle = "#e8e0d6";
+    ctx.fillText(formatTime(s.totalTime), W / 2, divY + 68);
+    const labels = [
+      s.behaviorProfile.dominantAction,
+      s.behaviorProfile.mousePersonality,
+      s.behaviorProfile.pace
+    ];
+    ctx.font = "12px Georgia, serif";
+    ctx.fillStyle = "rgba(232,224,214,0.4)";
+    ctx.fillText(labels.join("  ·  "), W / 2, divY + 92);
+    ctx.font = "14px Georgia, serif";
+    ctx.fillStyle = "rgba(232,224,214,0.55)";
+    ctx.fillText("Happy Easter! 🐰🥚", W / 2, divY + 130);
+    ctx.font = "11px Georgia, serif";
+    ctx.fillStyle = "rgba(232,224,214,0.3)";
+    ctx.fillText("Wishing you joy, peace, and light", W / 2, divY + 150);
+    ctx.font = "9px Georgia, serif";
+    ctx.fillStyle = "rgba(232,224,214,0.12)";
+    ctx.fillText("easter egg quest", W / 2, H - 16);
+    return c;
+  }
+  _roundRect(ctx, x, y, w, h, r) {
+    ctx.beginPath();
+    ctx.moveTo(x + r, y);
+    ctx.lineTo(x + w - r, y);
+    ctx.quadraticCurveTo(x + w, y, x + w, y + r);
+    ctx.lineTo(x + w, y + h - r);
+    ctx.quadraticCurveTo(x + w, y + h, x + w - r, y + h);
+    ctx.lineTo(x + r, y + h);
+    ctx.quadraticCurveTo(x, y + h, x, y + h - r);
+    ctx.lineTo(x, y + r);
+    ctx.quadraticCurveTo(x, y, x + r, y);
+    ctx.closePath();
+  }
+  // ─── Helpers ───────────────────────────────────────────────────────────
+  _flashButton(selector, text) {
+    var _a;
+    const span = (_a = this.shadow) == null ? void 0 : _a.querySelector(`${selector} span`);
+    if (!span) return;
+    const orig = span.textContent;
+    span.textContent = text;
+    setTimeout(() => {
+      span.textContent = orig;
+    }, 1500);
+  }
+  _escapeHtml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  }
+  // ─── Styles ────────────────────────────────────────────────────────────
+  _getStyles() {
+    const t = this.config.theme;
+    return `
+      .eeq-results {
+        pointer-events: auto;
+        background: linear-gradient(175deg, rgba(28,22,18,0.95) 0%, rgba(10,8,6,0.97) 100%);
+        backdrop-filter: blur(28px);
+        -webkit-backdrop-filter: blur(28px);
+        border: 1px solid rgba(212,165,80,0.1);
+        border-radius: 20px;
+        padding: 28px 36px 24px;
+        max-width: 320px;
+        width: 85vw;
+        opacity: 0;
+        transform: translateY(24px) scale(0.95);
+        transition: opacity 0.9s ease, transform 0.9s cubic-bezier(0.23, 1, 0.32, 1);
+        font-family: 'Georgia', 'Times New Roman', serif;
+        color: ${t.textColor};
+        text-align: center;
+        box-shadow: 0 24px 80px rgba(0,0,0,0.6), 0 4px 16px rgba(0,0,0,0.4),
+                    inset 0 1px 0 rgba(255,255,255,0.04);
+      }
+
+      .eeq-results-visible {
+        opacity: 1;
+        transform: translateY(0) scale(1);
+      }
+
+      .eeq-results-title {
+        font-size: 18px;
+        font-style: italic;
+        letter-spacing: 0.04em;
+        color: ${t.accent};
+        margin-bottom: 10px;
+        line-height: 1.35;
+        text-shadow: 0 0 30px rgba(212,165,80,0.15);
+      }
+
+      .eeq-time {
+        font-size: 30px;
+        font-family: 'SF Mono', 'Fira Code', 'Consolas', monospace;
+        letter-spacing: 0.06em;
+        margin-bottom: 12px;
+        background: linear-gradient(180deg, #f0ece6, #c8c0b4);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        background-clip: text;
+      }
+
+      .eeq-badges {
+        display: flex;
+        justify-content: center;
+        gap: 10px;
+        margin-bottom: 12px;
+        font-size: 18px;
+      }
+
+      .eeq-share-invite {
+        font-size: 13px;
+        color: rgba(232,224,214,0.5);
+        margin-bottom: 16px;
+        letter-spacing: 0.03em;
+      }
+
+      .eeq-badge {
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        width: 36px;
+        height: 36px;
+        border-radius: 50%;
+        background: rgba(255,255,255,0.03);
+        border: 1px solid rgba(255,255,255,0.07);
+        cursor: default;
+        transition: background 0.3s, border-color 0.3s;
+      }
+
+      .eeq-badge:hover {
+        background: rgba(212,165,80,0.08);
+        border-color: rgba(212,165,80,0.2);
+      }
+
+      .eeq-results-actions {
+        display: flex;
+        justify-content: center;
+        gap: 10px;
+      }
+
+      .eeq-btn {
+        display: inline-flex;
+        align-items: center;
+        gap: 6px;
+        background: rgba(255,255,255,0.02);
+        border: 1px solid rgba(255,255,255,0.1);
+        color: ${t.textColor};
+        padding: 8px 18px;
+        border-radius: 10px;
+        font-family: 'Georgia', serif;
+        font-size: 12px;
+        letter-spacing: 0.04em;
+        cursor: pointer;
+        transition: all 0.3s ease;
+        white-space: nowrap;
+      }
+
+      .eeq-btn svg {
+        flex-shrink: 0;
+        opacity: 0.7;
+        transition: opacity 0.3s;
+      }
+
+      .eeq-btn:hover {
+        border-color: ${t.accent};
+        color: ${t.accent};
+        background: rgba(212,165,80,0.06);
+        box-shadow: 0 0 20px rgba(212,165,80,0.08);
+      }
+
+      .eeq-btn:hover svg {
+        opacity: 1;
+      }
+
+      .eeq-btn:focus {
+        outline: 2px solid ${t.accent};
+        outline-offset: 2px;
+      }
+
+      .eeq-btn:active {
+        transform: scale(0.96);
+      }
+    `;
+  }
+};
+_ResultsRenderer.EGG_PALETTES = [
+  {
+    // Silver — polished chrome with white polka dots
+    base1: "#e0e4ea",
+    base2: "#c8c4c0",
+    accent: "#f4f4f6",
+    outline: "rgba(200,200,210,0.6)",
+    label: "Silver"
+  },
+  {
+    // Gold — rich 24k with ornate bands
+    base1: "#daa520",
+    base2: "#b8860b",
+    accent: "#f0d060",
+    outline: "rgba(218,165,32,0.6)",
+    label: "Gold"
+  },
+  {
+    // Festive — colorful Fabergé enamel
+    base1: "#c05070",
+    base2: "#3060a0",
+    accent: "#e6b422",
+    outline: "rgba(200,100,120,0.6)",
+    label: "Fabergé"
+  }
+];
+let ResultsRenderer = _ResultsRenderer;
+class ScoringEngine {
+  constructor() {
+    this._startTime = 0;
+    this._entryTime = 0;
+    this._stageResults = [];
+    this._extraClicks = 0;
+    this._chaoticMoveFrames = 0;
+    this._hesitations = 0;
+    this._failedAttempts = 0;
+    this._overcorrections = 0;
+  }
+  start() {
+    this._startTime = Date.now();
+    this._stageResults = [];
+    this._extraClicks = 0;
+    this._chaoticMoveFrames = 0;
+    this._hesitations = 0;
+    this._failedAttempts = 0;
+    this._overcorrections = 0;
+  }
+  recordEntryFound() {
+    this._entryTime = Date.now() - this._startTime;
+  }
+  recordStageResult(result) {
+    this._stageResults.push(result);
+    this._failedAttempts += Math.max(0, result.attempts - 1);
+  }
+  /** Called each frame to analyse input patterns for predictability. */
+  analyseFrame(snap) {
+    if (snap.velocity > 2e3) this._chaoticMoveFrames++;
+  }
+  /** Increment extra clicks (clicks outside meaningful interaction). */
+  recordExtraClick() {
+    this._extraClicks++;
+  }
+  /** Record hesitation events (start-stop-start within 600 ms). */
+  recordHesitation() {
+    this._hesitations++;
+  }
+  recordOvercorrection() {
+    this._overcorrections++;
+  }
+  computeFinalScore(inputStats) {
+    const totalTime = Date.now() - this._startTime;
+    const s1 = this._stageResults[0];
+    const s2 = this._stageResults[1];
+    const s3 = this._stageResults[2];
+    const predictability = this._computePredictability();
+    const clicks = (inputStats == null ? void 0 : inputStats.totalClicks) ?? 0;
+    const scrolls = (inputStats == null ? void 0 : inputStats.totalScrolls) ?? 0;
+    const keys = (inputStats == null ? void 0 : inputStats.totalKeyPresses) ?? 0;
+    const distance = (inputStats == null ? void 0 : inputStats.totalDistance) ?? 0;
+    const behaviorProfile = this._computeBehaviorProfile({
+      totalTime,
+      clicks,
+      scrolls,
+      keys,
+      distance,
+      maxVelocity: (inputStats == null ? void 0 : inputStats.maxVelocity) ?? 0,
+      stillnessBreaks: (s1 == null ? void 0 : s1.breaks) ?? 0,
+      motionFades: (s2 == null ? void 0 : s2.fades) ?? 0,
+      rhythmAccuracy: (s3 == null ? void 0 : s3.rhythmAccuracy) ?? 0,
+      predictabilityScore: predictability.score
+    });
+    return {
+      eggsFound: this._stageResults.length,
+      totalTime,
+      entryTime: this._entryTime,
+      egg1Time: (s1 == null ? void 0 : s1.stageTime) ?? 0,
+      egg2Time: (s2 == null ? void 0 : s2.stageTime) ?? 0,
+      egg3Time: (s3 == null ? void 0 : s3.stageTime) ?? 0,
+      stillnessBreaks: (s1 == null ? void 0 : s1.breaks) ?? 0,
+      motionFades: (s2 == null ? void 0 : s2.fades) ?? 0,
+      rhythmAccuracy: (s3 == null ? void 0 : s3.rhythmAccuracy) ?? 0,
+      predictabilityScore: predictability.score,
+      predictabilityLabel: predictability.label,
+      stageResults: this._stageResults,
+      behaviorProfile,
+      totalClicks: clicks,
+      totalScrolls: scrolls,
+      totalKeyPresses: keys,
+      totalDistance: distance,
+      eggSeed: Math.floor(Math.random() * 2147483647)
+    };
+  }
+  // ─── Behavior Profile & Title ──────────────────────────────────────────
+  _computeBehaviorProfile(d) {
+    const actionMax = Math.max(d.clicks, d.scrolls, d.keys);
+    let dominantAction;
+    if (actionMax === 0) {
+      dominantAction = "minimalist";
+    } else if (d.clicks >= d.scrolls && d.clicks >= d.keys) {
+      dominantAction = "clicker";
+    } else if (d.scrolls >= d.clicks && d.scrolls >= d.keys) {
+      dominantAction = "scroller";
+    } else {
+      dominantAction = "typist";
+    }
+    const dps = d.distance / Math.max(d.totalTime / 1e3, 1);
+    let mousePersonality;
+    if (dps > 600) mousePersonality = "tornado";
+    else if (dps > 250) mousePersonality = "conductor";
+    else if (dps > 60) mousePersonality = "surgeon";
+    else mousePersonality = "ghost";
+    const sec = d.totalTime / 1e3;
+    let pace;
+    if (sec < 45) pace = "speedster";
+    else if (sec < 120) pace = "steady";
+    else if (sec < 360) pace = "explorer";
+    else pace = "philosopher";
+    const title = this._pickTitle(d, dominantAction, mousePersonality, pace);
+    return { title, dominantAction, mousePersonality, pace };
+  }
+  _pickTitle(d, dominant, mouse, pace) {
+    const traits = [];
+    const sec = d.totalTime / 1e3;
+    if (sec < 30) traits.push({ score: 0.95, title: "Quantum Egg Locator" });
+    else if (sec < 45) traits.push({ score: 0.8, title: "Easter Lightning" });
+    else if (sec > 600) traits.push({ score: 0.85, title: "Egg Philosopher Supreme" });
+    else if (sec > 360) traits.push({ score: 0.7, title: "Scenic Route Connoisseur" });
+    const cpm = d.clicks / Math.max(sec / 60, 0.5);
+    if (cpm > 40) traits.push({ score: 0.9, title: "The Click Machine" });
+    else if (cpm > 20) traits.push({ score: 0.7, title: "Click Enthusiast" });
+    else if (d.clicks <= 3 && sec > 30) traits.push({ score: 0.75, title: "Clickless Wonder" });
+    if (d.scrolls > 100) traits.push({ score: 0.85, title: "Scroll Archaeologist" });
+    else if (d.scrolls > 50) traits.push({ score: 0.65, title: "Infinite Scroller" });
+    if (d.keys > 50) traits.push({ score: 0.8, title: "Keyboard Adventurer" });
+    else if (d.keys > 20) traits.push({ score: 0.6, title: "Secret Code Seeker" });
+    const km = d.distance / 1e3;
+    if (km > 50) traits.push({ score: 0.85, title: "Mouse Marathon Runner" });
+    else if (km > 20) traits.push({ score: 0.65, title: "Cursor Voyager" });
+    else if (km < 2 && sec > 30) traits.push({ score: 0.7, title: "Laser Pointer Specialist" });
+    if (d.maxVelocity > 8e3) traits.push({ score: 0.75, title: "Speed Demon" });
+    if (d.predictabilityScore >= 92) traits.push({ score: 0.85, title: "Human Clockwork" });
+    else if (d.predictabilityScore >= 80) traits.push({ score: 0.6, title: "The Algorithm" });
+    else if (d.predictabilityScore <= 12) traits.push({ score: 0.9, title: "Agent of Chaos" });
+    else if (d.predictabilityScore <= 25) traits.push({ score: 0.7, title: "Chaos Butterfly" });
+    if (d.rhythmAccuracy >= 95) traits.push({ score: 0.85, title: "Rhythm Oracle" });
+    else if (d.rhythmAccuracy >= 80) traits.push({ score: 0.6, title: "Beat Keeper" });
+    else if (d.rhythmAccuracy < 20 && d.rhythmAccuracy > 0) traits.push({ score: 0.75, title: "Jazz Improviser" });
+    if (d.stillnessBreaks === 0) traits.push({ score: 0.8, title: "Stone Buddha" });
+    else if (d.stillnessBreaks >= 15) traits.push({ score: 0.7, title: "Caffeinated Explorer" });
+    if (d.motionFades === 0 && sec > 20) traits.push({ score: 0.65, title: "Perpetual Motion" });
+    if (pace === "speedster" && dominant === "clicker") traits.push({ score: 0.92, title: "Turbo Clicker" });
+    if (pace === "philosopher" && mouse === "ghost") traits.push({ score: 0.88, title: "Meditation Champion" });
+    if (mouse === "tornado" && dominant === "typist") traits.push({ score: 0.87, title: "Keyboard Tornado" });
+    if (d.rhythmAccuracy >= 85 && d.clicks <= 5) traits.push({ score: 0.82, title: "Silent Perfectionist" });
+    if (d.predictabilityScore <= 20 && pace === "speedster") traits.push({ score: 0.88, title: "Controlled Chaos" });
+    if (dominant === "scroller" && pace === "explorer") traits.push({ score: 0.78, title: "Digital Archaeologist" });
+    if (mouse === "conductor" && d.rhythmAccuracy >= 70) traits.push({ score: 0.8, title: "Cursor Choreographer" });
+    if (dominant === "minimalist" && pace === "steady") traits.push({ score: 0.75, title: "Zen Navigator" });
+    if (d.stillnessBreaks >= 10 && d.rhythmAccuracy >= 80) traits.push({ score: 0.78, title: "Restless Virtuoso" });
+    if (km > 30 && pace === "speedster") traits.push({ score: 0.82, title: "Hyperdrive Activated" });
+    traits.sort((a, b) => b.score - a.score);
+    if (traits.length > 0) return traits[0].title;
+    const fallback = {
+      speedster: "Swift Egg Seeker",
+      steady: "Determined Hunter",
+      explorer: "Curious Wanderer",
+      philosopher: "Patient Sage"
+    };
+    return fallback[pace] ?? "Egg Explorer";
+  }
+  // ─── Predictability ────────────────────────────────────────────────────
+  _computePredictability() {
+    const clickNoise = Math.min(this._extraClicks / 30, 1);
+    const chaosNoise = Math.min(this._chaoticMoveFrames / 200, 1);
+    const hesitationNoise = Math.min(this._hesitations / 20, 1);
+    const failNoise = Math.min(this._failedAttempts / 10, 1);
+    const correctionNoise = Math.min(this._overcorrections / 15, 1);
+    const noise = clickNoise * 0.2 + chaosNoise * 0.25 + hesitationNoise * 0.2 + failNoise * 0.2 + correctionNoise * 0.15;
+    const predictability = Math.round((1 - noise) * 100);
+    const score = Math.max(0, Math.min(100, predictability));
+    return { score, label: this._labelForScore(score) };
+  }
+  _labelForScore(score) {
+    if (score >= 90) return "highly predictable";
+    if (score >= 75) return `more predictable than ${score}% of players`;
+    if (score >= 55) return "moderately predictable";
+    if (score >= 35) return `less predictable than ${100 - score}% of players`;
+    if (score >= 15) return "rare pattern";
+    return "deeply unpredictable";
+  }
+}
+const STORAGE_KEY = "eeq_scores";
+const PROGRESS_KEY = "eeq_progress";
+class Persistence {
+  constructor(enabled) {
+    this._enabled = enabled;
+  }
+  saveScore(score) {
+    if (!this._enabled) return;
+    try {
+      const existing = this._loadAll();
+      existing.push({
+        ...score,
+        date: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const trimmed = existing.slice(-50);
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(trimmed));
+    } catch {
+    }
+  }
+  getBestTime() {
+    const all = this._loadAll();
+    if (all.length === 0) return null;
+    return Math.min(...all.map((s) => s.totalTime));
+  }
+  getScoreCount() {
+    return this._loadAll().length;
+  }
+  getLastScore() {
+    const all = this._loadAll();
+    return all.length > 0 ? all[all.length - 1] : null;
+  }
+  clearScores() {
+    try {
+      localStorage.removeItem(STORAGE_KEY);
+    } catch {
+    }
+  }
+  _loadAll() {
+    try {
+      const raw = localStorage.getItem(STORAGE_KEY);
+      if (!raw) return [];
+      return JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+  // ─── Mid-game progress checkpointing ─────────────────────────────────
+  saveProgress(data) {
+    if (!this._enabled) return;
+    try {
+      localStorage.setItem(PROGRESS_KEY, JSON.stringify(data));
+    } catch {
+    }
+  }
+  loadProgress() {
+    if (!this._enabled) return null;
+    try {
+      const raw = localStorage.getItem(PROGRESS_KEY);
+      if (!raw) return null;
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  clearProgress() {
+    try {
+      localStorage.removeItem(PROGRESS_KEY);
+    } catch {
+    }
+  }
+}
+class StillnessStage {
+  constructor(config, script, input, bus) {
+    this._status = "active";
+    this._startTime = 0;
+    this._breaks = 0;
+    this._attempts = 0;
+    this._lastBreakNarrativeTime = 0;
+    this._narrativeIndex = 0;
+    this._bestProgress = 0;
+    this._introPlayed = false;
+    this.config = config;
+    this.script = script;
+    this.input = input;
+    this.bus = bus;
+  }
+  async start() {
+    this._startTime = Date.now();
+    this._attempts = 1;
+    this.input.resetPhases();
+    this.input.resetCounts();
+    this._introPlayed = false;
+    const introLines = this.script.stage1Intro;
+    for (let i = 0; i < introLines.length; i++) {
+      this.bus.emit("narrative:show", introLines[i]);
+      await this._wait(1500);
+    }
+    this.bus.emit("narrative:clear");
+    await this._wait(1e3);
+    this._introPlayed = true;
+  }
+  update(_dt) {
+    if (this._status === "complete" || !this._introPlayed) return this._status;
+    const requiredMs = this.config.stageDurations.stillnessMs;
+    const stillMs = this.input.stillDuration;
+    const progress = Math.min(1, stillMs / requiredMs);
+    if (progress > this._bestProgress) {
+      this._bestProgress = progress;
+    }
+    this.bus.emit("stage:progress", progress);
+    if (this.input.snapshot.isMoving && progress > 0.05) {
+      this._handleBreak();
+      return this._status;
+    }
+    if (stillMs >= requiredMs) {
+      this._status = "complete";
+      this.bus.emit("stage:progress", 1);
+      this.bus.emit("egg:reveal", 0);
+      return this._status;
+    }
+    return this._status;
+  }
+  cleanup() {
+  }
+  getResult() {
+    return {
+      stageTime: Date.now() - this._startTime,
+      attempts: this._attempts,
+      breaks: this._breaks
+    };
+  }
+  // ─── Internal ──────────────────────────────────────────────────────────
+  _handleBreak() {
+    this._breaks++;
+    const now = Date.now();
+    if (now - this._lastBreakNarrativeTime > 5e3) {
+      this._lastBreakNarrativeTime = now;
+      const reactions = this.script.stage1Reactions;
+      const line = reactions[this._narrativeIndex % reactions.length];
+      this._narrativeIndex++;
+      this.bus.emit("narrative:show", line);
+    }
+  }
+  _wait(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+  }
+}
+class MotionStage {
+  constructor(config, script, input, bus) {
+    this._status = "active";
+    this._startTime = 0;
+    this._fades = 0;
+    this._attempts = 0;
+    this._movingAccum = 0;
+    this._lastUpdateTime = 0;
+    this._narrativeIndex = 0;
+    this._lastFadeNarrativeTime = 0;
+    this._introPlayed = false;
+    this.FADE_THRESHOLD_MS = 2500;
+    this.config = config;
+    this.script = script;
+    this.input = input;
+    this.bus = bus;
+  }
+  async start() {
+    this._startTime = Date.now();
+    this._lastUpdateTime = Date.now();
+    this._movingAccum = 0;
+    this._attempts = 1;
+    this.input.resetPhases();
+    this.input.resetCounts();
+    this._introPlayed = false;
+    const introLines = this.script.stage2Intro;
+    for (let i = 0; i < introLines.length; i++) {
+      this.bus.emit("narrative:show", introLines[i]);
+      await this._wait(1500);
+    }
+    this.bus.emit("narrative:clear");
+    await this._wait(1e3);
+    this._introPlayed = true;
+  }
+  update(_dt) {
+    if (this._status === "complete" || !this._introPlayed) return this._status;
+    const now = Date.now();
+    const elapsed = now - this._lastUpdateTime;
+    this._lastUpdateTime = now;
+    const requiredMs = this.config.stageDurations.motionMs;
+    if (this.input.snapshot.isMoving) {
+      this._movingAccum += elapsed;
+      const vel = this.input.snapshot.velocity;
+      if (vel > 50) {
+        const spawnChance = Math.max(0.15, 1 - vel / 1200);
+        if (Math.random() < spawnChance) {
+          this.bus.emit("motion:trail", {
+            x: this.input.snapshot.mouseX,
+            y: this.input.snapshot.mouseY,
+            velocity: vel
+          });
+        }
+      }
+    } else {
+      const stillDuration = this.input.stillDuration;
+      if (stillDuration > this.FADE_THRESHOLD_MS && this._movingAccum > 500) {
+        this._fades++;
+        this._movingAccum = Math.max(0, this._movingAccum - stillDuration * 0.6);
+        this._handleFade();
+      }
+    }
+    const progress = Math.min(1, this._movingAccum / requiredMs);
+    this.bus.emit("stage:progress", progress);
+    if (this._movingAccum >= requiredMs) {
+      this._status = "complete";
+      this.bus.emit("stage:progress", 1);
+      this.bus.emit("egg:reveal", 1);
+      return this._status;
+    }
+    return this._status;
+  }
+  cleanup() {
+  }
+  getResult() {
+    return {
+      stageTime: Date.now() - this._startTime,
+      attempts: this._attempts,
+      fades: this._fades
+    };
+  }
+  // ─── Internal ──────────────────────────────────────────────────────────
+  _handleFade() {
+    const now = Date.now();
+    if (now - this._lastFadeNarrativeTime > 5e3) {
+      this._lastFadeNarrativeTime = now;
+      const reactions = this.script.stage2Reactions;
+      const line = reactions[this._narrativeIndex % reactions.length];
+      this._narrativeIndex++;
+      this.bus.emit("narrative:show", line);
+    }
+  }
+  _wait(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+  }
+}
+class RhythmStage {
+  constructor(config, script, input, bus) {
+    this._status = "active";
+    this._startTime = 0;
+    this._attempts = 0;
+    this._narrativeIndex = 0;
+    this._lastNarrativeTime = 0;
+    this._introPlayed = false;
+    this._goodCycles = 0;
+    this._totalCycles = 0;
+    this._lastPhaseCount = 0;
+    this._bestAccuracy = 0;
+    this.IDEAL_MOVE_MIN = 1800;
+    this.IDEAL_MOVE_MAX = 5e3;
+    this.IDEAL_PAUSE_MIN = 1200;
+    this.IDEAL_PAUSE_MAX = 4e3;
+    this.config = config;
+    this.script = script;
+    this.input = input;
+    this.bus = bus;
+  }
+  async start() {
+    this._startTime = Date.now();
+    this._attempts = 1;
+    this._goodCycles = 0;
+    this._totalCycles = 0;
+    this.input.resetPhases();
+    this.input.resetCounts();
+    this._introPlayed = false;
+    const introLines = this.script.stage3Intro;
+    for (let i = 0; i < introLines.length; i++) {
+      this.bus.emit("narrative:show", introLines[i]);
+      await this._wait(1500);
+    }
+    this.bus.emit("narrative:clear");
+    await this._wait(1e3);
+    this._introPlayed = true;
+    this._lastPhaseCount = this.input.phases.length;
+  }
+  update(_dt) {
+    if (this._status === "complete" || !this._introPlayed) return this._status;
+    const phases = this.input.phases;
+    const requiredCycles = this.config.stageDurations.rhythmCycles;
+    while (this._lastPhaseCount + 1 < phases.length) {
+      const p1 = phases[this._lastPhaseCount];
+      const p2 = phases[this._lastPhaseCount + 1];
+      if (p1 && p2) {
+        const isGood = this._evaluateCycle(p1, p2);
+        this._totalCycles++;
+        if (isGood) {
+          this._goodCycles++;
+        } else {
+          this._showReaction();
+        }
+        this._lastPhaseCount += 2;
+      } else {
+        break;
+      }
+    }
+    const accuracy = this._totalCycles > 0 ? this._goodCycles / this._totalCycles : 0;
+    if (accuracy > this._bestAccuracy) this._bestAccuracy = accuracy;
+    const progress = Math.min(1, this._goodCycles / requiredCycles);
+    this.bus.emit("stage:progress", progress);
+    this.bus.emit("rhythm:breathe", { accuracy, isMoving: this.input.snapshot.isMoving });
+    if (this._goodCycles >= requiredCycles) {
+      this._status = "complete";
+      this.bus.emit("stage:progress", 1);
+      this.bus.emit("egg:reveal", 2);
+      return this._status;
+    }
+    return this._status;
+  }
+  cleanup() {
+  }
+  getResult() {
+    return {
+      stageTime: Date.now() - this._startTime,
+      attempts: this._attempts,
+      rhythmAccuracy: this._totalCycles > 0 ? Math.round(this._goodCycles / this._totalCycles * 100) : 0
+    };
+  }
+  // ─── Internal ──────────────────────────────────────────────────────────
+  _evaluateCycle(a, b) {
+    const movePhase = a.type === "move" ? a : b.type === "move" ? b : null;
+    const stillPhase = a.type === "still" ? a : b.type === "still" ? b : null;
+    if (!movePhase || !stillPhase) return false;
+    const moveOk = movePhase.duration >= this.IDEAL_MOVE_MIN && movePhase.duration <= this.IDEAL_MOVE_MAX;
+    const stillOk = stillPhase.duration >= this.IDEAL_PAUSE_MIN && stillPhase.duration <= this.IDEAL_PAUSE_MAX;
+    return moveOk && stillOk;
+  }
+  _showReaction() {
+    const now = Date.now();
+    if (now - this._lastNarrativeTime > 5e3) {
+      this._lastNarrativeTime = now;
+      const reactions = this.script.stage3Reactions;
+      const line = reactions[this._narrativeIndex % reactions.length];
+      this._narrativeIndex++;
+      this.bus.emit("narrative:show", line);
+    }
+  }
+  _wait(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+  }
+}
+class PageReactor {
+  constructor() {
+    this._styleEl = null;
+    this._reactClass = "eeq-page-react";
+    this._injectStyles();
+  }
+  /** Trigger a reaction wave on 2-4 random visible page elements. */
+  react() {
+    const candidates = this._findCandidates();
+    if (!candidates.length) return;
+    const count = Math.min(candidates.length, 2 + Math.floor(Math.random() * 2));
+    const chosen = this._pickRandom(candidates, count);
+    const effects = ["eeq-react-pulse", "eeq-react-glow", "eeq-react-lift"];
+    for (let i = 0; i < chosen.length; i++) {
+      const el = chosen[i];
+      const effect = effects[Math.floor(Math.random() * effects.length)];
+      const delay = i * 200;
+      setTimeout(() => {
+        el.classList.add(this._reactClass, effect);
+        setTimeout(() => {
+          el.classList.remove(this._reactClass, effect);
+        }, 1100);
+      }, delay);
+    }
+  }
+  destroy() {
+    var _a;
+    document.querySelectorAll(`.${this._reactClass}`).forEach((el) => {
+      el.className = el.className.replace(/\beeq-react-\S+/g, "").trim();
+    });
+    (_a = this._styleEl) == null ? void 0 : _a.remove();
+    this._styleEl = null;
+  }
+  _findCandidates() {
+    var _a;
+    const all = document.querySelectorAll(
+      "p, h1, h2, h3, h4, h5, li, a, img, button, blockquote, figcaption, td, th"
+    );
+    const result = [];
+    for (const el of all) {
+      if ((_a = el.id) == null ? void 0 : _a.startsWith("eeq-")) continue;
+      if (el.closest('[id^="eeq-"]')) continue;
+      const rect = el.getBoundingClientRect();
+      if (rect.width === 0 || rect.height === 0) continue;
+      if (rect.bottom < 0 || rect.top > window.innerHeight) continue;
+      if (el.classList.contains(this._reactClass)) continue;
+      result.push(el);
+    }
+    return result;
+  }
+  _pickRandom(arr, count) {
+    const copy = [...arr];
+    const result = [];
+    for (let i = 0; i < count && copy.length; i++) {
+      const idx = Math.floor(Math.random() * copy.length);
+      result.push(copy.splice(idx, 1)[0]);
+    }
+    return result;
+  }
+  _injectStyles() {
+    this._styleEl = document.createElement("style");
+    this._styleEl.textContent = `
+      @keyframes eeq-pulse-kf {
+        0%, 100% { transform: scale(1); }
+        50% { transform: scale(1.018); }
+      }
+      @keyframes eeq-glow-kf {
+        0%, 100% { filter: brightness(1); }
+        50% { filter: brightness(1.15) saturate(1.1); }
+      }
+      @keyframes eeq-lift-kf {
+        0%, 100% { transform: translateY(0); }
+        50% { transform: translateY(-2px); }
+      }
+      .eeq-react-pulse {
+        animation: eeq-pulse-kf 1s ease-in-out !important;
+      }
+      .eeq-react-glow {
+        animation: eeq-glow-kf 1s ease-in-out !important;
+      }
+      .eeq-react-lift {
+        animation: eeq-lift-kf 1s ease-in-out !important;
+      }
+    `;
+    document.head.appendChild(this._styleEl);
+  }
+}
+class PageBreather {
+  constructor() {
+    this._active = false;
+    this._intensity = 0;
+    this._targetIntensity = 0;
+    this._rafId = 0;
+    this._overlay = null;
+    this._startTime = 0;
+    this._isUserMoving = false;
+    this._inSync = false;
+    this.CYCLE_MS = 6e3;
+    this._tick = () => {
+      if (!this._active || !this._overlay) return;
+      this._rafId = requestAnimationFrame(this._tick);
+      this._intensity += (this._targetIntensity - this._intensity) * 0.06;
+      const elapsed = Date.now() - this._startTime;
+      const phase = elapsed % this.CYCLE_MS / this.CYCLE_MS;
+      const wave = (Math.sin(phase * Math.PI * 2 - Math.PI / 2) + 1) * 0.5;
+      const shouldMove = phase < 0.5;
+      this._inSync = shouldMove === this._isUserMoving;
+      const baseOpacity = wave * 0.85;
+      const syncBonus = this._inSync ? 0.15 : 0;
+      const opacity = this._intensity * (baseOpacity + (1 - wave) * 0.05 + syncBonus);
+      this._overlay.style.opacity = String(Math.min(1, opacity));
+    };
+  }
+  start() {
+    if (this._active) return;
+    this._active = true;
+    this._startTime = Date.now();
+    const el = document.createElement("div");
+    el.style.cssText = [
+      "position:fixed",
+      "top:0",
+      "left:0",
+      "width:100%",
+      "height:100%",
+      "pointer-events:none",
+      "z-index:999980",
+      "opacity:0",
+      "background:radial-gradient(ellipse at center, transparent 30%, rgba(0,0,0,0.7) 100%)",
+      "transition:opacity 0.3s ease"
+    ].join(";");
+    document.body.appendChild(el);
+    this._overlay = el;
+    this._tick();
+  }
+  update(accuracy, isMoving) {
+    if (!this._active) return;
+    this._isUserMoving = isMoving;
+    const raw = Math.max(0, Math.min(1, (accuracy - 0.05) / 0.5));
+    this._targetIntensity = 0.5 + raw * 0.5;
+  }
+  /** Whether the user is currently in sync with the breathing rhythm. */
+  isInSync() {
+    return this._inSync;
+  }
+  stop() {
+    var _a;
+    if (!this._active) return;
+    this._active = false;
+    cancelAnimationFrame(this._rafId);
+    (_a = this._overlay) == null ? void 0 : _a.remove();
+    this._overlay = null;
+    this._intensity = 0;
+    this._targetIntensity = 0;
+    this._inSync = false;
+  }
+  destroy() {
+    this.stop();
+  }
+}
+class GameController {
+  constructor(config, script) {
+    this.bus = new EventBus();
+    this.fsm = new StateMachine();
+    this.input = new InputTracker();
+    this.scoring = new ScoringEngine();
+    this.hiddenEntry = null;
+    this.narrative = null;
+    this.hud = null;
+    this.shrine = null;
+    this.threeRenderer = null;
+    this.fallbackRenderer = null;
+    this.overlay = null;
+    this.results = null;
+    this.eggRenderer = null;
+    this.activeStage = null;
+    this.pageReactor = null;
+    this._lastPageReactTime = 0;
+    this._lastReactProgress = 0;
+    this.pageBreather = null;
+    this._updateRaf = 0;
+    this._running = false;
+    this._destroyed = false;
+    this._onPageHide = () => this._handlePageClose();
+    this._tremorStyle = null;
+    this._tremorClass = "eeq-tremor";
+    this._lastFrameTime = 0;
+    this._gameLoop = () => {
+      var _a;
+      if (!this._running || this._destroyed) return;
+      this._updateRaf = requestAnimationFrame(this._gameLoop);
+      if (this.state.isPaused) return;
+      const now = performance.now();
+      const dt = (now - this._lastFrameTime) / 1e3;
+      this._lastFrameTime = now;
+      this.scoring.analyseFrame(this.input.snapshot);
+      (_a = this.hud) == null ? void 0 : _a.update(this.state, this.fsm.label);
+      if (this.activeStage) {
+        const status = this.activeStage.update(dt);
+        if (status === "complete") {
+          this._running = false;
+          cancelAnimationFrame(this._updateRaf);
+          const currentStage = this.fsm.state;
+          if (currentStage === "stage1-active") {
+            this.fsm.transitionTo("stage1-success");
+          } else if (currentStage === "stage2-active") {
+            this.fsm.transitionTo("stage2-success");
+          } else if (currentStage === "stage3-active") {
+            this.fsm.transitionTo("stage3-success");
+          }
+        }
+      }
+    };
+    this.config = config;
+    this.script = script;
+    this.persistence = new Persistence(config.scoring.enableLocal);
+    this.state = {
+      stage: "idle",
+      eggsFound: 0,
+      startTime: 0,
+      stageStartTime: 0,
+      isPaused: false,
+      eggs: [
+        { found: false },
+        { found: false },
+        { found: false }
+      ]
+    };
+  }
+  // ─── Lifecycle ─────────────────────────────────────────────────────────
+  async init() {
+    var _a, _b;
+    this.fsm.onTransition((from, to) => this._onTransition(from, to));
+    this.bus.on("narrative:show", (text) => {
+      var _a2;
+      return (_a2 = this.narrative) == null ? void 0 : _a2.showLine(text);
+    });
+    this.bus.on("narrative:clear", () => {
+      var _a2;
+      return (_a2 = this.narrative) == null ? void 0 : _a2.clear();
+    });
+    this.bus.on("egg:reveal", (index) => this._handleEggReveal(index));
+    this.bus.on("stage:progress", (p) => this._handleStageProgress(p));
+    this.bus.on("motion:trail", (data) => {
+      var _a2;
+      (_a2 = this.eggRenderer) == null ? void 0 : _a2.addTrail(data.x, data.y, data.velocity);
+    });
+    this.bus.on("rhythm:breathe", (data) => {
+      var _a2, _b2, _c;
+      (_a2 = this.eggRenderer) == null ? void 0 : _a2.setBreathIntensity(data.accuracy);
+      (_b2 = this.pageBreather) == null ? void 0 : _b2.update(data.accuracy, data.isMoving);
+      if (((_c = this.pageBreather) == null ? void 0 : _c.isInSync()) && this.threeRenderer) {
+        this.threeRenderer.showProgressParticles(0.6 + data.accuracy * 0.4);
+      }
+    });
+    this.overlay = new OverlayManager(this.config);
+    this.overlay.mount();
+    this.narrative = new NarrativeRenderer(this.config);
+    this.narrative.mount();
+    this.shrine = new ShrineRenderer(this.config);
+    this.shrine.mount((eggIndex) => this._onShrineEggClick(eggIndex));
+    await this._initEggRenderer();
+    if (this.threeRenderer) {
+      this.threeRenderer.onCollectEgg((index) => {
+        this._onEggLongPressCollect(index);
+      });
+    }
+    this.scoring.start();
+    (_b = (_a = this.config.callbacks).onInit) == null ? void 0 : _b.call(_a);
+    window.addEventListener("pagehide", this._onPageHide);
+    window.addEventListener("beforeunload", this._onPageHide);
+    const checkpoint = this.persistence.loadProgress();
+    if (checkpoint) {
+      this._resumeFromCheckpoint(checkpoint);
+    } else {
+      this.fsm.transitionTo("entry");
+    }
+  }
+  pause() {
+    var _a;
+    this.state.isPaused = true;
+    (_a = this.hud) == null ? void 0 : _a.pause();
+  }
+  resume() {
+    var _a;
+    this.state.isPaused = false;
+    (_a = this.hud) == null ? void 0 : _a.resume();
+  }
+  async restart() {
+    this._cleanup();
+    this.fsm.reset();
+    this.persistence.clearProgress();
+    this.state = {
+      stage: "idle",
+      eggsFound: 0,
+      startTime: 0,
+      stageStartTime: 0,
+      isPaused: false,
+      eggs: [
+        { found: false },
+        { found: false },
+        { found: false }
+      ]
+    };
+    this.scoring.start();
+    this.fsm.transitionTo("entry");
+  }
+  destroy() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    this._destroyed = true;
+    window.removeEventListener("pagehide", this._onPageHide);
+    window.removeEventListener("beforeunload", this._onPageHide);
+    this._cleanup();
+    (_a = this.narrative) == null ? void 0 : _a.destroy();
+    (_b = this.hud) == null ? void 0 : _b.destroy();
+    (_c = this.shrine) == null ? void 0 : _c.destroy();
+    (_d = this.threeRenderer) == null ? void 0 : _d.destroy();
+    (_e = this.fallbackRenderer) == null ? void 0 : _e.destroy();
+    (_f = this.overlay) == null ? void 0 : _f.destroy();
+    (_g = this.results) == null ? void 0 : _g.destroy();
+    this._stopAnticipationTremor();
+    (_h = this.pageReactor) == null ? void 0 : _h.destroy();
+    this.pageReactor = null;
+    (_i = this.pageBreather) == null ? void 0 : _i.destroy();
+    this.pageBreather = null;
+    this.input.stop();
+    this.bus.clear();
+    this.fsm.reset();
+    (_k = (_j = this.config.callbacks).onDestroy) == null ? void 0 : _k.call(_j);
+  }
+  _handlePageClose() {
+    if (this._destroyed) return;
+    const stage = this.fsm.state;
+    if (stage !== "idle" && stage !== "entry" && stage !== "results" && stage !== "complete") {
+      this._saveCheckpoint(stage);
+    }
+    this.destroy();
+  }
+  // ─── FSM Transition Handler ────────────────────────────────────────────
+  async _onTransition(from, to) {
+    var _a;
+    this.state.stage = to;
+    this.state.stageStartTime = Date.now();
+    (_a = this.hud) == null ? void 0 : _a.update(this.state, this.fsm.label);
+    const checkpointStages = [
+      "stage1-intro",
+      "stage2-intro",
+      "stage3-intro",
+      "finale"
+    ];
+    if (checkpointStages.includes(to)) {
+      this._saveCheckpoint(to);
+    }
+    switch (to) {
+      case "entry":
+        await this._startEntry();
+        break;
+      case "stage1-intro":
+        await this._startStage1();
+        break;
+      case "stage1-active":
+        this._startGameLoop();
+        break;
+      case "stage1-success":
+        await this._handleStageSuccess(0);
+        break;
+      case "stage2-intro":
+        await this._startStage2();
+        break;
+      case "stage2-active":
+        this._startGameLoop();
+        break;
+      case "stage2-success":
+        await this._handleStageSuccess(1);
+        break;
+      case "stage3-intro":
+        await this._startStage3();
+        break;
+      case "stage3-active":
+        this._startGameLoop();
+        break;
+      case "stage3-success":
+        await this._handleStageSuccess(2);
+        break;
+      case "finale":
+        await this._startFinale();
+        break;
+      case "results":
+        this._showResults();
+        break;
+    }
+  }
+  // ─── Progress Checkpointing ────────────────────────────────────────────
+  _saveCheckpoint(stage) {
+    this.persistence.saveProgress({
+      stage,
+      eggsFound: this.state.eggsFound,
+      eggsState: [
+        this.state.eggs[0].found,
+        this.state.eggs[1].found,
+        this.state.eggs[2].found
+      ],
+      savedAt: Date.now()
+    });
+  }
+  _resumeFromCheckpoint(cp) {
+    var _a, _b;
+    const validResumeStages = [
+      "stage1-intro",
+      "stage2-intro",
+      "stage3-intro",
+      "finale"
+    ];
+    if (!validResumeStages.includes(cp.stage)) {
+      this.persistence.clearProgress();
+      this.fsm.transitionTo("entry");
+      return;
+    }
+    this.state.eggsFound = cp.eggsFound;
+    this.state.startTime = Date.now();
+    for (let i = 0; i < 3; i++) {
+      this.state.eggs[i].found = cp.eggsState[i];
+    }
+    (_a = this.shrine) == null ? void 0 : _a.show();
+    for (let i = 0; i < cp.eggsFound; i++) {
+      (_b = this.shrine) == null ? void 0 : _b.fillSlot(i);
+    }
+    this.fsm.forceState(cp.stage);
+    this._onTransition("idle", cp.stage);
+  }
+  // ─── Entry ─────────────────────────────────────────────────────────────
+  async _startEntry() {
+    var _a;
+    try {
+      if (localStorage.getItem("eeq_optout") === "1") return;
+    } catch {
+    }
+    this.state.startTime = Date.now();
+    (_a = this.hud) == null ? void 0 : _a.startTimer();
+    this.hiddenEntry = new HiddenEntry(this.config, this.script, () => {
+      var _a2, _b;
+      this.scoring.recordEntryFound();
+      (_b = (_a2 = this.config.callbacks).onEntryFound) == null ? void 0 : _b.call(_a2);
+      this._onEntryFound();
+    });
+    this.hiddenEntry.start();
+  }
+  async _onEntryFound() {
+    var _a, _b, _c, _d;
+    (_a = this.hiddenEntry) == null ? void 0 : _a.cleanup();
+    this.hiddenEntry = null;
+    this._startAnticipationTremor();
+    (_b = this.shrine) == null ? void 0 : _b.show();
+    await ((_c = this.narrative) == null ? void 0 : _c.showSequence(this.script.entryConfirmation, 1500));
+    (_d = this.narrative) == null ? void 0 : _d.clear();
+    this._stopAnticipationTremor();
+    await this._wait(800);
+    this.input.start();
+    this.fsm.transitionTo("stage1-intro");
+  }
+  _startAnticipationTremor() {
+    this._tremorStyle = document.createElement("style");
+    this._tremorStyle.textContent = `
+      @keyframes eeq-tremor {
+        0%, 100% { transform: translate(0, 0); }
+        10% { transform: translate(-0.5px, 0.3px); }
+        20% { transform: translate(0.6px, -0.4px); }
+        30% { transform: translate(-0.3px, 0.5px); }
+        40% { transform: translate(0.4px, 0.2px); }
+        50% { transform: translate(-0.4px, -0.3px); }
+        60% { transform: translate(0.3px, 0.5px); }
+        70% { transform: translate(-0.5px, -0.2px); }
+        80% { transform: translate(0.2px, 0.4px); }
+        90% { transform: translate(-0.3px, -0.5px); }
+      }
+      .${this._tremorClass} {
+        animation: eeq-tremor 0.6s ease-in-out infinite !important;
+      }
+    `;
+    document.head.appendChild(this._tremorStyle);
+    const candidates = document.querySelectorAll(
+      'a, button, span, small, label, svg, img, i, [role="button"], nav li'
+    );
+    let count = 0;
+    candidates.forEach((el) => {
+      var _a;
+      const rect = el.getBoundingClientRect();
+      if (rect.width > 300 || rect.height > 100) return;
+      if (rect.width === 0 || rect.height === 0) return;
+      if (rect.bottom < 0 || rect.top > window.innerHeight) return;
+      if ((_a = el.id) == null ? void 0 : _a.startsWith("eeq-")) return;
+      if (el.closest('[id^="eeq-"]')) return;
+      const delay = Math.random() * 800;
+      const htmlEl = el;
+      setTimeout(() => {
+        if (this._tremorStyle) htmlEl.classList.add(this._tremorClass);
+      }, delay);
+      count++;
+      if (count > 40) return;
+    });
+  }
+  _stopAnticipationTremor() {
+    var _a;
+    document.querySelectorAll(`.${this._tremorClass}`).forEach((el) => {
+      el.classList.remove(this._tremorClass);
+    });
+    (_a = this._tremorStyle) == null ? void 0 : _a.remove();
+    this._tremorStyle = null;
+  }
+  // ─── Stage 1: Stillness ────────────────────────────────────────────────
+  async _startStage1() {
+    var _a, _b, _c, _d;
+    (_b = (_a = this.config.callbacks).onStageStart) == null ? void 0 : _b.call(_a, "stage1-intro");
+    (_c = this.hud) == null ? void 0 : _c.update(this.state, this.fsm.label);
+    (_d = this.eggRenderer) == null ? void 0 : _d.startRenderLoop();
+    const stage = new StillnessStage(this.config, this.script, this.input, this.bus);
+    this.activeStage = stage;
+    await stage.start();
+    this.fsm.transitionTo("stage1-active");
+  }
+  // ─── Stage 2: Motion ───────────────────────────────────────────────────
+  async _startStage2() {
+    var _a, _b, _c;
+    (_b = (_a = this.config.callbacks).onStageStart) == null ? void 0 : _b.call(_a, "stage2-intro");
+    (_c = this.hud) == null ? void 0 : _c.update(this.state, this.fsm.label);
+    const stage = new MotionStage(this.config, this.script, this.input, this.bus);
+    this.activeStage = stage;
+    await stage.start();
+    this.fsm.transitionTo("stage2-active");
+  }
+  // ─── Stage 3: Rhythm ──────────────────────────────────────────────────
+  async _startStage3() {
+    var _a, _b, _c;
+    (_b = (_a = this.config.callbacks).onStageStart) == null ? void 0 : _b.call(_a, "stage3-intro");
+    (_c = this.hud) == null ? void 0 : _c.update(this.state, this.fsm.label);
+    const stage = new RhythmStage(this.config, this.script, this.input, this.bus);
+    this.activeStage = stage;
+    await stage.start();
+    this.fsm.transitionTo("stage3-active");
+    this.pageBreather = new PageBreather();
+    this.pageBreather.start();
+  }
+  // ─── Game Loop ─────────────────────────────────────────────────────────
+  _startGameLoop() {
+    if (this._running) return;
+    this._running = true;
+    this._lastFrameTime = performance.now();
+    this._gameLoop();
+  }
+  // ─── Egg Reveal ────────────────────────────────────────────────────────
+  _handleEggReveal(index) {
+    var _a, _b, _c, _d;
+    this.state.eggs[index].found = true;
+    this.state.eggs[index].foundTime = Date.now();
+    this.state.eggsFound++;
+    (_a = this.eggRenderer) == null ? void 0 : _a.revealEgg(index);
+    (_b = this.hud) == null ? void 0 : _b.flashEggFound(index);
+    (_d = (_c = this.config.callbacks).onEggFound) == null ? void 0 : _d.call(_c, index);
+  }
+  async _handleStageSuccess(eggIndex) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (this.activeStage) {
+      const result = this.activeStage.getResult();
+      this.scoring.recordStageResult(result);
+      this.activeStage.cleanup();
+      this.activeStage = null;
+      (_b = (_a = this.config.callbacks).onStageComplete) == null ? void 0 : _b.call(_a, this.fsm.state, result);
+    }
+    const successLines = eggIndex === 0 ? this.script.stage1Success : eggIndex === 1 ? this.script.stage2Success : this.script.stage3Success;
+    await ((_c = this.narrative) == null ? void 0 : _c.showSequence(successLines, 1500));
+    (_d = this.narrative) == null ? void 0 : _d.clear();
+    await this._wait(800);
+    if (this.threeRenderer) {
+      this.threeRenderer.enableInteraction(eggIndex);
+    } else {
+      (_e = this.eggRenderer) == null ? void 0 : _e.collectEgg(eggIndex);
+      (_f = this.shrine) == null ? void 0 : _f.fillSlot(eggIndex);
+      await this._wait(1500);
+      if (eggIndex < 2) {
+        (_g = this.shrine) == null ? void 0 : _g.activateSlot(eggIndex);
+      } else {
+        await this._wait(1e3);
+        this.fsm.transitionTo("finale");
+      }
+    }
+  }
+  // ─── Shrine Click (advance to next stage) ──────────────────────────────
+  _onShrineEggClick(eggIndex) {
+    var _a;
+    (_a = this.shrine) == null ? void 0 : _a.deactivateSlot(eggIndex);
+    if (eggIndex === 0) {
+      this.fsm.transitionTo("stage2-intro");
+    } else if (eggIndex === 1) {
+      this.fsm.transitionTo("stage3-intro");
+    }
+  }
+  // ─── Long-press collect (3D egg interaction) ───────────────────────────
+  async _onEggLongPressCollect(eggIndex) {
+    var _a, _b, _c, _d, _e;
+    (_a = this.eggRenderer) == null ? void 0 : _a.collectEgg(eggIndex);
+    (_b = this.shrine) == null ? void 0 : _b.fillSlot(eggIndex);
+    if (eggIndex === 2) {
+      (_c = this.pageBreather) == null ? void 0 : _c.destroy();
+      this.pageBreather = null;
+    }
+    const congrats = [
+      "egg found — well done",
+      "another one — you're getting closer",
+      "all three — remarkable"
+    ];
+    (_d = this.narrative) == null ? void 0 : _d.showCelebration(congrats[eggIndex] ?? "egg collected");
+    await this._wait(2200);
+    (_e = this.narrative) == null ? void 0 : _e.clear();
+    await this._wait(400);
+    if (eggIndex < 2) {
+      if (eggIndex === 0) {
+        this.fsm.transitionTo("stage2-intro");
+      } else {
+        this.fsm.transitionTo("stage3-intro");
+      }
+    } else {
+      await this._wait(800);
+      this.fsm.transitionTo("finale");
+    }
+  }
+  // ─── Stage Progress ────────────────────────────────────────────────────
+  _handleStageProgress(progress) {
+    if (this.threeRenderer) {
+      this.threeRenderer.showProgressParticles(progress);
+    }
+    const now = Date.now();
+    if (progress > this._lastReactProgress + 0.03 && now - this._lastPageReactTime > 8e3) {
+      this._lastPageReactTime = now;
+      this._lastReactProgress = progress;
+      if (!this.pageReactor) {
+        this.pageReactor = new PageReactor();
+      }
+      this.pageReactor.react();
+    }
+    if (progress < this._lastReactProgress - 0.1) {
+      this._lastReactProgress = progress;
+    }
+  }
+  // ─── Finale ────────────────────────────────────────────────────────────
+  async _startFinale() {
+    var _a, _b, _c, _d, _e, _f;
+    (_b = (_a = this.config.callbacks).onFinaleStart) == null ? void 0 : _b.call(_a);
+    (_c = this.shrine) == null ? void 0 : _c.hideAll();
+    await this._wait(1e3);
+    (_d = this.eggRenderer) == null ? void 0 : _d.startFinale();
+    await ((_e = this.narrative) == null ? void 0 : _e.showSequence(this.script.finale, 1500));
+    (_f = this.narrative) == null ? void 0 : _f.clear();
+    await this._wait(4e3);
+    this.fsm.transitionTo("results");
+  }
+  // ─── Results ───────────────────────────────────────────────────────────
+  _showResults() {
+    var _a, _b, _c;
+    const snap = this.input.snapshot;
+    const score = this.scoring.computeFinalScore({
+      totalClicks: snap.totalClicks,
+      totalScrolls: snap.totalScrolls,
+      totalKeyPresses: snap.totalKeyPresses,
+      totalDistance: snap.totalDistance,
+      maxVelocity: snap.maxVelocity
+    });
+    if (this.threeRenderer) {
+      this.threeRenderer.setFestiveEggSeed(score.eggSeed);
+    }
+    this.persistence.saveScore(score);
+    this.persistence.clearProgress();
+    if (this.config.scoring.leaderboardAdapter) {
+      this.config.scoring.leaderboardAdapter.submitScore(score).catch(() => {
+      });
+    }
+    (_a = this.eggRenderer) == null ? void 0 : _a.stopRenderLoop();
+    this.results = new ResultsRenderer(this.config);
+    this.results.show(
+      score,
+      () => {
+        this.destroy();
+      }
+    );
+    (_c = (_b = this.config.callbacks).onComplete) == null ? void 0 : _c.call(_b, score);
+  }
+  // ─── Renderer Init ─────────────────────────────────────────────────────
+  async _initEggRenderer() {
+    const mode = this.config.renderer;
+    if (mode === "3d" || mode === "auto") {
+      this.threeRenderer = new ThreeRenderer(this.config);
+      const ok = await this.threeRenderer.init();
+      if (ok) {
+        this.eggRenderer = this.threeRenderer;
+        return;
+      }
+      this.threeRenderer = null;
+    }
+    this.fallbackRenderer = new FallbackRenderer(this.config);
+    await this.fallbackRenderer.init();
+    this.eggRenderer = this.fallbackRenderer;
+  }
+  // ─── Helpers ───────────────────────────────────────────────────────────
+  _cleanup() {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    this._running = false;
+    if (this._updateRaf) cancelAnimationFrame(this._updateRaf);
+    (_a = this.hiddenEntry) == null ? void 0 : _a.cleanup();
+    (_b = this.activeStage) == null ? void 0 : _b.cleanup();
+    this.activeStage = null;
+    (_c = this.shrine) == null ? void 0 : _c.reset();
+    (_d = this.narrative) == null ? void 0 : _d.clear();
+    (_e = this.overlay) == null ? void 0 : _e.hide();
+    this._lastPageReactTime = 0;
+    this._lastReactProgress = 0;
+    this._stopAnticipationTremor();
+    (_f = this.pageReactor) == null ? void 0 : _f.destroy();
+    this.pageReactor = null;
+    (_g = this.pageBreather) == null ? void 0 : _g.destroy();
+    this.pageBreather = null;
+    (_h = this.results) == null ? void 0 : _h.destroy();
+    this.results = null;
+    if (this.threeRenderer) {
+      this.threeRenderer.resetForRestart();
+    }
+  }
+  _wait(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+  }
+}
+let _instance = null;
+const EasterEggQuest = {
+  /**
+   * Initialize and start the Easter Egg Quest experience.
+   * Safe to call multiple times — destroys any previous instance first.
+   */
+  async init(config = {}) {
+    if (_instance) {
+      _instance.destroy();
+      _instance = null;
+    }
+    const resolved = resolveConfig(config);
+    const script = resolveNarrative(config.narrative);
+    _instance = new GameController(resolved, script);
+    await _instance.init();
+  },
+  /** Pause the game. */
+  pause() {
+    _instance == null ? void 0 : _instance.pause();
+  },
+  /** Resume the game. */
+  resume() {
+    _instance == null ? void 0 : _instance.resume();
+  },
+  /** Restart from the beginning. */
+  async restart() {
+    await (_instance == null ? void 0 : _instance.restart());
+  },
+  /** Destroy the instance, remove all overlays, restore DOM. */
+  destroy() {
+    _instance == null ? void 0 : _instance.destroy();
+    _instance = null;
+  }
+};
+export {
+  EasterEggQuest
+};