FactoryGameFan
diff --git a/‎docs/noise/client-preview-ROADMAP.md‎
Lines changed: 81 additions & 10 deletions b/‎docs/noise/client-preview-ROADMAP.md‎
Lines changed: 81 additions & 10 deletions
diff --git a/‎src/App.vue‎
Lines changed: 53 additions & 2 deletions b/‎src/App.vue‎
Lines changed: 53 additions & 2 deletions
diff --git a/‎src/components/ElevationPreviewPanel.vue‎
Lines changed: 28 additions & 4 deletions b/‎src/components/ElevationPreviewPanel.vue‎
Lines changed: 28 additions & 4 deletions
@@ -566,16 +566,87 @@ Done = ore patches overlaid on land, responding to the frequency/size/richness s
       and still far under vulcanus (13.82). Full before/after table and the
       land-only measurement: `docs/noise/fulgora-elevation-NOTES.md`.
 
-      Deferred for Fulgora: scrap resources, cliffs, and the island finder.
-      Two residuals remain open, and as far as anything measured so far can
-      tell they are the SAME unexplained post-argmax mechanism rather than two
-      defects: the original 18 land/ocean and shallow/deep tile mismatches are
-      boundary-exclusive and are NOT reachable by any model of the four ocean
-      expressions - the game places water where its own expressions score it
-      unplaceable - and the eight-land-tile argmax's 124 mismatches are also
-      boundary-exclusive and are not explained by a sampling offset or an
-      inflated formula either. Both need the post-argmax transition pass
-      reverse-engineered, not a constant re-fitted.
+      Deferred for Fulgora: scrap resources and cliffs (the island finder
+      below no longer is). Two residuals remain open, and as far as anything
+      measured so far can tell they are the SAME unexplained post-argmax
+      mechanism rather than two defects: the original 18 land/ocean and
+      shallow/deep tile mismatches are boundary-exclusive and are NOT
+      reachable by any model of the four ocean expressions - the game places
+      water where its own expressions score it unplaceable - and the
+      eight-land-tile argmax's 124 mismatches are also boundary-exclusive and
+      are not explained by a sampling offset or an inflated formula either.
+      Both need the post-argmax transition pass reverse-engineered, not a
+      constant re-fitted.
+
+      **Fulgora island finder - DONE 2026-08-15** (#27, spec
+      `docs/superpowers/specs/2026-08-15-fulgora-island-finder-design.md`).
+      Finds the largest buildable islands, ranked by largest inscribed
+      rectangle, inside a user-set search radius, and groups nearby islands
+      into chains (a big power pole's 30-tile wire reach). Five stages, each
+      its own module under `src/noise/islands/`: survey the search box for
+      candidate Voronoi cells (`cellSurvey.ts`), rasterize a coarse land mask
+      per candidate and compute its largest inscribed rectangle
+      (`islandMask.ts`, `largestRectangle.ts`), refine the top 50 by coarse
+      area at finer resolution, chain islands whose land comes within 30
+      tiles (`chainGraph.ts`), and list the results in a sortable UI panel
+      that re-centers the preview on a click.
+
+      **Perf, measured 2026-08-15** (`test/render-cost.perf.spec.ts`,
+      `FMW_PERF_BLOCK=islands`, min of 3, seed 2967702466): the survey pass
+      (Stage 1), scanning a 4,000-tile box at the derived `grid / 8` step,
+      costs **~2.5 us per sample** (84 ms for 33,489 samples, 375 candidates
+      found) - in line with the design spec's own throwaway measurement of
+      2.33 us per `cells` evaluation. One coarse measure-shaped render
+      (Stage 2: a 256x256-tile window at 8 tiles/px, `view: "terrain"`, never
+      `"all"` - see `findIslands.ts`'s header for why) costs **~24 ms** in
+      this Node test harness.
+
+      **The full end-to-end search time for the default 5,000-tile radius is
+      unmeasured.** This perf block times the two per-unit costs above, not
+      the whole survey -> coarse -> refine -> chain pipeline run across the
+      app's worker pool. The design spec's own ~15s figure for that case
+      (section 4) is a design-time estimate from a throwaway benchmark, not a
+      number this task measured - treat it as unconfirmed until a real
+      end-to-end run is timed and recorded here.
+
+      **The chain stage is NOT negligible, and now has a measured figure.**
+      The design spec's own estimate (section 4) called stage 4 (dedup +
+      chain, `chainGraph.ts`) negligible beside the coarse/refine renders.
+      Measured directly on real Fulgora data (radius 5000, seed 2967702466,
+      2,313 coarse candidates deduping to 2,000): the two `chainComponents`
+      calls together cost **~365 ms** - small next to the render stages
+      (which run into the tens of seconds), but a real, countable cost, not
+      zero. A pre-fix version of `chainGraph.ts` re-extracted each mask's
+      land-tile array on every pairwise comparison instead of once per mask;
+      a 2026-08-15 review fix hoists that extraction (`chainGraph.ts`,
+      `chainComponents`). On this same real-data shape the hoist's own effect
+      was small (the box-gap prefilter already discards 99.8%+ of pairs
+      cheaply, so the redundant work it removes is a small fraction of an
+      already-small stage) - the fix is still correct and worth keeping, just
+      don't expect it to move the total search time by much.
+
+      **The render window's grow-on-border-touch has a known limit.** A
+      2026-08-15 review fix found that `findIslands.ts`'s render window
+      (candidate bounding box + a flat pad) could cut a multi-cell island off
+      at its own edge, undercounting its land and rectangle and even
+      flipping which of two candidates ranks higher. The fix re-renders at a
+      doubled pad whenever the isolated island mask still touches the
+      window's border, capped at 3 growths (pad 32 -> 64 -> 128 -> 256). An
+      island whose true extent needs more padding than that - i.e. one that
+      still touches the border after the pad reaches 256 - stays clipped: its
+      reported rectangle is a real measurement of a truncated slice, not the
+      whole island, and `IslandResult.clipped` records that so the panel can
+      say so (the `!` marker beside a clipped row's rectangle, next to the
+      existing `~` marker for an unrefined one). No case in the current
+      seed/radius test fixtures needs more than pad 256, but nothing rules
+      one out at a larger radius.
+
+      **Accuracy**: Fulgora's land/ocean split agrees with the real game on
+      99.86% of positions (Fulgora V1, above), and the residual mismatches
+      are boundary-exclusive - they sit exactly where an island's edge is,
+      which is exactly what a rectangle measurement reads. So a reported
+      rectangle is accurate to about a tile, not exact; the panel says this
+      once rather than implying an exact answer.
 
 ## Milestone 5 - integration
 
 
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { ref } from "vue";
+import { ref, watch } from "vue";
 import { SUPPORTED_VERSIONS_LABEL } from "./codec/mapExchangeString";
 import { FACTORIO_TARGET_VERSION } from "./model/factorioTarget";
 import { BUILD_INFO, BUILD_STAMP } from "./model/buildStamp";
@@ -8,6 +8,7 @@ import AdvancedTab from "./components/AdvancedTab.vue";
 import ElevationPreviewPanel from "./components/ElevationPreviewPanel.vue";
 import EnemyTab from "./components/EnemyTab.vue";
 import ImportPanel from "./components/ImportPanel.vue";
+import IslandFinderPanel from "./components/IslandFinderPanel.vue";
 import PresetBar from "./components/PresetBar.vue";
 import PreviewPanel from "./components/PreviewPanel.vue";
 import ResourcesTab from "./components/ResourcesTab.vue";
@@ -19,6 +20,26 @@ const TABS = ["Resources", "Terrain", "Enemy", "Advanced", "Preview"];
 const activeTab = ref("Resources");
 const selectedPlanet = ref<Planet>("nauvis");
 const showImport = ref(false);
+/**
+ * The last island the finder's results table was jumped to - fed straight to
+ * ElevationPreviewPanel's `centerX`/`centerY` props, which move the client
+ * preview's render window onto it. `null` (not 0) while nothing has been
+ * jumped to yet, so the preview keeps its own "centered on world origin"
+ * default rather than this component asserting a coordinate.
+ */
+const jumpTarget = ref<{ x: number; y: number } | null>(null);
+
+function onIslandJump(target: { x: number; y: number }) {
+  jumpTarget.value = target;
+  activeTab.value = "Preview";
+}
+
+// A jump target named for one planet's geography is meaningless on another -
+// switching planets without clearing it would leave a stale coordinate note
+// (and a stale render center) pointing at nothing in particular.
+watch(selectedPlanet, () => {
+  jumpTarget.value = null;
+});
 </script>
 
 <template>
@@ -75,7 +96,17 @@ const showImport = ref(false);
           <ResourcesTab v-if="activeTab === 'Resources'" />
           <TerrainTab v-else-if="activeTab === 'Terrain'" />
           <EnemyTab v-else-if="activeTab === 'Enemy'" />
-          <ElevationPreviewPanel v-else-if="activeTab === 'Preview'" :planet="selectedPlanet" />
+          <div v-else-if="activeTab === 'Preview'" class="preview-tab">
+            <IslandFinderPanel :planet="selectedPlanet" @jump="onIslandJump" />
+            <p v-if="jumpTarget" class="jump-note" data-test="jump-target">
+              Centered on {{ jumpTarget.x }}, {{ jumpTarget.y }}.
+            </p>
+            <ElevationPreviewPanel
+              :planet="selectedPlanet"
+              :center-x="jumpTarget?.x"
+              :center-y="jumpTarget?.y"
+            />
+          </div>
           <AdvancedTab v-else />
         </div>
       </main>
@@ -188,6 +219,26 @@ const showImport = ref(false);
   flex: 1;
 }
 
