From aed6724157022385b60562fbc7e52e8090d856f8 Mon Sep 17 00:00:00 2001
From: mikidoodle <mihir@pidgon.com>
Date: Thu, 24 Sep 2026 13:46:13 -0400
Subject: [PATCH 1/9] Improve event accessibility and admin tools

---
 .../components/_blackhole_preview.scss        |  65 ++++++
 app/components/sidebar_component.html.erb     |   9 +
 .../admin/buku_x3_events_controller.rb        |  18 ++
 app/controllers/my/settings_controller.rb     |   3 +
 app/helpers/application_helper.rb             |   4 +
 .../controllers/blackhole_controller.js       | 169 ++++++++++++--
 app/models/user/preference.rb                 |   1 +
 .../rocket_progress/contributor_export.rb     |  47 ++++
 app/views/admin/buku_x3_events/show.html.erb  |   9 +
 app/views/layouts/application.html.erb        |  11 +-
 app/views/shared/_blackhole.html.erb          |   5 +-
 app/views/shared/_event_simulator.html.erb    |  38 +++
 config/routes.rb                              |   1 +
 ...cle_effects_enabled_to_user_preferences.rb |   5 +
 db/schema.rb                                  |   3 +-
 .../admin/buku_x3_events_controller_test.rb   |  60 +++++
 .../buku_x3/progress_controller_test.rb       |   6 +-
 .../buku_x3/reveals_controller_test.rb        |  49 ++++
 test/controllers/my_controller_test.rb        |  19 ++
 test/fixtures/user/preferences.yml            |   1 +
 test/javascript/blackhole_options_test.mjs    | 221 ++++++++++++++++++
 test/models/user/preference_test.rb           |   2 +
 test/services/rocket_progress_test.rb         |  48 ++++
 23 files changed, 766 insertions(+), 28 deletions(-)
 create mode 100644 app/services/rocket_progress/contributor_export.rb
 create mode 100644 app/views/shared/_event_simulator.html.erb
 create mode 100644 db/migrate/20260924060219_add_particle_effects_enabled_to_user_preferences.rb