+.preview-tab {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  /* IslandFinderPanel sizes to its content; ElevationPreviewPanel is the one
+     that wants the remaining room. */
+  height: 100%;
+}
+
+.preview-tab > :last-child {
+  flex: 1;
+  min-height: 0;
+}
+
+.jump-note {
+  margin: 0;
+  font-size: 0.9em;
+  color: var(--f-text-dim);
+}
+
 .preview {
   background: var(--f-panel);
   padding: 8px;
 
@@ -1,6 +1,6 @@
 <!-- src/components/ElevationPreviewPanel.vue -->
 <script setup lang="ts">
-import { computed, ref } from "vue";
+import { computed, ref, watch } from "vue";
 import { elevationCtxFromPreset } from "../model/elevationPreviewCtx";
 import { PLANET_LABELS, type Planet } from "../model/planets";
 import { surfaceSeedForPlanet } from "../model/planetSurfaceSeed";
@@ -17,7 +17,20 @@ import { useElevationPreview, type ElevationRenderer } from "./useElevationPrevi
 const PREVIEW_PX = 1024;
 const TILES_PER_PIXEL = 1;
 
-const props = defineProps<{ renderer?: ElevationRenderer; planet?: Planet }>();
+const props = defineProps<{
+  renderer?: ElevationRenderer;
+  planet?: Planet;
+  /**
+   * World coordinate the render window is centered on - the island finder's
+   * jump-to target (#27). Both default to 0, which reproduces the original
+   * "always centered on world origin" behavior exactly (`half` subtracted,
+   * nothing else). Optional rather than required so every caller that
+   * predates this - the whole app before Task 8, and most of this file's own
+   * tests - is unaffected.
+   */
+  centerX?: number;
+  centerY?: number;
+}>();
 // In the app no renderer is passed -> build the real worker-backed one (which
 // registers its own onBeforeUnmount). Tests inject a fake, so no Worker is made.
 const renderer = props.renderer ?? useElevationPreview();
@@ -196,8 +209,8 @@ async function generate() {
         view: effectiveView.value,
         width: PREVIEW_PX,
         height: PREVIEW_PX,
-        originX: -half,
-        originY: -half,
+        originX: (props.centerX ?? 0) - half,
+        originY: (props.centerY ?? 0) - half,
         tilesPerPixel: TILES_PER_PIXEL,
         waterLevel: info.ctx.waterLevel,
         segmentationMultiplier: info.ctx.segmentationMultiplier,
@@ -241,6 +254,17 @@ async function generate() {
     loading.value = false;
   }
 }
+
+// Re-center on a jump target automatically, but only once the user has
+// already asked for a render at least once - a caller that sets centerX/
+// centerY before the first Generate click (e.g. mounting straight onto a
+// jump target) must not trigger a render the user never asked for.
+watch(
+  () => [props.centerX, props.centerY],
+  () => {
+    if (hasRendered.value) void generate();
+  },
+);
 </script>
 
 <template>