diff --git a/app/assets/stylesheets/components/_blackhole_preview.scss b/app/assets/stylesheets/components/_blackhole_preview.scss
index 31de9c80c..8bb6a4a9a 100644
--- a/app/assets/stylesheets/components/_blackhole_preview.scss
+++ b/app/assets/stylesheets/components/_blackhole_preview.scss
@@ -1,3 +1,68 @@
+.event-simulator {
+  position: fixed;
+  right: var(--space-m);
+  bottom: var(--space-m);
+  z-index: 9998;
+  width: min(360px, calc(100vw - 2 * var(--space-m)));
+  max-height: 80dvh;
+  overflow: auto;
+  border: 2px solid var(--color-brand-lilac);
+  border-radius: 8px;
+  background: var(--color-set-1-bg);
+  color: var(--color-space-text);
+  font-size: var(--font-size-m);
+
+  &__toggle {
+    padding: var(--space-m);
+    cursor: pointer;
+  }
+  &__controls {
+    padding: 0 var(--space-m) var(--space-m);
+    display: grid;
+    gap: var(--space-s);
+  }
+  &__field {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: var(--space-s);
+  }
+  &__field input {
+    max-width: 45%;
+    accent-color: var(--color-brand-lilac);
+  }
+  &__field input[type="number"] {
+    background: var(--color-set-2-bg);
+    color: inherit;
+    border: 1px solid var(--color-set-2-fg-secondary);
+    border-radius: 8px;
+    padding: var(--space-xxs);
+  }
+  &__hint {
+    color: var(--color-set-1-fg-secondary);
+    margin: 0;
+  }
+  &__status {
+    color: var(--color-brand-lilac);
+    margin: 0;
+  }
+  &__actions {
+    display: flex;
+    flex-wrap: wrap;
+    gap: var(--space-xs);
+  }
+  &__actions button,
+  &__actions a {
+    cursor: pointer;
+    border: 1px solid var(--color-brand-lilac);
+    border-radius: 999px;
+    background: var(--color-set-2-bg);
+    color: inherit;
+    padding: var(--space-xxs) var(--space-xs);
+    font: inherit;
+  }
+}
+
 .blackhole {
   &__masks {
     position: absolute;
diff --git a/app/components/sidebar_component.html.erb b/app/components/sidebar_component.html.erb
index 62cec3b3c..57d7f1304 100644
--- a/app/components/sidebar_component.html.erb
+++ b/app/components/sidebar_component.html.erb
@@ -140,6 +140,15 @@
         <small class="settings-form__hint">Blur sensitive info like addresses and API keys</small>
       </div>
 
+      <div class="settings-form__field">
+        <label class="settings-form__checkbox">
+          <%= hidden_field_tag :particle_effects_enabled, "0", id: nil %>
+          <%= check_box_tag :particle_effects_enabled, "1", preference.particle_effects_enabled?, id: "particle_effects_enabled" %>
+          <span>Show disintegration particles</span>
+        </label>
+        <small class="settings-form__hint">Turn off drifting particles while keeping the event damage and cursor repair effect</small>
+      </div>
+
       <% if user.slack_id.present? %>
         <div class="settings-form__field">
           <label class="settings-form__checkbox">
diff --git a/app/controllers/admin/buku_x3_events_controller.rb b/app/controllers/admin/buku_x3_events_controller.rb
index ae0be2389..adcff1354 100644
--- a/app/controllers/admin/buku_x3_events_controller.rb
+++ b/app/controllers/admin/buku_x3_events_controller.rb
@@ -18,4 +18,22 @@ def update
   rescue ActiveRecord::RecordInvalid => e
     redirect_to admin_jim_takeover_path, alert: e.record.errors.full_messages.to_sentence, status: :see_other
   end
+
+  def export_bukux2
+    authorize :admin, :manage_buku_event?
+    export = RocketProgress::ContributorExport.new
+    csv = export.to_csv
+    PaperTrail::Version.create!(
+      item_type: "User", item_id: current_user.id, event: "export_bukux2_contributors",
+      whodunnit: current_user.id.to_s,
+      object_changes: {
+        report: [ nil, "bukux2 contributors" ],
+        ship_window_start: [ nil, RocketProgress::ContributorExport::WINDOW.begin.iso8601 ],
+        ship_window_end_exclusive: [ nil, RocketProgress::ContributorExport::WINDOW.end.iso8601 ],
+        exported_users: [ nil, export.rows.size ]
+      }
+    )
+    response.headers["Cache-Control"] = "no-store"
+    send_data csv, filename: "bukux2-contributors-through-2026-09-24.csv", type: "text/csv; charset=utf-8", disposition: "attachment"
+  end
 end
diff --git a/app/controllers/my/settings_controller.rb b/app/controllers/my/settings_controller.rb
index e6b26d18d..d4c331cd7 100644
--- a/app/controllers/my/settings_controller.rb
+++ b/app/controllers/my/settings_controller.rb
@@ -9,6 +9,9 @@ def update
       leaderboard_optin: params[:leaderboard_optin] == "1",
       search_engine_indexing_off: params[:search_engine_indexing_off] == "1"
     }
+    if params.key?(:particle_effects_enabled)
+      pref_attrs[:particle_effects_enabled] = params[:particle_effects_enabled] == "1"
+    end
 
     if current_user.preference.has_attribute?(:streak_slack_status_enabled)
       new_val = params[:streak_slack_status_enabled] == "1"
diff --git a/app/helpers/application_helper.rb b/app/helpers/application_helper.rb
index 6d40ca4db..e7797785d 100644
--- a/app/helpers/application_helper.rb
+++ b/app/helpers/application_helper.rb
@@ -231,6 +231,10 @@ def active_users_stats
     "unavailable"
   end
 
+  def local_event_simulator?
+    Rails.env.development? && request.host.in?(%w[localhost 127.0.0.1 ::1 [::1]])
+  end
+
   private
 
   def find_achievement_asset(icon_name)
diff --git a/app/javascript/controllers/blackhole_controller.js b/app/javascript/controllers/blackhole_controller.js
index de5656dd8..679b662ab 100644
--- a/app/javascript/controllers/blackhole_controller.js
+++ b/app/javascript/controllers/blackhole_controller.js
@@ -4,12 +4,18 @@ import { Delaunay } from "d3";
 const CARD_SURFACES =
   ".feed-post-card, .feed-composer, .rocket-progress, .rail-widget, .raffle-widget, .sidebar__logo-img, .sidebar__user-card";
 const MEDIA_CONTENT = "img, video, iframe, svg";
+const SIDEBAR_SURFACES = [
+  "#primary-nav",
+  ".sidebar__logo-img",
+  ".sidebar__user-card",
+];
 // Story scenes must remain intact even at 100% damage, including previews
 // inserted into the page after the effect has already started.
 const EXCLUDED_SCENES = ".visual-novel, .buku-x3-reveal";
 const PROTECTED_CONTENT =
   "a:not(.feed-post-card__overlay-link), button, input, textarea, select, summary, img, video, iframe, svg, [role='progressbar'], [role='meter'], [contenteditable]";
 const SVG_NS = "http://www.w3.org/2000/svg";
+const SIMULATOR_KEY = "stardance-event-simulator-v1";
 const clamp = (n, min = 0, max = 1) => Math.min(max, Math.max(min, n));
 const random = (x, y, seed = 0) => {
   const value = Math.sin(x * 127.1 + y * 311.7 + seed * 74.7) * 43758.5453;
@@ -36,11 +42,36 @@ export default class extends Controller {
     visualIntensity: { type: Number, default: 100 },
     progressUrl: String,
     awaitingReveal: Boolean,
+    particlesEnabled: { type: Boolean, default: true },
+    simulatorEnabled: Boolean,
   };
 
-  static targets = ["masks", "canvas", "text"];
+  static targets = [
+    "masks",
+    "canvas",
+    "text",
+    "simulatorForm",
+    "simulatorStatus",
+  ];
 
   connect() {
+    this.simulation = null;
+    if (this.simulatorEnabledValue && this.hasSimulatorFormTarget) {
+      try {
+        const saved = JSON.parse(sessionStorage.getItem(SIMULATOR_KEY));
+        if (saved) {
+          for (const field of this.simulatorFormTarget.elements) {
+            if (field.disabled || !(field.name in saved)) continue;
+            if (field.type === "checkbox")
+              field.checked = saved[field.name] === true;
+            else field.value = saved[field.name];
+          }
+          this.readSimulation();
+        }
+      } catch {
+        /* Storage may be unavailable; the preview still works. */
+      }
+    }
     this.repairRadius = 145;
     this.pointer = null;
     this.level = 0;
@@ -117,7 +148,13 @@ export default class extends Controller {
     });
     this.surfaceResize = new ResizeObserver(this.invalidate);
     this.sizeCanvas();
-    this.setIntensity(this.intensityValue);
+    this.setIntensity(this.intensityValue, { immediate: true });
+    if (this.simulatorEnabledValue) {
+      // Status controllers elsewhere on the page connect in the same turn.
+      this.simulatorFrame = requestAnimationFrame(() =>
+        this.setIntensity(this.latestIntensity),
+      );
+    }
     if (this.progressUrlValue) {
       this.pollTimer = window.setInterval(() => this.refreshProgress(), 60000);
       this.refreshProgress();
@@ -125,6 +162,7 @@ export default class extends Controller {
   }
 
   disconnect() {
+    cancelAnimationFrame(this.simulatorFrame);
     this.stopPolling();
     this.reset();
     this.observer.disconnect();
@@ -183,19 +221,22 @@ export default class extends Controller {
     }
   }
 
-  setIntensity(value) {
+  setIntensity(value, { immediate = false } = {}) {
     if (!Number.isFinite(value)) return;
     this.latestIntensity = value;
     this.sceneBlocked = this.scenesBlocked();
-    const damage = clamp(value / 100);
+    const damage = clamp((this.simulation?.damage ?? value) / 100);
     // Scale the visuals without changing the score sent to the tug-of-war.
-    const strength = (this.visualIntensityValue ?? 100) / 100;
+    const strength =
+      (this.simulation?.strength ?? this.visualIntensityValue ?? 100) / 100;
     this.requested = clamp(damage * strength);
-    if (this.progressUrlValue) {
+    if (this.progressUrlValue || this.simulatorEnabledValue) {
       this.dispatch("progress", {
         detail: {
           percent: damage * 100,
-          hours: this.teamHours,
+          hours: this.simulation
+            ? { buku: this.simulation.buku, bean: this.simulation.bean }
+            : this.teamHours,
         },
       });
     }
@@ -203,16 +244,73 @@ export default class extends Controller {
       this.reset();
       return;
     }
-    this.dirty = true;
+    // Navigation restores the current damage, not a fresh destruction scene.
+    // Live updates and the first role reveal still ease into their new level.
+    if (immediate) {
+      this.level = this.requested;
+      this.cutSurfaces(false);
+    }
+    this.dirty = !immediate;
     this.wake();
   }
 
   scenesBlocked() {
     return (
-      this.awaitingRevealValue || !!document.querySelector(EXCLUDED_SCENES)
+      (this.awaitingRevealValue && !this.simulation) ||
+      !!document.querySelector(EXCLUDED_SCENES)
     );
   }
 
+  readSimulation() {
+    const fields = this.simulatorFormTarget.elements;
+    const number = (name, max) =>
+      clamp(Number(fields.namedItem(name).value) || 0, 0, max);
+    this.simulation = {
+      damage: number("damage", 100),
+      buku: number("buku", 1000000),
+      bean: number("bean", 1000000),
+      strength: number("strength", 200),
+      particles: fields.namedItem("particles").checked,
+      cursorRepair: fields.namedItem("cursorRepair").checked,
+    };
+    this.simulatorStatusTarget.textContent = `${this.simulation.damage}% damaged · ${this.simulation.strength}% visual intensity · preview active`;
+  }
+
+  simulate(event) {
+    event.preventDefault();
+    if (!this.simulatorEnabledValue || !this.hasSimulatorFormTarget) return;
+    const fields = this.simulatorFormTarget.elements;
+    if (["buku", "bean"].includes(event.target.name)) {
+      const buku = Math.max(0, Number(fields.namedItem("buku").value) || 0);
+      const bean = Math.max(0, Number(fields.namedItem("bean").value) || 0);
+      fields.namedItem("damage").value = clamp(25 + (buku - bean) / 50, 0, 100);
+    }
+    this.readSimulation();
+    this.particles = [];
+    this.dustBudget = 0;
+    try {
+      sessionStorage.setItem(SIMULATOR_KEY, JSON.stringify(this.simulation));
+    } catch {
+      /* Optional storage. */
+    }
+    this.setIntensity(this.latestIntensity);
+  }
+
+  resetSimulation() {
+    if (!this.simulatorEnabledValue) return;
+    this.simulation = null;
+    this.particles = [];
+    this.simulatorFormTarget.reset();
+    this.simulatorStatusTarget.textContent = "live event values";
+    try {
+      sessionStorage.removeItem(SIMULATOR_KEY);
+    } catch {
+      /* Optional storage. */
+    }
+    this.setIntensity(this.latestIntensity);
+    if (this.progressUrlValue) this.refreshProgress();
+  }
+
   revealComplete() {
     this.awaitingRevealValue = false;
     // The scene may still be fading out; its removal will resume the effect.
@@ -259,7 +357,11 @@ export default class extends Controller {
     this.emitAmbientDust(dt);
     this.draw(dt);
     if (
-      (this.level > 0 ||
+      ((this.level > 0 &&
+        this.particlesEnabledValue &&
+        this.simulation?.particles !== false) ||
+        this.repairActive ||
+        this.repairDirty ||
         this.level !== this.requested ||
         this.particles.length) &&
       !this.reducedMotion.matches
@@ -313,7 +415,7 @@ export default class extends Controller {
         path,
         original: element.style.getPropertyValue("clip-path"),
         priority: element.style.getPropertyPriority("clip-path"),
-        seed: this.surfaces.size * 31,
+        seed: this.surfaceSeed(element),
         card: cards.includes(element),
       });
       element.style.setProperty("clip-path", `url(#${clip.id})`);
@@ -321,6 +423,14 @@ export default class extends Controller {
     }
   }
 
+  surfaceSeed(element) {
+    // Permanent sidebar fragments must not depend on the current page's cards.
+    const index = SIDEBAR_SURFACES.findIndex((selector) =>
+      element.matches(selector),
+    );
+    return index < 0 ? this.surfaces.size * 31 : -(index + 1) * 31;
+  }
+
   cutSurfaces(emit) {
     this.collectSurfaces();
     this.repairTime = performance.now();
@@ -374,7 +484,7 @@ export default class extends Controller {
       surface.path.setAttribute("d", path);
       if (this.level > 0.82) this.drawDamagedText(element, rect, path, surface);
     }
-    if (emit && !this.reducedMotion.matches) this.emitDust(35);
+    if (emit && !this.reducedMotion.matches) this.emitDust(8);
   }
 
   localRect(rect, surfaceRect, padding = 5) {
@@ -665,6 +775,7 @@ export default class extends Controller {
   }
 
   repairStrength(cell, rect) {
+    if (this.simulation?.cursorRepair === false) return 0;
     const distance = this.pointer
       ? Math.hypot(
           cell.cx + rect.left - this.pointer.x,
@@ -690,18 +801,30 @@ export default class extends Controller {
   }
 
   emitAmbientDust(dt) {
-    if (!this.level || this.reducedMotion.matches) return;
+    if (
+      !this.particlesEnabledValue ||
+      this.simulation?.particles === false ||
+      !this.level ||
+      this.reducedMotion.matches
+    )
+      return;
     // Fractional particles accumulate, so even 1% emits a gentle trickle.
     // The rate is per second, independent of the display's refresh rate.
-    this.dustBudget = (this.dustBudget || 0) + dt * this.level * 180;
+    this.dustBudget = (this.dustBudget || 0) + dt * this.level * 45;
     const count = Math.floor(this.dustBudget);
     this.dustBudget -= count;
     this.emitDust(count);
   }
 
   emitDust(count) {
+    if (
+      !this.particlesEnabledValue ||
+      this.simulation?.particles === false ||
+      this.reducedMotion.matches
+    )
+      return;
     if (!this.fringe?.length && !this.dustBounds?.length) return;
-    for (let i = 0; i < count && this.particles.length < 1200; i++) {
+    for (let i = 0; i < count && this.particles.length < 180; i++) {
       let source = this.fringe[Math.floor(Math.random() * this.fringe.length)];
       if (!source) {
         // When no fragment is mid-break (including total decay), let residual
@@ -718,11 +841,11 @@ export default class extends Controller {
         y: source.y,
         vx: 15 + Math.random() * 35,
         vy: -12 - Math.random() * 25,
-        size: 1.8 + Math.random() ** 1.5 * 6.5,
+        size: 1 + Math.random() ** 1.5 * 3,
         angle: Math.random() * Math.PI,
         spin: Math.random() * 3 - 1.5,
         age: 0,
-        life: 2.4 + Math.random() * 2,
+        life: 1.5 + Math.random(),
         color: this.particleColor,
       });
     }
@@ -731,7 +854,13 @@ export default class extends Controller {
   draw(dt) {
     const ctx = this.canvasContext;
     ctx.clearRect(0, 0, this.width, this.height);
-    if (!this.level || this.reducedMotion.matches) return;
+    if (
+      !this.particlesEnabledValue ||
+      this.simulation?.particles === false ||
+      !this.level ||
+      this.reducedMotion.matches
+    )
+      return;
     this.particles = this.particles.filter((p) => p.age < p.life);
     for (const p of this.particles) {
       p.age += dt;
@@ -744,7 +873,9 @@ export default class extends Controller {
       ctx.translate(p.x, p.y);
       ctx.rotate(p.angle + p.age * p.spin);
       ctx.globalAlpha =
-        Math.min(p.age * 10, 1) * clamp((p.life - p.age) / (p.life * 0.65));
+        0.55 *
+        Math.min(p.age * 10, 1) *
+        clamp((p.life - p.age) / (p.life * 0.65));
       ctx.fillStyle = p.color;
       const scale = p.size * (1 - (p.age / p.life) * 0.45);
       ctx.fillRect(-scale / 2, -scale / 2, scale, scale * 0.65);
diff --git a/app/models/user/preference.rb b/app/models/user/preference.rb
index 7092103c6..ebfd7825a 100644
--- a/app/models/user/preference.rb
+++ b/app/models/user/preference.rb
@@ -4,6 +4,7 @@
 #
 #  id                                       :bigint           not null, primary key
 #  leaderboard_optin                        :boolean          default(FALSE), not null
+#  particle_effects_enabled                 :boolean          default(TRUE), not null
 #  search_engine_indexing_off               :boolean          default(FALSE), not null
 #  send_notifications_for_followed_projects :boolean          default(TRUE), not null
 #  send_notifications_for_followed_users    :boolean          default(TRUE), not null
diff --git a/app/services/rocket_progress/contributor_export.rb b/app/services/rocket_progress/contributor_export.rb
new file mode 100644
index 000000000..e18e03f9c
--- /dev/null
+++ b/app/services/rocket_progress/contributor_export.rb
@@ -0,0 +1,47 @@
+require "csv"
+require "set"
+
+module RocketProgress
+  # A current-data report of the bukux2 campaign, not a historical snapshot of
+  # approval state. Late approvals and subsequent fraud deductions are included.
+  class ContributorExport
+    WINDOW = WINDOW_START...WINDOW_END.next_day.beginning_of_day
+    HEADERS = %w[user_id username slack_id counted_ships approved_hours].freeze
+
+    def rows
+      @rows ||= begin
+        totals = {}
+        RocketProgress.approved_reviews
+          .where(post_ship_events: { created_at: WINDOW })
+          .pluck(:user_id, :post_ship_event_id, Arel.sql(RocketProgress::NET_MINUTES_SQL))
+          .each do |user_id, ship_id, minutes|
+            next unless minutes.positive?
+
+            total = totals[user_id] ||= { minutes: 0, ships: Set.new }
+            total[:minutes] += minutes
+            total[:ships] << ship_id
+          end
+
+        User.where(id: totals.keys).order(:id).pluck(:id, :display_name, :slack_id).map do |id, name, slack_id|
+          total = totals.fetch(id)
+          [ id, safe_cell(name), safe_cell(slack_id), total[:ships].size, (total[:minutes] / 60.0).round(2) ]
+        end
+      end
+    end
+
+    def to_csv
+      CSV.generate do |csv|
+        csv << HEADERS
+        rows.each { |row| csv << row }
+      end
+    end
+
+    private
+
+    def safe_cell(value)
+      text = value.to_s
+      # Quoting CSV alone does not prevent spreadsheet formula execution.
+      text.match?(/\A(?:\s*[=+\-@]|[\t\r\n])/) ? "'#{text}" : text
+    end
+  end
+end
diff --git a/app/views/admin/buku_x3_events/show.html.erb b/app/views/admin/buku_x3_events/show.html.erb
index 9bedc0f08..5c6e525ef 100644
--- a/app/views/admin/buku_x3_events/show.html.erb
+++ b/app/views/admin/buku_x3_events/show.html.erb
@@ -43,6 +43,15 @@
   </section>
 
   <% if policy(:admin).manage_buku_event? %>
+    <section aria-labelledby="bukux2-export-heading">
+      <h2 id="bukux2-export-heading">bukux2 contributors</h2>
+      <p class="admin-dashboard__metric-note">ships from september 3–24, 2026 inclusive · eastern time · users with positive net approved hours under bukux2 rules</p>
+      <p class="admin-dashboard__metric-note">uses current approvals and fraud deductions, including late approvals · one row per user with username, slack id, counted ships, and approved hours</p>
+      <%= button_to "download bukux2 contributors csv", admin_bukux2_contributors_export_path,
+                    method: :post, class: "btn-primary", form: { data: { turbo: false } } %>
+      <%= link_to "view export audit history", admin_audit_logs_path(event: "export_bukux2_contributors") %>
+    </section>
+
     <section class="admin-dashboard__event-controls" aria-labelledby="buku-intensity-heading">
       <h2 id="buku-intensity-heading">disintegration intensity</h2>
       <p>visual effect only · does not change team hours or the tug-of-war score</p>
diff --git a/app/views/layouts/application.html.erb b/app/views/layouts/application.html.erb
index f231d1ce0..f97b7fe75 100644
--- a/app/views/layouts/application.html.erb
+++ b/app/views/layouts/application.html.erb
@@ -71,11 +71,14 @@
         data-controller="<%= 'mihi-mode' if current_user.present? && Flipper.enabled?(:mihimode, current_user) %>"
         data-mihi-mode-activation-url-value="<%= mihi_activations_path %>"
         data-mihi-mode-image-url-value="<%= asset_path('mihi/portrait.jpg') %>">
-    <% if current_user.present? && Flipper.enabled?(:bukux3, current_user) %>
+    <% buku_enabled = current_user.present? && Flipper.enabled?(:bukux3, current_user) %>
+    <% if !controller_path.start_with?("admin/") && (buku_enabled || local_event_simulator?) %>
       <% buku_event = BukuX3::Event.current %>
-      <%= render "shared/blackhole", intensity: buku_event&.percent || BukuX3::Event::STARTING_PERCENT,
-                 visual_intensity: buku_event&.visual_intensity || 100, progress_url: buku_x3_progress_path(format: :json),
-                 awaiting_reveal: !(current_user.onboarded? && current_user.has_dismissed?(VisualNovelComponent::BUKU_X3_DISMISS_THING) && current_user.has_dismissed?(BukuX3RevealComponent::DISMISS_THING)) %>
+      <%= render "shared/blackhole", intensity: buku_enabled ? (buku_event&.percent || BukuX3::Event::STARTING_PERCENT) : 0,
+                 visual_intensity: buku_event&.visual_intensity || 100, progress_url: buku_enabled ? buku_x3_progress_path(format: :json) : nil,
+                 particles_enabled: current_user&.preference&.particle_effects_enabled? != false,
+                 simulator: local_event_simulator?,
+                 awaiting_reveal: buku_enabled && !(current_user.onboarded? && current_user.has_dismissed?(VisualNovelComponent::BUKU_X3_DISMISS_THING) && current_user.has_dismissed?(BukuX3RevealComponent::DISMISS_THING)) %>
     <% end %>
     <% if @show_boot_splash %>
       <div class="app-loading" aria-hidden="true">
diff --git a/app/views/shared/_blackhole.html.erb b/app/views/shared/_blackhole.html.erb
index e72b2ebb5..0984098dc 100644
--- a/app/views/shared/_blackhole.html.erb
+++ b/app/views/shared/_blackhole.html.erb
@@ -1,11 +1,14 @@
-<%# locals: (intensity: 0, progress_url: nil, awaiting_reveal: false, visual_intensity: 100) %>
+<%# locals: (intensity: 0, progress_url: nil, awaiting_reveal: false, visual_intensity: 100, particles_enabled: true, simulator: false) %>
 <div class="blackhole" data-controller="blackhole" data-mihi-mode-ignore
      data-blackhole-intensity-value="<%= intensity %>"
      data-blackhole-visual-intensity-value="<%= visual_intensity %>"
+     data-blackhole-particles-enabled-value="<%= particles_enabled %>"
+     data-blackhole-simulator-enabled-value="<%= simulator %>"
      data-blackhole-awaiting-reveal-value="<%= awaiting_reveal %>"
      data-action="buku-x3-reveal:complete@window->blackhole#revealComplete buku-x3-reveal:preview-complete@window->blackhole#revealComplete"
      data-blackhole-progress-url-value="<%= progress_url %>">
   <svg class="blackhole__masks" aria-hidden="true" width="0" height="0" data-blackhole-target="masks"><defs></defs></svg>
   <div class="blackhole__text" aria-hidden="true" inert data-blackhole-target="text"></div>
   <canvas class="blackhole__dust" aria-hidden="true" data-blackhole-target="canvas"></canvas>
+  <%= render "shared/event_simulator", particles_enabled: particles_enabled if simulator %>
 </div>
diff --git a/app/views/shared/_event_simulator.html.erb b/app/views/shared/_event_simulator.html.erb
new file mode 100644
index 000000000..611411191
--- /dev/null
+++ b/app/views/shared/_event_simulator.html.erb
@@ -0,0 +1,38 @@
+<%# locals: (particles_enabled: true) %>
+<details class="event-simulator">
+  <summary class="event-simulator__toggle">event simulator · local only</summary>
+  <form class="event-simulator__controls" data-blackhole-target="simulatorForm" data-action="input->blackhole#simulate submit->blackhole#simulate">
+    <p class="event-simulator__hint">browser-only preview · no real hours or roles are changed</p>
+    <p class="event-simulator__status" role="status" data-blackhole-target="simulatorStatus">live event values</p>
+    <label class="event-simulator__field">damage (%)
+      <input type="range" name="damage" min="0" max="100" step="1" value="25">
+    </label>
+    <label class="event-simulator__field">buku hours
+      <input type="number" name="buku" min="0" step="50" value="0">
+    </label>
+    <label class="event-simulator__field">bean hours
+      <input type="number" name="bean" min="0" step="50" value="0">
+    </label>
+    <p class="event-simulator__hint">team hours start from 25% damage · 50 hours move it by 1%</p>
+    <label class="event-simulator__field">visual intensity (%)
+      <input type="range" name="strength" min="0" max="200" step="5" value="100">
+    </label>
+    <label class="event-simulator__field">particles
+      <%= check_box_tag :particles, "1", particles_enabled, disabled: !particles_enabled %>
+    </label>
+    <% unless particles_enabled %>
+      <p class="event-simulator__hint">particles are disabled in your user settings</p>
+    <% end %>
+    <label class="event-simulator__field">cursor repair radius
+      <input type="checkbox" name="cursorRepair" checked>
+    </label>
+    <div class="event-simulator__actions">
+      <button type="button" data-action="blackhole#simulate">apply preview</button>
+      <button type="button" data-action="blackhole#resetSimulation">restore live values</button>
+    </div>
+    <div class="event-simulator__actions">
+      <%= link_to "preview buku", home_path(buku_preview: "buku") %>
+      <%= link_to "preview bean", home_path(buku_preview: "bean") %>
+    </div>
+  </form>
+</details>
diff --git a/config/routes.rb b/config/routes.rb
index c63c5a5cb..02595d803 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -649,6 +649,7 @@
     root to: "application#index"
     resource :buku_x3_event, only: :update
     get "jim_takeover", to: "buku_x3_events#show", as: :jim_takeover
+    post "jim_takeover/bukux2_contributors", to: "buku_x3_events#export_bukux2", as: :bukux2_contributors_export
     get "dashboard/counts/:key", to: "dashboard_counts#show", as: :dashboard_count
 
     resource :funnel, only: [ :show ], controller: "funnel"
diff --git a/db/migrate/20260924060219_add_particle_effects_enabled_to_user_preferences.rb b/db/migrate/20260924060219_add_particle_effects_enabled_to_user_preferences.rb
new file mode 100644
index 000000000..c7fd2b75a
--- /dev/null
+++ b/db/migrate/20260924060219_add_particle_effects_enabled_to_user_preferences.rb
@@ -0,0 +1,5 @@
+class AddParticleEffectsEnabledToUserPreferences < ActiveRecord::Migration[8.1]
+  def change
+    add_column :user_preferences, :particle_effects_enabled, :boolean, default: true, null: false
+  end
+end
diff --git a/db/schema.rb b/db/schema.rb
index d32fa163d..b9ae8979f 100644
--- a/db/schema.rb
+++ b/db/schema.rb
@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[8.1].define(version: 2026_09_23_225733) do
+ActiveRecord::Schema[8.1].define(version: 2026_09_24_060219) do
   # These are extensions that must be enabled in order to support this database
   enable_extension "pg_catalog.plpgsql"
   enable_extension "pg_trgm"
@@ -1632,6 +1632,7 @@
   create_table "user_preferences", force: :cascade do |t|
     t.datetime "created_at", null: false
     t.boolean "leaderboard_optin", default: false, null: false
+    t.boolean "particle_effects_enabled", default: true, null: false
     t.boolean "search_engine_indexing_off", default: false, null: false
     t.boolean "send_notifications_for_followed_projects", default: true, null: false
     t.boolean "send_notifications_for_followed_users", default: true, null: false
diff --git a/test/controllers/admin/buku_x3_events_controller_test.rb b/test/controllers/admin/buku_x3_events_controller_test.rb
index c36db0610..a3657b4aa 100644
--- a/test/controllers/admin/buku_x3_events_controller_test.rb
+++ b/test/controllers/admin/buku_x3_events_controller_test.rb
@@ -25,6 +25,65 @@ class Admin::BukuX3EventsControllerTest < ActionDispatch::IntegrationTest
     assert_includes response.body, "visual_intensity"
   end
 
+  test "admin pages never render disintegration or the local simulator" do
+    host! "localhost"
+    sign_in @admin
+    Flipper.enable(:bukux3)
+    @admin.update!(onboarded_at: Time.current, things_dismissed: %w[bukux3_intro bukux3_role_reveal])
+    @event.update!(destruction_minutes: BukuX3::Event::MAX_DESTRUCTION_MINUTES)
+    Rails.stub(:env, ActiveSupport::StringInquirer.new("development")) do
+      # Missions deliberately uses the application layout instead of admin.
+      [ admin_root_path, admin_jim_takeover_path, admin_missions_path, admin_audit_logs_path ].each do |path|
+        get path
+        assert_response :success
+        assert_select "[data-controller~='blackhole'], .event-simulator", count: 0
+      end
+      get home_path
+      assert_response :success
+      assert_select "[data-controller~='blackhole']", count: 1
+    end
+  ensure
+    Flipper.disable(:bukux3)
+  end
+
+  test "admins can download an uncached csv with an accessible attributed audit entry" do
+    sign_in @admin
+    assert_difference "PaperTrail::Version.where(event: 'export_bukux2_contributors').count", 1 do
+      post admin_bukux2_contributors_export_path
+    end
+    assert_response :success
+    assert_equal "text/csv", response.media_type
+    assert_equal "no-store", response.headers["Cache-Control"]
+    assert_includes response.headers["Content-Disposition"], "attachment"
+    assert_includes response.headers["Content-Disposition"], "bukux2-contributors-through-2026-09-24.csv"
+    assert_equal RocketProgress::ContributorExport::HEADERS, CSV.parse(response.body).first
+    version = PaperTrail::Version.where(event: "export_bukux2_contributors").last
+    assert_equal @admin.id.to_s, version.whodunnit
+    assert_equal [ nil, 0 ], version.changeset["exported_users"]
+    get admin_audit_logs_path(event: "export_bukux2_contributors")
+    assert_response :success
+    assert_includes response.body, "export_bukux2_contributors"
+  end
+
+  test "export authorizes before reading participant data" do
+    user = users(:one)
+    user.grant_role!(:workshop_manager)
+    sign_in user
+    RocketProgress::ContributorExport.stub(:new, -> { flunk "must authorize first" }) do
+      post admin_bukux2_contributors_export_path
+    end
+    assert_response :forbidden
+    get admin_jim_takeover_path
+    assert_select "form[action=?]", admin_bukux2_contributors_export_path, count: 0
+  end
+
+  test "signed out requests cannot export contributors" do
+    assert_no_difference "PaperTrail::Version.where(event: 'export_bukux2_contributors').count" do
+      post admin_bukux2_contributors_export_path
+    end
+    assert_response :not_found
+  end
+
   test "off and double strength are allowed but malformed or out of range values are rejected" do
     sign_in @admin
     [ 0, 200, 100 ].each do |intensity|
@@ -92,6 +151,7 @@ class Admin::BukuX3EventsControllerTest < ActionDispatch::IntegrationTest
     end
     assert_select "table", count: 0
     assert_select "form[action=?]", admin_buku_x3_event_path
+    assert_select "form[action=?][data-turbo='false']", admin_bukux2_contributors_export_path
   end
 
   test "ordinary users cannot access the event dashboard" do
diff --git a/test/controllers/buku_x3/progress_controller_test.rb b/test/controllers/buku_x3/progress_controller_test.rb
index 93dee26b0..9df26f660 100644
--- a/test/controllers/buku_x3/progress_controller_test.rb
+++ b/test/controllers/buku_x3/progress_controller_test.rb
@@ -12,19 +12,19 @@ class BukuX3::ProgressControllerTest < ActionDispatch::IntegrationTest
     Flipper.disable(:blackhole)
   end
 
-  test "development pages have no event test buttons or simulator panels" do
+  test "non-local development pages have no event test buttons or simulator panels" do
     sign_in(@user)
     Flipper.enable(:blackhole)
     Rails.env.stub(:development?, true) do
       get home_path
       assert_response :success
-      assert_select ".blackhole, .buku-x3-preview, .buku-x3-simulator, .blackhole__panel", count: 0
+      assert_select ".blackhole, .buku-x3-preview, .event-simulator, .blackhole__panel", count: 0
 
       Flipper.enable(:bukux3)
       get home_path
       assert_response :success
       assert_select ".blackhole", count: 1
-      assert_select ".buku-x3-preview, .buku-x3-simulator, .blackhole__panel", count: 0
+      assert_select ".buku-x3-preview, .event-simulator, .blackhole__panel", count: 0
     end
   end
 
diff --git a/test/controllers/buku_x3/reveals_controller_test.rb b/test/controllers/buku_x3/reveals_controller_test.rb
index 85d858615..6129e6e3e 100644
--- a/test/controllers/buku_x3/reveals_controller_test.rb
+++ b/test/controllers/buku_x3/reveals_controller_test.rb
@@ -11,6 +11,55 @@ class BukuX3::RevealsControllerTest < ActionDispatch::IntegrationTest
 
   teardown { Flipper.disable(:bukux3) }
 
+  test "simulator is available only on local development hosts" do
+    host! "localhost"
+    get home_path
+    assert_select ".event-simulator", count: 0
+    Rails.stub(:env, ActiveSupport::StringInquirer.new("development")) do
+      get home_path
+      assert_select ".event-simulator", count: 1
+      assert_select "[data-blackhole-simulator-enabled-value='true']", count: 1
+      host! "stardance.example"
+      get home_path
+      assert_select ".event-simulator", count: 0
+    end
+  end
+
+  test "local simulator is usable without enabling the event flag" do
+    Flipper.disable(:bukux3)
+    host! "localhost"
+    Rails.stub(:env, ActiveSupport::StringInquirer.new("development")) do
+      get home_path
+      assert_select ".event-simulator", count: 1
+      assert_select "[data-blackhole-intensity-value='0'][data-blackhole-progress-url-value='']", count: 1
+    end
+  end
+
+  test "local simulator respects the particle preference saved through settings" do
+    host! "localhost"
+    sign_in(@user)
+    patch my_settings_path, params: { particle_effects_enabled: "0" }
+    assert_redirected_to root_path
+    Rails.stub(:env, ActiveSupport::StringInquirer.new("development")) do
+      get home_path
+      assert_response :success
+      assert_select "[data-blackhole-particles-enabled-value='false']", count: 1
+      assert_select ".event-simulator input[name='particles'][disabled]:not([checked])", count: 1
+    end
+  end
+
+  test "dashboard renders the saved particle preference without disabling damage" do
+    @user.update!(things_dismissed: %w[bukux3_intro bukux3_role_reveal])
+    [ false, true ].each do |enabled|
+      @user.preference.update!(particle_effects_enabled: enabled)
+      get home_path
+      assert_response :success
+      assert_select ".blackhole[data-blackhole-particles-enabled-value='#{enabled}'][data-blackhole-awaiting-reveal-value='false']", count: 1
+      assert_select "input#particle_effects_enabled[type='checkbox']", count: 1
+      assert_select "input#particle_effects_enabled[checked]", count: enabled ? 1 : 0
+    end
+  end
+
   test "first load contains only the explanation, never a prefetched role" do
     BukuX3::Assignment.stub(:buku?, ->(_) { flunk "role must wait until after intro" }) do
       get home_path
diff --git a/test/controllers/my_controller_test.rb b/test/controllers/my_controller_test.rb
index a78361a2e..a853ed03b 100644
--- a/test/controllers/my_controller_test.rb
+++ b/test/controllers/my_controller_test.rb
@@ -31,4 +31,23 @@ class MyResourcesTest < ActionDispatch::IntegrationTest
     assert_response :success
     assert user.reload.has_dismissed?("willsbuilds_banner")
   end
+
+  test "particle preference can be disabled and enabled without changing another user" do
+    user = users(:one)
+    other_preference = users(:two).preference
+    other_preference.update!(particle_effects_enabled: true)
+    sign_in user
+
+    patch my_settings_path, params: { particle_effects_enabled: "0" }
+    assert_redirected_to root_path
+    assert_not user.preference.reload.particle_effects_enabled
+    assert other_preference.reload.particle_effects_enabled
+
+    patch my_settings_path, params: { hcb_email: "grants@example.test" }
+    assert_not user.preference.reload.particle_effects_enabled, "unrelated updates preserve the preference"
+
+    patch my_settings_path, params: { particle_effects_enabled: "1" }
+    assert_redirected_to root_path
+    assert user.preference.reload.particle_effects_enabled
+  end
 end
diff --git a/test/fixtures/user/preferences.yml b/test/fixtures/user/preferences.yml
index 234204dcc..fd032bcb0 100644
--- a/test/fixtures/user/preferences.yml
+++ b/test/fixtures/user/preferences.yml
@@ -6,6 +6,7 @@
 #
 #  id                                       :bigint           not null, primary key
 #  leaderboard_optin                        :boolean          default(FALSE), not null
+#  particle_effects_enabled                 :boolean          default(TRUE), not null
 #  search_engine_indexing_off               :boolean          default(FALSE), not null
 #  send_notifications_for_followed_projects :boolean          default(TRUE), not null
 #  send_notifications_for_followed_users    :boolean          default(TRUE), not null
diff --git a/test/javascript/blackhole_options_test.mjs b/test/javascript/blackhole_options_test.mjs
index 06c6cfbc0..4bc364d38 100644
--- a/test/javascript/blackhole_options_test.mjs
+++ b/test/javascript/blackhole_options_test.mjs
@@ -2,6 +2,227 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import BlackholeController from "../../app/javascript/controllers/blackhole_controller.js";
 
+test("navigation restores damage immediately, but live changes still animate", () => {
+  const controller = {
+    scenesBlocked: () => false,
+    visualIntensityValue: 100,
+    cutSurfaces(emit) {
+      this.emitted = emit;
+    },
+    wake() {},
+  };
+  BlackholeController.prototype.setIntensity.call(controller, 25, {
+    immediate: true,
+  });
+  assert.equal(controller.level, 0.25);
+  assert.equal(controller.emitted, false);
+  BlackholeController.prototype.setIntensity.call(controller, 50);
+  assert.equal(controller.level, 0.25);
+  assert.equal(controller.requested, 0.5);
+});
+
+test("simulated hours and strength override live polls without replacing live state", () => {
+  const controller = {
+    simulatorEnabledValue: true,
+    simulation: { damage: 75, strength: 50, buku: 2500, bean: 0 },
+    scenesBlocked: () => false,
+    dispatch(name, { detail }) {
+      this.progress = detail;
+    },
+    wake() {},
+  };
+  BlackholeController.prototype.setIntensity.call(controller, 30);
+  assert.equal(controller.latestIntensity, 30);
+  assert.equal(controller.requested, 0.375);
+  assert.deepEqual(controller.progress, {
+    percent: 75,
+    hours: { buku: 2500, bean: 0 },
+  });
+  controller.simulation = null;
+  BlackholeController.prototype.setIntensity.call(
+    controller,
+    controller.latestIntensity,
+  );
+  assert.equal(controller.requested, 0.3);
+});
+
+test("simulator actions are inert when the server has not enabled the simulator", () => {
+  const controller = { simulatorEnabledValue: false };
+  BlackholeController.prototype.simulate.call(controller, {
+    preventDefault() {},
+  });
+  BlackholeController.prototype.resetSimulation.call(controller);
+  assert.equal(controller.simulation, undefined);
+});
+
+test("simulator can disable cursor repair", () => {
+  const strength = BlackholeController.prototype.repairStrength.call(
+    { simulation: { cursorRepair: false } },
+    {},
+    {},
+  );
+  assert.equal(strength, 0);
+});
+
+test("initial damage cannot bypass the intro or role reveal", () => {
+  const controller = {
+    scenesBlocked: () => true,
+    reset() {
+      this.level = this.requested = 0;
+    },
+    cutSurfaces() {
+      assert.fail("must not disintegrate story scenes");
+    },
+  };
+  BlackholeController.prototype.setIntensity.call(controller, 75, {
+    immediate: true,
+  });
+  assert.equal(controller.level, 0);
+});
+
+test("sidebar fragmentation does not change with page surface count", () => {
+  for (const selector of [
+    "#primary-nav",
+    ".sidebar__logo-img",
+    ".sidebar__user-card",
+  ]) {
+    const element = { matches: (value) => value === selector };
+    const seed = (size) =>
+      BlackholeController.prototype.surfaceSeed.call(
+        { surfaces: { size } },
+        element,
+      );
+    assert.equal(seed(3), seed(25));
+    assert.ok(seed(3) < 0);
+  }
+});
+
+test("particle opt-out disables both ambient dust and destruction bursts", () => {
+  const controller = {
+    particlesEnabledValue: false,
+    reducedMotion: { matches: false },
+    level: 1,
+    particles: [],
+    fringe: [{ x: 10, y: 20 }],
+    emitDust: BlackholeController.prototype.emitDust,
+  };
+  BlackholeController.prototype.emitAmbientDust.call(controller, 1);
+  controller.emitDust(100);
+  assert.equal(controller.particles.length, 0);
+  assert.equal(controller.dustBudget, undefined);
+});
+
+test("restoring a simulator preview cannot overwrite the saved particle opt-out", () => {
+  const fields = {
+    damage: { value: "64" },
+    buku: { value: "0" },
+    bean: { value: "0" },
+    strength: { value: "100" },
+    particles: { checked: true },
+    cursorRepair: { checked: true },
+  };
+  const controller = {
+    particlesEnabledValue: false,
+    simulatorFormTarget: { elements: { namedItem: (name) => fields[name] } },
+    simulatorStatusTarget: {},
+  };
+  BlackholeController.prototype.readSimulation.call(controller);
+  assert.equal(
+    controller.simulation.particles,
+    true,
+    "even an older saved preview may request particles",
+  );
+  assert.equal(
+    controller.particlesEnabledValue,
+    false,
+    "the saved preference remains authoritative",
+  );
+});
+
+test("particles require both user permission and simulator permission", () => {
+  for (const [preference, preview, expected] of [
+    [false, true, 0],
+    [true, false, 0],
+    [true, true, 45],
+  ]) {
+    const controller = {
+      particlesEnabledValue: preference,
+      simulation: { particles: preview },
+      reducedMotion: { matches: false },
+      level: 1,
+      particles: [],
+      fringe: [{ x: 10, y: 20 }],
+      emitDust: BlackholeController.prototype.emitDust,
+    };
+    BlackholeController.prototype.emitAmbientDust.call(controller, 1);
+    assert.equal(controller.particles.length, expected);
+    controller.particles = [];
+    controller.emitDust(8);
+    assert.equal(controller.particles.length, expected ? 8 : 0);
+    if (!expected) {
+      controller.canvasContext = {
+        clearRect() {},
+        save() {
+          assert.fail("disabled particles must not be painted");
+        },
+      };
+      controller.particles = [{ age: 0, life: 1 }];
+      BlackholeController.prototype.draw.call(controller, 0.01);
+    }
+  }
+});
+
+test("ambient dust is restrained and respects reduced motion", () => {
+  const controller = {
+    particlesEnabledValue: true,
+    reducedMotion: { matches: false },
+    level: 1,
+    particles: [],
+    fringe: [{ x: 10, y: 20 }],
+    emitDust: BlackholeController.prototype.emitDust,
+  };
+  BlackholeController.prototype.emitAmbientDust.call(controller, 1);
+  assert.equal(controller.particles.length, 45);
+  controller.emitDust(1000);
+  assert.equal(controller.particles.length, 180);
+  assert.ok(controller.particles.every((p) => p.size <= 4 && p.life <= 2.5));
+  controller.particles = [];
+  controller.reducedMotion.matches = true;
+  controller.emitDust(100);
+  assert.equal(controller.particles.length, 0);
+});
+
+test("cursor repair finishes even with particles disabled", () => {
+  let wakes = 0;
+  const controller = {
+    particlesEnabledValue: false,
+    reducedMotion: { matches: false },
+    level: 0.25,
+    requested: 0.25,
+    particles: [],
+    repairDirty: true,
+    lastMask: 100,
+    cutSurfaces() {
+      this.cut = true;
+    },
+    emitAmbientDust() {},
+    draw() {},
+    wake() {
+      wakes++;
+    },
+  };
+  BlackholeController.prototype.tick.call(controller, 110);
+  assert.equal(wakes, 1, "a throttled repair must schedule another frame");
+  BlackholeController.prototype.tick.call(controller, 150);
+  assert.equal(controller.cut, true);
+  assert.equal(controller.repairDirty, false);
+  assert.equal(
+    wakes,
+    1,
+    "idle dust-free pages do not need continuous animation",
+  );
+});
+
 test("admin intensity scales visuals without changing the event score", () => {
   const controller = {
     progressUrlValue: "/progress",
diff --git a/test/models/user/preference_test.rb b/test/models/user/preference_test.rb
index db7410c21..b1a07226d 100644
--- a/test/models/user/preference_test.rb
+++ b/test/models/user/preference_test.rb
@@ -4,6 +4,7 @@
 #
 #  id                                       :bigint           not null, primary key
 #  leaderboard_optin                        :boolean          default(FALSE), not null
+#  particle_effects_enabled                 :boolean          default(TRUE), not null
 #  search_engine_indexing_off               :boolean          default(FALSE), not null
 #  send_notifications_for_followed_projects :boolean          default(TRUE), not null
 #  send_notifications_for_followed_users    :boolean          default(TRUE), not null
@@ -35,6 +36,7 @@ class User::PreferenceTest < ActiveSupport::TestCase
     assert_not user.preference.send_votes_to_slack
     assert_not user.preference.leaderboard_optin
     assert_not user.preference.search_engine_indexing_off
+    assert user.preference.particle_effects_enabled
   end
 
   test "each user can only have one preference record" do
diff --git a/test/services/rocket_progress_test.rb b/test/services/rocket_progress_test.rb
index 88eeebaa0..29e25b801 100644
--- a/test/services/rocket_progress_test.rb
+++ b/test/services/rocket_progress_test.rb
@@ -109,6 +109,54 @@ class RocketProgressTest < ActiveSupport::TestCase
     assert_equal 0, RocketProgress.snapshot(user: @owner).user_hours
   end
 
+  test "contributor export groups ships and net hours into one row per user" do
+    review = reviewed_ship(minutes: 180, at: @in_window)
+    deduct!(review, minutes: 30)
+    reviewed_ship(minutes: 60, at: @in_window)
+
+    rows = CSV.parse(RocketProgress::ContributorExport.new.to_csv, headers: true)
+    assert_equal RocketProgress::ContributorExport::HEADERS, rows.headers
+    assert_equal 1, rows.length
+    assert_equal @owner.id.to_s, rows.first["user_id"]
+    assert_equal @owner.display_name, rows.first["username"]
+    assert_equal @owner.slack_id, rows.first["slack_id"]
+    assert_equal "2", rows.first["counted_ships"]
+    assert_equal "3.5", rows.first["approved_hours"]
+  end
+
+  test "contributor export includes the full last eastern day and late approvals" do
+    finish = RocketProgress::ContributorExport::WINDOW.end
+    reviewed_ship(minutes: 600, at: RocketProgress::WINDOW_START - 1.second)
+    reviewed_ship(minutes: 60, at: RocketProgress::WINDOW_START)
+    late = reviewed_ship(minutes: 60, at: finish - 1.second)
+    late.update_columns(reviewed_at: finish + 2.days)
+    reviewed_ship(minutes: 600, at: finish)
+
+    row = RocketProgress::ContributorExport.new.rows.sole
+    assert_equal 2, row[3]
+    assert_equal 2.0, row[4]
+  end
+
+  test "contributor export excludes banned users, below-floor approvals and zero net hours" do
+    reviewed_ship(minutes: 20, approved: 5, at: @in_window)
+    zero = reviewed_ship(minutes: 60, at: @in_window)
+    deduct!(zero, minutes: 60)
+    banned = create_user(slack_id: "U_EXPORT_BANNED", display_name: "banned-export", verified: true)
+    reviewed_ship(minutes: 60, at: @in_window, user: banned)
+    banned.update_columns(banned: true)
+
+    export = RocketProgress::ContributorExport.new
+    assert_empty export.rows
+    assert_equal [ RocketProgress::ContributorExport::HEADERS ], CSV.parse(export.to_csv)
+  end
+
+  test "contributor csv escapes spreadsheet formulas and quotes names correctly" do
+    reviewed_ship(minutes: 60, at: @in_window)
+    @owner.update_columns(display_name: "=HYPERLINK(\"https://example.test\",\"hi\")")
+    row = CSV.parse(RocketProgress::ContributorExport.new.to_csv, headers: true).first
+    assert_equal "'#{@owner.reload.display_name}", row["username"]
+  end
+
   private
     # An approved YSWS review with one reviewed devlog, whose ship event was
     # posted (created_at) at `at` — the timestamp RocketProgress windows

From 81d0e770d8749b184d5c37a5c4e65928a41e2736 Mon Sep 17 00:00:00 2001
From: mikidoodle <mihir@pidgon.com>
Date: Thu, 24 Sep 2026 13:51:07 -0400
Subject: [PATCH 2/9] change text

---
 app/components/buku_x3_status_component.rb       | 5 ++++-
 app/components/sidebar_component.html.erb        | 2 +-
 test/components/buku_x3_status_component_test.rb | 2 +-
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/app/components/buku_x3_status_component.rb b/app/components/buku_x3_status_component.rb
index e944832e2..38cb166e7 100644
--- a/app/components/buku_x3_status_component.rb
+++ b/app/components/buku_x3_status_component.rb
@@ -28,7 +28,10 @@ def buku?
   end
   def role_name = buku? ? "buku buku" : "bean"
   def icon = "events/bukux3/#{buku? ? 'buku' : 'bean'}.png"
-  def reminder = "your hours will #{buku? ? 'destroy' : 'repair'} the spaceship"
+  def reminder
+    buku? ? "your objective is to destroy the ship - every hour you code contributes to the downfall of the beans and tears stardance apart" :
+      "your hours will repair the spaceship"
+  end
   def percent = event&.percent || BukuX3::Event::STARTING_PERCENT
   def marker_position = 100 - percent
   def display_percent = helpers.number_with_precision(percent, precision: 1, strip_insignificant_zeros: true)
diff --git a/app/components/sidebar_component.html.erb b/app/components/sidebar_component.html.erb
index 57d7f1304..912f0e3e6 100644
--- a/app/components/sidebar_component.html.erb
+++ b/app/components/sidebar_component.html.erb
@@ -146,7 +146,7 @@
           <%= check_box_tag :particle_effects_enabled, "1", preference.particle_effects_enabled?, id: "particle_effects_enabled" %>
           <span>Show disintegration particles</span>
         </label>
-        <small class="settings-form__hint">Turn off drifting particles while keeping the event damage and cursor repair effect</small>
+        <small class="settings-form__hint">Turn off drifting particles</small>
       </div>
 
       <% if user.slack_id.present? %>
diff --git a/test/components/buku_x3_status_component_test.rb b/test/components/buku_x3_status_component_test.rb
index be6a3d394..c9771ecd3 100644
--- a/test/components/buku_x3_status_component_test.rb
+++ b/test/components/buku_x3_status_component_test.rb
@@ -32,7 +32,7 @@ class BukuX3StatusComponentTest < ViewComponent::TestCase
     assert_selector ".buku-x3-status__role", text: "you're a buku buku"
     assert_selector "button.buku-x3-status__toggle[aria-label='show your event role'][aria-pressed='false']"
     assert_selector "img[src*='events/bukux3/buku']"
-    assert_selector ".buku-x3-status__reminder", exact_text: "your hours will destroy the spaceship"
+    assert_selector ".buku-x3-status__reminder", exact_text: "your objective is to destroy the ship - every hour you code contributes to the downfall of the beans and tears stardance apart"
     assert_selector "[role='meter'][aria-valuenow='25.0'][aria-valuemax='100'][style='--tug-position: 75.0%']"
     assert_selector ".buku-x3-status__team--buku img[src*='bukux3/buku-pulling'][width='2752'][height='2064']"
     assert_selector ".buku-x3-status__team--bean img[src*='bukux3/bean-pulling'][width='2752'][height='2064']"

From f14fcdd16a8e27f140f11b20c5466084e2d8a7d6 Mon Sep 17 00:00:00 2001
From: mikidoodle <mihir@pidgon.com>
Date: Thu, 24 Sep 2026 14:01:13 -0400
Subject: [PATCH 3/9] Fix event simulator ERB lint

---
 app/views/shared/_event_simulator.html.erb | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/app/views/shared/_event_simulator.html.erb b/app/views/shared/_event_simulator.html.erb
index 611411191..b6ebaba32 100644
--- a/app/views/shared/_event_simulator.html.erb
+++ b/app/views/shared/_event_simulator.html.erb
@@ -5,17 +5,17 @@
     <p class="event-simulator__hint">browser-only preview · no real hours or roles are changed</p>
     <p class="event-simulator__status" role="status" data-blackhole-target="simulatorStatus">live event values</p>
     <label class="event-simulator__field">damage (%)
-      <input type="range" name="damage" min="0" max="100" step="1" value="25">
+      <input type="range" name="damage" min="0" max="100" step="1" value="25" autocomplete="off">
     </label>
     <label class="event-simulator__field">buku hours
-      <input type="number" name="buku" min="0" step="50" value="0">
+      <input type="number" name="buku" min="0" step="50" value="0" autocomplete="off">
     </label>
     <label class="event-simulator__field">bean hours
-      <input type="number" name="bean" min="0" step="50" value="0">
+      <input type="number" name="bean" min="0" step="50" value="0" autocomplete="off">
     </label>
     <p class="event-simulator__hint">team hours start from 25% damage · 50 hours move it by 1%</p>
     <label class="event-simulator__field">visual intensity (%)
-      <input type="range" name="strength" min="0" max="200" step="5" value="100">
+      <input type="range" name="strength" min="0" max="200" step="5" value="100" autocomplete="off">
     </label>
     <label class="event-simulator__field">particles
       <%= check_box_tag :particles, "1", particles_enabled, disabled: !particles_enabled %>

From 2faf39f012bc3b85b890508f1fc7a00f3a051ec8 Mon Sep 17 00:00:00 2001
From: mikidoodle <mihir@pidgon.com>
Date: Fri, 25 Sep 2026 12:24:13 -0400
Subject: [PATCH 4/9] update hours calculation

---
 app/services/buku_x3/refresh.rb       |  5 ++-
 test/services/buku_x3/refresh_test.rb | 58 +++++++++++++++++++++++----
 2 files changed, 54 insertions(+), 9 deletions(-)

diff --git a/app/services/buku_x3/refresh.rb b/app/services/buku_x3/refresh.rb
index ad1bcf9c8..d203b19fd 100644
--- a/app/services/buku_x3/refresh.rb
+++ b/app/services/buku_x3/refresh.rb
@@ -23,10 +23,11 @@ def initialize(event, now)
 
     def reconcile!
       existing = @event.contributions.index_by(&:ysws_review_id)
+      # Use bukux2's approved-minute accounting without waiting for the overall
+      # review to finish, but exclude rejected/misfiled ships from this event.
       rows = RocketProgress.approved_reviews
         .where("post_ship_events.created_at > ? AND post_ship_events.created_at <= ?", @event.unlocked_at, @now)
         .where.not(post_ship_events: { certification_status: Post::ShipEvent::HIDDEN_STATUSES })
-        .where(reviewed_at: ..@now)
         .group("post_ship_events.created_at")
         .pluck(:id, :user_id, "post_ship_events.created_at", Arel.sql(RocketProgress::NET_MINUTES_SQL))
       users = User.where(id: rows.map { |row| row[1] }).select(:id).index_by(&:id)
@@ -40,7 +41,7 @@ def reconcile!
         contribution.save! if contribution.changed?
       end
 
-      # A ban, reopened/rejected review, or reduced approval can remove a
+      # A ban, hidden ship, deleted review, or reduced approval can remove a
       # previously counted ship. Retain its audit record but remove its effect.
       existing.each_value do |contribution|
         contribution.update!(minutes: 0) unless contribution.minutes.zero?
diff --git a/test/services/buku_x3/refresh_test.rb b/test/services/buku_x3/refresh_test.rb
index 920540528..b607d2d7f 100644
--- a/test/services/buku_x3/refresh_test.rb
+++ b/test/services/buku_x3/refresh_test.rb
@@ -92,8 +92,8 @@ class BukuX3RefreshTest < ActiveSupport::TestCase
     assert_equal 25, @event.reload.percent
   end
 
-  test "pending incomplete and under-minimum reviews do not count" do
-    reviewed_ship(user: @buku, minutes: 6000, at: @cutoff + 1.hour, reviewed_at: nil)
+  test "unapproved and under-minimum reviews do not count" do
+    reviewed_ship(user: @buku, minutes: 6000, approved: 0, at: @cutoff + 1.hour, reviewed_at: nil)
     reviewed_ship(user: @buku, minutes: 100, approved: 5, at: @cutoff + 2.hours)
     refresh
     assert_empty @event.contributions
@@ -112,18 +112,61 @@ class BukuX3RefreshTest < ActiveSupport::TestCase
     assert_equal 26, @event.reload.percent
   end
 
-  test "reopening or rejecting a previously counted review removes its effect" do
+  test "reopening a review does not remove its approved minutes" do
     review = reviewed_ship(user: @buku, minutes: 3000, at: @cutoff + 1.hour)
     refresh
     review.update!(reviewed_at: nil)
     refresh
+    assert_equal 26, @event.reload.percent
+  end
+
+  test "rejected and misfiled ships are excluded and previously counted hours are removed" do
+    review = reviewed_ship(user: @buku, minutes: 3000, at: @cutoff + 1.hour)
+    %w[rejected misfiled].each do |status|
+      review.post_ship_event.update_columns(certification_status: "approved")
+      refresh
+      assert_equal 26, @event.reload.percent
+      review.post_ship_event.update_columns(certification_status: status)
+      hidden = reviewed_ship(user: @human, minutes: 1500, at: @cutoff + 2.hours)
+      hidden.post_ship_event.update_columns(certification_status: status)
+      refresh
+      assert_equal 25, @event.reload.percent
+      assert_equal 0, @event.contributions.find_by!(ysws_review: review).minutes
+      assert_not @event.contributions.exists?(ysws_review: hidden)
+    end
+  end
+
+  test "removing approved minutes removes the effect and restoring them catches up" do
+    review = reviewed_ship(user: @buku, minutes: 3000, at: @cutoff + 1.hour)
+    refresh
+    review.devlog_reviews.sole.update!(approved_minutes: 0)
+    refresh
     assert_equal 25, @event.reload.percent
-    review.update!(reviewed_at: Time.current)
+    assert_equal 0, @event.contributions.sole.minutes
+    review.devlog_reviews.sole.update!(approved_minutes: 3000)
     refresh
     assert_equal 26, @event.reload.percent
-    review.post_ship_event.update_columns(certification_status: "rejected")
+    assert_equal 1, @event.contributions.count
+  end
+
+  test "refresh backfills unfinished reviews without role reveals using bukux2 accounting" do
+    [ @buku, @human ].each { |user| user.update!(things_dismissed: []) }
+    reviewed_ship(user: @buku, minutes: 120, at: @cutoff + 1.hour, reviewed_at: nil)
+    review = reviewed_ship(user: @human, minutes: 90, at: @cutoff + 2.hours, reviewed_at: nil)
+    Certification::Integrity.create!(ship_event: review.post_ship_event, reviewer: @buku,
+                                     status: :deducted, deduction_minutes: 30)
     refresh
-    assert_equal 25, @event.reload.percent
+
+    expected_minutes = RocketProgress.approved_reviews
+      .where("post_ship_events.created_at > ? AND post_ship_events.created_at <= ?", @cutoff, Time.current)
+      .pluck(Arel.sql(RocketProgress::NET_MINUTES_SQL)).sum
+    assert_equal 180, expected_minutes
+    assert_equal expected_minutes, @event.contributions.sum(:minutes)
+    assert_equal({ buku: 2, bean: 1 }, @event.reload.team_hours)
+    assert_no_difference "BukuX3::Contribution.count" do
+      refresh
+    end
+    assert_equal({ buku: 2, bean: 1 }, @event.reload.team_hours)
   end
 
   test "repairs at zero do not bank credit against future damage" do
@@ -143,11 +186,12 @@ class BukuX3RefreshTest < ActiveSupport::TestCase
   end
 
   test "late approvals replay in ship order rather than job order" do
-    early = reviewed_ship(user: @buku, minutes: 3000, at: @cutoff + 1.hour, reviewed_at: nil)
+    early = reviewed_ship(user: @buku, minutes: 3000, approved: 0, at: @cutoff + 1.hour, reviewed_at: nil)
     reviewed_ship(user: @human, minutes: 1500, at: @cutoff + 2.hours)
     refresh
     assert_equal 24.5, @event.reload.percent
     early.update!(reviewed_at: Time.current)
+    early.devlog_reviews.sole.update!(approved_minutes: 3000, status: :approved)
     refresh
     assert_equal 25.5, @event.reload.percent
   end

From 4851d8d082082392ed0ed2908f347dba8af73a5a Mon Sep 17 00:00:00 2001
From: mikidoodle <mihir@pidgon.com>
Date: Fri, 25 Sep 2026 14:01:05 -0400
Subject: [PATCH 5/9] Optimize disintegration rendering performance

---
 .../controllers/blackhole_controller.js       | 166 +++++++++++++----
 test/javascript/blackhole_options_test.mjs    |   1 +
 .../javascript/blackhole_performance_test.mjs | 170 ++++++++++++++++++
 3 files changed, 306 insertions(+), 31 deletions(-)
 create mode 100644 test/javascript/blackhole_performance_test.mjs

diff --git a/app/javascript/controllers/blackhole_controller.js b/app/javascript/controllers/blackhole_controller.js
index 679b662ab..cbe89d7e7 100644
--- a/app/javascript/controllers/blackhole_controller.js
+++ b/app/javascript/controllers/blackhole_controller.js
@@ -334,6 +334,17 @@ export default class extends Controller {
 
   tick(time) {
     this.frame = null;
+    // Slow mask generation also puts dust on a 30fps budget. Keep scheduling
+    // repairs even when a frame is skipped or particles are disabled.
+    if (
+      !this.reducedMotion.matches &&
+      this.maskInterval > 60 &&
+      this.lastTime &&
+      time - this.lastTime < 32
+    ) {
+      this.wake();
+      return;
+    }
     const dt = Math.min((time - (this.lastTime || time)) / 1000, 0.05);
     this.lastTime = time;
     const previous = this.level;
@@ -342,17 +353,17 @@ export default class extends Controller {
       : this.level + (this.requested - this.level) * (1 - Math.exp(-dt * 5));
     if (Math.abs(this.level - this.requested) < 0.001)
       this.level = this.requested;
+    if (this.level !== previous) this.maskDirty = true;
     if (
-      this.dirty ||
-      ((this.repairActive || this.repairDirty) &&
-        time - (this.lastMask || 0) > 45) ||
-      (this.level !== previous &&
-        (this.level === this.requested || time - (this.lastMask || 0) > 45))
+      (this.dirty || this.repairActive || this.repairDirty || this.maskDirty) &&
+      (this.reducedMotion.matches ||
+        time - (this.lastMask || 0) >= (this.maskInterval || 45))
     ) {
       this.cutSurfaces(this.level > previous);
       this.lastMask = time;
       this.dirty = false;
       this.repairDirty = false;
+      this.maskDirty = false;
     }
     this.emitAmbientDust(dt);
     this.draw(dt);
@@ -362,6 +373,8 @@ export default class extends Controller {
         this.simulation?.particles !== false) ||
         this.repairActive ||
         this.repairDirty ||
+        this.dirty ||
+        this.maskDirty ||
         this.level !== this.requested ||
         this.particles.length) &&
       !this.reducedMotion.matches
@@ -376,6 +389,8 @@ export default class extends Controller {
         surface.clip.remove();
         surface.textClip?.remove();
         surface.textCopy?.remove();
+        this.fragmentMeshes?.delete(surface.geometry?.seed);
+        this.fragmentFields?.delete(surface.geometry?.seed);
         this.surfaces.delete(element);
       }
     }
@@ -432,7 +447,8 @@ export default class extends Controller {
   }
 
   cutSurfaces(emit) {
-    this.collectSurfaces();
+    const started = performance.now();
+    if (this.dirty || !this.surfaces.size) this.collectSurfaces();
     this.repairTime = performance.now();
     this.repairActive = false;
     this.textTarget.hidden = this.level <= 0.82;
@@ -456,22 +472,11 @@ export default class extends Controller {
         top: Math.max(0, rect.top),
         bottom: Math.min(this.height, rect.bottom),
       });
-      let layer = element;
-      while (layer.parentElement && getComputedStyle(layer).zIndex === "auto")
-        layer = layer.parentElement;
-      const seed =
-        (Number.parseInt(getComputedStyle(layer).zIndex, 10) || 0) +
-        surface.seed;
-      surface.layerIndex = getComputedStyle(layer).zIndex;
-      // Parent layers leave each card to its own mask, avoiding double erosion
-      // while the cursor repair pocket restores nearby fragments.
-      const nestedCards = surface.card
-        ? []
-        : [...element.querySelectorAll(CARD_SURFACES)];
-      const excludedRects = nestedCards.map((card) =>
-        this.localRect(card.getBoundingClientRect(), rect, 12),
+      const { seed, protectedRects, excludedRects } = this.surfaceGeometry(
+        element,
+        surface,
+        rect,
       );
-      const protectedRects = this.protectedRects(element, rect, nestedCards);
 
       const path = this.fragmentPath(
         rect,
@@ -481,10 +486,55 @@ export default class extends Controller {
         excludedRects,
         surface.card,
       );
-      surface.path.setAttribute("d", path);
+      if (surface.lastPath !== path) {
+        surface.path.setAttribute("d", path);
+        surface.lastPath = path;
+      }
       if (this.level > 0.82) this.drawDamagedText(element, rect, path, surface);
     }
     if (emit && !this.reducedMotion.matches) this.emitDust(8);
+    this.recordMaskCost(performance.now() - started);
+  }
+
+  recordMaskCost(milliseconds) {
+    this.maskCost =
+      this.maskCost == null
+        ? milliseconds
+        : this.maskCost * 0.8 + milliseconds * 0.2;
+    // Budget approximately a quarter of main-thread time for masks, with a
+    // ceiling so cursor repair remains responsive even on slower hardware.
+    this.maskInterval = clamp(this.maskCost * 4, 45, 160);
+  }
+
+  surfaceGeometry(element, surface, rect) {
+    const cached = surface.geometry;
+    if (
+      !this.dirty &&
+      cached &&
+      cached.revision === this.textRevision &&
+      ["left", "top", "width", "height"].every(
+        (key) => cached.rect[key] === rect[key],
+      )
+    )
+      return cached;
+
+    let layer = element;
+    while (layer.parentElement && getComputedStyle(layer).zIndex === "auto")
+      layer = layer.parentElement;
+    surface.layerIndex = getComputedStyle(layer).zIndex;
+    const nestedCards = surface.card
+      ? []
+      : [...element.querySelectorAll(CARD_SURFACES)];
+    // Parent layers leave each card to its own mask, avoiding double erosion.
+    return (surface.geometry = {
+      rect,
+      revision: this.textRevision,
+      seed: (Number.parseInt(surface.layerIndex, 10) || 0) + surface.seed,
+      excludedRects: nestedCards.map((card) =>
+        this.localRect(card.getBoundingClientRect(), rect, 12),
+      ),
+      protectedRects: this.protectedRects(element, rect, nestedCards),
+    });
   }
 
   localRect(rect, surfaceRect, padding = 5) {
@@ -680,7 +730,7 @@ export default class extends Controller {
     return cells;
   }
 
-  fragmentPath(
+  fragmentField(
     rect,
     size,
     seed,
@@ -688,9 +738,23 @@ export default class extends Controller {
     excludedRects = [],
     card = true,
   ) {
-    const holes = [];
-    for (const cell of this.fragmentCells(rect, size, seed)) {
-      const { cx, cy, vertices, bounds } = cell;
+    const cells = this.fragmentCells(rect, size, seed);
+    this.fragmentFields ||= new Map();
+    const cached = this.fragmentFields.get(seed);
+    if (
+      cached &&
+      cached.cells === cells &&
+      cached.width === rect.width &&
+      cached.height === rect.height &&
+      cached.size === size &&
+      cached.card === card &&
+      cached.protectedRects === protectedRects &&
+      cached.excludedRects === excludedRects
+    )
+      return cached.field;
+    const field = [];
+    for (const cell of cells) {
+      const { cx, cy, bounds } = cell;
       const x = cx / size;
       const y = cy / size;
       // Clustered erosion with the original irregular fragment boundaries.
@@ -747,14 +811,52 @@ export default class extends Controller {
           : protectedContent
             ? textThreshold
             : Math.min(edgeThreshold, backgroundThreshold);
+      field.push({ cell, start });
+    }
+    this.fragmentFields.set(seed, {
+      cells,
+      width: rect.width,
+      height: rect.height,
+      size,
+      card,
+      protectedRects,
+      excludedRects,
+      field,
+    });
+    return field;
+  }
+
+  fragmentPath(
+    rect,
+    size,
+    seed,
+    protectedRects = [],
+    excludedRects = [],
+    card = true,
+  ) {
+    const holes = [];
+    for (const entry of this.fragmentField(
+      rect,
+      size,
+      seed,
+      protectedRects,
+      excludedRects,
+      card,
+    )) {
+      const { cell, start } = entry;
+      const { cx, cy, vertices } = cell;
       let erosion = clamp((this.level - start) / 0.07);
       erosion *= 1 - this.repairStrength(cell, rect);
       if (!erosion) continue;
-      const polygon = vertices.map(
-        ([px, py]) =>
-          `${(cx + (px - cx) * erosion).toFixed(1)},${(cy + (py - cy) * erosion).toFixed(1)}`,
-      );
-      holes.push(`M${polygon.join("L")}Z`);
+      if (entry.erosion !== erosion) {
+        const polygon = vertices.map(
+          ([px, py]) =>
+            `${(cx + (px - cx) * erosion).toFixed(1)},${(cy + (py - cy) * erosion).toFixed(1)}`,
+        );
+        entry.path = `M${polygon.join("L")}Z`;
+        entry.erosion = erosion;
+      }
+      holes.push(entry.path);
       const viewportX = cx + rect.left;
       const viewportY = cy + rect.top;
       if (
@@ -896,6 +998,7 @@ export default class extends Controller {
     this.pointer = null;
     this.repairActive = false;
     this.repairDirty = false;
+    this.maskDirty = false;
     for (const [element, surface] of this.surfaces) {
       if (surface.original)
         element.style.setProperty(
@@ -911,6 +1014,7 @@ export default class extends Controller {
     this.surfaceResize?.disconnect();
     this.surfaces.clear();
     this.fragmentMeshes?.clear();
+    this.fragmentFields?.clear();
     this.canvasContext.clearRect(0, 0, this.width, this.height);
     this.textTarget.replaceChildren();
   }
diff --git a/test/javascript/blackhole_options_test.mjs b/test/javascript/blackhole_options_test.mjs
index 4bc364d38..4650bd0a9 100644
--- a/test/javascript/blackhole_options_test.mjs
+++ b/test/javascript/blackhole_options_test.mjs
@@ -266,6 +266,7 @@ test("cursor repair removes nearby holes, including at full destruction", () =>
     const controller = {
       level,
       fragmentCells: () => [cell],
+      fragmentField: BlackholeController.prototype.fragmentField,
       repairStrength: () => 1,
       fringe: [],
       width: 100,
diff --git a/test/javascript/blackhole_performance_test.mjs b/test/javascript/blackhole_performance_test.mjs
new file mode 100644
index 000000000..9c4780e94
--- /dev/null
+++ b/test/javascript/blackhole_performance_test.mjs
@@ -0,0 +1,170 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import BlackholeController from "../../app/javascript/controllers/blackhole_controller.js";
+
+const rect = { left: 0, top: 0, width: 900, height: 600 };
+const areas = Array.from({ length: 40 }, (_, i) => ({
+  left: 30,
+  right: 650,
+  top: 30 + i * 13,
+  bottom: 40 + i * 13,
+  kind: "text",
+}));
+
+function controller() {
+  return Object.assign(Object.create(BlackholeController.prototype), {
+    width: 1200,
+    height: 800,
+    level: 0.64,
+    fringe: [],
+    pointer: null,
+    repairRadius: 145,
+    repairTime: 0,
+    reducedMotion: { matches: false },
+  });
+}
+
+test("cached masks exactly preserve the previous staged decay pattern", () => {
+  const c = controller();
+  const excluded = [];
+  // Captured from the pre-optimization implementation at three decay stages.
+  for (const [level, hash] of [
+    [0.25, "0178e138849a80bf5691bdea97c257ddb98cd6b8fb27fc7756ef74cf94cd0a81"],
+    [0.64, "f3e47170fce97f8ee9e5395e7da2332ce051dcb81d7651e48d7382f47f91d61e"],
+    [0.9, "aa8837cc32cde70850d56d33c79423aa65694649a847f4dff494f65eb318a9d2"],
+  ]) {
+    c.level = level;
+    const path = c.fragmentPath(rect, 9, 31, areas, excluded);
+    assert.equal(createHash("sha256").update(path).digest("hex"), hash);
+    const field = c.fragmentFields.get(31).field;
+    assert.equal(c.fragmentPath(rect, 9, 31, areas, excluded), path);
+    assert.equal(c.fragmentFields.get(31).field, field);
+  }
+});
+
+test("fragment fields invalidate when geometry, protected content, or exclusions change", () => {
+  const c = controller();
+  const excluded = [];
+  const field = c.fragmentField(rect, 9, 31, areas, excluded);
+  assert.notEqual(
+    c.fragmentField({ ...rect, width: 800 }, 9, 31, areas, excluded),
+    field,
+  );
+  const resized = c.fragmentFields.get(31).field;
+  assert.notEqual(
+    c.fragmentField({ ...rect, width: 800 }, 9, 31, [...areas], excluded),
+    resized,
+  );
+  const allExcluded = [{ left: -100, top: -100, right: 1000, bottom: 700 }];
+  assert.deepEqual(c.fragmentField(rect, 9, 31, areas, allExcluded), []);
+});
+
+test("cursor repairs and subsequent decay remain live on cached fields", () => {
+  const c = controller();
+  c.level = 0.9;
+  const excluded = [];
+  const damaged = c.fragmentPath(rect, 9, 31, areas, excluded);
+  const field = c.fragmentFields.get(31).field;
+  c.pointer = { x: 300, y: 200 };
+  c.repairTime = 50;
+  assert.notEqual(c.fragmentPath(rect, 9, 31, areas, excluded), damaged);
+  assert.equal(c.fragmentFields.get(31).field, field);
+  c.pointer = null;
+  c.repairTime = 10000;
+  assert.equal(c.fragmentPath(rect, 9, 31, areas, excluded), damaged);
+});
+
+test("cursor-only changes reuse text measurements but scrolling and mutations invalidate them", () => {
+  const previousStyle = globalThis.getComputedStyle;
+  globalThis.getComputedStyle = () => ({ zIndex: "5" });
+  try {
+    const c = controller();
+    let reads = 0;
+    c.textRevision = 1;
+    c.protectedRects = () => {
+      reads++;
+      return [];
+    };
+    const element = {};
+    const surface = { card: true, seed: 1 };
+    const initial = c.surfaceGeometry(element, surface, rect);
+    assert.equal(c.surfaceGeometry(element, surface, { ...rect }), initial);
+    assert.equal(reads, 1);
+    c.surfaceGeometry(element, surface, { ...rect, top: -20 });
+    assert.equal(reads, 2);
+    c.dirty = true;
+    c.surfaceGeometry(element, surface, { ...rect, top: -20 });
+    assert.equal(reads, 3);
+    c.dirty = false;
+    c.textRevision++;
+    c.surfaceGeometry(element, surface, { ...rect, top: -20 });
+    assert.equal(reads, 4);
+  } finally {
+    if (previousStyle) globalThis.getComputedStyle = previousStyle;
+    else delete globalThis.getComputedStyle;
+  }
+});
+
+test("slow masks lower their update rate and recover when work becomes cheaper", () => {
+  const c = controller();
+  c.recordMaskCost(100);
+  assert.equal(c.maskInterval, 160);
+  for (let i = 0; i < 30; i++) c.recordMaskCost(1);
+  assert.equal(c.maskInterval, 45);
+});
+
+test("throttled dirty masks keep scheduling until the final state is painted", () => {
+  let cuts = 0;
+  let wakes = 0;
+  const c = {
+    level: 0.25,
+    requested: 0.25,
+    lastTime: 100,
+    lastMask: 100,
+    maskInterval: 100,
+    dirty: true,
+    particles: [],
+    reducedMotion: { matches: false },
+    cutSurfaces() {
+      cuts++;
+    },
+    emitAmbientDust() {},
+    draw() {},
+    wake() {
+      wakes++;
+    },
+  };
+  BlackholeController.prototype.tick.call(c, 110);
+  assert.equal(cuts, 0);
+  assert.equal(wakes, 1);
+  BlackholeController.prototype.tick.call(c, 140);
+  assert.equal(cuts, 0);
+  assert.equal(wakes, 2);
+  BlackholeController.prototype.tick.call(c, 210);
+  assert.equal(cuts, 1);
+  assert.equal(c.dirty, false);
+  assert.equal(wakes, 2);
+});
+
+test("reduced motion paints dirty masks immediately without needing another animation frame", () => {
+  let cuts = 0;
+  const c = {
+    level: 0.25,
+    requested: 0.25,
+    lastMask: 100,
+    lastTime: 100,
+    maskInterval: 160,
+    dirty: true,
+    particles: [],
+    reducedMotion: { matches: true },
+    cutSurfaces() {
+      cuts++;
+    },
+    emitAmbientDust() {},
+    draw() {},
+    wake() {},
+  };
+  BlackholeController.prototype.tick.call(c, 110);
+  assert.equal(cuts, 1);
+});

From 26271e8475330078abc0215a36cd99746a14c982 Mon Sep 17 00:00:00 2001
From: mikidoodle <mihir@pidgon.com>
Date: Sat, 26 Sep 2026 16:48:36 -0400
Subject: [PATCH 6/9] Fix disintegration text and mask scroll alignment

---
 .../components/_blackhole_preview.scss        |  15 ++-
 .../controllers/blackhole_controller.js       |  68 ++++++++--
 .../javascript/blackhole_performance_test.mjs | 126 +++++++++++++++++-
 3 files changed, 194 insertions(+), 15 deletions(-)

diff --git a/app/assets/stylesheets/components/_blackhole_preview.scss b/app/assets/stylesheets/components/_blackhole_preview.scss
index 8bb6a4a9a..9818923b5 100644
--- a/app/assets/stylesheets/components/_blackhole_preview.scss
+++ b/app/assets/stylesheets/components/_blackhole_preview.scss
@@ -79,7 +79,14 @@
   }
 
   &__text {
-    display: contents;
+    // An untransformed document-space origin: scrolling text copies move with
+    // the browser's scroll layer instead of chasing it through animation frames.
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 0;
+    height: 0;
+    pointer-events: none;
   }
 
   &__text[hidden] {
@@ -87,7 +94,7 @@
   }
 
   &__text-copy {
-    position: fixed !important;
+    position: absolute !important;
     right: auto !important;
     bottom: auto !important;
     margin: 0 !important;
@@ -95,6 +102,10 @@
     transform: none !important;
     max-width: none !important;
     max-height: none !important;
+
+    &--fixed {
+      position: fixed !important;
+    }
   }
 
   &__text-copy[hidden] {
diff --git a/app/javascript/controllers/blackhole_controller.js b/app/javascript/controllers/blackhole_controller.js
index cbe89d7e7..719c506e3 100644
--- a/app/javascript/controllers/blackhole_controller.js
+++ b/app/javascript/controllers/blackhole_controller.js
@@ -89,7 +89,12 @@ export default class extends Controller {
       this.dirty = true;
       this.wake();
     };
-    this.onScroll = this.invalidate;
+    this.onScroll = (event) => {
+      // Mirroring an inner scroller must not trigger another mask rebuild.
+      if (this.element.contains(event.target)) return;
+      this.syncDamagedText();
+      this.invalidate();
+    };
     this.onPointerMove = (event) => {
       if (!this.requested || event.pointerType === "touch") return;
       this.pointer = { x: event.clientX, y: event.clientY };
@@ -336,7 +341,9 @@ export default class extends Controller {
     this.frame = null;
     // Slow mask generation also puts dust on a 30fps budget. Keep scheduling
     // repairs even when a frame is skipped or particles are disabled.
+    // Scroll/layout invalidations must follow the page on the very next frame.
     if (
+      !this.dirty &&
       !this.reducedMotion.matches &&
       this.maskInterval > 60 &&
       this.lastTime &&
@@ -356,7 +363,8 @@ export default class extends Controller {
     if (this.level !== previous) this.maskDirty = true;
     if (
       (this.dirty || this.repairActive || this.repairDirty || this.maskDirty) &&
-      (this.reducedMotion.matches ||
+      (this.dirty ||
+        this.reducedMotion.matches ||
         time - (this.lastMask || 0) >= (this.maskInterval || 45))
     ) {
       this.cutSurfaces(this.level > previous);
@@ -529,6 +537,7 @@ export default class extends Controller {
     return (surface.geometry = {
       rect,
       revision: this.textRevision,
+      viewportText: this.textFollowsViewport(element),
       seed: (Number.parseInt(surface.layerIndex, 10) || 0) + surface.seed,
       excludedRects: nestedCards.map((card) =>
         this.localRect(card.getBoundingClientRect(), rect, 12),
@@ -652,18 +661,11 @@ export default class extends Controller {
     }
     const copy = surface.textCopy;
     copy.hidden = false;
-    copy.style.left = `${rect.left}px`;
-    copy.style.top = `${rect.top}px`;
+    this.positionDamagedText(element, surface, rect);
     copy.style.width = `${rect.width}px`;
     copy.style.height = `${rect.height}px`;
     copy.style.zIndex = surface.layerIndex;
     copy.style.clipPath = `url(#${surface.textClip.id})`;
-    copy.scrollTop = element.scrollTop;
-    copy.scrollLeft = element.scrollLeft;
-    for (const [original, clone] of surface.scrollCopies) {
-      clone.scrollTop = original.scrollTop;
-      clone.scrollLeft = original.scrollLeft;
-    }
     // The complementary path paints off-white glyphs only inside actual holes.
     surface.textPath.setAttribute(
       "d",
@@ -673,6 +675,52 @@ export default class extends Controller {
     );
   }
 
+  textFollowsViewport(element) {
+    for (let ancestor = element; ancestor; ancestor = ancestor.parentElement) {
+      if (["fixed", "sticky"].includes(getComputedStyle(ancestor).position))
+        return true;
+    }
+    return false;
+  }
+
+  positionDamagedText(
+    element,
+    surface,
+    rect,
+    origin = this.textTarget.getBoundingClientRect(),
+  ) {
+    const copy = surface.textCopy;
+    const fixed = surface.geometry.viewportText;
+    copy.classList.toggle("blackhole__text-copy--fixed", fixed);
+    // Ordinary copies share document scrolling with the original. Only fixed
+    // and sticky UI uses viewport coordinates (including descendants of it).
+    copy.style.left = `${rect.left - (fixed ? 0 : origin.left)}px`;
+    copy.style.top = `${rect.top - (fixed ? 0 : origin.top)}px`;
+    copy.scrollTop = element.scrollTop;
+    copy.scrollLeft = element.scrollLeft;
+    for (const [original, clone] of surface.scrollCopies) {
+      clone.scrollTop = original.scrollTop;
+      clone.scrollLeft = original.scrollLeft;
+    }
+  }
+
+  syncDamagedText() {
+    if (this.textTarget.hidden) return;
+    const origin = this.textTarget.getBoundingClientRect();
+    // Sticky transitions and nested scrollers need a cheap position update,
+    // not a full Voronoi rebuild, before the next mask-animation frame.
+    for (const [element, surface] of this.surfaces) {
+      if (!surface.textCopy || surface.textCopy.hidden || !element.isConnected)
+        continue;
+      this.positionDamagedText(
+        element,
+        surface,
+        element.getBoundingClientRect(),
+        origin,
+      );
+    }
+  }
+
   fragmentCells(rect, size, seed) {
     // Deterministic sites with a wide guard band keep the same Voronoi cells
     // when scrolling. Cache the mesh while only intensity is changing.
diff --git a/test/javascript/blackhole_performance_test.mjs b/test/javascript/blackhole_performance_test.mjs
index 9c4780e94..54d738b18 100644
--- a/test/javascript/blackhole_performance_test.mjs
+++ b/test/javascript/blackhole_performance_test.mjs
@@ -114,7 +114,7 @@ test("slow masks lower their update rate and recover when work becomes cheaper",
   assert.equal(c.maskInterval, 45);
 });
 
-test("throttled dirty masks keep scheduling until the final state is painted", () => {
+test("throttled animation masks keep scheduling until the final state is painted", () => {
   let cuts = 0;
   let wakes = 0;
   const c = {
@@ -123,7 +123,7 @@ test("throttled dirty masks keep scheduling until the final state is painted", (
     lastTime: 100,
     lastMask: 100,
     maskInterval: 100,
-    dirty: true,
+    maskDirty: true,
     particles: [],
     reducedMotion: { matches: false },
     cutSurfaces() {
@@ -143,10 +143,41 @@ test("throttled dirty masks keep scheduling until the final state is painted", (
   assert.equal(wakes, 2);
   BlackholeController.prototype.tick.call(c, 210);
   assert.equal(cuts, 1);
-  assert.equal(c.dirty, false);
+  assert.equal(c.maskDirty, false);
   assert.equal(wakes, 2);
 });
 
+test("scroll and layout invalidations bypass both throttles even on slow machines", () => {
+  let cuts = 0;
+  const c = {
+    level: 0.9,
+    requested: 0.9,
+    lastTime: 100,
+    lastMask: 100,
+    maskInterval: 160,
+    dirty: true,
+    particles: [],
+    reducedMotion: { matches: false },
+    cutSurfaces() {
+      cuts++;
+    },
+    emitAmbientDust() {},
+    draw() {},
+    wake() {},
+  };
+  for (const time of [110, 120, 130]) {
+    c.dirty = true;
+    BlackholeController.prototype.tick.call(c, time);
+    assert.equal(
+      c.lastMask,
+      time,
+      "scroll masks must track each new viewport position",
+    );
+    assert.equal(c.dirty, false);
+  }
+  assert.equal(cuts, 3);
+});
+
 test("reduced motion paints dirty masks immediately without needing another animation frame", () => {
   let cuts = 0;
   const c = {
@@ -168,3 +199,92 @@ test("reduced motion paints dirty masks immediately without needing another anim
   BlackholeController.prototype.tick.call(c, 110);
   assert.equal(cuts, 1);
 });
+
+test("page text retains document coordinates across vertical and horizontal scrolling", () => {
+  const c = controller();
+  const copy = {
+    style: {},
+    classList: {
+      toggle(name, fixed) {
+        assert.equal(fixed, false);
+      },
+    },
+  };
+  const element = { scrollTop: 0, scrollLeft: 0 };
+  const surface = {
+    textCopy: copy,
+    geometry: { viewportText: false },
+    scrollCopies: [],
+  };
+  c.positionDamagedText(
+    element,
+    surface,
+    { left: 200, top: 600 },
+    { left: 0, top: 0 },
+  );
+  assert.equal(copy.style.top, "600px");
+  assert.equal(copy.style.left, "200px");
+  c.positionDamagedText(
+    element,
+    surface,
+    { left: 120, top: 100 },
+    { left: -80, top: -500 },
+  );
+  assert.equal(
+    copy.style.top,
+    "600px",
+    "native scrolling moves the copy, not a delayed top update",
+  );
+  assert.equal(copy.style.left, "200px");
+});
+
+test("fixed sidebar text stays viewport anchored and nested scroll offsets are mirrored", () => {
+  const c = controller();
+  const copy = {
+    style: {},
+    classList: {
+      toggle(name, fixed) {
+        assert.equal(fixed, true);
+      },
+    },
+  };
+  const original = { scrollTop: 45, scrollLeft: 12 };
+  const clone = {};
+  const surface = {
+    textCopy: copy,
+    geometry: { viewportText: true },
+    scrollCopies: [[original, clone]],
+  };
+  c.positionDamagedText(
+    original,
+    surface,
+    { left: 20, top: 300 },
+    { left: -80, top: -500 },
+  );
+  assert.equal(copy.style.top, "300px");
+  assert.equal(copy.style.left, "20px");
+  assert.equal(copy.scrollTop, 45);
+  assert.equal(clone.scrollTop, 45);
+  assert.equal(clone.scrollLeft, 12);
+});
+
+test("viewport anchoring includes fixed and sticky ancestors, not ordinary page text", () => {
+  const previousStyle = globalThis.getComputedStyle;
+  globalThis.getComputedStyle = (element) => ({ position: element.position });
+  try {
+    const c = controller();
+    for (const position of ["fixed", "sticky", "relative", "static"]) {
+      const element = {
+        position: "static",
+        parentElement: { position, parentElement: null },
+      };
+      assert.equal(
+        c.textFollowsViewport(element),
+        ["fixed", "sticky"].includes(position),
+      );
+    }
+  } finally {
+    if (previousStyle) globalThis.getComputedStyle = previousStyle;
+    else delete globalThis.getComputedStyle;
+  }
+});

From 0472d3cd4f310b884372ac632634bebe224f7917 Mon Sep 17 00:00:00 2001
From: mikidoodle <mihir@pidgon.com>
Date: Sat, 26 Sep 2026 20:02:51 -0400
Subject: [PATCH 7/9] Improve disintegration scroll caching and add performance
 benchmarks

---
 .../controllers/blackhole_controller.js       |  79 ++++++-
 docs/disintegration-performance.md            | 170 ++++++++++++++
 script/benchmark_disintegration.compose.yml   |   8 +
 script/benchmark_disintegration.mjs           | 207 ++++++++++++++++++
 .../javascript/blackhole_performance_test.mjs | 169 ++++++++++++++
 5 files changed, 621 insertions(+), 12 deletions(-)
 create mode 100644 docs/disintegration-performance.md
 create mode 100644 script/benchmark_disintegration.compose.yml
 create mode 100644 script/benchmark_disintegration.mjs

diff --git a/app/javascript/controllers/blackhole_controller.js b/app/javascript/controllers/blackhole_controller.js
index dd3128f17..22d63804d 100644
--- a/app/javascript/controllers/blackhole_controller.js
+++ b/app/javascript/controllers/blackhole_controller.js
@@ -16,6 +16,7 @@ const PROTECTED_CONTENT =
   "a:not(.feed-post-card__overlay-link), button, input, textarea, select, summary, img, video, iframe, svg, [role='progressbar'], [role='meter'], [contenteditable]";
 const SVG_NS = "http://www.w3.org/2000/svg";
 const SIMULATOR_KEY = "stardance-event-simulator-v1";
+const MESH_OVERSCAN = 128;
 const clamp = (n, min = 0, max = 1) => Math.min(max, Math.max(min, n));
 const random = (x, y, seed = 0) => {
   const value = Math.sin(x * 127.1 + y * 311.7 + seed * 74.7) * 43758.5453;
@@ -539,13 +540,33 @@ export default class extends Controller {
       revision: this.textRevision,
       viewportText: this.textFollowsViewport(element),
       seed: (Number.parseInt(surface.layerIndex, 10) || 0) + surface.seed,
-      excludedRects: nestedCards.map((card) =>
-        this.localRect(card.getBoundingClientRect(), rect, 12),
+      excludedRects: this.reuseRects(
+        cached?.excludedRects,
+        nestedCards.map((card) =>
+          this.localRect(card.getBoundingClientRect(), rect, 12),
+        ),
+      ),
+      protectedRects: this.reuseRects(
+        cached?.protectedRects,
+        this.protectedRects(element, rect, nestedCards),
       ),
-      protectedRects: this.protectedRects(element, rect, nestedCards),
     });
   }
 
+  reuseRects(previous, current) {
+    // Scrolling changes viewport coordinates, not necessarily local geometry.
+    // Keep field-cache identity when the freshly measured content is unchanged;
+    // sticky children, inner scrolling, and reflow still invalidate immediately.
+    return previous?.length === current.length &&
+      current.every((area, index) =>
+        ["left", "right", "top", "bottom", "kind"].every(
+          (key) => area[key] === previous[index][key],
+        ),
+      )
+      ? previous
+      : current;
+  }
+
   localRect(rect, surfaceRect, padding = 5) {
     return {
       left: rect.left - surfaceRect.left - padding,
@@ -722,19 +743,44 @@ export default class extends Controller {
   }
 
   fragmentCells(rect, size, seed) {
-    // Deterministic sites with a wide guard band keep the same Voronoi cells
-    // when scrolling. Cache the mesh while only intensity is changing.
-    const left = Math.floor(Math.max(-rect.left, -size) / size) - 1;
-    const right =
+    // Keep a bounded overscan strip so small scrolls do not retriangulate the
+    // same card every nine pixels. Sites remain anchored to local coordinates.
+    let left = Math.floor(Math.max(-rect.left, -size) / size) - 1;
+    let right =
       Math.ceil(Math.min(this.width - rect.left, rect.width + size) / size) + 1;
-    const top = Math.floor(Math.max(-rect.top, -size) / size) - 1;
-    const bottom =
+    let top = Math.floor(Math.max(-rect.top, -size) / size) - 1;
+    let bottom =
       Math.ceil(Math.min(this.height - rect.top, rect.height + size) / size) +
       1;
-    const key = `${left}:${right}:${top}:${bottom}:${size}`;
     this.fragmentMeshes ||= new Map();
     const cached = this.fragmentMeshes.get(seed);
-    if (cached?.key === key) return cached.cells;
+    if (
+      cached &&
+      cached.size === size &&
+      cached.width === rect.width &&
+      cached.height === rect.height &&
+      cached.left <= left &&
+      cached.right >= right &&
+      cached.top <= top &&
+      cached.bottom >= bottom
+    )
+      return cached.cells;
+    const overscanLeft =
+      rect.left < 0 ? Math.max(0, -rect.left - MESH_OVERSCAN) : -rect.left;
+    left = Math.floor(Math.max(overscanLeft, -size) / size) - 1;
+    right =
+      Math.ceil(
+        Math.min(this.width - rect.left + MESH_OVERSCAN, rect.width + size) /
+          size,
+      ) + 1;
+    const overscanTop =
+      rect.top < 0 ? Math.max(0, -rect.top - MESH_OVERSCAN) : -rect.top;
+    top = Math.floor(Math.max(overscanTop, -size) / size) - 1;
+    bottom =
+      Math.ceil(
+        Math.min(this.height - rect.top + MESH_OVERSCAN, rect.height + size) /
+          size,
+      ) + 1;
     const sites = [];
     for (let y = top - 4; y <= bottom + 4; y++) {
       for (let x = left - 4; x <= right + 4; x++) {
@@ -774,7 +820,16 @@ export default class extends Controller {
         },
       });
     });
-    this.fragmentMeshes.set(seed, { key, cells });
+    this.fragmentMeshes.set(seed, {
+      left,
+      right,
+      top,
+      bottom,
+      size,
+      width: rect.width,
+      height: rect.height,
+      cells,
+    });
     return cells;
   }
 
diff --git a/docs/disintegration-performance.md b/docs/disintegration-performance.md
new file mode 100644
index 000000000..a1817cbfe
--- /dev/null
+++ b/docs/disintegration-performance.md
@@ -0,0 +1,170 @@
+# Disintegration performance comparison — September 26, 2026
+
+## Scope and method
+
+Compared the actual `fragmentPath` implementation in three revisions:
+
+- **Main:** `3045af69de136b00e89daf1ef5ac8193add87c06`.
+- **Previous performance version:** `535cb819927a9265ed386333e9c86a892afd8795`.
+- **New:** working-tree renderer with local-rectangle reuse and a 128px mesh overscan margin (source SHA-256 `19b14ba7a8f91ba24e781db99153bf222cb8348d886014c59d6d9b60b574a29c`).
+
+Node 22 in isolated OrbStack Docker containers. Revisions run sequentially,
+in a fresh process, using these CPU/RAM limits: 1 CPU/512 MiB,
+0.5 CPU/256 MiB, and 0.25 CPU/192 MiB. Swap is capped at the memory limit.
+The running Rails server and user's browser resource limits are unchanged.
+
+Each scenario has three trials of 48 measured updates, plus one separately
+measured cold build per trial. There is a small implementation warm-up before
+testing. Caches start empty for every trial. The harness uses real controller
+methods, deterministic geometry, and simulated text measurements. It does not
+replace the renderer with a simplified implementation.
+
+Scenarios: stationary card, moving cursor followed by repair decay, 25–94%
+damage transition, slow and fast tall-surface scrolling, scrolling and cursor
+repair on a Phantom-sized card, and a 1920×1080 text-heavy viewport. Slow scroll
+moves 10px per update; fast scroll moves 160px. Tall surfaces are 5000px high.
+The Phantom-sized surface is 310×480px. Most scenarios contain 40 text rectangles;
+the wide viewport contains 100. Grid size is 9px throughout.
+
+**These are rendering-math timings, not browser FPS measurements.** They exclude
+DOM measurement, SVG parsing/painting, layout, compositing, particle canvas draws,
+and the Phantom WebGL shader. Fractional Docker CPU quotas cause scheduling
+pauses; they do not emulate a specific low-end processor or GPU. A 16.7ms
+calculation already consumes an entire 60Hz frame budget before those other
+costs, but a faster calculation alone cannot establish a smooth frame rate.
+
+`trialTotalMs / 48` includes rebuilds in the average update cost. Median timings
+alone hide the expensive cache-boundary updates. Cold costs are reported
+separately. Run order is fixed, not randomized; three trials are useful for
+diagnosis, not a statistically controlled hardware certification.
+
+## Reproduce
+
+From the repository root, choose an unused service port and an existing absolute
+output directory. For example:
+
+```sh
+BENCH_RESULTS_DIR=/absolute/path/to/results \
+BENCH_CPUS=0.25 BENCH_MEMORY=192m STARDANCE_PORT=3003 \
+docker compose -f docker-compose.yml \
+  -f script/benchmark_disintegration.compose.yml \
+  run --rm --no-deps --service-ports --entrypoint node web \
+  --expose-gc script/benchmark_disintegration.mjs working \
+  /benchmark-results/quartercpu-working.json
+```
+
+Replace `working` with either commit above to compare a baseline. Repeat with
+the other CPU/RAM profiles. An optional third argument selects comma-separated
+scenario names (for example `steady-card,slow-scroll,fast-scroll,phantom-scroll`).
+The JSON includes controller source hashes, timing
+distributions, mesh-build counts, process peak RSS, cgroup peak memory, and actual
+CPU throttle and OOM counters. No database writes, feature-flag changes, source
+checkout changes, or production connections are involved.
+
+## Findings
+
+### One CPU / 512 MiB
+
+Milliseconds per update, using the median of the three trial averages. Unlike
+the per-update median, this includes the cost of mesh rebuilds during scrolling.
+
+| Scenario                    |   Main | Previous performance |   New |
+| --------------------------- | -----: | -------------------: | ----: |
+| Stationary card             |   7.47 |                 0.42 |  0.29 |
+| Cursor repair, 94% damage   |  15.73 |                 4.71 |  4.63 |
+| Damage transition           |   8.20 |                 1.92 |  1.98 |
+| Slow tall-surface scroll    |  56.01 |                62.74 |  8.33 |
+| Fast tall-surface scroll    |  61.66 |                68.30 | 89.99 |
+| Phantom-sized card scroll   |   4.44 |                 4.49 |  0.08 |
+| Phantom-sized cursor repair |   5.45 |                 2.50 |  2.19 |
+| Wide text-heavy scroll      | 170.96 |               177.64 | 24.96 |
+
+The slow-scroll improvement is about **6.7×**, including rebuild costs; the wide
+case improves about **6.8×**. Mesh construction drops from 49 to 4 builds per
+trial. The Phantom-sized scrolling card drops from 11 builds to 1.
+
+**Fast scrolling regresses about 46% versus main.** A 160px movement usually
+outruns the 128px overscan margin, rebuilding a larger mesh on 45 of 49 updates.
+For the tall surface, the largest mesh grows from 9,476 to 12,463 cells. The new
+cache is effective for small movements but pays extra work when it misses.
+
+**Tail latency remains a problem.** Slow-scroll p95 rises from 86ms to 104ms,
+despite the much lower average. Wide-scroll p95 rises from 203ms to 234ms. New
+wide-scroll cold builds have a 282ms median. These long main-thread operations
+can still cause visible stalls on slower machines.
+
+The largest generated SVG path in the wide case grows from approximately 1.74MB
+to 2.12MB. Browser parsing/painting of those paths is an additional cost absent
+from this benchmark. Lower JavaScript average cost does not establish that the
+full rendering pipeline is cheap.
+
+### Half CPU / 256 MiB: incomplete comparison
+
+Main and the previous performance version completed all scenarios. The new
+renderer completed four scenarios before the runtime stalled. Docker status
+queries and the local app health endpoint also stopped responding. The
+benchmark container was stopped; the local app and Docker then responded, with
+the health endpoint returning HTTP 200. The app and database containers were
+not restarted or reconfigured.
+
+The previous version's wide-scroll run contains a 38.8-second outlier. Its raw
+result is retained, but this profile should **not** be used as a clean comparative
+result. The cause of the runtime-wide stall is not established.
+
+### Quarter CPU / 192 MiB
+
+After the stalled run, the final profile was narrowed to four key scenarios
+on main and the new renderer. Both completed. Same units and aggregation as
+the one-CPU table:
+
+| Scenario                  |   Main |    New |
+| ------------------------- | -----: | -----: |
+| Stationary card           |  50.00 |   2.19 |
+| Slow tall-surface scroll  | 389.29 |  57.91 |
+| Fast tall-surface scroll  | 408.67 | 697.73 |
+| Phantom-sized card scroll |  21.05 |   2.04 |
+
+Slow scrolling again improves **6.7×**, while fast scrolling regresses **71%**.
+Slow-scroll p95 is 611ms on main and 694ms on new; fast-scroll p95 is 694ms
+versus 1,092ms. The new fast-scroll cold-build median is 1,216ms. This is not
+a smooth low-end experience even though cached updates themselves are cheap.
+
+### Memory and verification
+
+Seven complete runs produced 48 scenario results and 6,912 measured updates,
+plus 144 cold-build samples. This excludes the stopped partial run. CPU quota
+and throttle counters in the JSON confirm that the limits were applied.
+
+Completed runs used roughly 103–138 MiB peak process RSS. All completed runs
+reported zero cgroup OOM/OOM-kill events, including the 192 MiB profile. This is
+one synthetic surface at a time, not the entire browser's footprint and not
+proof of long-session memory stability. The raw `retainedHeapMiB` field is only
+incremental post-GC heap growth; it is not a reliable standalone cache-size
+measurement. The harness now names that field `heapGrowthAfterGcMiB` explicitly.
+
+All **44 frontend regression tests passed**, including new diagonal scroll
+reversal/geometry checks and disconnected-surface cache cleanup. Existing tests
+cover deterministic visual output, scroll/text coordinates, cursor repair,
+reduced motion, particle opt-out, and Phantom render scheduling and quality.
+
+In the actual local browser, the populated home feed was checked at 94% damage,
+including page and nested discover-rail scrolling. Sampled text-copy coordinates
+matched their original elements (0px delta), the Phantom mask was active, and
+there were no browser console errors. Notifications navigation also worked.
+These are correctness/sanity observations, not high-speed scroll recordings or
+quantitative browser/GPU performance tests.
+
+### Interpretation and next steps
+
+Keep the cached geometry/field/path work: stationary interaction and small
+scroll updates benefit substantially. Do not call the low-spec work finished.
+The next target should be mesh rebuilding and SVG path size, especially during
+large scroll jumps and first paint. Options to test include motion-aware
+overscan, coarser geometry under sustained load, and moving mesh construction
+off the main thread. Preserve immediate cursor and scroll alignment; reintroducing
+an input/render FPS cap would not address the expensive rebuild itself.
+
+The Phantom measurements above concern its **disintegration mask**, not shader
+GPU execution. Its existing tests verify per-frame rendering, cached layout,
+reused uniform arrays, adaptive resolution, and offscreen/hidden suspension.
+No real GPU timing or throttled-browser FPS measurement was available here.
diff --git a/script/benchmark_disintegration.compose.yml b/script/benchmark_disintegration.compose.yml
new file mode 100644
index 000000000..9c8172553
--- /dev/null
+++ b/script/benchmark_disintegration.compose.yml
@@ -0,0 +1,8 @@
+# Opt-in limits for one-off benchmarks only. Do not use this override for bin/dev.
+services:
+  web:
+    cpus: "${BENCH_CPUS:-1}"
+    mem_limit: "${BENCH_MEMORY:-512m}"
+    memswap_limit: "${BENCH_MEMORY:-512m}"
+    volumes:
+      - "${BENCH_RESULTS_DIR:?Set a benchmark output directory}:/benchmark-results"
diff --git a/script/benchmark_disintegration.mjs b/script/benchmark_disintegration.mjs
new file mode 100644
index 000000000..b6242622c
--- /dev/null
+++ b/script/benchmark_disintegration.mjs
@@ -0,0 +1,207 @@
+// Rendering-math benchmark, not a browser FPS test. Run in an isolated,
+// resource-limited container; see docs/disintegration-performance.md.
+import { execFileSync } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+import { performance } from "node:perf_hooks";
+import { createHash } from "node:crypto";
+
+const [revision = "working", output, onlyScenario] = process.argv.slice(2);
+const file = "app/javascript/controllers/blackhole_controller.js";
+let source =
+  revision === "working"
+    ? readFileSync(file, "utf8")
+    : execFileSync(
+        "git",
+        ["-c", "safe.directory=/app", "show", `${revision}:${file}`],
+        { encoding: "utf8" },
+      );
+const sourceHash = createHash("sha256").update(source).digest("hex");
+for (const name of ["@hotwired/stimulus", "d3"])
+  source = source.replace(
+    JSON.stringify(name),
+    JSON.stringify(import.meta.resolve(name)),
+  );
+const Controller = (
+  await import(
+    `data:text/javascript;base64,${Buffer.from(source).toString("base64")}`
+  )
+).default;
+const frames = 48;
+const trials = 3;
+const scenarios = [
+  { name: "steady-card", width: 900, height: 600, level: 0.64 },
+  { name: "cursor-card", width: 900, height: 600, level: 0.94, cursor: true },
+  { name: "damage-transition", width: 900, height: 600, transition: true },
+  { name: "slow-scroll", width: 900, height: 5000, level: 0.64, scroll: 10 },
+  { name: "fast-scroll", width: 900, height: 5000, level: 0.94, scroll: 160 },
+  { name: "phantom-scroll", width: 310, height: 480, level: 0.64, scroll: 2 },
+  {
+    name: "phantom-cursor",
+    width: 310,
+    height: 480,
+    level: 0.94,
+    cursor: true,
+  },
+  {
+    name: "wide-text-scroll",
+    width: 1600,
+    height: 5000,
+    viewportWidth: 1920,
+    viewportHeight: 1080,
+    level: 0.94,
+    scroll: 10,
+    lines: 100,
+  },
+];
+const readCgroup = (name) => {
+  try {
+    return readFileSync(`/sys/fs/cgroup/${name}`, "utf8").trim();
+  } catch {
+    return null;
+  }
+};
+const percentile = (values, fraction) =>
+  [...values].sort((a, b) => a - b)[Math.ceil(values.length * fraction) - 1];
+const results = [];
+// Warm the implementation before recording; measured controllers still start
+// with empty caches, so cold-build cost remains a separate measured sample.
+const makeController = (scenario) =>
+  Object.assign(Object.create(Controller.prototype), {
+    width: scenario.viewportWidth || 1200,
+    height: scenario.viewportHeight || 800,
+    level: scenario.level ?? 0.64,
+    fringe: [],
+    pointer: null,
+    repairRadius: 145,
+    repairTime: 0,
+    reducedMotion: { matches: false },
+  });
+const warm = makeController({});
+for (let i = 0; i < 8; i++)
+  warm.fragmentPath({ left: 0, top: 0, width: 400, height: 300 }, 9, 7, [], []);
+const throttleBefore = readCgroup("cpu.stat");
+for (const scenario of scenarios) {
+  if (onlyScenario && !onlyScenario.split(",").includes(scenario.name))
+    continue;
+  const samples = [],
+    cold = [],
+    totals = [],
+    heap = [],
+    builds = [];
+  let maxCells = 0,
+    pathBytes = 0;
+  for (let trial = 0; trial < trials; trial++) {
+    global.gc?.();
+    const heapBefore = process.memoryUsage().heapUsed;
+    const c = makeController(scenario);
+    let previousAreas,
+      previousExcluded,
+      previousMesh,
+      meshBuilds = 0;
+    const frameTimes = [];
+    for (let frame = 0; frame <= frames; frame++) {
+      const offset = scenario.scroll
+        ? (frame * scenario.scroll) % Math.max(1, scenario.height - 100)
+        : 0;
+      const rect = {
+        left: 0,
+        top: -offset,
+        width: scenario.width,
+        height: scenario.height,
+      };
+      c.level = scenario.transition
+        ? 0.25 + (frame / frames) * 0.69
+        : scenario.level;
+      c.pointer =
+        scenario.cursor && frame < frames * 0.75
+          ? { x: 20 + ((frame * 17) % scenario.width), y: 150 }
+          : null;
+      c.repairTime = frame * 50;
+      c.fringe = [];
+      // A scroll refreshes DOM measurements in the real renderer. Stationary
+      // frames reuse them; newest renderer also reuses equal local rectangles.
+      let areas = previousAreas;
+      let excluded = previousExcluded;
+      if (!areas || scenario.scroll) {
+        areas = Array.from({ length: scenario.lines || 40 }, (_, i) => ({
+          left: 30,
+          right: scenario.width - 30,
+          top: 30 + i * 13,
+          bottom: 40 + i * 13,
+          kind: "text",
+        }));
+        excluded = [];
+      }
+      const start = performance.now();
+      if (c.reuseRects) {
+        areas = c.reuseRects(previousAreas, areas);
+        excluded = c.reuseRects(previousExcluded, excluded);
+      }
+      const path = c.fragmentPath(rect, 9, 31, areas, excluded);
+      const duration = performance.now() - start;
+      previousAreas = areas;
+      previousExcluded = excluded;
+      const mesh = c.fragmentMeshes?.get(31)?.cells;
+      if (mesh !== previousMesh) meshBuilds++;
+      previousMesh = mesh;
+      maxCells = Math.max(maxCells, mesh?.length || 0);
+      pathBytes = Math.max(pathBytes, path.length);
+      if (frame === 0) cold.push(duration);
+      else {
+        samples.push(duration);
+        frameTimes.push(duration);
+      }
+    }
+    totals.push(frameTimes.reduce((sum, value) => sum + value, 0));
+    builds.push(meshBuilds);
+    global.gc?.();
+    heap.push(
+      Math.max(0, process.memoryUsage().heapUsed - heapBefore) / 1048576,
+    );
+  }
+  const round = (n) => Number(n.toFixed(2));
+  results.push({
+    scenario: scenario.name,
+    samples: samples.length,
+    medianMs: round(percentile(samples, 0.5)),
+    p95Ms: round(percentile(samples, 0.95)),
+    maxMs: round(Math.max(...samples)),
+    coldMedianMs: round(percentile(cold, 0.5)),
+    trialTotalMs: totals.map(round),
+    meshBuilds: builds,
+    maxCells,
+    maxPathBytes: pathBytes,
+    // Incremental post-GC heap growth, not total cache size or a leak test.
+    heapGrowthAfterGcMiB: heap.map(round),
+    over16msPercent: round(
+      (100 * samples.filter((n) => n > 16.67).length) / samples.length,
+    ),
+    over50msPercent: round(
+      (100 * samples.filter((n) => n > 50).length) / samples.length,
+    ),
+  });
+  console.log(JSON.stringify(results.at(-1)));
+}
+const report = {
+  revision,
+  sourceHash,
+  node: process.version,
+  frames,
+  trials,
+  cpuMax: readCgroup("cpu.max"),
+  memoryMax: readCgroup("memory.max"),
+  memoryPeak: readCgroup("memory.peak"),
+  memoryEvents: readCgroup("memory.events"),
+  maxRssKiB: process.resourceUsage().maxRSS,
+  throttleBefore,
+  throttleAfter: readCgroup("cpu.stat"),
+  results,
+};
+if (output) writeFileSync(output, JSON.stringify(report, null, 2) + "\n");
+console.log(
+  JSON.stringify({
+    revision,
+    cpuMax: report.cpuMax,
+    maxRssKiB: report.maxRssKiB,
+  }),
+);
diff --git a/test/javascript/blackhole_performance_test.mjs b/test/javascript/blackhole_performance_test.mjs
index 54d738b18..e4aa34a55 100644
--- a/test/javascript/blackhole_performance_test.mjs
+++ b/test/javascript/blackhole_performance_test.mjs
@@ -60,6 +60,175 @@ test("fragment fields invalidate when geometry, protected content, or exclusions
   assert.deepEqual(c.fragmentField(rect, 9, 31, areas, allExcluded), []);
 });
 
+test("small scrolls reuse meshes, while large jumps and resizing rebuild them", () => {
+  const c = controller();
+  const tall = { ...rect, height: 5000 };
+  const initial = c.fragmentCells(tall, 9, 31);
+  for (let offset = 10; offset <= 120; offset += 10)
+    assert.equal(c.fragmentCells({ ...tall, top: -offset }, 9, 31), initial);
+  const jumped = c.fragmentCells({ ...tall, top: -600 }, 9, 31);
+  assert.notEqual(jumped, initial);
+  const resized = c.fragmentCells({ ...tall, top: -600, width: 800 }, 9, 31);
+  assert.notEqual(resized, jumped);
+  assert.ok(
+    resized.length < 20000,
+    "tall pages must not allocate a full-page mesh",
+  );
+});
+
+test("diagonal scroll reversals preserve visible polygons and keep one mesh per surface", () => {
+  const c = controller();
+  const normalize = (cells, rect) =>
+    cells
+      .filter(
+        ({ cx, cy }) =>
+          cx >= -rect.left &&
+          cx <= c.width - rect.left &&
+          cy >= -rect.top &&
+          cy <= c.height - rect.top,
+      )
+      .map(({ cx, cy, vertices }) => [
+        cx,
+        cy,
+        vertices.map((point) => point.map((n) => n.toFixed(6))).sort(),
+      ]);
+  for (const [left, top] of [
+    [-200, -300],
+    [-250, -350],
+    [-210, -310],
+    [-20, -30],
+    [-800, -1200],
+  ]) {
+    const rect = { left, top, width: 3000, height: 5000 };
+    const actual = normalize(c.fragmentCells(rect, 9, 31), rect);
+    const expected = normalize(controller().fragmentCells(rect, 9, 31), rect);
+    assert.equal(actual.length, expected.length);
+    for (let i = 0; i < actual.length; i++)
+      assert.deepEqual(actual[i], expected[i]);
+    assert.equal(c.fragmentMeshes.size, 1);
+  }
+});
+
+test("removed surfaces release their meshes, fields, and text copies", () => {
+  const previousDocument = globalThis.document;
+  globalThis.document = { querySelectorAll: () => [], body: { children: [] } };
+  try {
+    const c = controller();
+    let removed = 0,
+      unobserved = 0;
+    const element = { isConnected: false };
+    const removable = () => ({ remove: () => removed++ });
+    c.surfaces = new Map([
+      [
+        element,
+        {
+          geometry: { seed: 31 },
+          clip: removable(),
+          textClip: removable(),
+          textCopy: removable(),
+        },
+      ],
+    ]);
+    c.surfaceResize = { unobserve: () => unobserved++ };
+    c.fragmentMeshes = new Map([[31, {}]]);
+    c.fragmentFields = new Map([[31, {}]]);
+    c.collectSurfaces();
+    assert.equal(c.surfaces.size, 0);
+    assert.equal(c.fragmentMeshes.size, 0);
+    assert.equal(c.fragmentFields.size, 0);
+    assert.equal(removed, 3);
+    assert.equal(unobserved, 1);
+  } finally {
+    if (previousDocument === undefined) delete globalThis.document;
+    else globalThis.document = previousDocument;
+  }
+});
+
+test("scroll caching preserves visible polygon geometry without seams", () => {
+  const c = controller();
+  const tall = { ...rect, height: 5000 };
+  c.fragmentCells(tall, 9, 31);
+  for (const offset of [50, 120, 500, 650]) {
+    const scrolled = { ...tall, top: -offset };
+    const cached = c.fragmentCells(scrolled, 9, 31);
+    const fresh = controller().fragmentCells(scrolled, 9, 31);
+    const visible = (cells) =>
+      cells
+        .filter(
+          ({ cx, cy }) =>
+            cx >= 0 &&
+            cx <= rect.width &&
+            cy >= offset &&
+            cy <= offset + c.height,
+        )
+        .map(({ cx, cy, vertices }) => [
+          cx,
+          cy,
+          vertices.map((point) => point.map((n) => n.toFixed(6))).sort(),
+        ]);
+    const actual = visible(cached);
+    const expected = visible(fresh);
+    assert.equal(actual.length, expected.length);
+    for (let index = 0; index < actual.length; index++)
+      assert.deepEqual(actual[index], expected[index]);
+  }
+});
+
+test("scrolling a Phantom-sized card reuses its decay field but respects changed text bounds", () => {
+  const previousStyle = globalThis.getComputedStyle;
+  globalThis.getComputedStyle = () => ({ zIndex: "5", position: "relative" });
+  try {
+    const c = controller();
+    c.textRevision = 1;
+    c.dirty = true;
+    let textLeft = 20;
+    c.protectedRects = () => [
+      { left: textLeft, right: 280, top: 250, bottom: 300, kind: "text" },
+    ];
+    const element = {};
+    const surface = { card: true, seed: 31 };
+    const ad = { left: 850, top: 150, width: 310, height: 480 };
+    const geometry = c.surfaceGeometry(element, surface, ad);
+    const field = c.fragmentField(
+      ad,
+      9,
+      geometry.seed,
+      geometry.protectedRects,
+      geometry.excludedRects,
+    );
+    const scrolled = { ...ad, top: 50 };
+    const next = c.surfaceGeometry(element, surface, scrolled);
+    assert.equal(next.protectedRects, geometry.protectedRects);
+    assert.equal(next.excludedRects, geometry.excludedRects);
+    assert.equal(
+      c.fragmentField(
+        scrolled,
+        9,
+        next.seed,
+        next.protectedRects,
+        next.excludedRects,
+      ),
+      field,
+    );
+    textLeft = 30;
+    const changed = c.surfaceGeometry(element, surface, scrolled);
+    assert.notEqual(changed.protectedRects, next.protectedRects);
+    assert.notEqual(
+      c.fragmentField(
+        scrolled,
+        9,
+        changed.seed,
+        changed.protectedRects,
+        changed.excludedRects,
+      ),
+      field,
+    );
+  } finally {
+    if (previousStyle) globalThis.getComputedStyle = previousStyle;
+    else delete globalThis.getComputedStyle;
+  }
+});
+
 test("cursor repairs and subsequent decay remain live on cached fields", () => {
   const c = controller();
   c.level = 0.9;

From 0d3a98952afc24a2fee3ba67abcedf44373ef3e1 Mon Sep 17 00:00:00 2001
From: mikidoodle <mihir@pidgon.com>
Date: Sun, 27 Sep 2026 01:28:33 -0400
Subject: [PATCH 8/9] Add proportional logo decay and retire rocket progress
 bar

---
 app/assets/stylesheets/application.scss       |   1 -
 .../components/_buku_x3_status.scss           |   8 +-
 .../components/_rocket_progress.scss          | 221 ------------------
 .../buku_x3_status_component.html.erb         |  18 +-
 app/components/buku_x3_status_component.rb    |   8 +-
 .../rocket_progress_component.html.erb        |  39 ----
 app/components/rocket_progress_component.rb   |  46 ----
 .../controllers/blackhole_controller.js       |  17 +-
 app/views/home/index.html.erb                 |   7 +-
 .../buku_x3_status_component_test.rb          |  38 ++-
 .../rocket_progress_component_test.rb         |  45 ----
 .../buku_x3/reveals_controller_test.rb        |   6 +-
 test/controllers/home_controller_test.rb      |  28 +++
 test/javascript/blackhole_logo_test.mjs       | 100 ++++++++
 14 files changed, 203 insertions(+), 379 deletions(-)
 delete mode 100644 app/assets/stylesheets/components/_rocket_progress.scss
 delete mode 100644 app/components/rocket_progress_component.html.erb
 delete mode 100644 app/components/rocket_progress_component.rb
 delete mode 100644 test/components/rocket_progress_component_test.rb
 create mode 100644 test/javascript/blackhole_logo_test.mjs

diff --git a/app/assets/stylesheets/application.scss b/app/assets/stylesheets/application.scss
index 59fbbb292..5c817d9d7 100644
--- a/app/assets/stylesheets/application.scss
+++ b/app/assets/stylesheets/application.scss
@@ -69,7 +69,6 @@
 @use "components/vega_sprite";
 @use "components/visual_novel";
 @use "components/buku_x3_reveal";
-@use "components/rocket_progress";
 
 // Pages
 @use "pages/onboarding" as onboarding_pages;
diff --git a/app/assets/stylesheets/components/_buku_x3_status.scss b/app/assets/stylesheets/components/_buku_x3_status.scss
index 9fef34a39..06ca1376d 100644
--- a/app/assets/stylesheets/components/_buku_x3_status.scss
+++ b/app/assets/stylesheets/components/_buku_x3_status.scss
@@ -1,4 +1,6 @@
 .buku-x3-status {
+  --buku-team-color: var(--color-set-1-fg-secondary);
+
   position: relative;
   display: grid;
   align-items: center;
@@ -63,8 +65,8 @@
     }
   }
 
-  &[data-role-open],
-  &:has(&__toggle:focus-visible) {
+  &--interactive[data-role-open],
+  &--interactive:has(.buku-x3-status__toggle:focus-visible) {
     .buku-x3-status__identity {
       visibility: visible;
       opacity: 1;
@@ -76,7 +78,7 @@
   }
 
   @media (hover: hover) {
-    &:not(&--compact):hover {
+    &--interactive:hover {
       .buku-x3-status__identity {
         visibility: visible;
         opacity: 1;
diff --git a/app/assets/stylesheets/components/_rocket_progress.scss b/app/assets/stylesheets/components/_rocket_progress.scss
deleted file mode 100644
index ce0c0095c..000000000
--- a/app/assets/stylesheets/components/_rocket_progress.scss
+++ /dev/null
@@ -1,221 +0,0 @@
-// Pinned rocket-repair goal at the top of the home feed (:bukux2). Vega stands
-// in front of the strip's left end and rises out of the top of it, and the
-// strip's chrome dissolves behind him — the same treatment as the intro
-// dialogue's bar, so the track reads as growing out of him rather than as a
-// box with a border drawn across his chest. The track is the piece doing the
-// talking, so the strip carries no explanatory copy.
-//
-// Surface follows docs/branding.md §3: set-2 fill, 2px cream highlight border,
-// 8px radius.
-.rocket-progress {
-  --rocket-progress-avatar-height: 132px;
-  --rocket-progress-avatar-inset: var(--space-xs);
-  // wrench-buddy.png is 1504x1438.
-  --rocket-progress-avatar-ratio: 1.0459;
-  // Where the portrait stops and the strip's chrome (and its text) begin.
-  --rocket-progress-gutter: calc(
-    var(--rocket-progress-avatar-inset) + var(--rocket-progress-avatar-height) *
-      var(--rocket-progress-avatar-ratio) + var(--space-m)
-  );
-
-  position: relative;
-  display: flex;
-  // Top margin reserves the part of him that rises past the strip's top edge.
-  margin: var(--space-xxl) 0 var(--space-m);
-  padding: var(--space-m) var(--space-l);
-  // Floor matches the strip's natural height so the hover growth animates from
-  // it rather than jumping once min-height passes the content height.
-  min-height: 5.5rem;
-  transition: min-height 200ms ease;
-}
-
-// Chrome on its own layer so it can fade out on the left without taking the
-// text with it — a mask applies to an element's children too.
-.rocket-progress::before {
-  content: "";
-  position: absolute;
-  inset: 0;
-  z-index: -1;
-  background: var(--color-set-2-bg);
-  border: 2px solid var(--color-brand-highlight);
-  border-radius: var(--profile-radius);
-  mask-image: linear-gradient(
-    to right,
-    transparent,
-    #000 var(--rocket-progress-gutter)
-  );
-}
-
-.rocket-progress__avatar {
-  height: var(--rocket-progress-avatar-height);
-  width: calc(
-    var(--rocket-progress-avatar-height) * var(--rocket-progress-avatar-ratio)
-  );
-  object-fit: contain;
-
-  position: absolute;
-  left: var(--rocket-progress-avatar-inset);
-  // Centered on the strip rather than feet-on-the-bottom-edge — this art
-  // isn't the tall standing pose the old sprite was.
-  top: 50%;
-  transform: translateY(-50%);
-  filter: drop-shadow(0 6px 14px var(--color-shadow-deep));
-}
-
-.rocket-progress__avatar,
-.rocket-progress__body {
-  transition: opacity 200ms ease;
-}
-
-.rocket-progress__body {
-  display: flex;
-  flex: 1;
-  flex-direction: column;
-  gap: var(--space-xs);
-  // Starts where the chrome has fully faded back in.
-  margin-left: var(--rocket-progress-gutter);
-  min-width: 0;
-}
-
-// Explanation copy that swaps in over the strip on hover, in place of the
-// hours/progress bar — same footprint, just a different story.
-.rocket-progress__hover-copy {
-  position: absolute;
-  inset: 0;
-  display: flex;
-  align-items: center;
-  padding: var(--space-l) var(--space-xl);
-  opacity: 0;
-  pointer-events: none;
-  transition: opacity 200ms ease;
-
-  p {
-    margin: 0;
-    color: var(--color-space-text);
-    font-family: var(--font-family-text);
-    font-size: var(--font-size-m);
-    line-height: 1.4;
-  }
-}
-
-// Tall enough for the copy plus its full padding — the strip's natural height
-// leaves the text no room to breathe vertically.
-.rocket-progress:hover {
-  min-height: 8rem;
-
-  .rocket-progress__avatar,
-  .rocket-progress__body {
-    opacity: 0;
-  }
-
-  .rocket-progress__hover-copy {
-    opacity: 1;
-  }
-}
-
-.rocket-progress__header {
-  display: flex;
-  flex-wrap: wrap;
-  align-items: baseline;
-  justify-content: space-between;
-  gap: var(--space-xxs) var(--space-m);
-}
-
-// Small heading per docs/branding.md §2.1 — bold, all caps.
-.rocket-progress__eyebrow {
-  margin: 0;
-  color: var(--color-brand-highlight);
-  font-family: var(--font-family-text);
-  font-size: var(--font-size-m);
-  font-weight: 700;
-  letter-spacing: 0.06em;
-  text-transform: uppercase;
-}
-
-.rocket-progress__count {
-  margin: 0;
-  font-family: var(--font-family-text);
-  line-height: 1.1;
-}
-
-.rocket-progress__hours {
-  color: var(--color-space-text);
-  font-size: var(--font-size-xxl);
-  font-weight: 700;
-}
-
-.rocket-progress__goal {
-  color: var(--color-set-3-fg-secondary);
-  font-size: var(--font-size-m);
-}
-
-// A chunky track rather than the 8px strip the shared component defaults to:
-// this bar is the whole point of the container. Sunk into the page background
-// so the fill reads as sitting in a channel.
-.rocket-progress__bar {
-  height: 22px;
-  background: var(--color-set-1-bg);
-  border: 2px solid var(--color-space-surface-soft);
-
-  .progress-bar__fill {
-    position: relative;
-    width: var(--rocket-progress-fill);
-    overflow: hidden;
-    background: var(--color-brand-highlight);
-  }
-}
-
-.rocket-progress__contribution {
-  position: absolute;
-  inset-block: 0;
-  right: 0;
-  width: var(--rocket-progress-contribution);
-  background: var(--color-brand-mint);
-  box-shadow: inset 2px 0 var(--color-set-2-bg);
-}
-
-.rocket-progress__contribution-caption {
-  display: flex;
-  justify-content: flex-end;
-  width: var(--rocket-progress-fill);
-  min-width: max-content;
-  max-width: 100%;
-  padding-top: var(--space-xs);
-}
-
-.rocket-progress__contribution-label {
-  color: var(--color-brand-mint);
-  font-size: var(--font-size-s);
-  line-height: 1.4;
-  white-space: nowrap;
-
-  strong {
-    font-weight: 700;
-  }
-}
-
-@media (max-width: 600px) {
-  .rocket-progress {
-    --rocket-progress-avatar-height: 104px;
-
-    padding: var(--space-s) var(--space-m);
-  }
-
-  .rocket-progress__bar {
-    height: 18px;
-  }
-}
-
-@media (prefers-reduced-motion: reduce) {
-  .rocket-progress {
-    transition: none;
-  }
-
-  .rocket-progress__bar .progress-bar__fill {
-    transition: none;
-  }
-
-  .rocket-progress:hover .rocket-progress__avatar {
-    animation: none;
-  }
-}
diff --git a/app/components/buku_x3_status_component.html.erb b/app/components/buku_x3_status_component.html.erb
index 4e3b8dcee..1fa13825f 100644
--- a/app/components/buku_x3_status_component.html.erb
+++ b/app/components/buku_x3_status_component.html.erb
@@ -1,20 +1,22 @@
-<section class="buku-x3-status <%= 'buku-x3-status--compact' if compact? %> buku-x3-status--<%= buku? ? 'buku' : 'bean' %>"
+<section class="buku-x3-status <%= 'buku-x3-status--compact' if compact? %> <%= "buku-x3-status--#{buku? ? 'buku' : 'bean'}" if role_visible? %> <%= 'buku-x3-status--interactive' if role_visible? && !compact? %>"
          aria-label="<%= compact? ? 'your private event role' : 'bukus versus beans' %>"
          data-controller="buku-x3-status"
          data-buku-x3-status-live-hours-value="<%= (compact? ? {} : team_hours).to_json %>"
          data-action="blackhole:progress@window->buku-x3-status#update">
-  <% unless compact? %>
+  <% if role_visible? && !compact? %>
     <button type="button" class="buku-x3-status__toggle" aria-label="show your event role" aria-pressed="false"
             data-buku-x3-status-target="toggle"
             data-action="click->buku-x3-status#toggleRole keydown.esc->buku-x3-status#dismissRole"></button>
   <% end %>
-  <div class="buku-x3-status__identity">
-    <%= image_tag icon, class: "buku-x3-status__icon", alt: "", width: 120, height: 132 %>
-    <div>
-      <p class="buku-x3-status__role">you're a <strong><%= role_name %></strong></p>
-      <p class="buku-x3-status__reminder"><%= reminder %></p>
+  <% if role_visible? %>
+    <div class="buku-x3-status__identity">
+      <%= image_tag icon, class: "buku-x3-status__icon", alt: "", width: 120, height: 132 %>
+      <div>
+        <p class="buku-x3-status__role">you're a <strong><%= role_name %></strong></p>
+        <p class="buku-x3-status__reminder"><%= reminder %></p>
+      </div>
     </div>
-  </div>
+  <% end %>
   <% unless compact? %>
     <div class="buku-x3-status__damage">
       <p class="buku-x3-status__label"><strong data-buku-x3-status-target="amount"><%= display_percent %>% damaged</strong></p>
diff --git a/app/components/buku_x3_status_component.rb b/app/components/buku_x3_status_component.rb
index 38cb166e7..00dfedc63 100644
--- a/app/components/buku_x3_status_component.rb
+++ b/app/components/buku_x3_status_component.rb
@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-# Private role reminder. Call sites pass the signed-in viewer, never a profile
-# or project owner; do not cache this fragment across users.
+# Public team progress with an optional private role reminder. Call sites pass
+# the viewer, never a profile/project owner; do not cache across users.
 class BukuX3StatusComponent < ViewComponent::Base
   def initialize(user:, compact: false, preview: false, preview_role: "buku")
     @user = user
@@ -11,6 +11,10 @@ def initialize(user:, compact: false, preview: false, preview_role: "buku")
   end
 
   def render?
+    !compact? || role_visible?
+  end
+
+  def role_visible?
     return true if preview?
 
     @user.present? && @user.onboarded? && Flipper.enabled?(:bukux3, @user) &&
diff --git a/app/components/rocket_progress_component.html.erb b/app/components/rocket_progress_component.html.erb
deleted file mode 100644
index 0554c718d..000000000
--- a/app/components/rocket_progress_component.html.erb
+++ /dev/null
@@ -1,39 +0,0 @@
-<section class="rocket-progress">
-  <%= image_tag "rocket_progress/wrench-buddy.png", class: "rocket-progress__avatar", alt: "" %>
-
-  <div class="rocket-progress__body">
-    <div class="rocket-progress__header">
-      <h2 class="rocket-progress__eyebrow"><%= heading %></h2>
-      <p class="rocket-progress__count">
-        <span class="rocket-progress__hours"><%= display_hours %></span>
-        <span class="rocket-progress__goal">/ <%= display_goal %> hours</span>
-      </p>
-    </div>
-
-    <div class="rocket-progress__meter" style="--rocket-progress-fill: <%= fill_percent %>%; --rocket-progress-contribution: <%= contribution_percent %>%">
-      <div class="progress-bar rocket-progress__bar"
-           role="progressbar"
-           aria-valuenow="<%= [hours, goal].min %>"
-           aria-valuemin="0"
-           aria-valuemax="<%= goal %>"
-           aria-label="<%= progress_label %>">
-        <div class="progress-bar__fill">
-          <% if contribution? %>
-            <span class="rocket-progress__contribution" aria-hidden="true"></span>
-          <% end %>
-        </div>
-      </div>
-      <% if contribution? %>
-        <div class="rocket-progress__contribution-caption">
-          <span class="rocket-progress__contribution-label">
-            <span aria-hidden="true">✦</span> You contributed <strong><%= display_contribution %> h</strong>
-          </span>
-        </div>
-      <% end %>
-    </div>
-  </div>
-
-  <div class="rocket-progress__hover-copy" aria-hidden="true">
-    <p>Every hour that you or any stardancer codes adds to the rocket's build progress! Once the repairs are complete, everyone who's contributed at least five hours gets limited-edition stickers :D</p>
-  </div>
-</section>
diff --git a/app/components/rocket_progress_component.rb b/app/components/rocket_progress_component.rb
deleted file mode 100644
index 9525d2675..000000000
--- a/app/components/rocket_progress_component.rb
+++ /dev/null
@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-# Pinned strip at the top of the home feed: how many approved hours the program
-# has banked toward repairing Vega's rocket. Same story as the :bukux2 intro
-# dialogue, so it hides with that flag and the home page is untouched without
-# it.
-#
-# The figure comes from RocketProgress, which derives it from approved YSWS
-# submissions whose ship landed inside the campaign window — nothing here
-# writes anything.
-class RocketProgressComponent < ViewComponent::Base
-  attr_reader :user
-
-  def initialize(user:)
-    @user = user
-  end
-
-  def render? = Flipper.enabled?(:bukux2, user)
-
-  def progress = @progress ||= RocketProgress.snapshot(user: user)
-
-  def hours = progress.hours
-  def goal = progress.goal_hours
-  def remaining = progress.remaining_hours
-  def complete? = progress.complete?
-
-  def heading
-    complete? && !Flipper.enabled?(:bukux3, user) ? "The rocket is being built..." : "Rocket repair"
-  end
-
-  def contribution? = progress.user_hours.positive?
-  def fill_percent = [ hours / goal.to_f * 100, 100 ].min.round(4)
-  def contribution_percent = hours.positive? ? (progress.user_hours.to_f / hours * 100).clamp(0, 100).round(4) : 0
-  def display_contribution = helpers.number_with_precision(progress.user_hours, precision: 2, strip_insignificant_zeros: true, delimiter: ",")
-
-  def progress_label
-    label = "#{display_hours} of #{display_goal} hours logged toward fixing the rocket"
-    contribution? ? "#{label}, including #{display_contribution} hours from you" : label
-  end
-
-  # Whole hours read better on a 5000-hour goal; the exact figure still goes to
-  # the progress bar's aria-valuenow.
-  def display_hours = helpers.number_with_delimiter(hours.round)
-  def display_goal = helpers.number_with_delimiter(goal)
-  def display_remaining = helpers.number_with_delimiter(remaining.ceil)
-end
diff --git a/app/javascript/controllers/blackhole_controller.js b/app/javascript/controllers/blackhole_controller.js
index 22d63804d..46aa13bb3 100644
--- a/app/javascript/controllers/blackhole_controller.js
+++ b/app/javascript/controllers/blackhole_controller.js
@@ -2,7 +2,7 @@ import { Controller } from "@hotwired/stimulus";
 import { Delaunay } from "d3";
 
 const CARD_SURFACES =
-  ".feed-post-card, .feed-composer, .rocket-progress, .rail-widget, .raffle-widget, .phantom-promo, .sidebar__logo-img, .sidebar__user-card";
+  ".feed-post-card, .feed-composer, .rail-widget, .raffle-widget, .phantom-promo, .sidebar__logo-img, .sidebar__user-card";
 const MEDIA_CONTENT = "img, video, iframe, svg";
 const SIDEBAR_SURFACES = [
   "#primary-nav",
@@ -441,6 +441,7 @@ export default class extends Controller {
         priority: element.style.getPropertyPriority("clip-path"),
         seed: this.surfaceSeed(element),
         card: cards.includes(element),
+        proportional: element.matches(".sidebar__logo-img"),
       });
       element.style.setProperty("clip-path", `url(#${clip.id})`);
       this.surfaceResize.observe(element);
@@ -494,6 +495,7 @@ export default class extends Controller {
         protectedRects,
         excludedRects,
         surface.card,
+        surface.proportional,
       );
       if (surface.lastPath !== path) {
         surface.path.setAttribute("d", path);
@@ -840,6 +842,7 @@ export default class extends Controller {
     protectedRects = [],
     excludedRects = [],
     card = true,
+    proportional = false,
   ) {
     const cells = this.fragmentCells(rect, size, seed);
     this.fragmentFields ||= new Map();
@@ -851,6 +854,7 @@ export default class extends Controller {
       cached.height === rect.height &&
       cached.size === size &&
       cached.card === card &&
+      cached.proportional === proportional &&
       cached.protectedRects === protectedRects &&
       cached.excludedRects === excludedRects
     )
@@ -877,6 +881,12 @@ export default class extends Controller {
         bounds.top < safe.bottom &&
         bounds.bottom > safe.top;
       if (excludedRects.some(overlaps)) continue;
+      // The logo dissolves throughout the whole event, independently of the
+      // delayed image/text stages. Stable uniform thresholds track damage.
+      if (proportional) {
+        field.push({ cell, start: random(x, y, seed + 12) * 0.93 });
+        continue;
+      }
       const protectedContent = protectedRects.some(overlaps);
       const imageContent = protectedRects.some(
         (area) => area.kind === "image" && overlaps(area),
@@ -922,6 +932,7 @@ export default class extends Controller {
       height: rect.height,
       size,
       card,
+      proportional,
       protectedRects,
       excludedRects,
       field,
@@ -936,6 +947,7 @@ export default class extends Controller {
     protectedRects = [],
     excludedRects = [],
     card = true,
+    proportional = false,
   ) {
     const holes = [];
     for (const entry of this.fragmentField(
@@ -945,10 +957,13 @@ export default class extends Controller {
       protectedRects,
       excludedRects,
       card,
+      proportional,
     )) {
       const { cell, start } = entry;
       const { cx, cy, vertices } = cell;
       let erosion = clamp((this.level - start) / 0.07);
+      // Polygon area scales quadratically; keep proportional damage linear.
+      if (proportional) erosion = Math.sqrt(erosion);
       erosion *= 1 - this.repairStrength(cell, rect);
       if (!erosion) continue;
       if (entry.erosion !== erosion) {
diff --git a/app/views/home/index.html.erb b/app/views/home/index.html.erb
index 3a6feff20..22188a1b1 100644
--- a/app/views/home/index.html.erb
+++ b/app/views/home/index.html.erb
@@ -8,12 +8,7 @@
   <main class="app-layout__main feed-home" aria-label="Home feed" data-controller="feed-keyboard feed-tabs" data-feed-tabs-feed-url-value="<%= home_feed_path %>">
     <%= turbo_frame_tag "buku_x3_home_status", class: ("buku-x3-home-preview" if Rails.env.development?), data: { controller: "buku-x3-status", action: "buku-x3-reveal:complete@window->buku-x3-status#refresh" } do %>
       <% preview_role = params[:buku_preview].presence_in(%w[buku bean]) if Rails.env.development? %>
-      <% event_status = BukuX3StatusComponent.new(user: current_user, preview: preview_role.present?, preview_role: preview_role) %>
-      <% if event_status.render? %>
-        <%= render event_status %>
-      <% else %>
-        <%= render RocketProgressComponent.new(user: current_user) %>
-      <% end %>
+      <%= render BukuX3StatusComponent.new(user: current_user, preview: preview_role.present?, preview_role: preview_role) %>
     <% end %>
     <% if current_user.present? && Flipper.enabled?(:mihimode, current_user) %>
       <%= render ActionButtonComponent.new(
diff --git a/test/components/buku_x3_status_component_test.rb b/test/components/buku_x3_status_component_test.rb
index c9771ecd3..ec7d11164 100644
--- a/test/components/buku_x3_status_component_test.rb
+++ b/test/components/buku_x3_status_component_test.rb
@@ -75,7 +75,7 @@ class BukuX3StatusComponentTest < ViewComponent::TestCase
       BukuX3::Assignment.stub(:buku?, ->(_) { flunk "premature role disclosure" }) do
         render_inline BukuX3StatusComponent.new(user: @user)
       end
-      assert_no_selector ".buku-x3-status"
+      assert_public_progress_only
     end
   end
 
@@ -86,20 +86,40 @@ class BukuX3StatusComponentTest < ViewComponent::TestCase
     @event.update!(unlocked_at: 1.minute.ago)
     Flipper.disable(:bukux3)
     render_inline BukuX3StatusComponent.new(user: @user)
-    assert_no_selector ".buku-x3-status"
+    assert_public_progress_only
   end
 
   test "signed out and incomplete accounts cannot see a role" do
-    render_inline BukuX3StatusComponent.new(user: nil)
+    BukuX3::Assignment.stub(:buku?, ->(_) { flunk "must not compute an undisclosed role" }) do
+      render_inline BukuX3StatusComponent.new(user: nil)
+      assert_public_progress_only
+      @user.update!(onboarded_at: nil)
+      render_inline BukuX3StatusComponent.new(user: @user)
+      assert_public_progress_only
+    end
+  end
+
+  test "public progress works without the event flag or an event record" do
+    Flipper.disable(:bukux3)
+    BukuX3::Event.stub(:current, nil) do
+      render_inline BukuX3StatusComponent.new(user: nil)
+    end
+    assert_public_progress_only
+    assert_selector "[role='meter'][aria-valuenow='25']"
+    assert_selector ".buku-x3-status__hours", text: "0 h shipped", count: 2
+  end
+
+  test "compact private reminder stays hidden for guests and incomplete accounts" do
+    render_inline BukuX3StatusComponent.new(user: nil, compact: true)
     assert_no_selector ".buku-x3-status"
     @user.update!(onboarded_at: nil)
-    render_inline BukuX3StatusComponent.new(user: @user)
+    render_inline BukuX3StatusComponent.new(user: @user, compact: true)
     assert_no_selector ".buku-x3-status"
   end
 
   test "panel preview cannot bypass gates outside development" do
     render_inline BukuX3StatusComponent.new(user: nil, preview: true, preview_role: "bean")
-    assert_no_selector ".buku-x3-status"
+    assert_public_progress_only
   end
 
   test "development preview uses an explicit role without assigning an account" do
@@ -112,4 +132,12 @@ class BukuX3StatusComponentTest < ViewComponent::TestCase
     assert_no_selector ".buku-x3-status__preview"
     assert_selector "img[src*='events/bukux3/bean']"
   end
+
+  private
+
+  def assert_public_progress_only
+    assert_selector ".buku-x3-status [role='meter']"
+    assert_no_selector ".buku-x3-status__identity, .buku-x3-status__toggle, .buku-x3-status--interactive"
+    assert_no_selector ".buku-x3-status--buku, .buku-x3-status--bean"
+  end
 end
diff --git a/test/components/rocket_progress_component_test.rb b/test/components/rocket_progress_component_test.rb
deleted file mode 100644
index be4c7dde4..000000000
--- a/test/components/rocket_progress_component_test.rb
+++ /dev/null
@@ -1,45 +0,0 @@
-require "test_helper"
-
-class RocketProgressComponentTest < ViewComponent::TestCase
-  test "personal hours occupy the end of the filled total without adding to it" do
-    render_progress(hours: 2750, user_hours: 150)
-
-    assert_selector "[role='progressbar'][aria-valuenow='2750']"
-    assert_selector ".rocket-progress__contribution-label", text: "You contributed 150 h"
-    assert_selector ".rocket-progress__meter[style*='--rocket-progress-fill: 55.0%']"
-    assert_selector ".rocket-progress__meter[style*='--rocket-progress-contribution: 5.4545%']"
-  end
-
-  test "no contribution segment or label when the user has not contributed" do
-    render_progress(hours: 0, user_hours: 0)
-
-    assert_no_selector ".rocket-progress__contribution"
-    assert_no_selector ".rocket-progress__contribution-label"
-  end
-
-  test "small contributions retain fractional hours and completed goals stay capped" do
-    render_progress(hours: 5250, user_hours: 0.1)
-
-    assert_selector "[role='progressbar'][aria-valuenow='5000']"
-    assert_selector ".rocket-progress__contribution-label", text: "You contributed 0.1 h"
-    assert_selector ".rocket-progress__meter[style*='--rocket-progress-fill: 100%']"
-  end
-
-  test "flag still hides the entire component" do
-    Flipper.stub(:enabled?, false) do
-      render_inline RocketProgressComponent.new(user: users(:one))
-      assert_no_selector ".rocket-progress"
-    end
-  end
-
-  private
-
-    def render_progress(hours:, user_hours:)
-      snapshot = RocketProgress::Snapshot.new(hours: hours, goal_hours: 5000, user_hours: user_hours)
-      Flipper.stub(:enabled?, true) do
-        RocketProgress.stub(:snapshot, snapshot) do
-          render_inline RocketProgressComponent.new(user: users(:one))
-        end
-      end
-    end
-end
diff --git a/test/controllers/buku_x3/reveals_controller_test.rb b/test/controllers/buku_x3/reveals_controller_test.rb
index 6129e6e3e..23db14e8d 100644
--- a/test/controllers/buku_x3/reveals_controller_test.rb
+++ b/test/controllers/buku_x3/reveals_controller_test.rb
@@ -67,7 +67,8 @@ class BukuX3::RevealsControllerTest < ActionDispatch::IntegrationTest
     assert_response :success
     assert_select ".visual-novel[data-visual-novel-dismiss-thing-value='bukux3_intro']", count: 1
     assert_select "dialog.buku-x3-reveal", count: 0
-    assert_select ".buku-x3-status", count: 0
+    assert_select ".buku-x3-status [role='meter']", count: 1
+    assert_select ".buku-x3-status__identity, .buku-x3-status__toggle", count: 0
   end
 
   test "reveal endpoint requires the intro to be completed" do
@@ -118,7 +119,8 @@ class BukuX3::RevealsControllerTest < ActionDispatch::IntegrationTest
       get home_path(buku_preview: "bean")
     end
     assert_response :success
-    assert_select ".buku-x3-status", count: 0
+    assert_select ".buku-x3-status [role='meter']", count: 1
+    assert_select ".buku-x3-status__identity, .buku-x3-status__toggle", count: 0
     assert_select "turbo-frame#buku_x3_home_status", count: 1
   end
 end
diff --git a/test/controllers/home_controller_test.rb b/test/controllers/home_controller_test.rb
index 934cfa1a6..6e475125e 100644
--- a/test/controllers/home_controller_test.rb
+++ b/test/controllers/home_controller_test.rb
@@ -38,6 +38,34 @@ class HomeControllerTest < ActionDispatch::IntegrationTest
     assert_equal [ 1, 4, 5 ], selected.map(&:id)
   end
 
+  test "guests see team progress without a role hover or legacy rocket bar" do
+    Flipper.enable(:bukux2)
+    BukuX3::Assignment.stub(:buku?, ->(_) { flunk "guest must not receive a role" }) do
+      get home_path
+    end
+    assert_response :success
+    assert_select ".buku-x3-status [role='meter']", count: 1
+    assert_select ".buku-x3-status__toggle, .buku-x3-status__identity, .rocket-progress", count: 0
+  ensure
+    Flipper.disable(:bukux2)
+  end
+
+  test "unlinked accounts see team progress instead of rocket repair" do
+    @user.update!(onboarded_at: nil, things_dismissed: [])
+    sign_in @user
+    Flipper.enable(:bukux2)
+    Flipper.enable(:bukux3)
+    BukuX3::Assignment.stub(:buku?, ->(_) { flunk "unlinked account must not receive a role" }) do
+      get home_path
+    end
+    assert_response :success
+    assert_select ".buku-x3-status [role='meter']", count: 1
+    assert_select ".buku-x3-status__toggle, .buku-x3-status__identity, .rocket-progress", count: 0
+  ensure
+    Flipper.disable(:bukux2)
+    Flipper.disable(:bukux3)
+  end
+
   private
 
   def create_devlog(body:)
diff --git a/test/javascript/blackhole_logo_test.mjs b/test/javascript/blackhole_logo_test.mjs
new file mode 100644
index 000000000..2ec687cac
--- /dev/null
+++ b/test/javascript/blackhole_logo_test.mjs
@@ -0,0 +1,100 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import BlackholeController from "../../app/javascript/controllers/blackhole_controller.js";
+
+const rect = { left: 0, top: 0, width: 240, height: 100 };
+const image = [{ left: 0, top: 0, right: 240, bottom: 100, kind: "image" }];
+const excluded = [];
+const intact = "M-50000,-50000H50000V50000H-50000Z";
+
+function controller() {
+  return Object.assign(Object.create(BlackholeController.prototype), {
+    width: 1200,
+    height: 800,
+    level: 0.25,
+    fringe: [],
+    pointer: null,
+    repairRadius: 145,
+    repairTime: 0,
+    reducedMotion: { matches: false },
+  });
+}
+
+function mask(c, proportional = true) {
+  return c.fragmentPath(rect, 9, -62, image, excluded, true, proportional);
+}
+
+test("logo damage starts immediately, tracks the damage range, and is reversible", () => {
+  const c = controller();
+  const snapshots = new Map();
+  for (const level of [0, 0.25, 0.5, 0.75, 1]) {
+    c.level = level;
+    snapshots.set(level, mask(c));
+    const entries = c.fragmentFields
+      .get(-62)
+      .field.filter(
+        ({ cell }) =>
+          cell.cx >= 0 &&
+          cell.cx <= rect.width &&
+          cell.cy >= 0 &&
+          cell.cy <= rect.height,
+      );
+    const damage =
+      entries.reduce((sum, { erosion = 0 }) => sum + erosion ** 2, 0) /
+      entries.length;
+    assert.ok(
+      Math.abs(damage - level) < 0.07,
+      `${level}: actual damage ${damage}`,
+    );
+  }
+  assert.equal(snapshots.get(0), intact);
+  assert.notEqual(snapshots.get(0.25), intact);
+  for (const level of [0.75, 0.5, 0.25, 0]) {
+    c.level = level;
+    assert.equal(mask(c), snapshots.get(level));
+  }
+});
+
+test("proportional logo fields are cached separately from staged image decay", () => {
+  const c = controller();
+  const stagedPath = mask(c, false);
+  const staged = c.fragmentFields.get(-62).field;
+  assert.ok(
+    staged
+      .filter(
+        ({ cell }) =>
+          cell.cx >= 0 &&
+          cell.cx <= rect.width &&
+          cell.cy >= 0 &&
+          cell.cy <= rect.height,
+      )
+      .every(({ start }) => start >= 0.6),
+    "ordinary images still survive early damage",
+  );
+  const path = mask(c);
+  const proportional = c.fragmentFields.get(-62).field;
+  assert.notEqual(proportional, staged);
+  assert.notEqual(path, intact);
+  assert.equal(mask(c), path);
+  assert.equal(c.fragmentFields.get(-62).field, proportional);
+  assert.equal(mask(c, false), stagedPath);
+});
+
+test("logo fragments use the shared cursor repair and decay back after it leaves", () => {
+  const c = controller();
+  c.level = 1;
+  const damaged = mask(c);
+  c.pointer = { x: 120, y: 50 };
+  const repaired = mask(c);
+  assert.notEqual(repaired, damaged);
+  const center = c.fragmentFields
+    .get(-62)
+    .field.find(({ cell }) => Math.hypot(cell.cx - 120, cell.cy - 50) < 15);
+  assert.equal(center.cell.repair, 1);
+  c.pointer = null;
+  c.repairTime = 100;
+  mask(c);
+  assert.ok(center.cell.repair > 0 && center.cell.repair < 1);
+  c.repairTime = 10000;
+  assert.equal(mask(c), damaged);
+});

From 39e81e716aab592e4b7d9f5831234a291a628689 Mon Sep 17 00:00:00 2001
From: mikidoodle <mihir@pidgon.com>
Date: Thu, 1 Oct 2026 13:36:14 -0400
Subject: [PATCH 9/9] Update Brakeman to 8.1.0

---
 Gemfile.lock | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Gemfile.lock b/Gemfile.lock
index 6f4934458..7895feaa6 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -174,7 +174,7 @@ GEM
       argon2-kdf (>= 1)
     bootsnap (1.25.0)
       msgpack (~> 1.5)
-    brakeman (8.0.6)
+    brakeman (8.1.0)
       racc
     browser (6.2.0)
     builder (3.3.0)