diff --git a/docs/BACKLOG.md b/docs/BACKLOG.md
index cc01bb21e..d3a5ea131 100644
--- a/docs/BACKLOG.md
+++ b/docs/BACKLOG.md
@@ -60,13 +60,6 @@ From [ADR 0001 §"explicitly not deciding"](adrs/0001-fade-ownership.md):
 
 Diagnosed but unplanned. Captured here so they don't get lost; promote to a spec or plan when prioritised. Most have richer notes in agent memory (`~/.claude/projects/-Users-rulkens-Development-js-skymap/memory/`).
 
-- **Make the codebase `poi`-free (`poi*` → `structure*`)** — **Priority: high.** The data layer is already `StructureRecord` and the InfoCard family was renamed to `StructureDetailCard` / `CompactStructureCard` (`structure` props, `Structure` eyebrow). The legacy `poi` vocabulary survives in the engine/identity/URL layers and reads as a second name for the same concept — the exact "two names, one thing" wart the simplicity convention flags. Holdouts found 2026-06-07:
-  - **`isPoi` predicate** (`services/engine/isPoi.ts`) — imported by ~8 non-InfoCard sites (`FocusableTarget.d.ts`, `EngineCallbacks.d.ts`, `EngineCameraHandle.d.ts`, `useUrlSync.ts`, `useStructureMemberCount.ts`, `engine.ts`, `commitFocus.ts` + tests). Rename to `isStructure`.
-  - **`POI_CATEGORY_INFO` / `data/poiCategoryInfo.ts` / `PoiCategory` type** (`@types/engine/data/PoiCategory.d.ts`) — the category-info table + its type alias; co-design with the `STRUCTURE_CATEGORY_META` consolidation in the DRY item below (don't merge the genuinely-different category *lists*).
-  - **`poiUrl` / `resolvePoiFromPick`** (`services/url/poiUrl.ts`, `services/engine/helpers/resolvePoiFromPick.ts`) and the engine `selectedPoi` params in `selectionRingPass.ts` / `EngineSubsystemHandles.d.ts` / `engine.ts`.
-  - **⚠️ The `#poi=` deep-link URL param** (`services/url/poiUrl.ts`, `utils/url/hasDeepLink.ts`, `App.tsx`) is a **persisted format** — existing shared links use `#poi=cluster-…`. Renaming the param string would break them, so this needs a back-compat read (accept both `#poi=` and a new `#structure=`) or must be deliberately left as-is. Decide explicitly; do **not** blind-rename.
-
-  **Approach:** run `entanglement-radar` first to map the knots and the `#poi=` back-compat boundary, then apply via `/simplify` (delegate the edits per `feedback_simplify_edits_in_subagent`). Pairs with the `cluster* → structure*` naming migration and the structure-category-identity DRY item below — all three are the same "converge on `Structure*` vocabulary" cleanup. Mechanical apart from the URL-param decision; typecheck + tests are the safety net.
 - **Mobile layout reflow** — hover-on-touch is handled (`disable hover on touch input`, #226: hover-only affordances now route through tap). What remains is the general responsive layout pass: reflow the InfoCard / SettingsPanel / StatusBar for narrow viewports so the UI is usable on a phone, not just non-broken. **Update 2026-06-07:** the InfoCard half is specced — [2026-06-07 mobile bottom-sheet design](superpowers/specs/2026-06-07-mobile-info-card-bottom-sheet-design.md) (awaiting plan); the SettingsPanel launcher is a gated fast-follow pending an `entanglement-radar` pass over `SettingsPanel`.
 - **Lower-tier "close to home" weighting** — retune the small/medium tier subsampling so more galaxies survive near the camera's home position for maximum visual density on first load, while keeping the on-screen count fast. Distinct from the deliberate SDSS far-shell sample (memory `project_sdss_medium_intentionally_far`).
 - **Densely seed the Local Volume across all tiers (group explorability)** — surfaced 2026-06-04 with the `group` category. The 16 Local Volume groups are only interesting to fly into if their *member* galaxies are present, but `subsampleByAbsMag` (`tools/catalog/`) thins the nearby volume by absolute-magnitude cut, so faint dwarfs in the Local Group / M81 / Cen A / Sculptor etc. get culled — a group ring you focus into can be nearly empty at small/medium tier. Bias the subsampling to **keep galaxies inside (or near) the featured group spheres** regardless of `M_abs`, across small + medium and ideally large tiers, so each group has as many members as possible. Related to but distinct from the "close to home" weighting above: that's camera-home density; this is per-group membership density keyed off the structure seed. Implementation hooks: the group seed positions/radii (`data/structure_anchors.seed.json`) are available to the build, so the subsampler can spare points within `apparentRadiusMpc` of each group centre. Keep an eye on the on-screen count budget. Pairs with the cluster-focus member count (`PoiDetailCard` "Galaxies" row) — denser seeding makes that number meaningful at lower tiers.
diff --git a/docs/superpowers/plans/completed/2026-06-08-poi-free-codebase.md b/docs/superpowers/plans/completed/2026-06-08-poi-free-codebase.md
new file mode 100644
index 000000000..68cd56bf4
--- /dev/null
+++ b/docs/superpowers/plans/completed/2026-06-08-poi-free-codebase.md
@@ -0,0 +1,344 @@
+# Make the codebase `poi`-free — Implementation Plan
+
+> **Completed 2026-06-08** (PR #288). All three phases shipped; codebase is `poi`-free apart from the deliberate `#poi= is NOT a deep link` regression test. Follow-up shipped in the same PR: `CategoryLabelLayer` names the `'galaxyNames' | 'structure'` label-layer subset (was a raw literal union in five places). DoD audit: tests + typecheck + build green, no new TODOs, test parity improved.
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Remove all `poi`/`Poi`/`POI` vocabulary from `src/` + mirrored `tests/`, dissolving the two distinct concepts it hid (the label/marker category superset, and "structure") into honest, registry-derived names.
+
+**Architecture:** Three phases. **A** dissolves `PoiCategory` into registry-derived capability flags (`bearsLabel`/`bearsMarker`/`labelLayer`) + a derived `LabelCategory` type, narrows the marker axis to `StructureCategory`, folds the display-metadata table into `SOURCE_REGISTRY`, and de-special-cases the visibility setters. **B** folds the `#poi=` deep-link into `#focus=` (deletes the `poiUrl` codec, adds a `structure` variant to `FocusTarget`). **C** is the mechanical `poi → structure` rename of every site where `poi` already means "structure". Keep build + typecheck green at every commit.
+
+**Tech Stack:** TypeScript, Vite, React, Vitest. Source of truth: `docs/superpowers/specs/2026-06-08-poi-free-codebase-design.md`. Plan style: `docs/superpowers/conventions/plan-style.md` (contract code only — signatures + test names; no implementation bodies; cite files, don't paste).
+
+**Execution notes:** Executing subagents cannot run `npm`/`npx`; the main thread runs `npm test -- <path>` / `npm run typecheck` and commits. Stage specific paths only (never `git add -A`/`.`). Prettier only touched files. Commit as the user's git identity with a `Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>` trailer.
+
+---
+
+## Phase A — Dissolve `PoiCategory` into registry-derived axes
+
+### Task A1: Add capability + display fields to the registry rows
+
+**Files:**
+
+- Modify: `src/@types/data/SourceEntryBase.d.ts`
+- Modify: `src/data/sources.ts` (every `SOURCE_ENTRIES` row)
+- Test: `tests/data/sources.test.ts`
+
+**Contract** — add to `SourceEntryBase`:
+
+```ts
+/** True if this category carries toggleable on-screen text labels. */
+readonly bearsLabel: boolean;
+/** True if this category carries a ring/halo marker (structures only today). */
+readonly bearsMarker: boolean;
+/** Fade layer the labels live on. Present iff bearsLabel. */
+readonly labelLayer?: 'galaxyNames' | 'structure';
+/** Long form for detail surfaces ("Galaxy Cluster"). Present iff bearsLabel. */
+readonly detailLabel?: string;
+/** Compact form for chips/previews ("Cluster"). Present iff bearsLabel. */
+readonly shortLabel?: string;
+/** Plural for list/toggle headers ("Clusters"). Present iff bearsLabel. */
+readonly plural?: string;
+```
+
+These three display fields are **explicit** on each label-bearing row — deliberately NOT derived from the source `label`, because the famous-galaxy _source_ label (`'Famous'`) differs from the _category_ display copy. Decoupling them is what keeps the source name and the category name independent.
+
+Per-row values (see spec §A1/§A2 table):
+
+- `famousGalaxy`: `bearsLabel: true, bearsMarker: false, labelLayer: 'galaxyNames', detailLabel: 'Famous Galaxy', shortLabel: 'Galaxy', plural: 'Famous Galaxies'`. (Keep its existing source `label: 'Famous'` unchanged — only the category display fields are added.)
+- `cluster/supercluster/void/group`: `bearsLabel: true, bearsMarker: true, labelLayer: 'structure'`, with `detailLabel`/`shortLabel`/`plural` copied verbatim from the old `POI_CATEGORY_INFO` rows (`src/data/poiCategoryInfo.ts:24-50`).
+- `sdss/glade/2mrs/milliquas/synthetic`: `bearsLabel: false, bearsMarker: false` (omit `labelLayer`/`detailLabel`/`shortLabel`/`plural`).
+
+- [x] Add tests: `famousGalaxy row bears a label but no marker` (assert `bearsLabel` true, `bearsMarker` false, `labelLayer === 'galaxyNames'`); `famousGalaxy category copy is detail 'Famous Galaxy' / short 'Galaxy' / plural 'Famous Galaxies'`; `structure rows bear both a label and a marker` (loop cluster/supercluster/void/group); `bulk survey rows bear neither` (assert sdss/glade false/false).
+- [x] Run: `npm test -- sources` → new tests FAIL (fields absent).
+- [x] Add the five fields to `SourceEntryBase`; populate every row in `sources.ts`.
+- [x] Run: `npm test -- sources` and `npm run typecheck` → PASS.
+- [x] Commit (`git add src/@types/data/SourceEntryBase.d.ts src/data/sources.ts tests/data/sources.test.ts`).
+
+### Task A2: Derive `LABEL_CATEGORIES` + `LabelCategory` from the registry
+
+**Files:**
+
+- Create: `src/data/labelCategories.ts`
+- Create: `src/@types/engine/data/LabelCategory.d.ts`
+- Test: `tests/data/labelCategories.test.ts`
+
+**Contract** (mirror `src/data/structureCategories.ts` + `src/@types/engine/data/StructureCategory.d.ts`):
+
+```ts
+// src/data/labelCategories.ts
+export const LABEL_CATEGORIES = /* SOURCE_ENTRIES filtered by bearsLabel, mapped to .id, registry order */;
+// src/@types/engine/data/LabelCategory.d.ts
+export type LabelCategory = (typeof LABEL_CATEGORIES)[number];
+```
+
+- [x] Add tests in `tests/data/labelCategories.test.ts`: `LABEL_CATEGORIES contains famousGalaxy and the four structure categories` (assert sorted equals `['cluster','famousGalaxy','group','supercluster','void']`); `LABEL_CATEGORIES is a superset of STRUCTURE_CATEGORIES`; `LABEL_CATEGORIES excludes bulk surveys` (no `'sdss'`/`'glade'`).
+- [x] Run: `npm test -- labelCategories` → FAIL (module absent).
+- [x] Implement `labelCategories.ts` (filter `SOURCE_ENTRIES` by `bearsLabel`) and the `LabelCategory` type alias.
+- [x] Run: `npm test -- labelCategories` + `npm run typecheck` → PASS.
+- [x] Commit.
+
+### Task A3: Fold the display table into a registry-derived accessor
+
+**Files:**
+
+- Create: `src/data/categoryDisplayInfo.ts` (derived `CATEGORY_DISPLAY_INFO` keyed by `LabelCategory`, fields `{ label, shortLabel, plural }` sourced from the registry rows' `detailLabel`/`shortLabel`/`plural`)
+- Modify: every `POI_CATEGORY_INFO` consumer (enumerate with `rg -l 'POI_CATEGORY_INFO|poiCategoryInfo|PoiCategoryInfo' src` — expect InfoCard / SettingsPanel family)
+- Delete: `src/data/poiCategoryInfo.ts`
+- Test: `tests/data/categoryDisplayInfo.test.ts` (rename from any `poiCategoryInfo` test if one exists; else new)
+
+**Contract:**
+
+```ts
+export type CategoryDisplayInfo = { label: string; shortLabel: string; readonly plural: string };
+export const CATEGORY_DISPLAY_INFO: Readonly<Record<LabelCategory, CategoryDisplayInfo>>;
+```
+
+Mapping: `label ← row.detailLabel`; `shortLabel ← row.shortLabel`; `plural ← row.plural` (all explicit registry fields — see A1).
+
+- [x] Add tests: `CATEGORY_DISPLAY_INFO has a row per LabelCategory`; `cluster renders 'Galaxy Cluster' / 'Cluster' / 'Clusters'`; `famousGalaxy renders 'Famous Galaxy' / 'Galaxy' / 'Famous Galaxies'`.
+- [x] Run → FAIL.
+- [x] Implement `categoryDisplayInfo.ts` deriving from the registry; repoint every `POI_CATEGORY_INFO[x]` read to `CATEGORY_DISPLAY_INFO[x]`; delete `poiCategoryInfo.ts`.
+- [x] Run the touched tests + `npm run typecheck` → PASS. Confirm `rg 'POI_CATEGORY_INFO|poiCategoryInfo' src` is empty.
+- [x] Commit.
+
+### Task A4: Rename `PoiCategory` → `LabelCategory`; retype the visibility records
+
+**Files (enumerate first with `rg -l 'PoiCategory' src`):** `@types/settings/EngineSettingsState.d.ts`, `@types/settings/UseEngineSettingsState.d.ts`, `@types/engine/EngineCallbacks.d.ts`, `@types/engine/wiring/SettingsCallbackSeed.d.ts`, `@types/engine/subsystems/Selection.d.ts`, `@types/engine/handles/EngineLabelsHandle.d.ts`, `@types/engine/UseEngineReturn.d.ts`, `src/hooks/useEngine.ts`, `src/hooks/useEngineSettings.ts`, `src/components/SettingsPanel/SettingsPanel.tsx`, `src/services/engine/engine.ts`, `src/services/engine/labelStyleOverride.ts`, `src/services/engine/wiring/assetWiring.ts`, the 4 visibility-default fixtures under `tests/`.
+
+- Delete: `src/@types/engine/data/PoiCategory.d.ts`
+
+**Contract changes:**
+
+```ts
+readonly labelCategoryVisibility: Readonly<Record<LabelCategory, boolean>>;
+readonly markerCategoryVisibility: Readonly<Record<StructureCategory, boolean>>; // narrowed — no famousGalaxy
+// labelStyleOverride.ts:
+export type LabelStyleOverrideTarget = 'youAreHere' | LabelCategory;
+```
+
+Default-visibility literals (`engine.ts:451-465`, `useEngineSettings.ts:174-188`) derive from `LABEL_CATEGORIES` / `STRUCTURE_CATEGORIES` instead of hand-listed `{ famousGalaxy: true, cluster: true, ... }`.
+
+- [x] Update/add fixture + type tests first where assertions exist (`tests/@types/engineSettingsState.labelCategoryVisibility.test.ts`): assert `markerCategoryVisibility` has no `famousGalaxy` key and `labelCategoryVisibility` does.
+- [x] Run → FAIL.
+- [x] Replace `PoiCategory` with `LabelCategory` import-by-import; narrow the marker record key type to `StructureCategory`; derive the default literals from the category sets; delete `PoiCategory.d.ts`.
+- [x] Run `npm run typecheck` + the touched tests → PASS. `rg 'PoiCategory' src tests` empty.
+- [x] Commit.
+
+### Task A5: De-special-case the visibility setters
+
+**Files:**
+
+- Modify: `src/services/engine/engine.ts:261-323` (`setCategoryLabelVisible`, `setCategoryMarkerVisible`)
+- Test: existing `tests/services/engine/setCategoryVisibleFade.test.ts`, `tests/services/engine/setSourceVisibleFade.test.ts`
+
+**Contract:**
+
+```ts
+function setCategoryMarkerVisible(state, cb, category: StructureCategory, visible: boolean): void;
+function setCategoryLabelVisible(state, cb, category: LabelCategory, visible: boolean): void;
+```
+
+- `setCategoryMarkerVisible`: drop the `if (category !== 'famousGalaxy')` guard entirely — every `StructureCategory` fires a `markerLayer` fade.
+- `setCategoryLabelVisible`: replace the `if (category === 'famousGalaxy')` branch with a dispatch on the row's `labelLayer` field — `'galaxyNames'` fires the `galaxyNames` labelLayer fade (+ `setFamousLabelsVisible`); `'structure'` fires the structure labelLayer fade keyed by `category`.
+
+- [x] Update tests: `setCategoryMarkerVisible fires a markerLayer fade for every structure category`; `setCategoryLabelVisible routes famousGalaxy to the galaxyNames layer`; `...routes a structure category to the structure label layer`.
+- [x] Run → FAIL (guards still present / wrong signatures).
+- [x] Rewrite both setters per the contract.
+- [x] Run the two test files + `npm run typecheck` → PASS.
+- [x] Commit.
+
+---
+
+## Phase B — Fold `#poi=` into `#focus=`
+
+### Task B1: Add the `structure` variant to the focus codec
+
+**Files:**
+
+- Modify: `src/@types/camera/FocusTarget.d.ts`
+- Modify: `src/services/url/focusUrl.ts` (`parseFocusHash`, `selectionToFocusId`)
+- Test: `tests/services/url/focusUrl.test.ts`
+
+**Contract:**
+
+```ts
+export type FocusTarget =
+  | { kind: 'famous'; id: string }
+  | { kind: 'pgc'; pgc: bigint }
+  | { kind: 'sdss'; objID: bigint }
+  | { kind: 'pos'; raDeg: number; decDeg: number }
+  | { kind: 'structure'; id: string }; // NEW
+```
+
+- `parseFocusHash`: a `focus=` body whose id starts with `cluster-` / `supercluster-` / `void-` / `group-` → `{ kind: 'structure', id }`; the existing pgc/sdss/pos/famous ladder is otherwise unchanged. Derive the prefix set from `STRUCTURE_CATEGORIES` (no hardcoded list).
+- `selectionToFocusId(info: GalaxyInfo)` is galaxy-only; add a sibling path so a structure selection encodes to its `id` verbatim. (Check how `computeDesiredHash` calls it in B3 — the structure branch may bypass `selectionToFocusId` and use `record.id` directly. Pick whichever keeps the codec galaxy/structure split clean.)
+
+- [x] Add tests: `parseFocusHash routes cluster-virgo-m87 to kind structure`; one per category prefix; `a famous id without a structure prefix still routes to kind famous`; `pgc-/sdss-/pos@ ladder unchanged` (regression).
+- [x] Run: `npm test -- focusUrl` → FAIL.
+- [x] Implement the variant + prefix routing.
+- [x] Run → PASS + `npm run typecheck`.
+- [x] Commit.
+
+### Task B2: Drop `#poi=` from `hasDeepLink`
+
+**Files:**
+
+- Modify: `src/utils/url/hasDeepLink.ts:44-58`
+- Test: `tests/utils/url/hasDeepLink.test.ts`
+
+- [x] Add/adjust tests: `#focus=cluster-virgo-m87 is a deep link`; `#poi=... is NOT a deep link` (documents the intentional break); `#focus=m31` regression still true.
+- [x] Run → the `#poi=` test FAILs (still treated as deep link).
+- [x] Remove the `#poi=` branch (`hasDeepLink.ts:48`); update the docblock (drop the `#poi=` bullet).
+- [x] Run → PASS.
+- [x] Commit.
+
+### Task B3: Route structures through the single focus codec in `useUrlSync`
+
+**Files:**
+
+- Modify: `src/hooks/useUrlSync.ts` (imports, `InitialPending`, `computeDesiredHash`, `initialPendingFromHash`, hook body slot rename)
+- Test: `tests/hooks/useUrlSync.test.ts`
+
+**Contract:**
+
+```ts
+export type InitialPending =
+  | { kind: 'galaxy'; target: FocusTarget }
+  | { kind: 'structure'; id: string } // was { kind: 'poi'; poiId }
+  | { kind: null };
+```
+
+- Remove the `parsePoiHash` import + call. `initialPendingFromHash` parses one `#focus=` hash; a `kind:'structure'` `FocusTarget` → `{ kind:'structure', id }`, everything else → `{ kind:'galaxy', target }`.
+- `computeDesiredHash`: a structure focus writes `focus=<id>` (not `poi=<id>`). A galaxy writes `focus=<id>` as today.
+- Rename state slot `pendingPoiId` → `pendingStructureId` (and its setter); update the popstate handler + effect 4 (the structure drain) + the `UrlSyncReturn` shape (`@types/engine/UrlSyncReturn.d.ts`).
+- Keep BOTH pending slots and both drains — the resolution sources differ (async catalogs vs synchronous structure table); do not merge them.
+
+- [x] Update tests: `initialPendingFromHash routes #focus=cluster-... to kind structure`; `computeDesiredHash writes focus=<id> for a structure target`; `galaxy hashes unchanged`; rename existing `poi`-named cases.
+- [x] Run: `npm test -- useUrlSync` → FAIL.
+- [x] Apply the changes (the `camera.focusOn` drain already accepts structures — no logic change there, just the slot/parse rename).
+- [x] Run → PASS + `npm run typecheck`.
+- [x] Commit.
+
+### Task B4: Delete the `poiUrl` codec
+
+**Files:**
+
+- Delete: `src/services/url/poiUrl.ts`, `tests/services/url/poiUrl.test.ts`
+
+- [x] Confirm `rg 'poiUrl|parsePoiHash|poiIdToHash' src tests` shows only the files to delete (B1/B3 removed all consumers).
+- [x] Delete both files.
+- [x] Run `npm run typecheck` + `npm test -- url` → PASS.
+- [x] Commit (`git rm` the two paths).
+
+---
+
+## Phase C — Mechanical `poi → structure` renames
+
+> For each task: enumerate sites with `rg`, rename via edits + `git mv` for files, update the mirrored test, keep typecheck green. These are pure renames — no behaviour change.
+
+### Task C1: `isPoi` → `isStructure`
+
+**Files:** `git mv src/services/engine/isPoi.ts src/services/engine/isStructure.ts`; `git mv tests/services/engine/isPoi.test.ts tests/services/engine/isStructure.test.ts`; consumers via `rg -l '\bisPoi\b' src tests` (expect `pickToSelection`/`useUrlSync`/`commitFocus`/`engine.ts` + several `@types` JSDoc refs).
+
+**Contract:** `export function isStructure(target: FocusableTarget): target is StructureRecord`
+
+- [x] `git mv` both files; rename the function + all call sites + the test `describe`/imports.
+- [x] Run `npm test -- isStructure` + `npm run typecheck` → PASS. `rg '\bisPoi\b' src tests` empty.
+- [x] Commit.
+
+### Task C2: `resolvePoiFromPick` → `resolveStructureFromPick`
+
+**Files:** `git mv src/services/engine/helpers/resolvePoiFromPick.ts → resolveStructureFromPick.ts`; `git mv` its test; modify `src/services/engine/helpers/pickToSelection.ts` (consumer).
+
+**Contract:**
+
+```ts
+export type PickStructureInput = {
+  readonly category: StructureCategory;
+  readonly structureIndex: number;
+};
+export function resolveStructureFromPick(
+  structures: PickStructureStore,
+  input: PickStructureInput,
+): StructureRecord | null;
+```
+
+Note: the input `category` can narrow to `StructureCategory` now (the `famousGalaxy` early-return guard at `resolvePoiFromPick.ts:60` becomes unnecessary once the caller passes a `StructureCategory` — verify the caller's type; keep a defensive guard only if the caller still supplies a wider type).
+
+- [x] Rename file + fn + type + the `poiIndex` field → `structureIndex`; update `pickToSelection.ts` + the test.
+- [x] Run the test + `npm run typecheck` → PASS.
+- [x] Commit.
+
+### Task C3: `structurePoiStyles` → `structureMarkerStyles`
+
+**Files:** `git mv src/services/engine/presentation/structurePoiStyles.ts → structureMarkerStyles.ts`; `git mv tests/data/poiCategories.test.ts → tests/data/structureMarkerStyles.test.ts`; consumers via `rg -l 'STRUCTURE_POI_STYLES|structurePoiStyles' src tests` (expect `produceStructureMarkers`/`produceStructureLabels`).
+
+**Contract:** export `STRUCTURE_MARKER_STYLES` (type `StructureMarkerStyle` keeps its name); `SIG_MIN_ALPHA` unchanged.
+
+- [x] `git mv` both; rename the export + consumers; in the test, drop the `PoiCategory` import (use `StructureCategory`) and rename the `describe`.
+- [x] Run `npm test -- structureMarkerStyles` + `npm run typecheck` → PASS. `rg 'STRUCTURE_POI_STYLES|structurePoiStyles' src tests` empty.
+- [x] Commit.
+
+### Task C4: `poiIndex` → `structureIndex` in the marker/pick path
+
+**Files (sites not covered by C2):** `src/services/gpu/renderers/structureMarkerRenderer.ts`, `src/@types/rendering/StructureMarkerRenderer.d.ts`, `src/services/engine/presentation/produceStructureMarkers.ts`, `src/@types/engine/CreateClickResolverInput.d.ts`; mirrored tests (`structureMarkerRenderer.*.test.ts`, `ringPick.test.ts`).
+
+- [x] `rg -n '\bpoiIndex\b' src tests` → rename every remaining occurrence to `structureIndex` (field names, locals, comments).
+- [x] Run the affected renderer tests + `npm run typecheck` → PASS. `rg '\bpoiIndex\b' src tests` empty.
+- [x] Commit.
+
+### Task C5: `FocusState.poiId` → `structureId`; widen `category`
+
+**Files:** `src/@types/engine/state/FocusState.d.ts`; consumers via `rg -l 'poiId' src` (expect `structureFocusSubsystem`, `commitStructureFocus`, `structureMembership`, the membership-cache key); mirrored tests.
+
+**Contract:**
+
+```ts
+readonly structureId: string;          // was poiId
+readonly category: StructureCategory;  // was 'cluster' | 'supercluster' | 'void'  (now includes group)
+```
+
+- [x] Update tests asserting `FocusState` shape / the membership cache key first.
+- [x] Rename `poiId` → `structureId` everywhere; widen `category` to `StructureCategory`; check the membership-cache key string (`structureMembership.ts:12`) and any focus-framing switch handles `group` (it should, since group is already a focusable structure).
+- [x] Run the focus/membership tests + `npm run typecheck` → PASS.
+- [x] Commit.
+
+### Task C6: `selectedPoi` → `selectedStructure`
+
+**Files:** `rg -ln 'selectedPoi' src` → `src/services/engine/frame/passes/selectionRingPass.ts`, `src/@types/engine/handles/EngineSubsystemHandles.d.ts`, `src/services/engine/engine.ts` (mostly param names + comments).
+
+- [x] Rename the param/comment occurrences to `selectedStructure`.
+- [x] Run `npm run typecheck` + `npm test -- selectionRingPass` → PASS.
+- [x] Commit.
+
+### Task C7: Doc-comment + remaining-token sweep
+
+**Files:** every `poi`/`POI` left in comments. Enumerate: `rg -n 'poi|POI' src tests -g '*.ts' -g '*.tsx' -g '*.wesl' | rg -iv 'point|poisson|poison'`.
+
+- [x] For each remaining hit (docblocks in `commitGalaxyFocus`, `commitStructureFocus`, `clearAll`, `selectionSubsystem`, `buildStaticAnchorStructures`, `assetWiring`, `useUrlSync`, `useSplash`, `App.tsx`, etc.) reword "POI"/"poi" to "structure" (or "deep link" where it described the URL generically). Follow `feedback_comment_style` — timeless + terse, no history notes.
+- [x] `rg 'poi|POI' src tests -g '*.ts' -g '*.tsx' -g '*.wesl' | rg -iv 'point|poisson|poison'` → empty.
+- [x] Run `npm run typecheck` → PASS.
+- [x] Commit.
+
+### Task C8: Rename the remaining `*.poi.test.ts` files + final verification
+
+**Files:** `git mv tests/services/engine/phases/wireInput.poi.test.ts → wireInput.structure.test.ts`; `git mv tests/services/gpu/renderers/pickRenderer.poi.test.ts → pickRenderer.structure.test.ts`; `git mv tests/@types/engine/EngineCameraHandle.poi.test.ts → EngineCameraHandle.structure.test.ts`. Update each `describe`/imports if they reference renamed symbols.
+
+- [x] `git mv` the three files; fix any internal `poi` references.
+- [x] **Entanglement-radar verification:** run the `entanglement-radar` lens over `git diff main...HEAD` — confirm the spec's un-braided choices survived: `PoiCategory` gone (not re-spelled), marker record narrowed (no phantom `famousGalaxy`), the two URL resolution paths NOT merged, the famousGalaxy `if`-branches dissolved into `labelLayer` data. Note any regressions and fix before finishing.
+- [x] **Full sweep:** `find src tests -iname '*poi*'` empty; `rg 'poi|POI' src tests -g '*.ts' -g '*.tsx' -g '*.wesl' | rg -iv 'point|poisson|poison'` empty.
+- [x] Run full `npm test` + `npm run typecheck` + `npm run build` → all green.
+- [x] Prettier all touched files; commit.
+
+---
+
+## Self-review notes
+
+**Spec coverage:** A1–A5 cover spec Part A (capability flags A1, display fold A2/A3, derived types A2, record retype A4, setter de-special-case A5). B1–B4 cover Part B (codec variant B1, hasDeepLink B2, useUrlSync B3, delete B4). C1–C8 cover Part C (every rename row in the spec's Part C table + the test renames + the final entanglement-radar gate).
+
+**Judgement calls (flag for review):**
+
+1. **`famousGalaxy` display copy — RESOLVED (2026-06-08):** the category display fields are explicit on the row (not derived from the source `label`), so the famous _source_ keeps `label: 'Famous'` while the _category_ reads detail `'Famous Galaxy'` / short `'Galaxy'` / plural **`'Famous Galaxies'`** (user's call: toggle/header shows "Famous Galaxies"). Baked into A1/A3 above.
+2. **`tests/data/poiCategories.test.ts` fate:** the spec suggested re-scoping it to the derived sets, but it currently tests the _style table_. This plan instead renames it to `structureMarkerStyles.test.ts` (C3, style assertions) and creates a fresh `labelCategories.test.ts` (A2, derived sets). Two clear tests beats one re-scoped one.
+3. **`resolveStructureFromPick` defensive guard:** the `famousGalaxy` early-return may become dead once the caller passes `StructureCategory` (C2). Drop it only if the caller's type genuinely narrows; otherwise keep it.
diff --git a/docs/superpowers/specs/completed/2026-06-08-poi-free-codebase-design.md b/docs/superpowers/specs/completed/2026-06-08-poi-free-codebase-design.md
new file mode 100644
index 000000000..359096946
--- /dev/null
+++ b/docs/superpowers/specs/completed/2026-06-08-poi-free-codebase-design.md
@@ -0,0 +1,302 @@
+# Make the codebase `poi`-free — design
+
+**Date:** 2026-06-08
+**Status:** design (awaiting plan)
+**Worktree/branch:** `worktree-make-codebase-poi-free`
+**Backlog item:** "Make the codebase `poi`-free (`poi*` → `structure*`)" (Priority: high)
+
+## Motivation
+
+The data layer is already `StructureRecord` / `StructureStore` and the InfoCard
+family is `StructureDetailCard` / `CompactStructureCard`. The legacy `poi`
+("point of interest") vocabulary survives at the engine / identity / URL edges.
+An `entanglement-radar` pass (2026-06-08) found the wart is sharper than a
+straight rename: **`poi` is one name for two genuinely different concepts**, and
+a blind `poi → structure` rename would silently merge them.
+
+### Concept A — `poi` already _means_ "structure"
+
+These sites are about structures specifically; renaming to `structure` makes the
+name **more** accurate:
+
+- `isPoi(t): t is StructureRecord` — the predicate literally returns `StructureRecord`.
+- `resolvePoiFromPick → StructureRecord`, `PickPoiInput`, `poiIndex` (ring-pick decode).
+- `poiUrl.ts` / `parsePoiHash` / `poiIdToHash` / `#poi=` — encodes `StructureRecord.id`.
+- `FocusState.poiId` — the focused structure id (membership cache key).
+- `selectedPoi` engine param (`selectionRingPass`, `EngineSubsystemHandles`).
+- `STRUCTURE_POI_STYLES` / `structurePoiStyles.ts` — already keyed by `StructureCategory`.
+
+### Concept B — `poi` means "the focusable category superset"
+
+`PoiCategory = StructureCategory | 'famousGalaxy'` is **not** a synonym for
+`structure` — it is a strict superset including `famousGalaxy`. A mechanical
+`Poi → Structure` rename here is a type collision (`StructureCategory` exists)
+**and** a semantic lie (drops `famousGalaxy`). This type keys the SettingsPanel
+**label/marker visibility toggles**.
+
+Tracing why `famousGalaxy` is a member exposes the actual braid
+(`engine.ts:261-323`):
+
+- **Labels:** `famousGalaxy` _does_ bear labels (routed to the `galaxyNames`
+  fade layer); structures bear labels (routed to the structure label layer).
+- **Markers:** `famousGalaxy` has **no** ring/halo marker — the marker toggle
+  for it is a dead no-op; only structures bear markers.
+
+So the two real axes are different sets:
+
+- **label-bearing** = `{famousGalaxy, cluster, supercluster, void, group}`
+- **marker-bearing** = `{cluster, supercluster, void, group}` (structures only)
+
+The current code crushes both into one `PoiCategory` union and pays for it with
+`if (category === 'famousGalaxy')` branches and a **phantom `famousGalaxy` key**
+in the marker visibility record. "Having a label / having a marker" is a
+_property of the thing_, not a category that singles out famous galaxies — which
+is exactly what makes `famousGalaxy` look out of place in the union.
+
+## Goals
+
+1. No `poi`/`Poi`/`POI` identifier, filename, or doc-comment survives in `src/`
+   or the mirrored `tests/`. (`tools/` is already clean.)
+2. `PoiCategory` and the `famousGalaxy` special-casing **dissolve** into
+   registry-derived data — `famousGalaxy` becomes "just a row" with capability
+   flags, not a hand-listed exception.
+3. The `#poi=` deep-link folds entirely into `#focus=`; the `poiUrl` codec is
+   deleted.
+
+## Non-goals
+
+- No back-compat for old `#poi=` shared links — they intentionally fall through
+  to "no deep link" (decided 2026-06-08).
+- No change to the structure data layer, `.ccat` format, or the `Source.Cluster`
+  /`'cluster'` category vocabulary (already `Structure*`-clean).
+- No render/visual behaviour change. The label & marker toggles behave
+  identically; only the marker record sheds its dead `famousGalaxy` key.
+
+---
+
+## Part A — Dissolve `PoiCategory` into two registry-derived axes
+
+### A1. Registry capability flags
+
+Add to `SOURCE_REGISTRY` rows (via `SourceEntryBase` or per-variant):
+
+```ts
+// SourceEntryBase additions
+/** True if this category carries toggleable on-screen text labels. */
+readonly bearsLabel: boolean;
+/** True if this category carries a ring/halo marker (structures only today). */
+readonly bearsMarker: boolean;
+/**
+ * Which fade layer this category's labels live on. Present iff bearsLabel.
+ *  - 'galaxyNames' — the shared galaxy-name layer (famousGalaxy)
+ *  - 'structure'   — the per-structure-category label layer
+ */
+readonly labelLayer?: 'galaxyNames' | 'structure';
+```
+
+Settings per row:
+
+| row                                 | bearsLabel | bearsMarker | labelLayer    |
+| ----------------------------------- | ---------- | ----------- | ------------- |
+| famousGalaxy                        | true       | false       | 'galaxyNames' |
+| cluster                             | true       | true        | 'structure'   |
+| supercluster                        | true       | true        | 'structure'   |
+| void                                | true       | true        | 'structure'   |
+| group                               | true       | true        | 'structure'   |
+| sdss/glade/2mrs/milliquas/synthetic | false      | false       | —             |
+
+### A2. Display metadata folded into the registry
+
+The standalone `data/poiCategoryInfo.ts` (`POI_CATEGORY_INFO`, `PoiCategoryInfo`)
+is **removed**. Its three fields move onto the label-bearing registry rows. The
+existing `SourceEntryBase.label` already holds the short UI name
+(`'Cluster'`, `'Famous'`), so only the longer + plural forms are new:
+
+```ts
+// SourceEntryBase additions (present iff bearsLabel)
+/** Long form for detail surfaces ("Galaxy Cluster"). */
+readonly detailLabel?: string;
+/** Plural for list/toggle headers ("Clusters"). */
+readonly plural?: string;
+```
+
+Mapping from the old table: old `shortLabel` ≡ existing `label`; old `label`
+→ `detailLabel`; old `plural` → `plural`. (Note `famousGalaxy`'s existing
+registry `label` is `'Famous'` but its old `shortLabel` was `'Galaxy'` — the
+detail/short copy is reconciled in the plan; default to the old display-table
+strings since those are what the UI renders today.)
+
+A derived accessor (e.g. `categoryDisplayInfo(id)` or a derived
+`CATEGORY_DISPLAY_INFO` map built from the registry) replaces every
+`POI_CATEGORY_INFO[cat]` read.
+
+### A3. Derived category sets + types
+
+Derive from the registry (companion to `structureCategories.ts`):
+
+```ts
+// data/labelCategories.ts (new) — label-bearing rows, registry order
+export const LABEL_CATEGORIES = /* registry rows where bearsLabel */;
+export type LabelCategory = (typeof LABEL_CATEGORIES)[number];
+// = 'famousGalaxy' | 'cluster' | 'supercluster' | 'void' | 'group'
+```
+
+- `LabelCategory` **replaces `PoiCategory`** (honest name; still contains
+  `famousGalaxy` because famous galaxies genuinely _are_ the labelled galaxies —
+  that is data, not a special case). `@types/engine/data/PoiCategory.d.ts` is
+  deleted.
+- The **marker** axis narrows to `StructureCategory` (markers are structure-only).
+
+### A4. Visibility records re-typed
+
+- `labelCategoryVisibility: Readonly<Record<LabelCategory, boolean>>`
+- `markerCategoryVisibility: Readonly<Record<StructureCategory, boolean>>`
+  — **drops the phantom `famousGalaxy` key.**
+
+Touches `EngineSettingsState`, `UseEngineSettingsState`, `EngineCallbacks`,
+`SettingsCallbackSeed`, `Selection`, `EngineLabelsHandle`, `useEngineSettings`,
+`SettingsPanel`, `engine.ts` defaults, the 4 test fixtures. The hand-written
+`{ famousGalaxy: true, cluster: true, ... }` default literals derive from the
+category sets instead (also retires the backlog's "copy-pasted 8×
+DEFAULT_CATEGORY_VISIBILITY" sub-item for these records).
+
+### A5. Setters de-special-cased
+
+- `setCategoryMarkerVisible(category: StructureCategory, …)` — the
+  `if (category !== 'famousGalaxy')` no-op guard is **deleted**.
+- `setCategoryLabelVisible(category: LabelCategory, …)` — fires the fade on the
+  layer named by the row's `labelLayer` field (A1), replacing the
+  `if (category === 'famousGalaxy')` branch. `galaxyNames` → fade
+  `{kind:'labelLayer', layer:'galaxyNames'}` (plus `setFamousLabelsVisible`);
+  `structure` → fade `{kind:'labelLayer', layer:'<structure>', category}`.
+
+---
+
+## Part B — Fold `#poi=` into `#focus=`
+
+`camera.focusOn()` is already unified (accepts `GalaxyInfo | StructureRecord`),
+so only the URL codec layer is split.
+
+### B1. Single codec
+
+- **Delete** `services/url/poiUrl.ts` (`parsePoiHash`, `poiIdToHash`) and its
+  test.
+- `FocusTarget` gains a structure variant:
+
+  ```ts
+  export type FocusTarget =
+    | { kind: 'famous'; id: string }
+    | { kind: 'pgc'; pgc: bigint }
+    | { kind: 'sdss'; objID: bigint }
+    | { kind: 'pos'; raDeg: number; decDeg: number }
+    | { kind: 'structure'; id: string }; // NEW
+  ```
+
+- `parseFocusHash`: a `focus=` body whose id begins with a structure-category
+  prefix (`cluster-` / `supercluster-` / `void-` / `group-`) parses to
+  `{ kind: 'structure', id }`; otherwise the existing galaxy ladder is unchanged.
+  (Galaxy famous-ids never use those prefixes, so no collision.)
+- `selectionToFocusId`: for a structure selection, return `info.id` verbatim
+  (structure ids are already curated + stable, e.g. `cluster-virgo-m87`); the
+  galaxy ladder is unchanged.
+
+### B2. `hasDeepLink`
+
+Drop the `#poi=` branch. The `#focus=` branch now also covers structures.
+
+### B3. `useUrlSync`
+
+Keep the **two pending slots** — galaxy resolution is async against loaded
+catalogs; structure resolution is a synchronous table lookup. They are genuinely
+different resolution sources and must not be complected. The fold is purely at
+the codec/parse-routing level:
+
+- `initialPendingFromHash` parses one `#focus=` hash; a `kind:'structure'`
+  result routes to the structure slot, everything else to the galaxy slot. The
+  second parser call (`parsePoiHash`) is removed.
+- `InitialPending`'s `{ kind: 'poi'; poiId }` → `{ kind: 'structure'; id }`.
+- Slot/state rename: `pendingPoiId` → `pendingStructureId`.
+- `computeDesiredHash`: a structure target writes `focus=<id>` (via
+  `selectionToFocusId`), not `poi=<id>`.
+
+---
+
+## Part C — Mechanical `poi → structure` renames
+
+All sites where `poi` already means "structure":
+
+| Now                                                                                 | Becomes                                                                                           |
+| ----------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
+| `services/engine/isPoi.ts` `isPoi()`                                                | `isStructure.ts` `isStructure()`                                                                  |
+| `resolvePoiFromPick.ts`, `resolvePoiFromPick`, `PickPoiInput`, `poiIndex`           | `resolveStructureFromPick.ts`, `resolveStructureFromPick`, `PickStructureInput`, `structureIndex` |
+| `structurePoiStyles.ts`, `STRUCTURE_POI_STYLES`                                     | `structureMarkerStyles.ts`, `STRUCTURE_MARKER_STYLES`                                             |
+| `FocusState.poiId`                                                                  | `FocusState.structureId`                                                                          |
+| `FocusState.category: 'cluster'\|'supercluster'\|'void'`                            | `StructureCategory` (also picks up the missing `group`)                                           |
+| `selectedPoi` param (`selectionRingPass`, `EngineSubsystemHandles`, `engine.ts`)    | `selectedStructure`                                                                               |
+| `structureMarkerRenderer` `poiIndex` packing / `StructureMarkerRenderer` `poiIndex` | `structureIndex`                                                                                  |
+| `produceStructureMarkers` `poiIndex`                                                | `structureIndex`                                                                                  |
+| `CreateClickResolverInput` `poiIndex`                                               | `structureIndex`                                                                                  |
+
+Plus all `poi`/`POI` in doc-comments (`commitGalaxyFocus`, `commitStructureFocus`,
+`clearAll`, `selectionSubsystem`, `buildStaticAnchorStructures`,
+`structureMembership`, `assetWiring`, `FocusState`, …).
+
+Test files renamed to match: `isPoi.test.ts` → `isStructure.test.ts`,
+`resolvePoiFromPick.test.ts` → `resolveStructureFromPick.test.ts`,
+`wireInput.poi.test.ts` → `wireInput.structure.test.ts`,
+`pickRenderer.poi.test.ts` → `pickRenderer.structure.test.ts`,
+`EngineCameraHandle.poi.test.ts` → `EngineCameraHandle.structure.test.ts`,
+`poiCategories.test.ts` → `labelCategories.test.ts` (re-scoped to the derived
+sets). `poiUrl.test.ts` is **deleted**; its structure-id round-trip cases move
+into `focusUrl.test.ts`.
+
+---
+
+## Type changes (contract)
+
+```ts
+// @types/engine/data/LabelCategory.d.ts (replaces PoiCategory.d.ts)
+export type LabelCategory = (typeof LABEL_CATEGORIES)[number];
+
+// @types/camera/FocusTarget.d.ts — add the structure variant (B1)
+
+// @types/engine/state/FocusState.d.ts
+readonly structureId: string;          // was poiId
+readonly category: StructureCategory;  // was 'cluster' | 'supercluster' | 'void'
+
+// @types/settings/EngineSettingsState.d.ts
+readonly labelCategoryVisibility: Readonly<Record<LabelCategory, boolean>>;
+readonly markerCategoryVisibility: Readonly<Record<StructureCategory, boolean>>;
+
+// @types/data/SourceEntryBase.d.ts — add bearsLabel, bearsMarker, labelLayer?,
+//                                     detailLabel?, plural? (A1, A2)
+```
+
+## Testing
+
+- The rename is type-driven: a missed Concept-A/B site won't compile.
+  `npm run typecheck` + the full `npm test` suite are the safety net.
+- New `focusUrl` tests: `#focus=cluster-virgo-m87` ↔ `{kind:'structure'}`
+  round-trip; each structure-category prefix; galaxy ladder regression
+  unaffected; a structure id is never mis-parsed as a famous id.
+- New test: a `#poi=…` hash now yields no deep link (documents the intentional
+  break) — added to `hasDeepLink` / `focusUrl` tests.
+- New `labelCategories` test: `LABEL_CATEGORIES` / `MARKER_CATEGORIES` derive
+  the expected sets from the registry; the marker set excludes `famousGalaxy`.
+- `setCategoryMarkerVisible` / `setCategoryLabelVisible` tests updated for the
+  narrowed types and the `labelLayer`-driven routing.
+
+## Execution
+
+Per project workflow: `subagent-driven-development`. Edits delegated to
+background implementer subagents; the main thread runs `npm test` /
+`typecheck`, prettiers touched files, and commits. Branch + PR (squash-merge).
+No data rebuild or R2 sync — this is code-only (the `cluster*→structure*`
+artifact rename from #280 already handled the deploy side).
+
+## Out of scope (follow-ups)
+
+- The broader `STRUCTURE_CATEGORY_META` DRY consolidation beyond the display-info
+  fold done here (the `hasBulkCatalog` flag, the `POI_CATEGORIES_WITH_MARKERS`
+  derivation) — see `docs/BACKLOG.md`.
+- Promoting the Milky Way to a first-class `Source` — separate backlog item.
diff --git a/src/@types/animation/CategoryLabelLayer.d.ts b/src/@types/animation/CategoryLabelLayer.d.ts
new file mode 100644
index 000000000..1443fc61c
--- /dev/null
+++ b/src/@types/animation/CategoryLabelLayer.d.ts
@@ -0,0 +1,14 @@
+import type { LabelLayerId } from './LabelLayerId';
+
+/**
+ * CategoryLabelLayer — the fade layers a label-bearing *category* can route to.
+ *
+ * This is the subset of `LabelLayerId` reachable from a SOURCE_REGISTRY row's
+ * `labelLayer` field. The other two layers (`youAreHere`, `scaleBar`) are
+ * singleton overlays with no owning category, so they're excluded here.
+ *
+ * Derived from `LabelLayerId` via `Extract` rather than re-spelled, so the
+ * subset can never name a layer that doesn't exist on the fade registry — and
+ * renaming a layer in `LabelLayerId` propagates here for free.
+ */
+export type CategoryLabelLayer = Extract<LabelLayerId, 'galaxyNames' | 'structure'>;
diff --git a/src/@types/animation/FadeHandle.d.ts b/src/@types/animation/FadeHandle.d.ts
index fbf21bc1c..d75850345 100644
--- a/src/@types/animation/FadeHandle.d.ts
+++ b/src/@types/animation/FadeHandle.d.ts
@@ -25,9 +25,9 @@
  *                    Discriminator: `category: StructureCategory`. One
  *                    controller per category so a category's rings can
  *                    fade independently of the others.
- *   - labelLayer   — one logical label layer (you-are-here, POI,
+ *   - labelLayer   — one logical label layer (you-are-here, structure,
  *                    galaxy names, scale bar). Discriminator:
- *                    `layer: LabelLayerId`. POI labels additionally key
+ *                    `layer: LabelLayerId`. Structure labels additionally key
  *                    on `category: StructureCategory` so each structure
  *                    category's labels are a distinct controller; the
  *                    other layers (youAreHere/galaxyNames/scaleBar)
diff --git a/src/@types/animation/LabelLayerId.d.ts b/src/@types/animation/LabelLayerId.d.ts
index e7355b7b8..c51e87363 100644
--- a/src/@types/animation/LabelLayerId.d.ts
+++ b/src/@types/animation/LabelLayerId.d.ts
@@ -11,11 +11,11 @@
  *   - youAreHere — the "YOU ARE HERE" Milky Way pin (a single label +
  *                  marker line). Fades in when the camera reaches the
  *                  band where the marker is meaningful.
- *   - poi        — cluster + named-anchor labels emitted by
+ *   - structure  — cluster + named-anchor labels emitted by
  *                  `produceStructureLabels`.
  *   - galaxyNames — per-galaxy name labels (currently unused but
  *                   reserved; see future plans for hover-name overlay).
  *   - scaleBar   — the on-screen scale-bar HUD. Constructed by React,
  *                  not a GPU layer; reserved for tour integration.
  */
-export type LabelLayerId = 'youAreHere' | 'poi' | 'galaxyNames' | 'scaleBar';
+export type LabelLayerId = 'youAreHere' | 'structure' | 'galaxyNames' | 'scaleBar';
diff --git a/src/@types/camera/FocusTarget.d.ts b/src/@types/camera/FocusTarget.d.ts
index 823327f1a..93645fe2a 100644
--- a/src/@types/camera/FocusTarget.d.ts
+++ b/src/@types/camera/FocusTarget.d.ts
@@ -20,10 +20,15 @@
  *   sdss-<objID>     — SDSS row whose objID is the canonical handle
  *                      (19-digit bigint, exceeds JS Number safe range)
  *   pos@<ra>,<dec>   — fallback for 2MRS/GLADE rows without a PGC
+ *   cluster-virgo-m87  — structure record id: `${category}-${seed.id}`
+ *                        (category from STRUCTURE_CATEGORIES; stable
+ *                        across rebuilds because the seed id is curated)
  */
 
 export type FocusTarget =
   | { kind: 'famous'; id: string }
   | { kind: 'pgc'; pgc: bigint }
   | { kind: 'sdss'; objID: bigint }
-  | { kind: 'pos'; raDeg: number; decDeg: number };
+  | { kind: 'pos'; raDeg: number; decDeg: number }
+  /** A galaxy cluster, supercluster, void, or group anchor from the structure store. */
+  | { kind: 'structure'; id: string };
diff --git a/src/@types/data/SourceEntryBase.d.ts b/src/@types/data/SourceEntryBase.d.ts
index c36478f71..298c623ce 100644
--- a/src/@types/data/SourceEntryBase.d.ts
+++ b/src/@types/data/SourceEntryBase.d.ts
@@ -4,6 +4,8 @@
  * this base and adds its own discriminator (`type: '<kind>'`) plus
  * kind-specific fields.
  */
+import type { CategoryLabelLayer } from '../animation/CategoryLabelLayer';
+
 export type SourceEntryBase = {
   /** Unique readable key — string twin of the numeric `Source` code (e.g. `'sdss'`, `'cluster'`). */
   readonly id: string;
@@ -11,7 +13,7 @@ export type SourceEntryBase = {
   readonly label: string;
   /**
    * True if the source covers (approximately) the full celestial sphere.
-   * For surveys this is the footprint flag; for POIs it's trivially true
+   * For surveys this is the footprint flag; for structures it's trivially true
    * (anchors are individual points, not survey patches), so the renderer's
    * coverage-mask logic stays well-behaved across both kinds.
    */
@@ -23,4 +25,44 @@ export type SourceEntryBase = {
    * off at runtime — this is purely the default.
    */
   readonly visible: boolean;
+  /**
+   * True if this source carries toggleable on-screen text labels.
+   * Drives the label-visibility record and the fade-layer routing in the
+   * label subsystem. The two real label sets are:
+   *   - galaxyNames layer: famousGalaxy
+   *   - structure layer:   cluster, supercluster, void, group
+   * All bulk surveys (sdss, glade, 2mrs, milliquas, synthetic) are false.
+   */
+  readonly bearsLabel: boolean;
+  /**
+   * True if this source carries a ring/halo marker around its anchor point.
+   * Today this is exactly the structure category set (cluster, supercluster,
+   * void, group). famousGalaxy has no ring — only a name label — so the
+   * marker-visibility record excludes it entirely.
+   */
+  readonly bearsMarker: boolean;
+  /**
+   * Which fade layer this source's labels live on. Present iff bearsLabel.
+   *   - 'galaxyNames' — the shared galaxy-name layer (famousGalaxy rows)
+   *   - 'structure'   — the per-structure-category label layer
+   * Absent on non-label-bearing rows (bearsLabel === false).
+   */
+  readonly labelLayer?: CategoryLabelLayer;
+  /**
+   * Long-form label for detail surfaces (e.g. 'Galaxy Cluster', 'Famous Galaxy').
+   * Present iff bearsLabel.
+   */
+  readonly detailLabel?: string;
+  /**
+   * Compact label for chips and previews (e.g. 'Cluster', 'Galaxy').
+   * Present iff bearsLabel. The existing `label` field carries the shortest
+   * UI name ('Cluster', 'Famous') — shortLabel is the one step longer form
+   * the InfoCard chips use.
+   */
+  readonly shortLabel?: string;
+  /**
+   * Plural label for list and toggle headers (e.g. 'Clusters', 'Famous Galaxies').
+   * Present iff bearsLabel.
+   */
+  readonly plural?: string;
 };
diff --git a/src/@types/data/StructureSourceEntry.d.ts b/src/@types/data/StructureSourceEntry.d.ts
index 1a737f7c9..dcf774402 100644
--- a/src/@types/data/StructureSourceEntry.d.ts
+++ b/src/@types/data/StructureSourceEntry.d.ts
@@ -3,9 +3,9 @@ import type { SourceEntryBase } from './SourceEntryBase';
 /**
  * Structure-typed SOURCE_REGISTRY row — the marker-ring codes (Cluster,
  * Supercluster, Void, Group). No `.bin`, bands, or depth, so it just adds
- * `code` to the base. Named `'structure'`, not `'poi'`: famousGalaxy is a POI
- * too but rides the `survey` entry, so this discriminator is exactly the
- * marker-ring set.
+ * `code` to the base. The `'structure'` discriminator covers exactly the
+ * marker-ring set: famousGalaxy is also clickable but rides the `survey`
+ * entry, so it does not appear here.
  */
 export type StructureSourceEntry = SourceEntryBase & {
   readonly type: 'structure';
diff --git a/src/@types/engine/CreateClickResolverInput.d.ts b/src/@types/engine/CreateClickResolverInput.d.ts
index 29335c097..610423554 100644
--- a/src/@types/engine/CreateClickResolverInput.d.ts
+++ b/src/@types/engine/CreateClickResolverInput.d.ts
@@ -5,10 +5,10 @@ export type CreateClickResolverInput = {
   pickRenderer: PickRenderer;
   /**
    * Structure store projection for `pickToSelection` to resolve a ring
-   * hit's `(category, poiIndex)` to its record id. In production
+   * hit's `(category, structureIndex)` to its record id. In production
    * `wireInput` passes `state.data.structures`; tests stub a one-method
    * `{ byCategory }` object. An empty store resolves structure hits to
-   * null — no phantom POI card.
+   * null — no phantom selection.
    */
   structures: PickStructureStore;
 };
diff --git a/src/@types/engine/EngineCallbacks.d.ts b/src/@types/engine/EngineCallbacks.d.ts
index f7ffb6816..7f4650f30 100644
--- a/src/@types/engine/EngineCallbacks.d.ts
+++ b/src/@types/engine/EngineCallbacks.d.ts
@@ -13,7 +13,8 @@ import type { SourceType } from '../data/SourceType';
 import type { BiasMode } from '../data/BiasMode';
 import type { ToneMapCurve } from '../data/ToneMapCurve';
 import type { LoadProgressState } from '../loading/LoadProgressState';
-import type { PoiCategory } from './data/PoiCategory';
+import type { LabelCategory } from './data/LabelCategory';
+import type { StructureCategory } from './data/StructureCategory';
 import type { VolumeFieldRowData } from '../settings/VolumeFieldRowData';
 
 /**
@@ -81,7 +82,7 @@ export type EngineCallbacks = {
 
   /**
    * Selection-state callbacks.  Carry the resolved `FocusableTarget`
-   * (galaxy or POI) so consumers don't need to branch on a separate
+   * (galaxy or structure) so consumers don't need to branch on a separate
    * id callback — they receive the full GalaxyInfo / StructureRecord
    * directly.  Both required: every engine consumer needs hover /
    * select fan-out (InfoCard text, halo, hover preview).
@@ -105,7 +106,7 @@ export type EngineCallbacks = {
     onAutoRotateChange?: (enabled: boolean) => void;
     /**
      * Fired when the camera-focus target changes — i.e. the engine has
-     * started a tween toward (or away from) a specific galaxy or POI.
+     * started a tween toward (or away from) a specific galaxy or structure.
      *
      * Selection (`onSelectChange`) and focus are separate concepts:
      *   - Selection is the pin state — InfoCard, halo highlight.  A bare
@@ -118,8 +119,8 @@ export type EngineCallbacks = {
      * The deep-link URL hook subscribes to focus, not selection, so a
      * casual click doesn't pollute browser history with hash entries —
      * only deliberate focus actions do.  The `FocusableTarget` union
-     * means one callback covers both galaxy and POI focus; consumers
-     * branch on the discriminant (use `isPoi`).
+     * means one callback covers both galaxy and structure focus; consumers
+     * branch on the discriminant (use `isStructure`).
      */
     onFocusChange?: (target: FocusableTarget | null) => void;
     /**
@@ -178,9 +179,9 @@ export type EngineCallbacks = {
    * `onLoadProgress` aggregates byte counts across in-flight slots;
    * `null` means "no fetches in flight" (the UI fades the bar out).
    *
-   * `onStructureCountsChange` reports the number of POIs published per
-   * marker category (cluster / supercluster / void) after each
-   * `rebuildAllPois` merge — the structure analogue of the per-survey
+   * `onStructureCountsChange` reports the number of structures published per
+   * marker category (cluster / supercluster / void) after each structure
+   * rebuild — the structure analogue of the per-survey
    * `onCatalogReady` count, so the Structures panel can show "Clusters
    * 573" the way the Surveys panel shows "SDSS 1,234,567".  Fired with
    * the full snapshot (not a delta) because the three groups settle
@@ -191,7 +192,7 @@ export type EngineCallbacks = {
     onTierChange?: (tier: Tier) => void;
     onCatalogReady?: (source: SourceType, count: number) => void;
     onLoadProgress?: (progress: LoadProgressState | null) => void;
-    onStructureCountsChange?: (counts: Partial<Record<PoiCategory, number>>) => void;
+    onStructureCountsChange?: (counts: Partial<Record<StructureCategory, number>>) => void;
   };
 
   /**
@@ -231,7 +232,7 @@ export type EngineCallbacks = {
   filaments?: { onReady?: (stripCount: number, vertexCount: number) => void };
 
   /**
-   * Echoes for the two independent POI visibility axes
+   * Echoes for the two independent structure visibility axes
    * (label-text vs marker-glyph).  The two records are deliberately
    * separate — flipping one does NOT fire the other.  Label-text and
    * marker-glyph visibility are independent because a category's ring
@@ -243,8 +244,12 @@ export type EngineCallbacks = {
    * `setCategoryMarkerVisible(...)` call.
    */
   labels?: {
-    onLabelCategoryVisibilityChange?: (visibility: Readonly<Record<PoiCategory, boolean>>) => void;
-    onMarkerCategoryVisibilityChange?: (visibility: Readonly<Record<PoiCategory, boolean>>) => void;
+    onLabelCategoryVisibilityChange?: (
+      visibility: Readonly<Record<LabelCategory, boolean>>,
+    ) => void;
+    onMarkerCategoryVisibilityChange?: (
+      visibility: Readonly<Record<StructureCategory, boolean>>,
+    ) => void;
   };
 
   /**
diff --git a/src/@types/engine/FocusableTarget.d.ts b/src/@types/engine/FocusableTarget.d.ts
index 554ef63da..4947bd801 100644
--- a/src/@types/engine/FocusableTarget.d.ts
+++ b/src/@types/engine/FocusableTarget.d.ts
@@ -3,11 +3,11 @@ import type { StructureRecord } from './data/StructureRecord';
 
 /**
  * FocusableTarget — discriminated union of the two things the camera can
- * focus on: a single galaxy point or a point-of-interest anchor (cluster,
- * supercluster, void, famous-galaxy POI).
+ * focus on: a single galaxy point or a structure anchor (cluster,
+ * supercluster, void, famous-galaxy).
  *
  * Used by the public `camera.focusOn(target)` handle (which dispatches via
- * the `isPoi` predicate in `services/engine/isPoi.ts`) and by InfoCard's
+ * the `isStructure` predicate in `services/engine/isStructure.ts`) and by InfoCard's
  * unified `hovered` / `selected` props.  Deliberately distinct from
  * `FocusTarget` in `@types/camera/FocusTarget.d.ts`, which is the
  * URL-parsed deep-link descriptor (`{ kind: 'pgc' | 'objid' | 'famous', ...}`)
diff --git a/src/@types/engine/GalaxyInfo.d.ts b/src/@types/engine/GalaxyInfo.d.ts
index 017f44d01..a786dbc1c 100644
--- a/src/@types/engine/GalaxyInfo.d.ts
+++ b/src/@types/engine/GalaxyInfo.d.ts
@@ -277,7 +277,7 @@ export type GalaxyInfo = {
     /**
      * Curated human-friendly display name when one is set on the seed entry
      * (e.g. `"Andromeda Galaxy"` for M31).  When present, both the InfoCard
-     * headline and the POI label prefer this over `names[0]`; the rest of
+     * headline and the structure label prefer this over `names[0]`; the rest of
      * `names` appears as "Also known as" aliases.  Absent for most entries —
      * the seed only sets commonName for galaxies whose widely-recognised
      * name differs meaningfully from the catalog identifier.
diff --git a/src/@types/engine/UrlSyncReturn.d.ts b/src/@types/engine/UrlSyncReturn.d.ts
index b53b4504a..33dcb6178 100644
--- a/src/@types/engine/UrlSyncReturn.d.ts
+++ b/src/@types/engine/UrlSyncReturn.d.ts
@@ -9,5 +9,5 @@ import type { FocusTarget } from '../camera/FocusTarget';
  */
 export type UrlSyncReturn = {
   pendingTarget: FocusTarget | null;
-  pendingPoiId: string | null;
+  pendingStructureId: string | null;
 };
diff --git a/src/@types/engine/UseEngineInput.d.ts b/src/@types/engine/UseEngineInput.d.ts
index 587c3d07a..843078955 100644
--- a/src/@types/engine/UseEngineInput.d.ts
+++ b/src/@types/engine/UseEngineInput.d.ts
@@ -7,7 +7,7 @@ import type { EngineCallbacks } from './EngineCallbacks';
  * into a fully-populated `EngineCallbacks` object via spread (e.g.
  * `selection: { onHoverChange: setHovered, onSelectChange: setSelected,
  * ...extraSelection }`), so a caller that wants to subscribe to *just*
- * one method in a required bag (like `selection.onPoiHoverChange`)
+ * one method in a required bag (like `selection.onStructureHoverChange`)
  * shouldn't be forced to also re-supply the required ones the hook
  * already wires up.
  */
@@ -23,7 +23,7 @@ export type UseEngineInput = {
    * practice this is the `engineCallbacks` slice from
    * `useEngineSettings` — settings echoes that drive React-side
    * SettingsPanel state — plus App-level subscriptions to specific
-   * methods like `selection.onPoiHoverChange` for the POI hover preview.
+   * methods like `selection.onStructureHoverChange` for the structure hover preview.
    * Captured at first render; do not expect subsequent changes to take
    * effect.
    */
diff --git a/src/@types/engine/UseEngineReturn.d.ts b/src/@types/engine/UseEngineReturn.d.ts
index b6a2f845f..92ed9d3a5 100644
--- a/src/@types/engine/UseEngineReturn.d.ts
+++ b/src/@types/engine/UseEngineReturn.d.ts
@@ -5,7 +5,7 @@ import type { FocusableTarget } from './FocusableTarget';
 import type { ScaleInfo } from './ScaleInfo';
 import type { LoadProgressState } from '../loading/LoadProgressState';
 import type { Tier } from '../data/Tier';
-import type { PoiCategory } from './data/PoiCategory';
+import type { StructureCategory } from './data/StructureCategory';
 
 export type UseEngineReturn = {
   canvasRef: React.RefObject<HTMLCanvasElement | null>;
@@ -17,8 +17,8 @@ export type UseEngineReturn = {
   scale: ScaleInfo;
   fps: number;
   sourceCounts: Partial<Record<SourceType, number>>;
-  /** Per-marker-category POI counts (cluster / supercluster / void) for the Structures panel. */
-  structureCounts: Partial<Record<PoiCategory, number>>;
+  /** Per-category structure counts (cluster / supercluster / void / group) for the Structures panel. */
+  structureCounts: Partial<Record<StructureCategory, number>>;
   loadProgress: LoadProgressState | null;
   currentTier: Tier;
 };
diff --git a/src/@types/engine/UseKeyboardShortcutsInput.d.ts b/src/@types/engine/UseKeyboardShortcutsInput.d.ts
index 79b766372..248b019f2 100644
--- a/src/@types/engine/UseKeyboardShortcutsInput.d.ts
+++ b/src/@types/engine/UseKeyboardShortcutsInput.d.ts
@@ -3,7 +3,7 @@ import type { EngineHandle } from './EngineHandle';
 import type { FocusableTarget } from './FocusableTarget';
 
 export type UseKeyboardShortcutsInput = {
-  /** The currently-pinned target (galaxy or POI).  `f` is a no-op when null. */
+  /** The currently-pinned target (galaxy or structure).  `f` is a no-op when null. */
   selected: FocusableTarget | null;
   /** Used to gate the `/` shortcut so the palette doesn't reopen on top of itself. */
   paletteOpen: boolean;
diff --git a/src/@types/engine/UseUrlSyncInput.d.ts b/src/@types/engine/UseUrlSyncInput.d.ts
index 4095a75d8..34f5bb9e9 100644
--- a/src/@types/engine/UseUrlSyncInput.d.ts
+++ b/src/@types/engine/UseUrlSyncInput.d.ts
@@ -7,10 +7,9 @@ import type { FamousMetaEntry } from '../loading/FamousMetaEntry';
 import type { StructureRecord } from './data/StructureRecord';
 
 /**
- * Combined input for `useUrlSync` — both galaxy-side and POI-side state
+ * Combined input for `useUrlSync` — both galaxy-side and structure-side state
  * the hook needs to keep `location.hash` in lock-step with engine
- * selection.  Merge of the two legacy inputs (`UseFocusUrlInput` +
- * `UsePoiUrlSyncInput`) into one bag.
+ * selection.
  *
  * The reactive fields drive their respective drain effects' re-runs
  * as data lands; `engineHandleRef` is a mutable ref because the engine
@@ -18,13 +17,13 @@ import type { StructureRecord } from './data/StructureRecord';
  * not retrigger this hook on assignment.
  */
 export type UseUrlSyncInput = {
-  /** Camera-focus target — galaxy or POI; drives the URL hash. */
+  /** Camera-focus target — galaxy or structure; drives the URL hash. */
   focused: FocusableTarget | null;
   status: EngineStatus;
   sourceCounts: Partial<Record<SourceType, number>>;
   famousMeta: readonly FamousMetaEntry[];
   aliasMap: ReadonlyMap<bigint, readonly string[]>;
   ready: boolean;
-  pois: readonly StructureRecord[];
+  structures: readonly StructureRecord[];
   engineHandleRef: RefObject<EngineHandle | null>;
 };
diff --git a/src/@types/engine/data/LabelCategory.d.ts b/src/@types/engine/data/LabelCategory.d.ts
new file mode 100644
index 000000000..cddb1b01b
--- /dev/null
+++ b/src/@types/engine/data/LabelCategory.d.ts
@@ -0,0 +1,3 @@
+import { LABEL_CATEGORIES } from '../../../data/labelCategories';
+
+export type LabelCategory = (typeof LABEL_CATEGORIES)[number];
diff --git a/src/@types/engine/data/PickStructureStore.d.ts b/src/@types/engine/data/PickStructureStore.d.ts
index 55ea54d58..bc4a4aa25 100644
--- a/src/@types/engine/data/PickStructureStore.d.ts
+++ b/src/@types/engine/data/PickStructureStore.d.ts
@@ -3,7 +3,7 @@ import type { StructureCategory } from './StructureCategory';
 
 /**
  * Minimal projection of the structure store the pick path reads — just the
- * per-category lookup `pickToSelection` / `resolvePoiFromPick` need. Narrower
+ * per-category lookup `pickToSelection` / `resolveStructureFromPick` need. Narrower
  * than the full `StructureStore` so tests stub a one-method object literal.
  */
 export type PickStructureStore = {
diff --git a/src/@types/engine/data/PoiCategory.d.ts b/src/@types/engine/data/PoiCategory.d.ts
deleted file mode 100644
index 91c5fa102..000000000
--- a/src/@types/engine/data/PoiCategory.d.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-/**
- * PoiCategory — the full set of point-of-interest categories the UI and
- * selection layers speak: the three extended-structure categories plus
- * `famousGalaxy`.
- *
- * Defined as `StructureCategory | 'famousGalaxy'` so the structure categories
- * and this superset can't drift: adding a structure category in one place adds
- * it here too.
- *
- * Used where the FOUR-category space is genuinely needed — the SettingsPanel
- * label/marker visibility toggles, `EngineSettingsState`'s per-category
- * visibility records, the label-style override target, and the ring pick
- * decode (which can only ever yield a structure category, but shares the
- * decode type).  The structure-only layers (the store, its records, the
- * marker producer) use the narrower `StructureCategory`.
- */
-
-import type { StructureCategory } from './StructureCategory';
-
-export type PoiCategory = StructureCategory | 'famousGalaxy';
diff --git a/src/@types/engine/data/StructureGroupId.d.ts b/src/@types/engine/data/StructureGroupId.d.ts
index 6f1fa482d..08edcbc55 100644
--- a/src/@types/engine/data/StructureGroupId.d.ts
+++ b/src/@types/engine/data/StructureGroupId.d.ts
@@ -2,11 +2,9 @@
  * StructureGroupId — which slot a structure record occupies within the
  * structure store.
  *
- * This is the structure-store rename of `PoiGroupId`'s `staticAnchors` /
- * `clusterBulk` pair: `anchors` holds the hand-curated featured structures,
- * `bulk` holds the catalog-derived remainder.  `PoiGroupId`'s `famous`
- * group is dropped here — famous galaxies are galaxy data, not structures,
- * so they live outside the structure store entirely.
+ * `anchors` holds the hand-curated featured structures,
+ * `bulk` holds the catalog-derived remainder.  Famous galaxies are galaxy
+ * data, not structures, so they live outside the structure store entirely.
  *
  * The store's `all()` concatenation order is `anchors` then `bulk`.  That
  * order is load-bearing: it preserves the ring marker pick-index alignment
diff --git a/src/@types/engine/frame/RenderFrameSettings.d.ts b/src/@types/engine/frame/RenderFrameSettings.d.ts
index 80314d469..d03b5c4b2 100644
--- a/src/@types/engine/frame/RenderFrameSettings.d.ts
+++ b/src/@types/engine/frame/RenderFrameSettings.d.ts
@@ -20,7 +20,7 @@ export type RenderFrameSettings = {
    * Selected entity, or `null` when nothing is selected.  Galaxy
    * variants are translated inside `pointSpritesPass` to the packed
    * u32 `(source << 27) | localIdx` (or the `0xFFFFFFFF` "no selection"
-   * sentinel) the shader's halo path expects.  POI variants don't
+   * sentinel) the shader's halo path expects.  Structure variants don't
    * drive the halo and are treated as "no galaxy selected" by the pass.
    */
   selected: Selection | null;
diff --git a/src/@types/engine/handles/EngineCameraHandle.d.ts b/src/@types/engine/handles/EngineCameraHandle.d.ts
index 7800a004e..7caf2b62e 100644
--- a/src/@types/engine/handles/EngineCameraHandle.d.ts
+++ b/src/@types/engine/handles/EngineCameraHandle.d.ts
@@ -19,12 +19,12 @@ export type EngineCameraHandle = {
    * focus.  Dispatches by type:
    *   - GalaxyInfo → the galaxy focus path (commitFocus + onFocusChange).
    *   - StructureRecord → the structure focus path (commitStructureFocus,
-   *     framing distance derived from the category + onPoiFocusChange).
+   *     framing distance derived from the category + onStructureFocusChange).
    *
-   * Discrimination uses the `isPoi` predicate from `services/engine/isPoi.ts`.
+   * Discrimination uses the `isStructure` predicate from `services/engine/isStructure.ts`.
    * See `services/engine/helpers/dispatchFocusOn.ts` for the dispatcher
    * implementation.  Pre-bootstrap behaviour mirrors the per-kind paths:
-   * galaxy focus is a no-op when `state.cam` is null; POI focus still
+   * galaxy focus is a no-op when `state.cam` is null; structure focus still
    * fires the subsystem flag + React-side callback even with no camera
    * (deep-link drains that race bootstrap rely on that).
    */
diff --git a/src/@types/engine/handles/EngineGpuHandles.d.ts b/src/@types/engine/handles/EngineGpuHandles.d.ts
index 2790bac78..b51c9651e 100644
--- a/src/@types/engine/handles/EngineGpuHandles.d.ts
+++ b/src/@types/engine/handles/EngineGpuHandles.d.ts
@@ -89,7 +89,7 @@ export type EngineGpuHandles = {
   focusBgl: FocusUniformsBgl | null;
   /**
    * The single shared cluster-focus uniform (buffer + bind group + packer).
-   * Only one POI is focused at a time, so one buffer serves the whole
+   * Only one structure is focused at a time, so one buffer serves the whole
    * engine: written once per frame in `renderFrame`, and its bind group —
    * built against `focusBgl` — is bound by every focus-aware pipeline at
    * its own group slot (a bind group is tied to a layout, not a group
diff --git a/src/@types/engine/handles/EngineLabelsHandle.d.ts b/src/@types/engine/handles/EngineLabelsHandle.d.ts
index 4275cac88..4c55c61a9 100644
--- a/src/@types/engine/handles/EngineLabelsHandle.d.ts
+++ b/src/@types/engine/handles/EngineLabelsHandle.d.ts
@@ -1,20 +1,21 @@
 /**
- * EngineLabelsHandle — public-handle sub-bag for the POI overlay
+ * EngineLabelsHandle — public-handle sub-bag for the structure overlay
  * (clusters / superclusters / voids / famous galaxies).
  *
  * Despite the name "labels", this handle exposes setters for BOTH the
- * text-label axis AND the marker (ring + halo) axis of POI rendering.
+ * text-label axis AND the marker (ring + halo) axis of structure rendering.
  * The two axes are deliberately independent: a category's marker can be
  * hidden while its text label still renders, and vice versa.
  */
 
-import type { PoiCategory } from '../data/PoiCategory';
+import type { LabelCategory } from '../data/LabelCategory';
+import type { StructureCategory } from '../data/StructureCategory';
 
 export type EngineLabelsHandle = {
   /**
-   * Show/hide the TEXT LABEL for every POI in the given category.
-   * Forwards to
-   * `state.subsystems.pois.setCategoryLabelVisible(category, visible)`.
+   * Show/hide the TEXT LABEL for every source in the given label
+   * category.  Forwards to
+   * `state.subsystems.structures.setCategoryLabelVisible(category, visible)`.
    * Echoes back via `onLabelCategoryVisibilityChange` with the full
    * label-visibility record so the React shell can keep its checkboxes
    * in sync from one callback.
@@ -22,18 +23,19 @@ export type EngineLabelsHandle = {
    * Marker (ring + halo) visibility for the same category is untouched
    * — use `setCategoryMarkerVisible` for that axis.
    */
-  setCategoryLabelVisible(category: PoiCategory, visible: boolean): void;
+  setCategoryLabelVisible(category: LabelCategory, visible: boolean): void;
   /**
-   * Show/hide the MARKER (ring + halo) for every POI in the given
-   * category.  Forwards to
-   * `state.subsystems.pois.setCategoryMarkerVisible(category, visible)`.
+   * Show/hide the MARKER (ring + halo) for every structure in the given
+   * category.  Keyed by `StructureCategory` only: famous galaxies bear
+   * no ring marker.  Forwards to
+   * `state.subsystems.structures.setCategoryMarkerVisible(category, visible)`.
    * Echoes back via `onMarkerCategoryVisibilityChange` with the full
    * marker-visibility record.
    *
-   * Today the Structures master toggle (Task #6) is the only intended
-   * consumer; there is currently no per-category marker UI.  Label
-   * visibility for the same category is untouched — use
-   * `setCategoryLabelVisible` for that axis.
+   * Today the Structures master toggle is the only intended consumer;
+   * there is currently no per-category marker UI.  Label visibility for
+   * the same category is untouched — use `setCategoryLabelVisible` for
+   * that axis.
    */
-  setCategoryMarkerVisible(category: PoiCategory, visible: boolean): void;
+  setCategoryMarkerVisible(category: StructureCategory, visible: boolean): void;
 };
diff --git a/src/@types/engine/handles/EngineSelectionHandle.d.ts b/src/@types/engine/handles/EngineSelectionHandle.d.ts
index 4f1e8981b..64f3f07ae 100644
--- a/src/@types/engine/handles/EngineSelectionHandle.d.ts
+++ b/src/@types/engine/handles/EngineSelectionHandle.d.ts
@@ -13,22 +13,21 @@ import type { PgcAliasMap } from '../../loading/PgcAliasMap';
  */
 export type EngineSelectionHandle = {
   /**
-   * Programmatically clear the current selection — galaxy AND POI in one
+   * Programmatically clear the current selection — galaxy AND structure in one
    * call.  "Close the card" semantic: anywhere a user dismisses the
    * InfoCard (Esc, the × button, URL drift back to empty hash), both
    * sides collapse together in a single render frame.
    *
    * Order is deterministic: galaxy selection clears first
-   * (`onSelectChange` / `onFocusChange` fire), then POI selection
-   * (`onPoiFocusChange` fires).  Idempotent: calling with neither
-   * selected fires only the POI teardown's no-op callback chain
-   * (preserves the pre-2026-05-19 `clearPoiFocus` semantic — no
-   * presence gate).
+   * (`onSelectChange` / `onFocusChange` fire), then structure selection
+   * (`onStructureFocusChange` fires).  Idempotent: calling with neither
+   * selected fires only the structure teardown's no-op callback chain
+   * (no presence gate).
    *
-   * For code paths that need to clear ONLY the POI without disturbing
+   * For code paths that need to clear ONLY the structure without disturbing
    * a pinned galaxy, drop down to the engine internals.  There's no
    * public narrow-clear method (no real consumer existed when this
-   * was unified on 2026-05-19; revisit if a use case appears).
+   * was unified; revisit if a use case appears).
    */
   clear: () => void;
   /** Select (pin) the famous-atlas galaxy with the given id, then focus-tween. */
diff --git a/src/@types/engine/handles/EngineSubsystemHandles.d.ts b/src/@types/engine/handles/EngineSubsystemHandles.d.ts
index d61df17f9..dc7984c1b 100644
--- a/src/@types/engine/handles/EngineSubsystemHandles.d.ts
+++ b/src/@types/engine/handles/EngineSubsystemHandles.d.ts
@@ -100,7 +100,7 @@ export type EngineSubsystemHandles = {
    * Label director — owns `labelRenderer.setLabels` /
    * `markerLineRenderer.setLines`, polls every registered `LabelProducer`
    * each frame, merges outputs, and flushes once. Lets multiple overlays
-   * (you-are-here pin, cluster POIs, future galaxy/void labels) coexist
+   * (you-are-here pin, cluster structures, future galaxy/void labels) coexist
    * without stomping each other's full-set replacements.
    *
    * Constructed eagerly; the two renderers are wired during
@@ -112,7 +112,7 @@ export type EngineSubsystemHandles = {
   /**
    * Cluster focus-mode subsystem — drives the "dim non-members of the
    * selected cluster/SC/void" effect. Selection-driven: `runFrame` calls
-   * `update(selectedPoi, nowMs)` each frame and threads
+   * `update(selectedStructure, nowMs)` each frame and threads
    * `produceFocusUniforms(nowMs)` into the points draw. Constructed
    * eagerly; no GPU dep, non-null from t=0.
    */
diff --git a/src/@types/engine/state/FocusState.d.ts b/src/@types/engine/state/FocusState.d.ts
index c65de412a..0dff66d2d 100644
--- a/src/@types/engine/state/FocusState.d.ts
+++ b/src/@types/engine/state/FocusState.d.ts
@@ -1,10 +1,10 @@
 /**
- * FocusState — selected-POI state for the cluster-viz focus mode.
+ * FocusState — focused-structure state for the structure focus mode.
  *
  * The focus subsystem (created in plan 4) owns one of these at a time:
- * either the user has a POI selected and the field is fully populated,
+ * either the user has a structure focused and the field is fully populated,
  * or `active === false` and the rest of the fields hold whatever was
- * last selected (so the uniform-write path doesn't have to special-case
+ * last focused (so the uniform-write path doesn't have to special-case
  * "no selection" — the shader reads `active === false` and skips the
  * member alpha-multiplier branch).
  *
@@ -14,7 +14,7 @@
  *     in the subsystem or a per-frame conditional bind-group rebind.
  *     Carrying `active: boolean` in-band keeps the shader and CPU
  *     paths uniform.
- *   - The `memberPackedIds` array is reused across same-POI re-focus
+ *   - The `memberPackedIds` array is reused across same-structure re-focus
  *     events; nullifying it on deactivation would force a recomputation
  *     on every reactivation. Same field, `active = false`, no recompute.
  *
@@ -24,22 +24,23 @@
  */
 
 import type { Vec3 } from '../../math/Vec3';
+import type { StructureCategory } from '../data/StructureCategory';
 
 export type FocusState = {
   /**
-   * Stable POI identifier (matches `StructureRecord.id`). Used to key
-   * the membership cache (`(poiId, dataRev) → packedIds`) and to wire
+   * Stable structure identifier (matches `StructureRecord.id`). Used to key
+   * the membership cache (`(structureId, dataRev) → packedIds`) and to wire
    * the URL hash echo.
    */
-  readonly poiId: string;
+  readonly structureId: string;
 
   /**
-   * POI category — drives the camera framing multiplier (plan 3 §5.3)
-   * and the InfoCard layout. All three categories share one fade rule
+   * Structure category — drives the camera framing multiplier (plan 3 §5.3)
+   * and the InfoCard layout. Every category shares one fade rule
    * (interior galaxies stay bright), so the shader needs no per-category
    * bit.
    */
-  readonly category: 'cluster' | 'supercluster' | 'void';
+  readonly category: StructureCategory;
 
   /**
    * Packed-identity members from `structureMembership(...)`. CPU-side
@@ -50,14 +51,14 @@ export type FocusState = {
   readonly memberPackedIds: readonly number[];
 
   /**
-   * World-space center of the POI (Mpc). Mirrors
+   * World-space center of the structure (Mpc). Mirrors
    * `StructureRecord.worldPos`. Carried separately so the focus
-   * uniform write doesn't have to re-resolve the POI by id every frame.
+   * uniform write doesn't have to re-resolve the structure by id every frame.
    */
   readonly center: Vec3;
 
   /**
-   * Physical radius of the structure in Mpc — same value the POI's
+   * Physical radius of the structure in Mpc — same value the structure's
    * marker ring is drawn at, and the cone-search radius that produced
    * `memberPackedIds`.
    */
diff --git a/src/@types/engine/subsystems/Selection.d.ts b/src/@types/engine/subsystems/Selection.d.ts
index 82aa7df7e..8247a7e7c 100644
--- a/src/@types/engine/subsystems/Selection.d.ts
+++ b/src/@types/engine/subsystems/Selection.d.ts
@@ -14,7 +14,7 @@ import type { SourceType } from '../../data/SourceType';
  * The structure variant is structure-only by construction: famous
  * galaxies are picked through the galaxy point path (so they arrive as
  * `kind: 'galaxy'`), and the ring pick decode never yields a famous
- * category.  The wider `PoiCategory` superset (which does include
+ * category.  The wider `LabelCategory` superset (which does include
  * `famousGalaxy`) belongs to the settings / label layers, not here.
  *
  * The two variants share one slot inside `selectionSubsystem` because
diff --git a/src/@types/engine/subsystems/SelectionSubsystem.d.ts b/src/@types/engine/subsystems/SelectionSubsystem.d.ts
index 88aea56ab..70e933f9e 100644
--- a/src/@types/engine/subsystems/SelectionSubsystem.d.ts
+++ b/src/@types/engine/subsystems/SelectionSubsystem.d.ts
@@ -28,7 +28,7 @@ export type SelectionSubsystem = {
    * actual change.  Optional `prebuiltInfo` lets callers (e.g.
    * `selectByAlias`) pass the GalaxyInfo directly when the GPU upload
    * hasn't settled yet (the catalog is in `state.sources.catalogs` but the
-   * renderer hasn't received it).  Ignored for POI selections.
+   * renderer hasn't received it).  Ignored for structure selections.
    */
   setSelected(sel: Selection | null, prebuiltInfo?: GalaxyInfo | null): void;
   /**
@@ -36,7 +36,7 @@ export type SelectionSubsystem = {
    * actual change.  Symmetric with `setSelected`: the cluster-focus
    * fade reads `focused()` in `runFrame`, React mirrors the same
    * target into the URL hash.  Optional `prebuiltInfo` short-circuits
-   * the cloud lookup for the `selectByAlias` race; ignored for POI
+   * the cloud lookup for the `selectByAlias` race; ignored for structure
    * focuses.
    */
   setFocused(sel: Selection | null, prebuiltInfo?: GalaxyInfo | null): void;
diff --git a/src/@types/engine/subsystems/StructureFocusSubsystem.d.ts b/src/@types/engine/subsystems/StructureFocusSubsystem.d.ts
index 312e801bb..2da2e621d 100644
--- a/src/@types/engine/subsystems/StructureFocusSubsystem.d.ts
+++ b/src/@types/engine/subsystems/StructureFocusSubsystem.d.ts
@@ -4,7 +4,7 @@ import type { Destroyable } from '../../rendering/Destroyable';
 
 /**
  * StructureFocusSubsystem — owns cluster "focus mode": when a cluster /
- * supercluster / void POI is focused, non-member galaxies fade to ~8%
+ * supercluster / void structure is focused, non-member galaxies fade to ~8%
  * alpha over ~400 ms so the structure's membership pops out. All three
  * categories behave identically (the focused structure's interior
  * galaxies stay bright; voids are just an underdense case).
@@ -12,10 +12,10 @@ import type { Destroyable } from '../../rendering/Destroyable';
  * ### Focus-driven, not imperative
  *
  * The selection subsystem's `focused()` slot is the single source of
- * truth ("a cluster POI is focused" *is* "focus active"). So instead of
+ * truth ("a cluster structure is focused" *is* "focus active"). So instead of
  * scattering focusOn / clearFocus calls across every focus-mutating
- * site, this subsystem exposes one per-frame `update(focusedPoi, now)`
- * that diffs the focused POI's id against the currently-active id and
+ * site, this subsystem exposes one per-frame `update(focusedStructure, now)`
+ * that diffs the focused structure's id against the currently-active id and
  * drives the fade. No call sites to keep in sync.
  *
  * ### GPU re-derives membership
@@ -30,19 +30,19 @@ export type StructureFocusSubsystem = {
   readonly id: 'structureFocus';
 
   /**
-   * Per-frame state sync. Diffs `focusedPoi?.id` against the currently
+   * Per-frame state sync. Diffs `focusedStructure?.id` against the currently
    * active id:
-   *   - changed to a focus-eligible POI (cluster | supercluster | void):
+   *   - changed to a focus-eligible structure (cluster | supercluster | void):
    *     latch center/radius, fade toward 1 over 400 ms.
-   *   - changed to null OR a non-eligible POI (famousGalaxy): fade toward
+   *   - changed to null OR a non-eligible structure (famousGalaxy): fade toward
    *     0, keeping the last center/radius until blend settles at 0.
    *   - unchanged id: no-op (no re-fade).
    */
-  update(focusedPoi: StructureRecord | null, nowMs: number): void;
+  update(focusedStructure: StructureRecord | null, nowMs: number): void;
 
   /**
    * Pure read: ticks the fade and returns the live uniform value. At
-   * rest (no POI focused) returns an all-zero value (blend=0).
+   * rest (no structure focused) returns an all-zero value (blend=0).
    */
   produceFocusUniforms(nowMs: number): FocusUniformsValue;
 
diff --git a/src/@types/engine/wiring/SettingsCallbackSeed.d.ts b/src/@types/engine/wiring/SettingsCallbackSeed.d.ts
index 011913a6f..cc9efec98 100644
--- a/src/@types/engine/wiring/SettingsCallbackSeed.d.ts
+++ b/src/@types/engine/wiring/SettingsCallbackSeed.d.ts
@@ -13,7 +13,8 @@
 
 import type { BiasMode } from '../../data/BiasMode';
 import type { ToneMapCurve } from '../../data/ToneMapCurve';
-import type { PoiCategory } from '../data/PoiCategory';
+import type { LabelCategory } from '../data/LabelCategory';
+import type { StructureCategory } from '../data/StructureCategory';
 
 export type SettingsCallbackSeed = {
   pointSize: number;
@@ -31,15 +32,17 @@ export type SettingsCallbackSeed = {
   exposure: number;
   visibleSourceMask: number;
   /**
-   * Initial per-category POI label visibility — fired through
+   * Initial per-category label visibility — fired through
    * `cb.labels?.onLabelCategoryVisibilityChange?.(...)` so the React
    * shell seeds its label checkboxes from engine truth on startup.
    */
-  labelCategoryVisibility: Readonly<Record<PoiCategory, boolean>>;
+  labelCategoryVisibility: Readonly<Record<LabelCategory, boolean>>;
   /**
-   * Initial per-category POI MARKER visibility — fired through
-   * `cb.labels?.onMarkerCategoryVisibilityChange?.(...)`.  Independent
-   * axis from the label record; defaults to every category visible.
+   * Initial per-category MARKER visibility — fired through
+   * `cb.labels?.onMarkerCategoryVisibilityChange?.(...)`.  Keyed by
+   * `StructureCategory` only (no ring marker for famous galaxies);
+   * independent axis from the label record; defaults to every category
+   * visible.
    */
-  markerCategoryVisibility: Readonly<Record<PoiCategory, boolean>>;
+  markerCategoryVisibility: Readonly<Record<StructureCategory, boolean>>;
 };
diff --git a/src/@types/loading/AssetKey.d.ts b/src/@types/loading/AssetKey.d.ts
index d0b876c9e..f5a8dfaaa 100644
--- a/src/@types/loading/AssetKey.d.ts
+++ b/src/@types/loading/AssetKey.d.ts
@@ -8,7 +8,7 @@ import type { SourceType } from '../data/SourceType';
  * single `Source`:
  *
  *   - `'structureCatalog'` — the `.ccat` seed shared by Cluster, Supercluster,
- *     and Void POIs. All three `Source` codes pull their geometry from one file,
+ *     and Void structures. All three `Source` codes pull their geometry from one file,
  *     so a per-source fetch key would be wrong: there is no `structureCatalog`
  *     `Source`, and a single fetch must not trigger three loads.
  *
diff --git a/src/@types/loading/FamousMetaEntry.d.ts b/src/@types/loading/FamousMetaEntry.d.ts
index 1662fb176..0df5c16fd 100644
--- a/src/@types/loading/FamousMetaEntry.d.ts
+++ b/src/@types/loading/FamousMetaEntry.d.ts
@@ -7,7 +7,7 @@ export type FamousMetaEntry = {
   /**
    * Curated human-friendly display name (e.g. `"Andromeda Galaxy"`).
    * Mirrors the optional field on the seed entry.  Absent for most
-   * entries — the POI label producer falls back to `names`/`id`.
+   * entries — the famous-label producer falls back to `names`/`id`.
    */
   commonName?: string;
   description: string;
diff --git a/src/@types/loading/StructureCatalogPayload.d.ts b/src/@types/loading/StructureCatalogPayload.d.ts
index 197020011..d8885ce03 100644
--- a/src/@types/loading/StructureCatalogPayload.d.ts
+++ b/src/@types/loading/StructureCatalogPayload.d.ts
@@ -20,7 +20,7 @@ export type StructureMetaEntry = {
   names: string[];
   /** Normalized Abell/ACO designation (e.g. 'A2670'), or null. */
   abell: string | null;
-  /** One-liner shown in the POI info panel. */
+  /** One-liner shown in the structure info panel. */
   description: string;
 };
 
diff --git a/src/@types/rendering/FocusUniformsValue.d.ts b/src/@types/rendering/FocusUniformsValue.d.ts
index 5d854f218..620b330cc 100644
--- a/src/@types/rendering/FocusUniformsValue.d.ts
+++ b/src/@types/rendering/FocusUniformsValue.d.ts
@@ -6,16 +6,16 @@ import type { Vec3 } from '../math/Vec3';
  * byte layout). Produced each frame by structureFocusSubsystem and packed
  * into the points pipeline's singleton focus buffer.
  *
- * At rest (no POI focused) every field is zero — `blend: 0` makes the
+ * At rest (no structure focused) every field is zero — `blend: 0` makes the
  * shader's per-vertex multiplier collapse to 1.0, so center/radius are
  * don't-cares.
  */
 export type FocusUniformsValue = {
-  /** POI world-space centre in Mpc. `Readonly` because Vec3 is mutable. */
+  /** Focused structure world-space centre in Mpc. `Readonly` because Vec3 is mutable. */
   readonly center: Readonly<Vec3>;
   /**
    * Apparent (outer) radius in Mpc = `apparentRadiusMpc ?? physicalRadiusMpc`
-   * on the POI. The smoothstep edge where the fade reaches full recede (0.08).
+   * on the focused structure. The smoothstep edge where the fade reaches full recede (0.08).
    */
   readonly apparentRadiusMpc: number;
   /**
diff --git a/src/@types/rendering/InstancedQuadConfig.d.ts b/src/@types/rendering/InstancedQuadConfig.d.ts
index 25ba63323..d932bedaf 100644
--- a/src/@types/rendering/InstancedQuadConfig.d.ts
+++ b/src/@types/rendering/InstancedQuadConfig.d.ts
@@ -33,7 +33,7 @@ export type InstancedQuadConfig = {
    *  HDR offscreen `'rgba16float'`. */
   format: GPUTextureFormat;
   /** Canonical cluster-focus bind-group layout, bound at `@group(1)`.
-   *  The focus dim (non-members of a focused POI fade to 8%) is computed
+   *  The focus dim (non-members of a focused structure fade to 8%) is computed
    *  per instance in each consumer's vertex stage via
    *  `focusAlphaMultiplier`; the same shared layout serves every impostor
    *  pipeline so the points pass and the disks fade in lockstep. */
diff --git a/src/@types/rendering/Label.d.ts b/src/@types/rendering/Label.d.ts
index 8765d9f51..e6c7bd00b 100644
--- a/src/@types/rendering/Label.d.ts
+++ b/src/@types/rendering/Label.d.ts
@@ -101,7 +101,7 @@ export type Label = {
   /**
    * Vertical alignment of the text relative to `worldPos`.
    * Default 'baseline' (anchor sits on the text baseline; descenders
-   * hang below).  POI rings use 'center' so the label visually
+   * hang below).  Structure rings use 'center' so the label visually
    * straddles the ring centre rather than hanging beneath it.
    */
   readonly alignY?: LabelAlignY;
diff --git a/src/@types/rendering/LabelAlignY.d.ts b/src/@types/rendering/LabelAlignY.d.ts
index 78e9c6094..016ad15ec 100644
--- a/src/@types/rendering/LabelAlignY.d.ts
+++ b/src/@types/rendering/LabelAlignY.d.ts
@@ -7,7 +7,7 @@
  *                            the typographic convention every Y offset
  *                            in the atlas is measured against.
  *   `'center'`             — visual centre of the glyph bounding box
- *                            sits on the anchor.  Used by POI labels
+ *                            sits on the anchor.  Used by structure labels
  *                            (cluster / supercluster / void) that
  *                            anchor on a ring centre and want the
  *                            label text symmetrically straddled
diff --git a/src/@types/rendering/StructureMarkerRenderer.d.ts b/src/@types/rendering/StructureMarkerRenderer.d.ts
index 0fe53182f..0294e5645 100644
--- a/src/@types/rendering/StructureMarkerRenderer.d.ts
+++ b/src/@types/rendering/StructureMarkerRenderer.d.ts
@@ -6,7 +6,7 @@
  * (cluster / supercluster / void / group).  Per-category source-code
  * differentiation happens inside the renderer (one pre-built per-source
  * bind group each) so the pick path gets the correct
- * (sourceCode << 27) | poiIndex packing for free.
+ * (sourceCode << 27) | structureIndex packing for free.
  */
 
 import type { StructureMarkerDescriptor } from './StructureMarkerDescriptor';
diff --git a/src/@types/settings/EngineSettingsState.d.ts b/src/@types/settings/EngineSettingsState.d.ts
index 966feb4de..d7d472ba5 100644
--- a/src/@types/settings/EngineSettingsState.d.ts
+++ b/src/@types/settings/EngineSettingsState.d.ts
@@ -52,7 +52,8 @@
 
 import type { BiasMode } from '../data/BiasMode';
 import type { ToneMapCurve } from '../data/ToneMapCurve';
-import type { PoiCategory } from '../engine/data/PoiCategory';
+import type { LabelCategory } from '../engine/data/LabelCategory';
+import type { StructureCategory } from '../engine/data/StructureCategory';
 import type { FlowSettings } from './FlowSettings';
 import type { VolumeFieldId } from '../data/VolumeFieldId';
 import type { VolumeFieldSettings } from './VolumeFieldSettings';
@@ -177,23 +178,24 @@ export type EngineSettingsState = {
   };
 
   /**
-   * Per-category visibility for the POI TEXT LABEL overlay.  Keyed by
-   * the canonical `PoiCategory` union (`@types/engine/data/PoiCategory`).
-   * Defaults to every category visible.
+   * Per-category visibility for the TEXT LABEL overlay.  Keyed by
+   * `LabelCategory` — the label-bearing sources (`famousGalaxy` plus the
+   * structure categories).  Defaults to every category visible.
    *
    * This is one of two orthogonal records — see `markerCategoryVisibility`
    * for the marker (ring + halo) counterpart.  Label-text and marker
    * visibility are independent so a category's ring can be hidden while
    * its label still renders, and vice versa.
    */
-  labelCategoryVisibility: Record<PoiCategory, boolean>;
+  labelCategoryVisibility: Record<LabelCategory, boolean>;
   /**
-   * Per-category visibility for the POI MARKER overlay — the ring +
-   * halo glyph drawn at the POI's world anchor by
-   * `structureMarkerRenderer`.  Symmetric to `labelCategoryVisibility`;
-   * the two records are deliberately independent so the SettingsPanel
-   * can offer separate master toggles for "Labels" (text) and
-   * "Structures" (markers).  Defaults to every category visible.
+   * Per-category visibility for the MARKER overlay — the ring + halo glyph
+   * drawn at the structure's world anchor by `structureMarkerRenderer`.
+   * Keyed by `StructureCategory` only: famous galaxies bear no ring marker.
+   * Symmetric to `labelCategoryVisibility`; the two records are deliberately
+   * independent so the SettingsPanel can offer separate master toggles for
+   * "Labels" (text) and "Structures" (markers).  Defaults to every category
+   * visible.
    */
-  markerCategoryVisibility: Record<PoiCategory, boolean>;
+  markerCategoryVisibility: Record<StructureCategory, boolean>;
 };
diff --git a/src/@types/settings/UseEngineSettingsState.d.ts b/src/@types/settings/UseEngineSettingsState.d.ts
index c6c84603b..eef622ff0 100644
--- a/src/@types/settings/UseEngineSettingsState.d.ts
+++ b/src/@types/settings/UseEngineSettingsState.d.ts
@@ -30,7 +30,8 @@ import type { BiasMode } from '../data/BiasMode';
 import type { ToneMapCurve } from '../data/ToneMapCurve';
 import type { FlowSettings } from './FlowSettings';
 import type { VolumeFieldRowData } from './VolumeFieldRowData';
-import type { PoiCategory } from '../engine/data/PoiCategory';
+import type { LabelCategory } from '../engine/data/LabelCategory';
+import type { StructureCategory } from '../engine/data/StructureCategory';
 
 export type UseEngineSettingsState = {
   pointSize: number;
@@ -68,25 +69,24 @@ export type UseEngineSettingsState = {
    */
   volumeFields: ReadonlyArray<VolumeFieldRowData>;
   /**
-   * Per-category visibility for the POI TEXT LABEL overlay.  Mirrors
-   * the engine-side `EngineSettingsState.labelCategoryVisibility`; the
+   * Per-category visibility for the TEXT LABEL overlay.  Mirrors the
+   * engine-side `EngineSettingsState.labelCategoryVisibility`; the
    * SettingsPanel reads from this record to render the per-category
    * label checkboxes.  Engine echoes the whole record on every
    * `handle.labels.setCategoryLabelVisible(cat, visible)` call so the
    * UI stays in sync from a single subscription.
    */
-  labelCategoryVisibility: Record<PoiCategory, boolean>;
+  labelCategoryVisibility: Record<LabelCategory, boolean>;
   /**
-   * Per-category visibility for the POI MARKER overlay (ring + halo).
-   * Mirrors the engine-side
+   * Per-category visibility for the MARKER overlay (ring + halo), keyed
+   * by `StructureCategory` only.  Mirrors the engine-side
    * `EngineSettingsState.markerCategoryVisibility`.  Today there is no
    * per-category marker UI — every entry stays `true` unless the
-   * Structures master toggle (Task #6 of the 2026-05-19 audit) flips
-   * them as a batch.  Kept in state regardless so the React shell can
-   * present a snapshot and so the upcoming Structures toggle has a
-   * stable mirror to subscribe to.
+   * Structures master toggle flips them as a batch.  Kept in state
+   * regardless so the React shell can present a snapshot and so the
+   * Structures toggle has a stable mirror to subscribe to.
    */
-  markerCategoryVisibility: Record<PoiCategory, boolean>;
+  markerCategoryVisibility: Record<StructureCategory, boolean>;
   /**
    * Whether a 3Dconnexion SpaceMouse is currently paired and feeding
    * input reports.  Engine echoes this through
diff --git a/src/components/App/App.tsx b/src/components/App/App.tsx
index aeacfbe17..4064ebabb 100644
--- a/src/components/App/App.tsx
+++ b/src/components/App/App.tsx
@@ -118,7 +118,7 @@ export function App(): React.ReactElement {
 
   // Live "N galaxies" figure for a pinned cluster/SC/void card.  Recomputes
   // on selection / tier swap / catalog landing (`sourceCounts`) / survey
-  // toggle — null for galaxy selections and famous-galaxy POIs.
+  // toggle — null for galaxy selections and famous-galaxy structures.
   const selectedMemberCount = useStructureMemberCount({
     selected,
     engineHandleRef: handleRef,
@@ -175,7 +175,7 @@ export function App(): React.ReactElement {
   // Static structure table for the URL drain.  The engine owns the merged
   // list (static anchors + the async bulk cluster catalog), but threading
   // that as a reactive React slice would re-render App on every catalog load.
-  // Deep-link arrivals only need the static subset (`#poi=cluster-…` /
+  // Deep-link arrivals only need the static subset (`#focus=cluster-…` /
   // `supercluster-…` / `void-…`).  `useMemo([])` so the drain effect
   // doesn't re-fire on every render.
   const staticStructures = useMemo(() => buildStaticAnchorStructures(), []);
@@ -186,7 +186,7 @@ export function App(): React.ReactElement {
     famousMeta,
     aliasMap,
     ready: status.kind === 'ready',
-    pois: staticStructures,
+    structures: staticStructures,
     engineHandleRef: handleRef,
   });
 
diff --git a/src/components/DebugPanel/LabelEffectsSection.tsx b/src/components/DebugPanel/LabelEffectsSection.tsx
index b268f7292..f7a0f84a6 100644
--- a/src/components/DebugPanel/LabelEffectsSection.tsx
+++ b/src/components/DebugPanel/LabelEffectsSection.tsx
@@ -2,7 +2,7 @@
  * LabelEffectsSection — live-tuning controls for the label outline.
  *
  * Pick a target category, tune outline colour + width, then bake the
- * values into `POI_STYLES.<cat>` or `youAreHereSubsystem.ts`.  The
+ * values into `STRUCTURE_MARKER_STYLES.<cat>` or `youAreHereSubsystem.ts`.  The
  * override is a temporary hook, not a storage location.
  *
  * `setLabelStyleOverride` runs in `useEffect`, not during render —
@@ -15,16 +15,13 @@ import {
   clearLabelStyleOverride,
   type LabelStyleOverrideTarget,
 } from '../../services/engine/labelStyleOverride';
+import { LABEL_CATEGORIES } from '../../data/labelCategories';
 import type { Vec4 } from '../../@types/math/Vec4';
 
-const CATEGORIES: readonly LabelStyleOverrideTarget[] = [
-  'youAreHere',
-  'cluster',
-  'supercluster',
-  'famousGalaxy',
-  'void',
-  'group',
-];
+// `LabelStyleOverrideTarget` is `'youAreHere' | LabelCategory`, so the dropdown
+// is exactly the registry's label-bearing categories plus the you-are-here pin.
+// 'youAreHere' leads so it stays first in the dropdown.
+const CATEGORIES: readonly LabelStyleOverrideTarget[] = ['youAreHere', ...LABEL_CATEGORIES];
 
 function hexToRgb(hex: string): [number, number, number] {
   const m = /^#?([0-9a-f]{6})$/i.exec(hex);
diff --git a/src/components/InfoCard/CompactStructureCard.tsx b/src/components/InfoCard/CompactStructureCard.tsx
index 6d51b3110..3a8c2f3cd 100644
--- a/src/components/InfoCard/CompactStructureCard.tsx
+++ b/src/components/InfoCard/CompactStructureCard.tsx
@@ -7,7 +7,7 @@
 import type { ReactNode } from 'react';
 import type { StructureRecord } from '../../@types/engine/data/StructureRecord';
 import { formatDistance } from '../../utils/format/distance';
-import { POI_CATEGORY_INFO } from '../../data/poiCategoryInfo';
+import { CATEGORY_DISPLAY_INFO } from '../../data/categoryDisplayInfo';
 import styles from './CompactStructureCard.module.css';
 
 export type CompactStructureCardProps = {
@@ -28,7 +28,9 @@ export function CompactStructureCard({ structure }: CompactStructureCardProps):
       </div>
       <div className={styles.headlineRow}>
         <div className={styles.cardHeadline}>{structure.name}</div>
-        <span className={styles.sourceBadge}>{POI_CATEGORY_INFO[structure.category].shortLabel}</span>
+        <span className={styles.sourceBadge}>
+          {CATEGORY_DISPLAY_INFO[structure.category].shortLabel}
+        </span>
       </div>
       <div className={styles.cardDistLine}>
         {formatDistance(distanceMpc)}
diff --git a/src/components/InfoCard/InfoCard.tsx b/src/components/InfoCard/InfoCard.tsx
index 858f49a54..4ab13c616 100644
--- a/src/components/InfoCard/InfoCard.tsx
+++ b/src/components/InfoCard/InfoCard.tsx
@@ -1,5 +1,5 @@
 /**
- * InfoCard — routes hovered/selected galaxy + POI state into the detail and
+ * InfoCard — routes hovered/selected galaxy + structure state into the detail and
  * preview cards.  Renders nothing when both slots are null.
  *
  * Always renders the same outer wrapper across all states.  An earlier version
@@ -8,9 +8,9 @@
  * which lost the native `<details>` "More details" open state on every hover.
  *
  * Both `hovered` and `selected` accept the full `FocusableTarget` union
- * (`GalaxyInfo | StructureRecord`).  App.tsx merges POI and galaxy state
- * before handing them here — POI wins when both are present.  InfoCard then
- * dispatches via `isPoi` into typed sub-slots and picks the right detail-card
+ * (`GalaxyInfo | StructureRecord`).  App.tsx merges structure and galaxy state
+ * before handing them here — structure wins when both are present.  InfoCard then
+ * dispatches via `isStructure` into typed sub-slots and picks the right detail-card
  * variant (`GalaxyDetailCard` vs `StructureDetailCard`).
  */
 
@@ -18,7 +18,7 @@ import type { ReactNode } from 'react';
 import cx from 'classnames';
 import type { GalaxyInfo } from '../../@types/engine/GalaxyInfo';
 import type { FocusableTarget } from '../../@types/engine/FocusableTarget';
-import { isPoi } from '../../services/engine/isPoi';
+import { isStructure } from '../../services/engine/isStructure';
 import { GalaxyDetailCard } from './GalaxyDetailCard';
 import { StructureDetailCard } from './StructureDetailCard';
 import { CompactCard } from './CompactCard';
@@ -29,14 +29,14 @@ export type InfoCardProps = {
   /**
    * The point currently under the cursor, or null when the cursor is on empty
    * sky.  Can be either a galaxy or a structure — InfoCard dispatches via
-   * `isPoi` to render the appropriate hover variant.
+   * `isStructure` to render the appropriate hover variant.
    */
   hovered: FocusableTarget | null;
   /**
    * The pinned/selected target, or null when nothing is pinned.  Same dispatch
    * as `hovered`.  When both `hovered` and `selected` are non-null and of the
    * same kind (galaxy/galaxy or structure/structure), the stacked-pair layout applies;
-   * when they're different kinds (e.g. galaxy pinned, POI hovered), both render
+   * when they're different kinds (e.g. galaxy pinned, structure hovered), both render
    * in their respective slots.
    */
   selected: FocusableTarget | null;
@@ -49,14 +49,14 @@ export type InfoCardProps = {
   selectedMemberCount?: number | null;
   /**
    * Optional callback fired when the user clicks "Focus" (galaxy) or "Fly here"
-   * (POI) on the pinned card.  Caller routes to the unified handle method
+   * (structure) on the pinned card.  Caller routes to the unified handle method
    * `handle.camera.focusOn(target)`.
    */
   onFocus?: (target: FocusableTarget) => void;
   /**
    * Optional callback fired when the user clicks the Close (×) button on the
    * pinned card.  Same effect as pressing Esc — clears the selection.  Caller
-   * routes to `handle.selection.clear()` which tears down both galaxy AND POI
+   * routes to `handle.selection.clear()` which tears down both galaxy AND structure
    * selection in one call.
    */
   onClose?: () => void;
@@ -71,13 +71,13 @@ export function InfoCard({
 }: InfoCardProps): ReactNode {
   if (!hovered && !selected) return null;
 
-  // Dispatch via isPoi into typed sub-slots.  A StructureRecord is identified
+  // Dispatch via isStructure into typed sub-slots.  A StructureRecord is identified
   // by a top-level `category` field; GalaxyInfo carries category only at
-  // `galaxyType.category`.  See isPoi.ts for the discriminant rationale.
-  const selectedStructure = selected && isPoi(selected) ? selected : null;
-  const selectedGalaxy = selected && !isPoi(selected) ? (selected as GalaxyInfo) : null;
-  const hoveredStructure = hovered && isPoi(hovered) ? hovered : null;
-  const hoveredGalaxy = hovered && !isPoi(hovered) ? (hovered as GalaxyInfo) : null;
+  // `galaxyType.category`.  See isStructure.ts for the discriminant rationale.
+  const selectedStructure = selected && isStructure(selected) ? selected : null;
+  const selectedGalaxy = selected && !isStructure(selected) ? (selected as GalaxyInfo) : null;
+  const hoveredStructure = hovered && isStructure(hovered) ? hovered : null;
+  const hoveredGalaxy = hovered && !isStructure(hovered) ? (hovered as GalaxyInfo) : null;
 
   // Structure hover wins over galaxy hover when both are non-null (a transient
   // cross-render race; the engine's hover throttler normally clears the
diff --git a/src/components/InfoCard/StructureDetailCard.tsx b/src/components/InfoCard/StructureDetailCard.tsx
index e983b287a..b1415c5be 100644
--- a/src/components/InfoCard/StructureDetailCard.tsx
+++ b/src/components/InfoCard/StructureDetailCard.tsx
@@ -8,7 +8,7 @@ import type { ReactNode } from 'react';
 import type { StructureRecord } from '../../@types/engine/data/StructureRecord';
 import { formatDistance } from '../../utils/format/distance';
 import { formatAbellDesignation } from '../../utils/format/formatAbellDesignation';
-import { POI_CATEGORY_INFO } from '../../data/poiCategoryInfo';
+import { CATEGORY_DISPLAY_INFO } from '../../data/categoryDisplayInfo';
 import { CardHeader } from './CardHeader';
 import { CardRow } from './CardRow';
 import { DescriptionBlock } from './DescriptionBlock';
@@ -55,7 +55,9 @@ export function StructureDetailCard({
 
       <div className={styles.headlineRow}>
         <div className={styles.cardHeadline}>{structure.name}</div>
-        <span className={styles.sourceBadge}>{POI_CATEGORY_INFO[structure.category].label}</span>
+        <span className={styles.sourceBadge}>
+          {CATEGORY_DISPLAY_INFO[structure.category].label}
+        </span>
       </div>
 
       <div className={styles.cardSection}>
diff --git a/src/components/SettingsPanel/SettingsPanel.tsx b/src/components/SettingsPanel/SettingsPanel.tsx
index b19a9f531..8de5b2ade 100644
--- a/src/components/SettingsPanel/SettingsPanel.tsx
+++ b/src/components/SettingsPanel/SettingsPanel.tsx
@@ -87,8 +87,10 @@ import { BiasMode } from '../../data/biasMode';
 import type { BiasMode as BiasModeT } from '../../@types/data/BiasMode';
 import { ALL_TONE_MAP_CURVES, toneMapCurveLabel } from '../../data/toneMapCurve';
 import type { ToneMapCurve as ToneMapCurveT } from '../../@types/data/ToneMapCurve';
-import type { PoiCategory } from '../../@types/engine/data/PoiCategory';
-import { POI_CATEGORY_INFO } from '../../data/poiCategoryInfo';
+import type { LabelCategory } from '../../@types/engine/data/LabelCategory';
+import type { StructureCategory } from '../../@types/engine/data/StructureCategory';
+import { CATEGORY_DISPLAY_INFO } from '../../data/categoryDisplayInfo';
+import { LABEL_CATEGORIES } from '../../data/labelCategories';
 import { STRUCTURE_CATEGORIES } from '../../data/structureCategories';
 import type { ScalarFieldPaletteId } from '../../@types/data/ScalarFieldPaletteId';
 import type { VolumeFieldRowData } from '../../@types/settings/VolumeFieldRowData';
@@ -125,21 +127,6 @@ const TOGGLEABLE_SOURCES: readonly SourceType[] = [
   Source.Milliquas,
 ];
 
-/**
- * The label categories the "Labels" master toggle batches over.  All five
- * PoiCategory values — labels are independent of marker visibility (axis
- * separation landed in PR #160 / audit Q11).
- *
- * `famousGalaxy` is listed first — it's the label set the explorer is
- * most likely to recognise + most likely to toggle (named galaxies vs.
- * astronomer-jargon structure labels), so it gets the top row.  The
- * remaining four are spread from the canonical `STRUCTURE_CATEGORIES` so a
- * future fifth structure category flows through here automatically — the
- * structures master (which iterates `STRUCTURE_CATEGORIES` directly) and
- * the labels master can never drift apart.
- */
-const LABEL_CATEGORIES: readonly PoiCategory[] = ['famousGalaxy', ...STRUCTURE_CATEGORIES];
-
 /**
  * High-level Style picker options for the Cosmic web group.  Derived from
  * (volumes master, filaments master) at render time — see the picker's
@@ -178,13 +165,13 @@ type Props = {
   sourceCounts?: Partial<Record<SourceType, number>>;
 
   /**
-   * Per-marker-category POI counts (cluster / supercluster / void) for
+   * Per-marker-category structure counts (cluster / supercluster / void) for
    * the Structures section, shown beside each toggle the same way
    * `sourceCounts` annotates the Surveys rows.  A category absent from
    * the map (or the whole prop undefined, before the bulk `.ccat`
    * lands) renders the toggle without a count rather than "0".
    */
-  structureCounts?: Partial<Record<PoiCategory, number>>;
+  structureCounts?: Partial<Record<StructureCategory, number>>;
 
   /** Current point size in pixels.  Lives under Galaxies → Advanced. */
   pointSize: number;
@@ -249,13 +236,13 @@ type Props = {
    * toggle.  Wires to `handle.labels.setCategoryMarkerVisible` (added by
    * PR #160).
    */
-  markerCategoryVisibility?: Readonly<Record<PoiCategory, boolean>>;
-  onSetMarkerCategoryVisibility?: (category: PoiCategory, visible: boolean) => void;
+  markerCategoryVisibility?: Readonly<Record<StructureCategory, boolean>>;
+  onSetMarkerCategoryVisibility?: (category: StructureCategory, visible: boolean) => void;
 
   // ── Labels group (ALL text annotations) ────────────────────────────────
   /** Per-category LABEL visibility — independent of marker visibility. */
-  labelCategoryVisibility: Readonly<Record<PoiCategory, boolean>>;
-  onSetLabelCategoryVisibility: (category: PoiCategory, visible: boolean) => void;
+  labelCategoryVisibility: Readonly<Record<LabelCategory, boolean>>;
+  onSetLabelCategoryVisibility: (category: LabelCategory, visible: boolean) => void;
 
   // ── Display group (power-user disclosure) ──────────────────────────────
   /** Currently-selected tone-mapping curve. */
@@ -485,7 +472,7 @@ export function SettingsPanel({
       })()
     : null;
 
-  // ── Labels master (over all four PoiCategory entries) ───────────────────
+  // ── Labels master (over every LABEL_CATEGORIES entry) ───────────────────
   const labelsMaster = (() => {
     const enabledCount = LABEL_CATEGORIES.reduce<number>(
       (n, cat) => (labelCategoryVisibility[cat] ? n + 1 : n),
@@ -818,7 +805,7 @@ export function SettingsPanel({
             return (
               <div className={styles.panelRow} key={`marker-${cat}`}>
                 <label htmlFor={`toggle-marker-${cat}`}>
-                  {POI_CATEGORY_INFO[cat].plural}
+                  {CATEGORY_DISPLAY_INFO[cat].plural}
                   {count !== undefined && (
                     <span className={styles.sourceCount}>{count.toLocaleString()}</span>
                   )}
@@ -856,7 +843,7 @@ export function SettingsPanel({
             useful). */}
         {LABEL_CATEGORIES.map((cat) => (
           <div className={styles.panelRow} key={`label-${cat}`}>
-            <label htmlFor={`toggle-label-${cat}`}>{POI_CATEGORY_INFO[cat].plural}</label>
+            <label htmlFor={`toggle-label-${cat}`}>{CATEGORY_DISPLAY_INFO[cat].plural}</label>
             <input
               id={`toggle-label-${cat}`}
               type="checkbox"
diff --git a/src/data/buildStaticAnchorStructures.ts b/src/data/buildStaticAnchorStructures.ts
index b6f967381..9783bd470 100644
--- a/src/data/buildStaticAnchorStructures.ts
+++ b/src/data/buildStaticAnchorStructures.ts
@@ -11,7 +11,7 @@
  *       bootstrap writes these into the structure store so the label/ring
  *       overlays know where to draw.
  *
- *   2.  `hooks/useUrlSync.ts` — the React-side `#poi=<id>` deep-link drain
+ *   2.  `hooks/useUrlSync.ts` — the React-side `#focus=<id>` deep-link drain
  *       needs a `StructureRecord` to feed `camera.focusOn`, but App.tsx has
  *       no public read-side accessor for the engine's structure table (the
  *       store owns the list).
@@ -43,9 +43,9 @@
  * snapshot as a reactive React state slice would mean threading a new
  * callback through EngineCallbacks and re-rendering App on every catalog
  * load.  For the deep-link drain use case, the static subset is
- * sufficient — `#poi=cluster-virgo-m87` / `#poi=supercluster-coma-sc`
- * / `#poi=void-bootes-void` / `#poi=group-local-group` all live in this
- * table.  Famous-galaxy deep-links (`#poi=famous-…`) are a future
+ * sufficient — `#focus=cluster-virgo-m87` / `#focus=supercluster-coma-sc`
+ * / `#focus=void-bootes-void` / `#focus=group-local-group` all live in this
+ * table.  Famous-galaxy deep-links (`#focus=famous-…`) are a future
  * extension; the drain leaves the pending id set so a future "famous
  * galaxies ready" subscriber can resolve it.
  *
diff --git a/src/data/categoryDisplayInfo.ts b/src/data/categoryDisplayInfo.ts
new file mode 100644
index 000000000..cb5dba0c5
--- /dev/null
+++ b/src/data/categoryDisplayInfo.ts
@@ -0,0 +1,55 @@
+/**
+ * Per-category display metadata for label-bearing sources (cluster,
+ * supercluster, void, famousGalaxy, group).  Keyed by `LabelCategory`.
+ *
+ * Derived from the SOURCE_REGISTRY rows that carry `bearsLabel: true`,
+ * which are the canonical home of per-category copy since A1.  Consumers
+ * read from `SOURCE_REGISTRY` rows via this accessor so the copy
+ * module replaces that table with a registry-derived accessor so the copy
+ * lives in exactly one place and new label-bearing sources gain display info
+ * automatically from their registry row.
+ *
+ * Distinct from the presentation style tables (`structureMarkerStyles.ts` +
+ * `famousLabelStyle.ts`) — those own *rendering* config (halo/ring colors,
+ * pixel sizes, fade bands).  This owns *display* metadata (human labels).
+ */
+
+import type { LabelCategory } from '../@types/engine/data/LabelCategory';
+import { SOURCE_ENTRIES } from './sourceEntries';
+
+export type CategoryDisplayInfo = {
+  /** Long form for detail surfaces ('Galaxy Cluster', 'Famous Galaxy'). */
+  label: string;
+  /** Compact form for previews and chips ('Cluster', 'Galaxy'). */
+  shortLabel: string;
+  /** Plural form for list/toggle headers ('Clusters', 'Famous Galaxies'). */
+  readonly plural: string;
+};
+
+function buildDisplayInfo(): Readonly<Record<LabelCategory, CategoryDisplayInfo>> {
+  const result = {} as Record<LabelCategory, CategoryDisplayInfo>;
+  for (const entry of SOURCE_ENTRIES.filter((e) => e.bearsLabel)) {
+    const { id, detailLabel, shortLabel, plural } = entry;
+    if (detailLabel === undefined || shortLabel === undefined || plural === undefined) {
+      throw new Error(
+        `Source '${id}' has bearsLabel:true but is missing detailLabel/shortLabel/plural — ` +
+          'add these fields to its SOURCE_REGISTRY row.',
+      );
+    }
+    result[id as LabelCategory] = { label: detailLabel, shortLabel, plural };
+  }
+  return result as Readonly<Record<LabelCategory, CategoryDisplayInfo>>;
+}
+
+/**
+ * Display metadata for each label-bearing source category.  Sourced from
+ * `detailLabel` / `shortLabel` / `plural` on the SOURCE_REGISTRY rows where
+ * `bearsLabel` is true.
+ *
+ * Field semantics:
+ *   - `label`      — long form for detail surfaces ('Galaxy Cluster')
+ *   - `shortLabel` — compact form for chips ('Cluster')
+ *   - `plural`     — plural for list/toggle headers ('Clusters')
+ */
+export const CATEGORY_DISPLAY_INFO: Readonly<Record<LabelCategory, CategoryDisplayInfo>> =
+  buildDisplayInfo();
diff --git a/src/data/colourIndex.ts b/src/data/colourIndex.ts
index 64bb23d2c..436713478 100644
--- a/src/data/colourIndex.ts
+++ b/src/data/colourIndex.ts
@@ -48,7 +48,7 @@ export function pickColourIndex(
 ): number {
   const entry = SOURCE_REGISTRY[source];
   // The points pipeline only routes survey sources here; any other
-  // kind (POI, filament, volume) hitting this path means a
+  // kind (structure, filament, volume) hitting this path means a
   // picker/dispatch bug upstream.
   if (entry.type !== 'survey') {
     throw new Error(`pickColourIndex: non-survey source ${source} has no colour index`);
diff --git a/src/data/fonts.ts b/src/data/fonts.ts
index ba48352f5..6936d50e0 100644
--- a/src/data/fonts.ts
+++ b/src/data/fonts.ts
@@ -88,11 +88,9 @@ export const ATLAS_FONT_SIZE = 42;
 /**
  * ASCII printable: space (32) through tilde (126) — 95 characters.
  * Covers every Latin letter, digit, and punctuation mark we currently
- * render in labels (`'You are here'`, POI names, etc.).
+ * render in labels (`'You are here'`, structure names, etc.).
  */
-const ASCII_PRINTABLE = Array.from({ length: 95 }, (_, i) =>
-  String.fromCodePoint(32 + i),
-).join('');
+const ASCII_PRINTABLE = Array.from({ length: 95 }, (_, i) => String.fromCodePoint(32 + i)).join('');
 
 /**
  * Extended unit symbols used in scale-bar / coordinate labels:
diff --git a/src/data/labelCategories.ts b/src/data/labelCategories.ts
new file mode 100644
index 000000000..513be2c5f
--- /dev/null
+++ b/src/data/labelCategories.ts
@@ -0,0 +1,50 @@
+import type { LabelCategory } from '../@types/engine/data/LabelCategory';
+import type { CategoryLabelLayer } from '../@types/animation/CategoryLabelLayer';
+import { SOURCE_ENTRIES } from './sourceEntries';
+
+/**
+ * LABEL_CATEGORIES — every source that renders a text label in the 3D scene,
+ * in registry order.
+ *
+ * Two kinds of sources bear labels:
+ *   - 'famousGalaxy' — the curated atlas entry carries a name that floats above
+ *     the dot on a leader line (the 'galaxyNames' layer).
+ *   - Structure categories (cluster, supercluster, void, group) — each ring
+ *     carries a name on the 'structure' label layer.
+ *
+ * This is the label-visibility axis: settings toggles, fade registration, and
+ * the SettingsPanel label-on/off rows all iterate this set. Bulk surveys
+ * (SDSS, GLADE, 2MRS, Milliquas) do not bear labels and are excluded.
+ *
+ * Companion to STRUCTURE_CATEGORIES, which is the narrower structure-only axis
+ * (used where 'famousGalaxy' is irrelevant, e.g. the structure store and
+ * marker producer).
+ */
+export const LABEL_CATEGORIES = SOURCE_ENTRIES.filter((e) => e.bearsLabel).map((e) => e.id);
+
+/**
+ * LABEL_LAYER_BY_CATEGORY — which fade layer each label-bearing category's
+ * labels live on, keyed by category id.
+ *
+ * Routes the per-category label-visibility setter without a `=== 'famousGalaxy'`
+ * special-case: the registry row's `labelLayer` field ('galaxyNames' for the
+ * curated atlas, 'structure' for cluster/supercluster/void/group) is the single
+ * source of truth, so a new label-bearing source picks its layer from its row.
+ */
+function buildLabelLayers(): Readonly<Record<LabelCategory, CategoryLabelLayer>> {
+  const result = {} as Record<LabelCategory, CategoryLabelLayer>;
+  for (const entry of SOURCE_ENTRIES.filter((e) => e.bearsLabel)) {
+    const { id, labelLayer } = entry;
+    if (labelLayer === undefined) {
+      throw new Error(
+        `Source '${id}' has bearsLabel:true but no labelLayer — add 'galaxyNames' or ` +
+          "'structure' to its SOURCE_REGISTRY row.",
+      );
+    }
+    result[id as LabelCategory] = labelLayer;
+  }
+  return result as Readonly<Record<LabelCategory, CategoryLabelLayer>>;
+}
+
+export const LABEL_LAYER_BY_CATEGORY: Readonly<Record<LabelCategory, CategoryLabelLayer>> =
+  buildLabelLayers();
diff --git a/src/data/poiCategoryInfo.ts b/src/data/poiCategoryInfo.ts
deleted file mode 100644
index 36577b38c..000000000
--- a/src/data/poiCategoryInfo.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-/**
- * Per-category display metadata for points of interest (cluster, supercluster,
- * void, famousGalaxy, group).  Keyed by `PoiCategory`.  Add fields here when
- * the UI needs more per-category info (icon, accent color for chips, ordering,
- * etc.).
- *
- * Distinct from the presentation style tables (`structurePoiStyles.ts` +
- * `famousLabelStyle.ts`) — those own *rendering* config (halo/ring colors,
- * pixel sizes, fade bands).  This owns *display* metadata (human labels and
- * any future copy/iconography).
- */
-
-import type { PoiCategory } from '../@types/engine/data/PoiCategory';
-
-export type PoiCategoryInfo = {
-  /** Long form for detail surfaces ("Galaxy Cluster"). */
-  label: string;
-  /** Compact form for previews and chips ("Cluster"). */
-  shortLabel: string;
-  /** Plural form for list/toggle headers ("Clusters"). */
-  readonly plural: string;
-};
-
-export const POI_CATEGORY_INFO: Readonly<Record<PoiCategory, PoiCategoryInfo>> = {
-  cluster: {
-    label: 'Galaxy Cluster',
-    shortLabel: 'Cluster',
-    plural: 'Clusters',
-  },
-  supercluster: {
-    label: 'Supercluster',
-    shortLabel: 'Supercluster',
-    plural: 'Superclusters',
-  },
-  void: {
-    label: 'Cosmic Void',
-    shortLabel: 'Void',
-    plural: 'Voids',
-  },
-  famousGalaxy: {
-    label: 'Famous Galaxy',
-    shortLabel: 'Galaxy',
-    plural: 'Famous galaxies',
-  },
-  group: {
-    label: 'Galaxy Group',
-    shortLabel: 'Group',
-    plural: 'Groups',
-  },
-};
diff --git a/src/data/sources.ts b/src/data/sources.ts
index a816058ec..130ffd22c 100644
--- a/src/data/sources.ts
+++ b/src/data/sources.ts
@@ -15,7 +15,7 @@
  *                Each volume carries its own presentation defaults
  *                (palette, contrast, exposure, …).
  *
- * Only `'survey'` and `'poi'` codes are persisted to disk / packed into
+ * Only `'survey'` and `'structure'` codes are persisted to disk / packed into
  * GPU buffers; `'filament'` and `'volume'` codes exist solely so every
  * data source has one place to look. The visibility-bitmask helpers in
  * `utils/sourceMask` operate on survey codes only.
@@ -29,7 +29,7 @@ import type { Tier } from '../@types/data/Tier';
 
 /**
  * Stable numeric tag for every data source. Used as a `.bin` byte for
- * survey rows, packed into the pick texture for survey + POI hits, and
+ * survey rows, packed into the pick texture for survey + structure hits, and
  * as a registry key for filament + volume assets.
  *
  * IMPORTANT: integer values 0..8 are persisted in the `.bin` point-cloud
@@ -67,7 +67,7 @@ export const Source = {
   /**
    * Galaxy-cluster anchors (Virgo, Coma, Norma, ...). Picks against a
    * cluster's marker ring return source code 5 in the upper 5 bits of
-   * the packed identity; the 27-bit `localIdx` carries the POI's index
+   * the packed identity; the 27-bit `localIdx` carries the structure's index
    * into the cluster table. See `selectionEncoding.ts` for the layout.
    */
   Cluster: 5,
@@ -79,7 +79,7 @@ export const Source = {
    * Milliquas v8 (Flesch 2023) — the Million Quasars compilation. AGN
    * point sources (QSOs, BL Lacs, type-1 Seyferts, Seyfert-1 cores,
    * candidate quasars) rendered alongside the galaxy surveys for the
-   * optically-bright AGN sky. Slot 8 — slots 5/6/7 belong to the POI
+   * optically-bright AGN sky. Slot 8 — slots 5/6/7 belong to the structure
    * codes above, so the next survey integer is 8.
    */
   Milliquas: 8,
@@ -115,7 +115,7 @@ export const Source = {
   /**
    * Nearby galaxy-group anchors (Local Group, M81, Cen A, ...). Picks
    * against a group's marker ring return source code 15 in the upper 5
-   * bits of the packed identity; the 27-bit `localIdx` carries the POI's
+   * bits of the packed identity; the 27-bit `localIdx` carries the structure's
    * index into the structure store. Same encoding as Cluster/Supercluster/
    * Void. Seed-only (no bulk catalog), like Void. Appended at 15 — NEVER
    * renumber the survey codes 0–8 below it.
@@ -127,7 +127,7 @@ export const Source = {
 
 /**
  * Per-source metadata, keyed by every `Source`. Discriminated by `type`;
- * see the `SurveyEntry` / `PoiEntry` definitions for the field shapes.
+ * see the `SurveyEntry` / `StructureEntry` definitions for the field shapes.
  *
  * `as const satisfies Readonly<Record<Source, SourceEntry>>` preserves each
  * entry's literal `type`, so `SOURCE_REGISTRY[Source.SDSS]` narrows to
@@ -156,6 +156,8 @@ export const SOURCE_REGISTRY = {
     binBaseName: null, // generated at runtime; no file
     allSky: true, // uniform-in-sphere by construction
     visible: true,
+    bearsLabel: false,
+    bearsMarker: false,
     maxDistMpc: 1000, // matches the radius in synthetic.ts
     bandLabels: { u: 'u', g: 'g', r: 'r', i: 'i', z: 'z' },
     colourSpec: { slotA: 'u', slotB: 'g', rangeMin: 0.5, rangeMax: 2.0, kPerZ: 3.0 },
@@ -182,6 +184,8 @@ export const SOURCE_REGISTRY = {
     binBaseName: 'sdss',
     allSky: false,
     visible: true,
+    bearsLabel: false,
+    bearsMarker: false,
     // Main galaxy sample reaches z ~ 0.7+ for luminous red galaxies;
     // rounded up generously.
     maxDistMpc: 3000,
@@ -211,6 +215,8 @@ export const SOURCE_REGISTRY = {
     binBaseName: '2mrs',
     allSky: true,
     visible: true,
+    bearsLabel: false,
+    bearsMarker: false,
     // Flux-limited at K_s ≈ 11.75; effective z ≲ 0.06.
     maxDistMpc: 250,
     bandLabels: { u: '—', g: 'J', r: 'H', i: 'K', z: '—' },
@@ -237,6 +243,8 @@ export const SOURCE_REGISTRY = {
     binBaseName: 'glade',
     allSky: true,
     visible: true,
+    bearsLabel: false,
+    bearsMarker: false,
     // Covers most of the GLADE distance distribution. GLADE has a long
     // sparse tail past 1 Gpc that the default framing deliberately clips.
     maxDistMpc: 1500,
@@ -268,6 +276,12 @@ export const SOURCE_REGISTRY = {
     binBaseName: 'famous',
     allSky: true, // hand-picked entries from across the sky
     visible: true,
+    bearsLabel: true,
+    bearsMarker: false,
+    labelLayer: 'galaxyNames',
+    detailLabel: 'Famous Galaxy',
+    shortLabel: 'Galaxy',
+    plural: 'Famous Galaxies',
     maxDistMpc: 200, // covers the curated set: M31 → NGC 4889
     // Famous entries don't carry per-row photometry — the source survey
     // already measured it. The SDSS-mirroring labels are cosmetic so the
@@ -295,6 +309,12 @@ export const SOURCE_REGISTRY = {
     label: 'Cluster',
     allSky: true,
     visible: true,
+    bearsLabel: true,
+    bearsMarker: true,
+    labelLayer: 'structure',
+    detailLabel: 'Galaxy Cluster',
+    shortLabel: 'Cluster',
+    plural: 'Clusters',
   },
   [Source.Supercluster]: {
     type: 'structure',
@@ -303,6 +323,12 @@ export const SOURCE_REGISTRY = {
     label: 'Supercluster',
     allSky: true,
     visible: true,
+    bearsLabel: true,
+    bearsMarker: true,
+    labelLayer: 'structure',
+    detailLabel: 'Supercluster',
+    shortLabel: 'Supercluster',
+    plural: 'Superclusters',
   },
   [Source.Void]: {
     type: 'structure',
@@ -311,6 +337,12 @@ export const SOURCE_REGISTRY = {
     label: 'Void',
     allSky: true,
     visible: true,
+    bearsLabel: true,
+    bearsMarker: true,
+    labelLayer: 'structure',
+    detailLabel: 'Cosmic Void',
+    shortLabel: 'Void',
+    plural: 'Voids',
   },
   [Source.Group]: {
     type: 'structure',
@@ -319,6 +351,12 @@ export const SOURCE_REGISTRY = {
     label: 'Group',
     allSky: true,
     visible: true,
+    bearsLabel: true,
+    bearsMarker: true,
+    labelLayer: 'structure',
+    detailLabel: 'Galaxy Group',
+    shortLabel: 'Group',
+    plural: 'Groups',
   },
   [Source.Milliquas]: {
     type: 'survey',
@@ -327,6 +365,8 @@ export const SOURCE_REGISTRY = {
     label: 'Milliquas',
     binBaseName: 'milliquas',
     allSky: true,
+    bearsLabel: false,
+    bearsMarker: false,
     // Visible by default: the quasar source is stable enough to ship on.
     // It renders with the shared galaxy-billboard path (no quasar-specific
     // visuals yet), which is acceptable for the bright low-z tail the
@@ -387,6 +427,8 @@ export const SOURCE_REGISTRY = {
     // and most users want the points-only view first. They can flip it
     // on in the SettingsPanel.
     visible: false,
+    bearsLabel: false,
+    bearsMarker: false,
     binBaseName: 'filaments',
     // 1.0 is the unit baseline; user scales it down for a subtler overlay
     // or up for emphasis via the (future) Filaments slider.
@@ -401,6 +443,8 @@ export const SOURCE_REGISTRY = {
     // Default-off: the ~32 MB voxel payload is demand-loaded the first
     // time the user enables the field in the Volumes panel — not at boot.
     visible: false,
+    bearsLabel: false,
+    bearsMarker: false,
     handle: 'cf4-density',
     // Underscore in the filename for legacy reasons; `handle` mirrors it
     // in kebab-case for UI / settings keys.
@@ -429,6 +473,8 @@ export const SOURCE_REGISTRY = {
     // Default-on: this is the headline cosmic-web overlay; the global
     // intensity of 1.0 (set on this entry) gives it presence on first paint.
     visible: true,
+    bearsLabel: false,
+    bearsMarker: false,
     handle: 'mcpm',
     binBaseName: 'mcpm',
     tiered: true, // small / medium / large `.scfd` variants
@@ -454,6 +500,8 @@ export const SOURCE_REGISTRY = {
     label: 'Gaussian (debug)',
     allSky: true,
     visible: false,
+    bearsLabel: false,
+    bearsMarker: false,
     handle: 'debug-gaussian',
     binBaseName: null,
     tiered: false,
@@ -475,6 +523,8 @@ export const SOURCE_REGISTRY = {
     label: 'Cartesian grid (debug)',
     allSky: true,
     visible: false,
+    bearsLabel: false,
+    bearsMarker: false,
     handle: 'debug-cartesian',
     binBaseName: null,
     tiered: false,
@@ -496,6 +546,8 @@ export const SOURCE_REGISTRY = {
     label: 'Spherical grid (debug)',
     allSky: true,
     visible: false,
+    bearsLabel: false,
+    bearsMarker: false,
     handle: 'debug-spherical',
     binBaseName: null,
     tiered: false,
diff --git a/src/data/structureCategories.ts b/src/data/structureCategories.ts
index 860f50b7e..1e0bb076a 100644
--- a/src/data/structureCategories.ts
+++ b/src/data/structureCategories.ts
@@ -23,3 +23,13 @@ export const STRUCTURE_CATEGORY_CODES: Readonly<Record<StructureCategory, number
     StructureCategory,
     number
   >;
+
+/**
+ * Narrow a label-bearing category id to StructureCategory. Lets data-driven
+ * callers (e.g. the label-visibility setter) route on a registry field rather
+ * than a literal `=== 'famousGalaxy'` compare while keeping the type narrowed
+ * for the structure-only fade handles.
+ */
+export function isStructureCategory(id: string): id is StructureCategory {
+  return (STRUCTURE_CATEGORIES as readonly string[]).includes(id);
+}
diff --git a/src/data/surveyFluxLimits.ts b/src/data/surveyFluxLimits.ts
index a3f471a83..ed3cb66ac 100644
--- a/src/data/surveyFluxLimits.ts
+++ b/src/data/surveyFluxLimits.ts
@@ -1,12 +1,12 @@
 /**
  * Per-survey flux limits and Schechter luminosity-function parameters —
  * thin accessors over `SOURCE_REGISTRY`. The actual numbers live on each
- * survey entry (see `sources.ts`); this module only adds the POI throw
+ * survey entry (see `sources.ts`); this module only adds the non-survey throw
  * guard so callers that hand us a raw `Source` get a loud error rather
  * than silently reading `undefined`.
  */
 
-import { Source, SOURCE_REGISTRY } from './sources';
+import { SOURCE_REGISTRY } from './sources';
 import type { SchechterTriple } from '../@types/data/SchechterTriple';
 import type { SourceType } from '../@types/data/SourceType';
 
@@ -14,7 +14,7 @@ import type { SourceType } from '../@types/data/SourceType';
 export function surveyFluxLimit(source: SourceType): number {
   const entry = SOURCE_REGISTRY[source];
   if (entry.type !== 'survey') {
-    throw new Error(`surveyFluxLimit: POI source ${source} has no flux limit`);
+    throw new Error(`surveyFluxLimit: non-survey source ${source} has no flux limit`);
   }
   return entry.mLim;
 }
@@ -23,7 +23,7 @@ export function surveyFluxLimit(source: SourceType): number {
 export function surveySchechter(source: SourceType): SchechterTriple {
   const entry = SOURCE_REGISTRY[source];
   if (entry.type !== 'survey') {
-    throw new Error(`surveySchechter: POI source ${source} has no Schechter triple`);
+    throw new Error(`surveySchechter: non-survey source ${source} has no Schechter triple`);
   }
   return entry.schechter;
 }
diff --git a/src/hooks/useEngine.ts b/src/hooks/useEngine.ts
index 555323d6c..a00e0a22d 100644
--- a/src/hooks/useEngine.ts
+++ b/src/hooks/useEngine.ts
@@ -55,7 +55,7 @@ import type { UseEngineInput } from '../@types/engine/UseEngineInput';
 import type { UseEngineReturn } from '../@types/engine/UseEngineReturn';
 import { initialTierFromViewport } from '../utils/initialTierFromViewport';
 import type { SourceType } from '../@types/data/SourceType';
-import type { PoiCategory } from '../@types/engine/data/PoiCategory';
+import type { StructureCategory } from '../@types/engine/data/StructureCategory';
 
 /**
  * Initial scale-bar value that renders something sensible before the
@@ -86,7 +86,9 @@ export function useEngine(input: UseEngineInput = {}): UseEngineReturn {
   const [scale, setScale] = useState<ScaleInfo>(INITIAL_SCALE);
   const [fps, setFps] = useState<number>(0);
   const [sourceCounts, setSourceCounts] = useState<Partial<Record<SourceType, number>>>({});
-  const [structureCounts, setStructureCounts] = useState<Partial<Record<PoiCategory, number>>>({});
+  const [structureCounts, setStructureCounts] = useState<
+    Partial<Record<StructureCategory, number>>
+  >({});
   const [loadProgress, setLoadProgress] = useState<LoadProgressState | null>(null);
   // Lazy-init from viewport — `window` is guarded for SSR / unit-test
   // hosts.  Echoed by the engine via `onTierChange`, so this state
diff --git a/src/hooks/useEngineSettings.ts b/src/hooks/useEngineSettings.ts
index 234873bbc..accf2b086 100644
--- a/src/hooks/useEngineSettings.ts
+++ b/src/hooks/useEngineSettings.ts
@@ -42,7 +42,10 @@ import { useCallback, useState } from 'react';
 import type { BiasMode as BiasModeT } from '../@types/data/BiasMode';
 import type { ToneMapCurve as ToneMapCurveT } from '../@types/data/ToneMapCurve';
 import type { FlowSettings } from '../@types/settings/FlowSettings';
-import type { PoiCategory } from '../@types/engine/data/PoiCategory';
+import type { LabelCategory } from '../@types/engine/data/LabelCategory';
+import type { StructureCategory } from '../@types/engine/data/StructureCategory';
+import { LABEL_CATEGORIES } from '../data/labelCategories';
+import { STRUCTURE_CATEGORIES } from '../data/structureCategories';
 import {
   DEFAULT_ABS_MAG_LIMIT,
   DEFAULT_AUTO_ROTATE,
@@ -164,31 +167,30 @@ export function useEngineSettings(): UseEngineSettingsReturn {
     DEFAULT_SPACE_MOUSE_SENSITIVITY,
   );
 
-  // ── POI per-category visibility (two independent axes) ──────────────
-  // Engine echoes the full Record<PoiCategory, boolean> per axis on
-  // every matching setter call (plus once at init via
-  // seedSettingsCallbacks).  Label and marker visibility are kept as two
-  // separate records on purpose: conflating them into one axis lets a
-  // category hidden on one axis silently suppress it on the other.  Both
-  // seed to "all categories on" so first paint matches the engine default.
+  // ── Per-category visibility (two independent axes) ──────────────────
+  // Engine echoes the full per-axis record on every matching setter call
+  // (plus once at init via seedSettingsCallbacks).  Label and marker
+  // visibility are kept as two separate records on purpose: conflating
+  // them into one axis lets a category hidden on one axis silently
+  // suppress it on the other.  Both seed to "all categories on" so first
+  // paint matches the engine default.  The keys are DERIVED from each
+  // axis's category set — labels span `LABEL_CATEGORIES` (famousGalaxy +
+  // structures), markers span `STRUCTURE_CATEGORIES` only (no famous ring).
   const [labelCategoryVisibility, setLabelCategoryVisibility] = useState<
-    Record<PoiCategory, boolean>
-  >({
-    cluster: true,
-    supercluster: true,
-    famousGalaxy: true,
-    void: true,
-    group: true,
-  });
+    Record<LabelCategory, boolean>
+  >(
+    () =>
+      Object.fromEntries(LABEL_CATEGORIES.map((c) => [c, true])) as Record<LabelCategory, boolean>,
+  );
   const [markerCategoryVisibility, setMarkerCategoryVisibility] = useState<
-    Record<PoiCategory, boolean>
-  >({
-    cluster: true,
-    supercluster: true,
-    famousGalaxy: true,
-    void: true,
-    group: true,
-  });
+    Record<StructureCategory, boolean>
+  >(
+    () =>
+      Object.fromEntries(STRUCTURE_CATEGORIES.map((c) => [c, true])) as Record<
+        StructureCategory,
+        boolean
+      >,
+  );
 
   return {
     settings: {
diff --git a/src/hooks/useKeyboardShortcuts.ts b/src/hooks/useKeyboardShortcuts.ts
index d031ec080..9c60a1475 100644
--- a/src/hooks/useKeyboardShortcuts.ts
+++ b/src/hooks/useKeyboardShortcuts.ts
@@ -28,14 +28,8 @@ import { useEffect } from 'react';
 import type { UseKeyboardShortcutsInput } from '../@types/engine/UseKeyboardShortcutsInput';
 
 export function useKeyboardShortcuts(input: UseKeyboardShortcutsInput): void {
-  const {
-    selected,
-    paletteOpen,
-    engineHandleRef,
-    setPaletteOpen,
-    setUiHidden,
-    setDebugPanelOpen,
-  } = input;
+  const { selected, paletteOpen, engineHandleRef, setPaletteOpen, setUiHidden, setDebugPanelOpen } =
+    input;
 
   useEffect(() => {
     const onKeyDown = (e: KeyboardEvent) => {
@@ -65,8 +59,8 @@ export function useKeyboardShortcuts(input: UseKeyboardShortcutsInput): void {
       }
 
       // ── Esc — universal "close the card" gesture ──────────────
-      // `selection.clear()` tears down both galaxy selection AND POI
-      // focus in one call (unified 2026-05-19), so this single line
+      // `selection.clear()` tears down both galaxy selection AND structure
+      // focus in one call, so this single line
       // collapses whichever card variant is on screen.
       if (e.key === 'Escape') {
         engineHandleRef.current?.selection.clear();
diff --git a/src/hooks/useSplash.ts b/src/hooks/useSplash.ts
index 02b564045..22672c3e9 100644
--- a/src/hooks/useSplash.ts
+++ b/src/hooks/useSplash.ts
@@ -37,7 +37,7 @@
  *
  * ### Deep-link bypass
  *
- * A URL with `#focus=`, `#poi=`, or `?tour=` (see `hasDeepLink`) skips
+ * A URL with `#focus=` or `?tour=` (see `hasDeepLink`) skips
  * the splash on first arrival and never auto-shows it.  About pill
  * `reopen()` still works.  Power-user gates (`?debug`, etc.) do NOT
  * count as deep links.
diff --git a/src/hooks/useStructureMemberCount.ts b/src/hooks/useStructureMemberCount.ts
index 0cf51b863..a118583b3 100644
--- a/src/hooks/useStructureMemberCount.ts
+++ b/src/hooks/useStructureMemberCount.ts
@@ -11,13 +11,13 @@
  * frame.
  *
  * Returns `null` (caller omits the row) when nothing is countable: no
- * structure selected, a famous-galaxy POI, or the engine handle / catalogs
+ * structure selected, a famous-galaxy selection, or the engine handle / catalogs
  * aren't ready.  `getCloud` reads the engine's live catalog map, so a
  * stale tier never lingers — the next catalog landing re-fires the memo.
  */
 
 import { useMemo } from 'react';
-import { isPoi } from '../services/engine/isPoi';
+import { isStructure } from '../services/engine/isStructure';
 import { structureMemberCount } from '../utils/structure/structureMemberCount';
 import type { UseStructureMemberCountInput } from '../@types/engine/UseStructureMemberCountInput';
 
@@ -29,7 +29,7 @@ export function useStructureMemberCount({
   visibleSourceMask,
 }: UseStructureMemberCountInput): number | null {
   return useMemo(() => {
-    if (selected === null || !isPoi(selected)) return null;
+    if (selected === null || !isStructure(selected)) return null;
     const handle = engineHandleRef.current;
     if (handle === null) return null;
     return structureMemberCount(
diff --git a/src/hooks/useUrlSync.ts b/src/hooks/useUrlSync.ts
index cc48299e9..150c23bf9 100644
--- a/src/hooks/useUrlSync.ts
+++ b/src/hooks/useUrlSync.ts
@@ -1,12 +1,12 @@
 /**
- * useUrlSync — single owner of `window.location.hash`, handles both
- * `#focus=<galaxyId>` (galaxy commit) and `#poi=<poiId>` (POI commit)
- * segments in one place.
+ * useUrlSync — single owner of `window.location.hash`, encoding both
+ * galaxy and structure commits in one `#focus=<id>` segment (the codec
+ * distinguishes them by id shape).
  *
  * One owner can't race itself, so there are no "is the hash someone
  * else's segment?" prefix guards — the write effect just computes the
  * canonical body from whichever state slot is set.  Galaxy wins the mutex tiebreak
- * (matches engine click-handler precedence: POI clicks clear galaxy
+ * (matches engine click-handler precedence: structure clicks clear galaxy
  * selection at the engine level today, so "both set" is only ever a
  * transient cross-render race, and we resolve it deterministically
  * here as a belt-and-braces guarantee).
@@ -21,8 +21,8 @@
  * ──────────────────────────────────────────────────────────────────────
  * Why `pushState` (not `replaceState`)
  * ──────────────────────────────────────────────────────────────────────
- * Pinning a galaxy OR focusing a POI is a navigational act — Back
- * should return to the previous selection (galaxy ↔ POI ↔ empty).
+ * Pinning a galaxy OR focusing a structure is a navigational act — Back
+ * should return to the previous selection (galaxy ↔ structure ↔ empty).
  * popstate translates browser-driven hash changes into the same
  * pending-slot mechanism the initial mount uses.
  *
@@ -39,7 +39,7 @@
  *      disambiguates the URL on popstate via `initialPendingFromHash`,
  *      routes into the right pending slot, and clears stale pending
  *      from the other slot.  An empty hash on popstate calls
- *      `selection.clear()`, which tears down both galaxy and POI
+ *      `selection.clear()`, which tears down both galaxy and structure
  *      selection in one call.
  *
  *   2. State → URL — derives the canonical body via `computeDesiredHash`
@@ -52,16 +52,16 @@
  *      catalogs.  Resolution is monotonic: `unknown` is treated as
  *      "not yet" and the effect re-fires on data dep changes.
  *
- *   4. POI drain — resolves `pendingPoiId` against the POI table and
- *      dispatches via `camera.focusOn(poi)` (the unified method,
- *      which accepts both GalaxyInfo and StructureRecord).  Clears
- *      pending only on successful resolve; missing-id leaves pending
- *      set so a future `pois` change (e.g. famous-meta load) re-fires
- *      the drain.
+ *   4. Structure drain — resolves `pendingStructureId` against the
+ *      `structures` table and dispatches via `camera.focusOn(structure)` (the
+ *      unified method, which accepts both GalaxyInfo and
+ *      StructureRecord).  Clears pending only on successful resolve;
+ *      missing-id leaves pending set so a future `structures` change (e.g.
+ *      famous-meta load) re-fires the drain.
  *
  *   5. Galaxy supersede — collapses `pendingTarget` once `focused`
- *      lands (deep-link wins vs casual click race).  No POI supersede
- *      because the POI table is synchronous.
+ *      lands (deep-link wins vs casual click race).  No structure
+ *      supersede because the `structures` table is synchronous.
  */
 
 import { useEffect, useRef, useState } from 'react';
@@ -70,9 +70,8 @@ import type { UrlSyncReturn } from '../@types/engine/UrlSyncReturn';
 import type { FocusableTarget } from '../@types/engine/FocusableTarget';
 import type { GalaxyCatalog } from '../@types/data/GalaxyCatalog';
 import type { FocusTarget } from '../@types/camera/FocusTarget';
-import { isPoi } from '../services/engine/isPoi';
+import { isStructure } from '../services/engine/isStructure';
 import { parseFocusHash, selectionToFocusId } from '../services/url/focusUrl';
-import { parsePoiHash, poiIdToHash } from '../services/url/poiUrl';
 import { resolveFocusTarget } from '../services/engine/camera/resolveFocusTarget';
 import { SURVEY_SOURCES, Source } from '../data/sources';
 import type { SourceType } from '../@types/data/SourceType';
@@ -94,10 +93,10 @@ export type DesiredHashOutput = {
  * hash, what should the URL's hash *body* be, and does it already agree?
  *
  * Body shape:
- *   1. focused is a galaxy → `focus=<id>` (or `''` if non-encodable,
+ *   1. focused is a galaxy    → `focus=<id>` (or `''` if non-encodable,
  *      e.g. Synthetic source).
- *   2. focused is a POI    → `poi=<id>`.
- *   3. focused is null     → `''`.
+ *   2. focused is a structure → `focus=<id>`.
+ *   3. focused is null        → `''`.
  *
  * `matches` is the strip-leading-#-and-compare result, used by the write
  * effect to skip no-op `pushState` calls.
@@ -105,8 +104,8 @@ export type DesiredHashOutput = {
 export function computeDesiredHash(input: DesiredHashInput): DesiredHashOutput {
   let desiredHashBody = '';
   if (input.focused !== null) {
-    if (isPoi(input.focused)) {
-      desiredHashBody = poiIdToHash(input.focused.id);
+    if (isStructure(input.focused)) {
+      desiredHashBody = `focus=${input.focused.id}`;
     } else {
       const id = selectionToFocusId(input.focused);
       if (id) desiredHashBody = `focus=${id}`;
@@ -120,31 +119,39 @@ export function computeDesiredHash(input: DesiredHashInput): DesiredHashOutput {
 
 export type InitialPending =
   | { kind: 'galaxy'; target: FocusTarget }
-  | { kind: 'poi'; poiId: string }
+  | { kind: 'structure'; id: string }
   | { kind: null };
 
 /**
- * Pure parse-on-mount helper.  Tries the galaxy parser first, then the
- * POI parser, then returns `kind: null` for everything else.  Each
- * parser returns null for hashes that don't match its scheme, so
- * disambiguation is just "first match wins."
+ * Pure parse-on-mount helper.  Runs the single `#focus=` codec and routes
+ * its result: a `structure` FocusTarget becomes a structure pending slot
+ * (resolved synchronously against the `structures` table), any galaxy kind
+ * becomes a galaxy pending slot (resolved async against loaded catalogs),
+ * and a null parse becomes `kind: null`.
  */
 export function initialPendingFromHash(hash: string): InitialPending {
-  const galaxy = parseFocusHash(hash);
-  if (galaxy) return { kind: 'galaxy', target: galaxy };
-  const poi = parsePoiHash(hash);
-  if (poi) return { kind: 'poi', poiId: poi };
-  return { kind: null };
+  const target = parseFocusHash(hash);
+  if (!target) return { kind: null };
+  if (target.kind === 'structure') return { kind: 'structure', id: target.id };
+  return { kind: 'galaxy', target };
 }
 
 // ── React hook ─────────────────────────────────────────────────────────────
 
 export function useUrlSync(input: UseUrlSyncInput): UrlSyncReturn {
-  const { focused, status, sourceCounts, famousMeta, aliasMap, ready, pois, engineHandleRef } =
-    input;
+  const {
+    focused,
+    status,
+    sourceCounts,
+    famousMeta,
+    aliasMap,
+    ready,
+    structures,
+    engineHandleRef,
+  } = input;
 
   const [pendingTarget, setPendingTarget] = useState<FocusTarget | null>(null);
-  const [pendingPoiId, setPendingPoiId] = useState<string | null>(null);
+  const [pendingStructureId, setPendingStructureId] = useState<string | null>(null);
 
   // ── Effect 1: mount + popstate ────────────────────────────────────────
   // Parse the URL once on mount; install a `popstate` listener so
@@ -152,7 +159,7 @@ export function useUrlSync(input: UseUrlSyncInput): UrlSyncReturn {
   // resolution paths.  A single handler disambiguates via
   // `initialPendingFromHash` and clears the stale slot from the other
   // kind — we are the sole owner of the hash, so a switch in hash
-  // kind (e.g. back-nav from `#focus=m31` to `#poi=virgo`) is just
+  // kind (e.g. back-nav from `#focus=m31` to `#focus=cluster-virgo`) is just
   // "set the new slot, clear the old one."
   const mountedRef = useRef(false);
   useEffect(() => {
@@ -166,15 +173,15 @@ export function useUrlSync(input: UseUrlSyncInput): UrlSyncReturn {
 
     const initial = initialPendingFromHash(window.location.hash);
     if (initial.kind === 'galaxy') setPendingTarget(initial.target);
-    else if (initial.kind === 'poi') setPendingPoiId(initial.poiId);
+    else if (initial.kind === 'structure') setPendingStructureId(initial.id);
 
     const onPopState = () => {
       const next = initialPendingFromHash(window.location.hash);
       if (next.kind === 'galaxy') {
         setPendingTarget(next.target);
-        setPendingPoiId(null);
-      } else if (next.kind === 'poi') {
-        setPendingPoiId(next.poiId);
+        setPendingStructureId(null);
+      } else if (next.kind === 'structure') {
+        setPendingStructureId(next.id);
         setPendingTarget(null);
       } else {
         // Back-step to empty hash — clear any stale pending AND tell
@@ -182,7 +189,7 @@ export function useUrlSync(input: UseUrlSyncInput): UrlSyncReturn {
         // both).  Without this, the next render would write the previous
         // body back over the empty one.
         setPendingTarget(null);
-        setPendingPoiId(null);
+        setPendingStructureId(null);
         engineHandleRef.current?.selection.clear();
       }
     };
@@ -194,7 +201,7 @@ export function useUrlSync(input: UseUrlSyncInput): UrlSyncReturn {
 
   // ── Effect 2: state → URL ─────────────────────────────────────────────
   // Write the hash to match the selection.  Two guards:
-  //   - `pendingTarget !== null || pendingPoiId !== null`: don't fight
+  //   - `pendingTarget !== null || pendingStructureId !== null`: don't fight
   //     either pending slot.  If we wrote the desired body while a deep
   //     link is still resolving we'd clobber the URL that drove the
   //     pending state in the first place.  The write opens once both
@@ -210,7 +217,7 @@ export function useUrlSync(input: UseUrlSyncInput): UrlSyncReturn {
   useEffect(() => {
     if (typeof window === 'undefined') return;
     // Don't fight a still-resolving deep link on either side.
-    if (pendingTarget !== null || pendingPoiId !== null) return;
+    if (pendingTarget !== null || pendingStructureId !== null) return;
     const { desiredHashBody, matches } = computeDesiredHash({
       focused,
       currentHash: window.location.hash,
@@ -219,7 +226,7 @@ export function useUrlSync(input: UseUrlSyncInput): UrlSyncReturn {
     const base = window.location.pathname + window.location.search;
     const next = desiredHashBody ? `${base}#${desiredHashBody}` : base;
     window.history.pushState(null, '', next);
-  }, [focused, pendingTarget, pendingPoiId]);
+  }, [focused, pendingTarget, pendingStructureId]);
 
   // ── Effect 3: galaxy drain ────────────────────────────────────────────
   // Resolve pendingTarget against the engine's currently loaded data
@@ -273,27 +280,27 @@ export function useUrlSync(input: UseUrlSyncInput): UrlSyncReturn {
     // eventual banner; `unknown` simply waits for more data.
   }, [pendingTarget, status, sourceCounts, famousMeta, aliasMap, engineHandleRef]);
 
-  // ── Effect 4: POI drain ───────────────────────────────────────────────
-  // Resolve `pendingPoiId` against the POI table once the engine is
-  // ready.  We deliberately do NOT clear pending when the id isn't
-  // found — a tier swap or async famous-meta load can add entries
-  // later, and re-firing the drain on `pois` changes will pick them
+  // ── Effect 4: structure drain ─────────────────────────────────────────
+  // Resolve `pendingStructureId` against the `structures` table once the
+  // engine is ready.  We deliberately do NOT clear pending when the id
+  // isn't found — a tier swap or async famous-meta load can add entries
+  // later, and re-firing the drain on `structures` changes will pick them
   // up.  Clearing only on a successful resolve preserves the
   // "deep-link arrival waits as long as it takes" contract.
   //
   // `camera.focusOn` is the unified method that accepts both GalaxyInfo
   // and StructureRecord, routing each to its own commit path internally.
   useEffect(() => {
-    if (!pendingPoiId) return;
+    if (!pendingStructureId) return;
     if (!ready) return;
-    if (pois.length === 0) return;
+    if (structures.length === 0) return;
     const handle = engineHandleRef.current;
     if (!handle) return;
-    const poi = pois.find((p) => p.id === pendingPoiId);
-    if (!poi) return; // Leave pending set — re-fires when `pois` grows.
-    handle.camera.focusOn(poi); // The unified focusOn.
-    setPendingPoiId(null);
-  }, [pendingPoiId, ready, pois, engineHandleRef]);
+    const structure = structures.find((p) => p.id === pendingStructureId);
+    if (!structure) return; // Leave pending set — re-fires when `structures` grows.
+    handle.camera.focusOn(structure); // The unified focusOn.
+    setPendingStructureId(null);
+  }, [pendingStructureId, ready, structures, engineHandleRef]);
 
   // ── Effect 5: galaxy supersede ────────────────────────────────────────
   // The trigger is a FOCUS change, not a pendingTarget change.  Why
@@ -308,11 +315,12 @@ export function useUrlSync(input: UseUrlSyncInput): UrlSyncReturn {
   //
   // Bare canvas clicks set `selected` but NOT `focused`, so they don't
   // pre-empt a still-resolving deep link — the deep-link wins, which
-  // matches the user's URL-pasted intent.  POI deep links resolve on
-  // first paint (synchronous POI table), so no POI supersede is needed.
+  // matches the user's URL-pasted intent.  Structure deep links resolve
+  // on first paint (synchronous `structures` table), so no structure supersede
+  // is needed.
   useEffect(() => {
     if (focused !== null) setPendingTarget(null);
   }, [focused]);
 
-  return { pendingTarget, pendingPoiId };
+  return { pendingTarget, pendingStructureId };
 }
diff --git a/src/services/animation/fadeRegistry.ts b/src/services/animation/fadeRegistry.ts
index e11b65b10..f6f8b7e25 100644
--- a/src/services/animation/fadeRegistry.ts
+++ b/src/services/animation/fadeRegistry.ts
@@ -53,7 +53,7 @@ function serializeFadeHandle(h: FadeHandle): string {
       return `scalarField:${h.field}`;
     case 'markerLayer':
       return `markerLayer:${h.category}`;
-    // A category-less POI handle and a per-category one must not collide,
+    // A category-less structure handle and a per-category one must not collide,
     // and existing keys (e.g. `labelLayer:youAreHere`) must stay
     // byte-identical — so the category suffix is appended only when present.
     case 'labelLayer':
diff --git a/src/services/engine/camera/resolveFocusTarget.ts b/src/services/engine/camera/resolveFocusTarget.ts
index d7a956fc9..6adbe9312 100644
--- a/src/services/engine/camera/resolveFocusTarget.ts
+++ b/src/services/engine/camera/resolveFocusTarget.ts
@@ -86,6 +86,13 @@ export function resolveFocusTarget(input: ResolverInput): ResolverOutput {
       return resolveSdss(target.objID, input);
     case 'pos':
       return resolvePos(target.raDeg, target.decDeg, input);
+    case 'structure':
+      // Structures resolve through the structure-table drain in useUrlSync, not
+      // the galaxy cloud scan — a structure target never reaches the galaxy
+      // resolver in practice. Report unknown defensively so the switch is
+      // exhaustive and a stray structure target clears cleanly rather than
+      // falling through.
+      return { resolved: false, reason: 'unknown' };
   }
 }
 
diff --git a/src/services/engine/camera/structureFocusDistance.ts b/src/services/engine/camera/structureFocusDistance.ts
index af48444b7..c434abdf8 100644
--- a/src/services/engine/camera/structureFocusDistance.ts
+++ b/src/services/engine/camera/structureFocusDistance.ts
@@ -8,7 +8,7 @@
  * member galaxies, the local field. The ring + label are navigational chrome;
  * once you've arrived they're in the way. So we frame the structure large
  * enough that its marker has *just* crossed the close-approach fade-out
- * (`structurePoiStyles`' `markerMaxApparentRadiusPx`), leaving the interior
+ * (`structureMarkerStyles`' `markerMaxApparentRadiusPx`), leaving the interior
  * unobscured. The same fade governs the label, so label and ring disappear
  * together and the view is clean.
  *
diff --git a/src/services/engine/engine.ts b/src/services/engine/engine.ts
index 2c22b732f..646cd8c7e 100644
--- a/src/services/engine/engine.ts
+++ b/src/services/engine/engine.ts
@@ -121,7 +121,7 @@ import { clearAll } from './helpers/clearAll';
 import { commitFocus } from './helpers/commitFocus';
 import { commitGalaxyFocus } from './helpers/commitGalaxyFocus';
 import type { FocusableTarget } from '../../@types/engine/FocusableTarget';
-import { isPoi } from './isPoi';
+import { isStructure } from './isStructure';
 import { logCameraState } from './helpers/logCameraState';
 import type { AssetSlot } from '../../@types/loading/AssetSlot';
 import type { PgcAliasMap } from '../../@types/loading/PgcAliasMap';
@@ -141,7 +141,10 @@ import { clampVolumeTrim } from '../../utils/clampVolumeTrim';
 import { clampVolumeExposure } from '../../utils/clampVolumeExposure';
 import type { VolumeFieldRowData } from '../../@types/settings/VolumeFieldRowData';
 import type { VolumeFieldId } from '../../@types/data/VolumeFieldId';
-import type { PoiCategory } from '../../@types/engine/data/PoiCategory';
+import type { LabelCategory } from '../../@types/engine/data/LabelCategory';
+import type { StructureCategory } from '../../@types/engine/data/StructureCategory';
+import { LABEL_CATEGORIES, LABEL_LAYER_BY_CATEGORY } from '../../data/labelCategories';
+import { STRUCTURE_CATEGORIES, isStructureCategory } from '../../data/structureCategories';
 
 // ── SpaceMouse 6DOF input (optional, WebHID-only) ────────────────────────────
 //
@@ -261,25 +264,30 @@ export { setSourceVisibleImpl as setSourceVisibleForTest };
 function setCategoryLabelVisible(
   state: Pick<EngineState, 'data' | 'settings' | 'subsystems'>,
   cb: Pick<EngineCallbacks, 'labels'>,
-  category: PoiCategory,
+  category: LabelCategory,
   visible: boolean,
 ): void {
-  if (category === 'famousGalaxy') {
+  // Routing comes from the registry row's `labelLayer` field, not a literal
+  // category compare: 'galaxyNames' rows (the curated atlas) drive the galaxy
+  // store + shared galaxyNames fade layer; 'structure' rows fade their
+  // per-category handle on the shared `structure` label layer.
+  const durationMs = visible ? FADE_IN_DURATION_MS : FADE_OUT_DURATION_MS;
+  if (LABEL_LAYER_BY_CATEGORY[category] === 'galaxyNames') {
     state.data.galaxies.setFamousLabelsVisible(visible);
     // Famous-galaxy labels reuse the shared `galaxyNames` label layer rather
     // than minting a per-category handle (see FadeHandle's labelLayer doc).
     void state.subsystems.fades.fadeTo(
       { kind: 'labelLayer', layer: 'galaxyNames' },
       visible ? 1 : 0,
-      visible ? FADE_IN_DURATION_MS : FADE_OUT_DURATION_MS,
+      durationMs,
     );
-  } else {
-    // `category !== 'famousGalaxy'` narrows PoiCategory to StructureCategory,
-    // which is exactly what the labelLayer/poi handle's `category` field wants.
+  } else if (isStructureCategory(category)) {
+    // The 'structure' rows narrow to StructureCategory, which is exactly what
+    // the labelLayer/structure handle's `category` field wants.
     void state.subsystems.fades.fadeTo(
-      { kind: 'labelLayer', layer: 'poi', category },
+      { kind: 'labelLayer', layer: 'structure', category },
       visible ? 1 : 0,
-      visible ? FADE_IN_DURATION_MS : FADE_OUT_DURATION_MS,
+      durationMs,
     );
   }
   state.settings.labelCategoryVisibility = {
@@ -295,23 +303,17 @@ function setCategoryLabelVisible(
 function setCategoryMarkerVisible(
   state: Pick<EngineState, 'data' | 'settings' | 'subsystems'>,
   cb: Pick<EngineCallbacks, 'labels'>,
-  category: PoiCategory,
+  category: StructureCategory,
   visible: boolean,
 ): void {
-  // Famous galaxies have no ring/halo marker — curated thumbnails do that job —
-  // so a marker-visibility toggle for them is a no-op, AND there is no
-  // `markerLayer` handle to fade (markerLayer handles are keyed by
-  // StructureCategory only). Only structure categories route to the structure
-  // store's marker axis and fire a markerLayer fade. The `category !==
-  // 'famousGalaxy'` guard narrows PoiCategory to StructureCategory, which the
-  // markerLayer handle's `category` field requires.
-  if (category !== 'famousGalaxy') {
-    void state.subsystems.fades.fadeTo(
-      { kind: 'markerLayer', category },
-      visible ? 1 : 0,
-      visible ? FADE_IN_DURATION_MS : FADE_OUT_DURATION_MS,
-    );
-  }
+  // Only structure categories bear a ring/halo marker, so the marker axis is
+  // keyed by StructureCategory — every category here routes to the structure
+  // store's marker axis and fires a markerLayer fade.
+  void state.subsystems.fades.fadeTo(
+    { kind: 'markerLayer', category },
+    visible ? 1 : 0,
+    visible ? FADE_IN_DURATION_MS : FADE_OUT_DURATION_MS,
+  );
   state.settings.markerCategoryVisibility = {
     ...state.settings.markerCategoryVisibility,
     [category]: visible,
@@ -442,30 +444,22 @@ export function createEngine(canvas: HTMLCanvasElement, cb: EngineCallbacks): En
       // gate + look/motion knobs) lives here, spread from the single
       // `DEFAULT_FLOW` seed. The `state.data.flow` store stays status-only.
       flow: { ...DEFAULT_FLOW },
-      // Per-category POI visibility — two independent axes (label-text vs
-      // marker-glyph), both default-all-on.  Each record is the source of
-      // truth for its axis: adding a new POI category means widening
-      // `STRUCTURE_POI_STYLES` AND adding the row to BOTH records here.
-      // `group` is the fifth category, added alongside the nearby-galaxy-
-      // groups feature.
-      labelCategoryVisibility: {
-        cluster: true,
-        supercluster: true,
-        famousGalaxy: true,
-        void: true,
-        group: true,
-      },
+      // Per-category visibility — two independent axes (label-text vs
+      // marker-glyph), both default-all-on.  Each record's keys are DERIVED
+      // from its category set so the defaults can't drift from the union:
+      // labels span `LABEL_CATEGORIES` (famousGalaxy + structures), markers
+      // span `STRUCTURE_CATEGORIES` only (famous galaxies bear no ring).
+      labelCategoryVisibility: Object.fromEntries(LABEL_CATEGORIES.map((c) => [c, true])) as Record<
+        LabelCategory,
+        boolean
+      >,
       debug: {
         showPickBuffer: DEFAULT_SHOW_PICK_BUFFER,
         showDiskRadiusRing: DEFAULT_SHOW_DISK_RADIUS_RING,
       },
-      markerCategoryVisibility: {
-        cluster: true,
-        supercluster: true,
-        famousGalaxy: true,
-        void: true,
-        group: true,
-      },
+      markerCategoryVisibility: Object.fromEntries(
+        STRUCTURE_CATEGORIES.map((c) => [c, true]),
+      ) as Record<StructureCategory, boolean>,
     },
     bias: {
       // Bake-only sentinels — overwritten before the shader's mode-2/3/4
@@ -630,7 +624,7 @@ export function createEngine(canvas: HTMLCanvasElement, cb: EngineCallbacks): En
       labelDirector: createLabelDirectorSubsystem(),
 
       // ── Cluster focus-mode subsystem ─────────────────────────────
-      // Selection-driven: `runFrame` calls `update(selectedPoi, nowMs)` to
+      // Selection-driven: `runFrame` calls `update(selectedStructure, nowMs)` to
       // drive the 400 ms member-isolation fade and threads
       // `produceFocusUniforms` into the points draw.  Eager, no GPU dep.
       structureFocus: createStructureFocusSubsystem(),
@@ -796,7 +790,7 @@ export function createEngine(canvas: HTMLCanvasElement, cb: EngineCallbacks): En
   // reference each by name — no forward references, no `!` assertions.
 
   function clearSelection(): void {
-    // Unified teardown — clears galaxy/POI selection AND the focus slot
+    // Unified teardown — clears galaxy/structure selection AND the focus slot
     // (so the cluster-focus fade collapses) in one call.  The branching
     // + render-scheduling lives in `clearAll` so the engine.ts closure
     // stays a thin wrapper.  See clearAll.ts for the dismiss-vs-deselect
@@ -833,7 +827,7 @@ export function createEngine(canvas: HTMLCanvasElement, cb: EngineCallbacks): En
     // bootstrap would set `#focus=…` while the camera stays put.  The
     // structure branch skips the guard so deep-link drains can land
     // structure state pre-camera (see commitStructureFocus).
-    if (!isPoi(target) && !state.cam) return;
+    if (!isStructure(target) && !state.cam) return;
     commitFocus(state, target);
   }
 
diff --git a/src/services/engine/frame/encodeUiOverlay.ts b/src/services/engine/frame/encodeUiOverlay.ts
index 87fe5874e..492f052a0 100644
--- a/src/services/engine/frame/encodeUiOverlay.ts
+++ b/src/services/engine/frame/encodeUiOverlay.ts
@@ -1,6 +1,6 @@
 /**
  * encodeUiOverlay — composites the UI overlay layers (marker-lines, labels,
- * future POI labels, …) onto the tone-mapped swap-chain image after
+ * future structure labels, …) onto the tone-mapped swap-chain image after
  * the HDR pipeline.
  *
  * ### Why post-tone-map (vs. inside HDR_PASSES)
diff --git a/src/services/engine/frame/passes/index.ts b/src/services/engine/frame/passes/index.ts
index 327367f14..db111a3f5 100644
--- a/src/services/engine/frame/passes/index.ts
+++ b/src/services/engine/frame/passes/index.ts
@@ -11,7 +11,7 @@
  *     `uiOverlay` inside one render pass against the swap-chain view.
  *
  * The two registries share the `Pass` interface so a future overlay
- * (e.g. POI labels, debug HUD elements) just adds itself to whichever
+ * (e.g. structure labels, debug HUD elements) just adds itself to whichever
  * registry matches its blend semantics.  The DebugPanel's
  * `DISPLAY_SLOT_ORDER` derives from HDR_PASSES (timing-instrumented
  * per-pass) plus three trailing slots: `tone-map`, `ui-overlay` (the
@@ -33,7 +33,7 @@
  *   5. filaments           — cosmic-web skeleton overlay
  *   6. volume-upsample     — upsamples the half-res volume offscreen target
  *                            into the HDR target (when active fields exist)
- *   7. structure-markers     — at-rest halo + ring for cluster / SC / void POIs
+ *   7. structure-markers     — at-rest halo + ring for cluster / SC / void structures
  *
  * `textured-disks` is what remains of the briefly-split (and never-shipped)
  * `textured-quads` + `textured-disks` pair from 2026-05-18.  The quad
diff --git a/src/services/engine/frame/passes/selectionRingPass.ts b/src/services/engine/frame/passes/selectionRingPass.ts
index 249b4ecb5..bb1417645 100644
--- a/src/services/engine/frame/passes/selectionRingPass.ts
+++ b/src/services/engine/frame/passes/selectionRingPass.ts
@@ -21,9 +21,9 @@
  * galaxies.  The `max(diameterKpc, 30)` floor handles the synthetic-
  * fallback source and any pre-v4-format galaxy without a measured size.
  *
- * Decoupling the formula from the renderer leaves room for a POI
- * fold-in: `else if (selectedPoi !== null) { ... }` here picks up the
- * POI's visual radius without touching the renderer or shaders.
+ * Decoupling the formula from the renderer leaves room for a structure
+ * fold-in: `else if (selectedStructure !== null) { ... }` here picks up the
+ * structure's visual radius without touching the renderer or shaders.
  *
  * ## Why one writeBuffer is fine
  *
@@ -45,7 +45,7 @@ export const selectionRingPass: Pass = {
   enabled(state, _ctx, _settings) {
     if (state.gpu.selectionRingRenderer === null) return false;
     const sel = state.subsystems.selection.selected();
-    // Galaxy selections drive the halo; POI selections render through
+    // Galaxy selections drive the halo; structure selections render through
     // the cluster marker pass instead.
     return sel !== null && sel.kind === 'galaxy';
   },
@@ -87,10 +87,9 @@ export const selectionRingPass: Pass = {
     const ringRadiusPx = sizePx * RING_SIZE_SCALE;
 
     state.gpu.selectionRingRenderer!.setSelection({ worldPos, ringRadiusPx });
-    state.gpu.selectionRingRenderer!.render(
-      pass,
-      ctx.vp as Float32Array,
-      [ctx.canvasSize.width, ctx.canvasSize.height],
-    );
+    state.gpu.selectionRingRenderer!.render(pass, ctx.vp as Float32Array, [
+      ctx.canvasSize.width,
+      ctx.canvasSize.height,
+    ]);
   },
 };
diff --git a/src/services/engine/frame/runFrame.ts b/src/services/engine/frame/runFrame.ts
index faf46fdec..97c071778 100644
--- a/src/services/engine/frame/runFrame.ts
+++ b/src/services/engine/frame/runFrame.ts
@@ -185,7 +185,7 @@ export function runFrame(state: EngineState, deps: RunFrameDeps, nowMs: number):
   // ── Structure-focus recession (computed ONCE, EARLY) ────────────────
   //
   // Focus mode fades non-member galaxies away when a cluster /
-  // supercluster / void / group POI is focused.  Resolve the FOCUSED POI
+  // supercluster / void / group structure is focused.  Resolve the focused structure
   // (a bare single-click select does not count; galaxy / nothing both →
   // null) and let the subsystem diff it against its focused id to drive
   // the 400 ms member-isolation fade.
@@ -251,7 +251,7 @@ export function runFrame(state: EngineState, deps: RunFrameDeps, nowMs: number):
   // Runs BEFORE the GPU dispatch so `labelRenderer.setLabels` /
   // `markerLineRenderer.setLines` are uploaded before `renderFrame` reads
   // those buffers.  The director polls every registered `LabelProducer`
-  // (youAreHere, pois, ...), merges, change-detects via signature hash,
+  // (youAreHere, structures, ...), merges, change-detects via signature hash,
   // and flushes once; it null-checks its renderers, so this is safe before
   // the atlas load completes.
   state.subsystems.labelDirector.runFrame(state, ctx);
@@ -440,9 +440,9 @@ export function runFrame(state: EngineState, deps: RunFrameDeps, nowMs: number):
         state.gpu.timingService.descriptorFor('pick'),
       )
       .then((pick) => {
-        // Decode the pick to a hover `Selection` (galaxy / POI / null) via the
+        // Decode the pick to a hover `Selection` (galaxy / structure / null) via the
         // shared map — the same one the click path uses, so hover and click
-        // can't drift. One slot: setHovered(null) clears, a galaxy or POI hit
+        // can't drift. One slot: setHovered(null) clears, a galaxy or structure hit
         // replaces; setHovered equality-short-circuits, so a steady hover is a
         // no-op. The InfoCard reads the resolved target.
         state.subsystems.selection.setHovered(pickToSelection(pick, state.data.structures));
diff --git a/src/services/engine/helpers/clearAll.ts b/src/services/engine/helpers/clearAll.ts
index 73cb96b85..934e84c78 100644
--- a/src/services/engine/helpers/clearAll.ts
+++ b/src/services/engine/helpers/clearAll.ts
@@ -5,7 +5,7 @@ import type { EngineState } from '../../../@types/engine/state/EngineState';
  * method, wired to the deliberate "dismiss" gestures: the InfoCard ×
  * button and Esc.  Drops BOTH the selection slot and the focus slot,
  * so dismissing also collapses the cluster-focus member-isolation fade
- * (and clears the `#focus=` / `#poi=` URL hash via `onFocusChange`).
+ * (and clears the `#focus=` URL hash via `onFocusChange`).
  *
  * Each setter owns its own callback fan-out: `setSelected(null)` fires
  * `onSelectChange(null)`, `setFocused(null)` fires `onFocusChange(null)`.
diff --git a/src/services/engine/helpers/commitFocus.ts b/src/services/engine/helpers/commitFocus.ts
index 0ca850aa8..af94332f4 100644
--- a/src/services/engine/helpers/commitFocus.ts
+++ b/src/services/engine/helpers/commitFocus.ts
@@ -1,19 +1,19 @@
 import type { EngineState } from '../../../@types/engine/state/EngineState';
 import type { FocusableTarget } from '../../../@types/engine/FocusableTarget';
-import { isPoi } from '../isPoi';
+import { isStructure } from '../isStructure';
 import { commitGalaxyFocus } from './commitGalaxyFocus';
 import { commitStructureFocus } from './commitStructureFocus';
 
 /**
  * commitFocus — union-aware entry point for `camera.focusOn(target)`.
  *
- * Dispatches on `isPoi(target)`: a StructureRecord →
+ * Dispatches on `isStructure(target)`: a StructureRecord →
  * `commitStructureFocus`, a GalaxyInfo → `commitGalaxyFocus`. Both route
  * their callbacks through the selection subsystem, so this needs no `cb`
- * — it's pure dispatch, sharing the `isPoi` predicate with the InfoCard.
+ * — it's pure dispatch, sharing the `isStructure` predicate with the InfoCard.
  */
 export function commitFocus(state: EngineState, target: FocusableTarget): void {
-  if (isPoi(target)) {
+  if (isStructure(target)) {
     commitStructureFocus(state, target);
   } else {
     commitGalaxyFocus(state, target);
diff --git a/src/services/engine/helpers/commitGalaxyFocus.ts b/src/services/engine/helpers/commitGalaxyFocus.ts
index 1a08bfd56..76b2e408d 100644
--- a/src/services/engine/helpers/commitGalaxyFocus.ts
+++ b/src/services/engine/helpers/commitGalaxyFocus.ts
@@ -42,7 +42,7 @@ export function commitGalaxyFocus(state: EngineState, info: GalaxyInfo): void {
   state.subsystems.selection.setSelected(selection, info);
   // Latch the focus slot too — focusing a galaxy is a focus gesture, so
   // it supersedes any prior cluster focus: `runFrame` resolves a galaxy
-  // focus to a null POI, collapsing the member-isolation fade.
+  // focus to a null structure, collapsing the member-isolation fade.
   // `setFocused` owns the `onFocusChange` fan-out (URL hash); the
   // prebuilt `info` rides through the same race defense as setSelected.
   state.subsystems.selection.setFocused(selection, info);
diff --git a/src/services/engine/helpers/commitStructureFocus.ts b/src/services/engine/helpers/commitStructureFocus.ts
index dea909f33..972c580d7 100644
--- a/src/services/engine/helpers/commitStructureFocus.ts
+++ b/src/services/engine/helpers/commitStructureFocus.ts
@@ -4,7 +4,7 @@
  *
  * The setters carry no cam dependency, so they land even when `state.cam`
  * is null (pre-bootstrap / post-destroy) — a deep-link drain resolving
- * `#poi=…` before the camera is live still establishes state. Only the
+ * `#focus=…` before the camera is live still establishes state. Only the
  * tween is cam-gated, and `tweenToStructure` absorbs that internally. No
  * `cb`: the selection subsystem owns the callbacks both setters fire.
  */
diff --git a/src/services/engine/helpers/galaxyInfoBuilder.ts b/src/services/engine/helpers/galaxyInfoBuilder.ts
index ba4d15d8d..f41514ef6 100644
--- a/src/services/engine/helpers/galaxyInfoBuilder.ts
+++ b/src/services/engine/helpers/galaxyInfoBuilder.ts
@@ -469,7 +469,7 @@ export function buildGalaxyInfo(
     //
     //   1. Famous → curated `commonName` then `names[0]`.  Routed
     //      through the shared `famousDisplayName` helper so the
-    //      InfoCard headline and the POI label can't drift.
+    //      InfoCard headline and the structure label can't drift.
     //   2. Milliquas → "<PARENT> J<RA><Dec>" reconstructed from the
     //      per-record `parentSurveyByte` slot in the .bin (e.g.
     //      "SDSS J012345.67+891234.5", "2MASX J…").  When the byte is
diff --git a/src/services/engine/helpers/pickToSelection.ts b/src/services/engine/helpers/pickToSelection.ts
index d5d185d2a..e3ba7afd6 100644
--- a/src/services/engine/helpers/pickToSelection.ts
+++ b/src/services/engine/helpers/pickToSelection.ts
@@ -13,7 +13,7 @@
  */
 
 import { SOURCE_REGISTRY } from '../../../data/sources';
-import { resolvePoiFromPick } from './resolvePoiFromPick';
+import { resolveStructureFromPick } from './resolveStructureFromPick';
 import type { PickResult } from '../../../data/selectionEncoding';
 import type { Selection } from '../../../@types/engine/subsystems/Selection';
 import type { StructureCategory } from '../../../@types/engine/data/StructureCategory';
@@ -31,9 +31,9 @@ export function pickToSelection(
   if (entry?.type === 'structure') {
     // A structure entry's id *is* its category (StructureCategory derives from
     // exactly these ids), so the cast is sound by construction.
-    const record = resolvePoiFromPick(structures, {
+    const record = resolveStructureFromPick(structures, {
       category: entry.id as StructureCategory,
-      poiIndex: pick.localIdx,
+      structureIndex: pick.localIdx,
     });
     return record ? { kind: 'structure', id: record.id } : null;
   }
diff --git a/src/services/engine/helpers/resolvePoiFromPick.ts b/src/services/engine/helpers/resolveStructureFromPick.ts
similarity index 69%
rename from src/services/engine/helpers/resolvePoiFromPick.ts
rename to src/services/engine/helpers/resolveStructureFromPick.ts
index 7a7cdba73..cee2449ac 100644
--- a/src/services/engine/helpers/resolvePoiFromPick.ts
+++ b/src/services/engine/helpers/resolveStructureFromPick.ts
@@ -1,5 +1,5 @@
 /**
- * resolvePoiFromPick — map a structure pick hit `(category, poiIndex)` back
+ * resolveStructureFromPick — map a structure pick hit `(category, structureIndex)` back
  * to its `StructureRecord` by indexing into the structure store's
  * per-category table.
  *
@@ -9,7 +9,7 @@
  * category (cluster / supercluster / void) with `firstInstance` set to
  * that category's bucket offset; the fragment packs
  * `@builtin(instance_index) - bucketOffset` worth of slot info into the
- * pick texture as `poiIndex`.  `unpackPick` already returns the
+ * pick texture as `structureIndex`.  `unpackPick` already returns the
  * per-category-local 0-based index (see `selectionEncoding.ts` and the
  * dispatch comment in `structureMarkerRenderer.pickRing`), so the array
  * `structures.byCategory(cat)` is the canonical lookup.
@@ -22,17 +22,15 @@
  * and are discarded in-fragment rather than being omitted.  `setMarkers`
  * then re-groups by category preserving within-group order.  Because no
  * faded structure is dropped, the i-th descriptor of a category is the i-th
- * `byCategory(cat)` entry regardless of fade, so `byCategory(cat)[poiIndex]`
+ * `byCategory(cat)` entry regardless of fade, so `byCategory(cat)[structureIndex]`
  * resolves the pick hit's structure correctly.
  *
  * ### Why structures only
  *
  * Rings are a structure-only affordance (cluster / supercluster / void);
  * famous galaxies are picked through the point path, never the ring path.
- * A `famousGalaxy` category therefore can't arrive here from a ring pick —
- * the guard returns null defensively rather than indexing a store that
- * doesn't hold famous galaxies (and narrows `category` to a
- * `StructureCategory` for the `byCategory` lookup).
+ * The input `category` is therefore typed `StructureCategory` — a famous
+ * category can't reach this lookup by construction.
  *
  * ### Why a narrowed `structures` param rather than the full `EngineState`
  *
@@ -43,21 +41,18 @@
  */
 
 import type { StructureRecord } from '../../../@types/engine/data/StructureRecord';
-import type { PoiCategory } from '../../../@types/engine/data/PoiCategory';
+import type { StructureCategory } from '../../../@types/engine/data/StructureCategory';
 import type { PickStructureStore } from '../../../@types/engine/data/PickStructureStore';
 
-export type PickPoiInput = {
-  readonly category: PoiCategory;
-  readonly poiIndex: number;
+export type PickStructureInput = {
+  readonly category: StructureCategory;
+  readonly structureIndex: number;
 };
 
-export function resolvePoiFromPick(
+export function resolveStructureFromPick(
   structures: PickStructureStore,
-  input: PickPoiInput,
+  input: PickStructureInput,
 ): StructureRecord | null {
-  // Rings are structure-only; a famousGalaxy hit can't come from the ring
-  // pick path. The check also narrows `category` to `StructureCategory`.
-  if (input.category === 'famousGalaxy') return null;
   const records = structures.byCategory(input.category);
-  return records[input.poiIndex] ?? null;
+  return records[input.structureIndex] ?? null;
 }
diff --git a/src/services/engine/isPoi.ts b/src/services/engine/isStructure.ts
similarity index 71%
rename from src/services/engine/isPoi.ts
rename to src/services/engine/isStructure.ts
index 256f5d803..8062d1f26 100644
--- a/src/services/engine/isPoi.ts
+++ b/src/services/engine/isStructure.ts
@@ -2,19 +2,19 @@ import type { StructureRecord } from '../../@types/engine/data/StructureRecord';
 import type { FocusableTarget } from '../../@types/engine/FocusableTarget';
 
 /**
- * isPoi — runtime type predicate for FocusableTarget.
+ * isStructure — runtime type predicate for FocusableTarget.
  *
  * Uses `'category' in target` as the discriminant because StructureRecord
- * declares a top-level `category: PoiCategory` field, while GalaxyInfo
+ * declares a top-level `category: StructureCategory` field, while GalaxyInfo
  * carries category information only at the nested `galaxyType.category`
  * path.  `'in'` checks the top-level key only, so a GalaxyInfo never
- * widens into the POI branch by accident.
+ * widens into the structure branch by accident.
  *
  * Centralising the discriminant here means every public-handle dispatch
  * and every InfoCard render-branch agree on the same predicate.
  * Changing the discriminant later (e.g. adding an explicit `kind` field)
  * is then a single-file change.
  */
-export function isPoi(target: FocusableTarget): target is StructureRecord {
+export function isStructure(target: FocusableTarget): target is StructureRecord {
   return 'category' in target;
 }
diff --git a/src/services/engine/labelStyleOverride.ts b/src/services/engine/labelStyleOverride.ts
index b74e125db..74e6fffd9 100644
--- a/src/services/engine/labelStyleOverride.ts
+++ b/src/services/engine/labelStyleOverride.ts
@@ -15,7 +15,7 @@
  *
  * ### Why a single slot, not a per-category record?
  *
- * The workflow is "select category, tune, bake into POI_STYLES, move
+ * The workflow is "select category, tune, bake into the structure marker styles, move
  * to next category".  A per-category record would invite the user to
  * leave overrides stale across category switches; the single slot
  * makes the active target unambiguous.
@@ -31,13 +31,13 @@
  */
 
 import type { Vec4 } from '../../@types/math/Vec4';
-import type { PoiCategory } from '../../@types/engine/data/PoiCategory';
+import type { LabelCategory } from '../../@types/engine/data/LabelCategory';
 
 /**
  * The set of label-emitting categories the override can target.
  * Mirrors the dropdown in `LabelEffectsSection.tsx` — keep in sync.
  */
-export type LabelStyleOverrideTarget = 'youAreHere' | PoiCategory;
+export type LabelStyleOverrideTarget = 'youAreHere' | LabelCategory;
 
 /**
  * Read-only snapshot of the current override.  `targetCategory` is
diff --git a/src/services/engine/phases/initGpu.ts b/src/services/engine/phases/initGpu.ts
index 434c06ef8..cd76f08f4 100644
--- a/src/services/engine/phases/initGpu.ts
+++ b/src/services/engine/phases/initGpu.ts
@@ -207,7 +207,7 @@ export async function initGpu(state: EngineState, deps: BootstrapDeps): Promise<
   // was built eagerly in the engine state literal with no renderers yet.
   // Same `attachRenderer` post-construction pattern `biasCorrectionSubsystem`
   // uses.  The director (not youAreHere directly) owns the renderer refs:
-  // all `LabelProducer`s — youAreHere, pois, future overlays — are polled
+  // all `LabelProducer`s — youAreHere, structures, future overlays — are polled
   // by the director, which merges their outputs and flushes once.
   state.subsystems.labelDirector.attachRenderers(
     state.gpu.labelRenderer,
diff --git a/src/services/engine/phases/structureCatalogToStructures.ts b/src/services/engine/phases/structureCatalogToStructures.ts
index bc880c0bd..3b3b6deb4 100644
--- a/src/services/engine/phases/structureCatalogToStructures.ts
+++ b/src/services/engine/phases/structureCatalogToStructures.ts
@@ -24,7 +24,7 @@
  * ### Significance normalisation — PER CATEGORY
  *
  * `catalog.significance` holds the RAW source proxy: M500 (in 1e14 M☉) for
- * clusters, N_m member count for superclusters.  A POI's `significance`
+ * clusters, N_m member count for superclusters.  A structure's `significance`
  * field is a NORMALISED [0,1] weight (Task 6 maps it to ring alpha), so we
  * normalise here — but separately per category, because a 30-member
  * supercluster and a 1e14-M☉ cluster live on incomparable raw scales and a
@@ -107,7 +107,7 @@ export function structureCatalogToStructures(payload: StructureCatalogPayload):
   if (catalog.count === 0) return [];
 
   // First pass: gather the raw significance per category so the
-  // normalisers see the full subset before we emit any POI.  Clusters
+  // normalisers see the full subset before we emit any structure.  Clusters
   // normalise log10(M500); superclusters normalise N_m linearly.
   const clusterRaw: number[] = [];
   const superclusterRaw: number[] = [];
@@ -137,7 +137,7 @@ export function structureCatalogToStructures(payload: StructureCatalogPayload):
       category === 'cluster' ? normaliseCluster(raw) : normaliseSupercluster(raw);
     const common = {
       // `-bulk-` infix: distinct from the featured `${category}-${seed.id}`
-      // anchors and flags the POI as non-deep-linkable.
+      // anchors and flags the structure as non-deep-linkable.
       id: `${category}-bulk-${m.id}`,
       name: m.names[0]!,
       worldPos,
diff --git a/src/services/engine/phases/wireInput.ts b/src/services/engine/phases/wireInput.ts
index cb61b59a8..949c9cbbe 100644
--- a/src/services/engine/phases/wireInput.ts
+++ b/src/services/engine/phases/wireInput.ts
@@ -47,8 +47,8 @@ export async function wireInput(state: EngineState, deps: BootstrapDeps): Promis
   const renderer = state.gpu.renderer;
   if (!renderer) return;
   // Thread the cluster marker renderer through so the pick pass can
-  // append POI ring draws after the galaxy per-source loop — see the POI
-  // ring block inside `pick()` for the depth-ordering rationale.  Normalise
+  // append structure ring draws after the galaxy per-source loop — see the
+  // structure ring block inside `pick()` for the depth-ordering rationale.  Normalise
   // `null` → `undefined` so the renderer's param type stays `| undefined`
   // and the optional-vs-null distinction stays internal to the handle bag.
   const pickRenderer = createPickRenderer(
@@ -73,7 +73,7 @@ export async function wireInput(state: EngineState, deps: BootstrapDeps): Promis
   state.subsystems.clickResolver = createClickResolver({
     pickRenderer,
     // The structure store the resolver reads to turn a ring hit into a
-    // POI selection (via `pickToSelection`, shared with the hover path).
+    // structure selection (via `pickToSelection`, shared with the hover path).
     structures: state.data.structures,
   });
 
@@ -239,7 +239,7 @@ export async function wireInput(state: EngineState, deps: BootstrapDeps): Promis
       if (!pick) return;
       pick.then((sel) => {
         // Single-click is pure selection (null clears) for both galaxy and
-        // POI hits. setSelected resolves the target internally and fires
+        // structure hits. setSelected resolves the target internally and fires
         // onSelectChange so the React InfoCard swaps bodies; the dblclick
         // handler reads `selectedTarget()` to upgrade to focus.
         state.subsystems.selection.setSelected(sel);
diff --git a/src/services/engine/phases/wireSlots.ts b/src/services/engine/phases/wireSlots.ts
index 261da9a38..0ba655b8c 100644
--- a/src/services/engine/phases/wireSlots.ts
+++ b/src/services/engine/phases/wireSlots.ts
@@ -36,7 +36,7 @@
  *
  *   - `state.assetSlots.{filaments,famousMeta,structureCatalog,pgcAlias,
  *     cf4Density,mcpm}` (via `installSlots`) + `.syntheticVolumes` (DEV).
- *   - `state.subsystems.{loadProgress, pois}` + the impostor subsystem handles.
+ *   - `state.subsystems.{loadProgress, structures}` + the impostor subsystem handles.
  *   - `state.requests` may gain `'syntheticFallback'` (via the gate).
  *   - `cb.onStatusChange({ kind: 'loading' })` synchronously.
  *
diff --git a/src/services/engine/presentation/famousLabelStyle.ts b/src/services/engine/presentation/famousLabelStyle.ts
index 66d2a667b..3e0d0c85c 100644
--- a/src/services/engine/presentation/famousLabelStyle.ts
+++ b/src/services/engine/presentation/famousLabelStyle.ts
@@ -4,8 +4,8 @@
  * Unlike the structure styles, the famous-galaxy presentation is label-only —
  * curated thumbnails handle the close-approach detail, so there is no ring or
  * halo and none of the marker apparent-radius fade fields. Famous galaxies
- * instead carry a per-POI apparent-size gate (`minApparentSizePx`) with a
- * `fadeBandPx` smoothstep, a connecting anchor `lineColor`, and a per-POI
+ * instead carry a per-entry apparent-size gate (`minApparentSizePx`) with a
+ * `fadeBandPx` smoothstep, a connecting anchor `lineColor`, and a per-entry
  * `worldEmMpc` override (computed from the galaxy's diameter) — see
  * `produceFamousLabels`.
  */
@@ -23,12 +23,12 @@ export type FamousLabelStyle = {
   readonly minPixelSize: number;
   /** Ceiling clamp on projected em height in screen pixels. */
   readonly maxPixelSize: number;
-  /** Default label world-space em height (Mpc); per-POI override usually wins. */
+  /** Default label world-space em height (Mpc); per-entry override usually wins. */
   readonly worldEmMpc: number;
   /** Anchor-line stroke width in pixels. */
   readonly pixelWidth: number;
   /**
-   * Smoothstep fade-band width (px) above the per-POI `minApparentSizePx`.
+   * Smoothstep fade-band width (px) above the per-entry `minApparentSizePx`.
    * A galaxy whose apparent size lands inside `[min, min + fadeBandPx]` fades
    * in via smoothstep instead of popping; below the band it is skipped.
    */
@@ -39,7 +39,7 @@ export type FamousLabelStyle = {
   readonly outlineEmFrac: number;
 };
 
-/** The single famous-galaxy label style (copied verbatim from POI_STYLES). */
+/** The single famous-galaxy label style (copied verbatim from STRUCTURE_MARKER_STYLES). */
 export const FAMOUS_LABEL_STYLE: FamousLabelStyle = {
   labelColor: hexToGl('#FFF2CC'),
   lineColor: hexToGl('#E6D9B3'),
diff --git a/src/services/engine/presentation/focusRecession.ts b/src/services/engine/presentation/focusRecession.ts
index ddc78dd1a..efd913ef5 100644
--- a/src/services/engine/presentation/focusRecession.ts
+++ b/src/services/engine/presentation/focusRecession.ts
@@ -29,7 +29,7 @@
  *
  * ### Recession membership is an exhaustive switch
  *
- * Recession is *selective*: POI / galaxy-name labels and the diffuse
+ * Recession is *selective*: structure / galaxy-name labels and the diffuse
  * filament/volume fields recede under focus, but the YOU-ARE-HERE pin and
  * the scale bar must not. `recessionTargetFor` expresses that membership
  * as an exhaustive `switch (h.kind)` with NO `default` arm — every union
@@ -41,7 +41,7 @@
  * A function beats a flat string-keyed table here because some kinds
  * recede across *all* their discriminator values (`markerLayer` for every
  * category) while others recede for *some* (`labelLayer` for
- * `poi`/`galaxyNames` only). The switch says exactly that without
+ * `structure`/`galaxyNames` only). The switch says exactly that without
  * repetition.
  */
 
@@ -79,7 +79,7 @@ export function recessionTargetFor(h: FadeHandle): number | undefined {
       // Structure labels (any category) and famous-galaxy labels recede;
       // famous labels reuse the 'galaxyNames' handle. The YOU-ARE-HERE
       // pin ('youAreHere') and scale bar ('scaleBar') do not.
-      return h.layer === 'poi' || h.layer === 'galaxyNames' ? LABEL_RECESSION : undefined;
+      return h.layer === 'structure' || h.layer === 'galaxyNames' ? LABEL_RECESSION : undefined;
     // Non-recessing kinds — explicit so a new union member can't silently
     // skip declaring its stance.
     case 'survey':
diff --git a/src/services/engine/presentation/produceFamousLabels.ts b/src/services/engine/presentation/produceFamousLabels.ts
index c3e3195e6..46bdc18fb 100644
--- a/src/services/engine/presentation/produceFamousLabels.ts
+++ b/src/services/engine/presentation/produceFamousLabels.ts
@@ -44,7 +44,7 @@
  * The first time the producer emits any famous label, it fires the
  * `galaxyNames` `fadeTo(1)` once (a module-level latch). Because `galaxyNames`
  * is registered at opacity 1 (it never toggles off, only recedes under focus),
- * this ramp is a no-op — fired for SYMMETRY with the per-category POI load-in in
+ * this ramp is a no-op — fired for SYMMETRY with the per-category structure load-in in
  * `produceStructureLabels`, not to reveal anything.
  *
  * ### No declutter here — the director owns it
@@ -76,7 +76,7 @@ const FAMOUS_MIN_APPARENT_PX = 6;
 // is a bare function (not a closure over subsystem state), so the once-only
 // one-shot has nowhere to live except module scope. Fires the `galaxyNames`
 // `fadeTo(1)` the first time the producer emits any famous label, mirroring the
-// per-category POI load-in in `produceStructureLabels`. Reset between tests via
+// per-category structure load-in in `produceStructureLabels`. Reset between tests via
 // `__resetFamousLabelLoadIn`.
 let didFireFamousLoadIn = false;
 
@@ -258,7 +258,7 @@ export function produceFamousLabels(
       ownerLabelId: p.id,
     });
 
-    // Per-POI override fields apply only when the override targets the famous
+    // Per-structure override fields apply only when the override targets the famous
     // category; otherwise the category-default outline is kept.
     const overrideFields =
       override.targetCategory === 'famousGalaxy'
@@ -288,7 +288,7 @@ export function produceFamousLabels(
   // Galaxy-names load-in: fire the `galaxyNames` fade once on this producer's
   // first emitted famous label. Because `galaxyNames` is registered at opacity
   // 1 (it never toggles off, only recedes under focus), this `fadeTo(1)` is a
-  // no-op ramp — fired for SYMMETRY with the per-category POI load-in in
+  // no-op ramp — fired for SYMMETRY with the per-category structure load-in in
   // `produceStructureLabels`, not to reveal anything.
   if (!didFireFamousLoadIn && labels.length > 0) {
     didFireFamousLoadIn = true;
diff --git a/src/services/engine/presentation/produceStructureLabels.ts b/src/services/engine/presentation/produceStructureLabels.ts
index c546a1bd7..485176b1f 100644
--- a/src/services/engine/presentation/produceStructureLabels.ts
+++ b/src/services/engine/presentation/produceStructureLabels.ts
@@ -11,7 +11,7 @@
  *
  * Each label's final `fadeAlpha` is the distance fade multiplied by two
  * composed strands (see `focusRecession.ts`): the per-category toggle's
- * opacity (`opacityOf({labelLayer, poi, category})`, read from the
+ * opacity (`opacityOf({labelLayer, structure, category})`, read from the
  * FadeRegistry) and the focus recession factor. A category whose opacity is
  * exactly 0 is skipped wholesale — the only legitimate all-or-nothing skip.
  * The FOCUSED structure's own label is exempt from recession (factor 1): a
@@ -22,8 +22,7 @@
  * ### This producer owns the per-category load-in fade
  *
  * The first time a category emits a (visible) label, the producer fires its
- * `fadeTo(handle, 1)` once. The director used to fire a single category-less
- * poi load-in; that moved here so each category ramps in independently,
+ * `fadeTo(handle, 1)` once. Each category fires its load-in independently,
  * mirroring how the famous-galaxy layer fires its own load-in on first emit.
  *
  * ### No declutter here — the director owns it
@@ -45,7 +44,7 @@ import type { ReadyFrameContext } from '../../../@types/engine/frame/ReadyFrameC
 import type { EngineState } from '../../../@types/engine/state/EngineState';
 import type { LabelProducerOutput } from '../../../@types/engine/subsystems/LabelProducerOutput';
 import type { StructureCategory } from '../../../@types/engine/data/StructureCategory';
-import { STRUCTURE_POI_STYLES } from './structurePoiStyles';
+import { STRUCTURE_MARKER_STYLES } from './structureMarkerStyles';
 import { getLabelStyleOverride } from '../labelStyleOverride';
 import { focusRecession } from './focusRecession';
 import { FADE_IN_DURATION_MS } from '../../animation/fadeController';
@@ -98,7 +97,7 @@ export function produceStructureLabels(
     // registry. 0 is the all-or-nothing skip — a disabled category emits no
     // labels and never fires its load-in.
     const catOpacity = fades.opacityOf(
-      { kind: 'labelLayer', layer: 'poi', category: p.category },
+      { kind: 'labelLayer', layer: 'structure', category: p.category },
       now,
     );
     if (catOpacity === 0) continue;
@@ -111,7 +110,7 @@ export function produceStructureLabels(
     // instead of popping when the category toggles off mid-fade.
     if (fades.opacityOf({ kind: 'markerLayer', category: p.category }, now) === 0) continue;
 
-    const style = STRUCTURE_POI_STYLES[p.category];
+    const style = STRUCTURE_MARKER_STYLES[p.category];
 
     // Camera distance — for the marker close-approach / far-distance fades.
     const dx = p.worldPos[0] - cx;
@@ -171,7 +170,7 @@ export function produceStructureLabels(
       p.id === focusedStructureId
         ? 1
         : focusRecession(
-            { kind: 'labelLayer', layer: 'poi', category: p.category },
+            { kind: 'labelLayer', layer: 'structure', category: p.category },
             ctx.focusBlend,
           );
     fadeAlpha *= catOpacity * recession;
@@ -182,13 +181,13 @@ export function produceStructureLabels(
     if (!loadInFired.has(p.category)) {
       loadInFired.add(p.category);
       void fades.fadeTo(
-        { kind: 'labelLayer', layer: 'poi', category: p.category },
+        { kind: 'labelLayer', layer: 'structure', category: p.category },
         1,
         FADE_IN_DURATION_MS,
       );
     }
 
-    // Per-POI override fields: only structures whose category matches the
+    // Per-structure override fields: only structures whose category matches the
     // override's target adopt the outline values; others keep the default.
     const overrideFields =
       override.targetCategory === p.category
diff --git a/src/services/engine/presentation/produceStructureMarkers.ts b/src/services/engine/presentation/produceStructureMarkers.ts
index 83f5ebf5a..1f939c4a8 100644
--- a/src/services/engine/presentation/produceStructureMarkers.ts
+++ b/src/services/engine/presentation/produceStructureMarkers.ts
@@ -20,7 +20,7 @@
  * fully-faded ones, which emit alpha-0 colours the fragment discards. This
  * keeps each category's run index-aligned with `structureStore.byCategory(cat)`:
  * the ring pick path packs `@builtin(instance_index)` as the per-category-local
- * index and `resolvePoiFromPick` resolves it through `byCategory(cat)[poiIndex]`.
+ * index and `resolveStructureFromPick` resolves it through `byCategory(cat)[structureIndex]`.
  * Omitting a faded structure would index-shift that lookup. The only legitimate
  * skip is all-or-nothing-per-category — a category whose toggle opacity is
  * exactly 0 — which never perturbs within-category alignment. A mid-fade
@@ -31,7 +31,7 @@ import type { ReadyFrameContext } from '../../../@types/engine/frame/ReadyFrameC
 import type { EngineState } from '../../../@types/engine/state/EngineState';
 import type { Vec4 } from '../../../@types/math/Vec4';
 import type { StructureMarkerDescriptor } from '../../../@types/rendering/StructureMarkerDescriptor';
-import { STRUCTURE_POI_STYLES, SIG_MIN_ALPHA } from './structurePoiStyles';
+import { STRUCTURE_MARKER_STYLES, SIG_MIN_ALPHA } from './structureMarkerStyles';
 import { focusRecession } from './focusRecession';
 import { structureIdOf } from '../helpers/structureIdOf';
 
@@ -68,7 +68,7 @@ export function produceStructureMarkers(
     // Render at the WIDER apparent extent, falling back to the core for
     // structures that only set physicalRadiusMpc.
     const radiusMpc = p.apparentRadiusMpc ?? p.physicalRadiusMpc;
-    const style = STRUCTURE_POI_STYLES[p.category];
+    const style = STRUCTURE_MARKER_STYLES[p.category];
 
     const dx = p.worldPos[0] - cx;
     const dy = p.worldPos[1] - cy;
diff --git a/src/services/engine/presentation/structurePoiStyles.ts b/src/services/engine/presentation/structureMarkerStyles.ts
similarity index 95%
rename from src/services/engine/presentation/structurePoiStyles.ts
rename to src/services/engine/presentation/structureMarkerStyles.ts
index cd4e1f5eb..d58e2b76f 100644
--- a/src/services/engine/presentation/structurePoiStyles.ts
+++ b/src/services/engine/presentation/structureMarkerStyles.ts
@@ -1,5 +1,5 @@
 /**
- * structurePoiStyles — per-category visual style table for the extended
+ * structureMarkerStyles — per-category visual style table for the extended
  * structures (cluster / supercluster / void / group) rendered as ring/halo
  * markers and text labels.
  *
@@ -56,14 +56,14 @@ export type StructureMarkerStyle = {
 };
 
 /**
- * Per-category visual style table. Rows are copied verbatim from the former
- * `POI_STYLES` cluster/supercluster/void entries, with `group` added for the
+ * Per-category visual style table. Covers cluster/supercluster/void entries,
+ * with `group` added for the
  * Local Volume galaxy groups (0–13 Mpc). See the field docs above for
  * semantics and the tuning rationale (e.g. the per-category min-apparent
  * floors that keep the bulk catalog from papering the sky with sub-readable
  * specks).
  */
-export const STRUCTURE_POI_STYLES = {
+export const STRUCTURE_MARKER_STYLES = {
   cluster: {
     labelColor: hexToGl('#FFD966'),
     minPixelSize: 35,
diff --git a/src/services/engine/subsystems/labelDirectorSubsystem.ts b/src/services/engine/subsystems/labelDirectorSubsystem.ts
index 0a84e5435..d0a8726dc 100644
--- a/src/services/engine/subsystems/labelDirectorSubsystem.ts
+++ b/src/services/engine/subsystems/labelDirectorSubsystem.ts
@@ -111,12 +111,12 @@ export function createLabelDirectorSubsystem(): LabelDirectorSubsystem {
     // We deliberately DON'T include world positions or colours — the
     // glyph layout in `labelRenderer.setLabels` is the expensive
     // step we're protecting; static-position producers (youAreHere,
-    // pois) keep their positions stable and benefit from the skip.
+    // structures) keep their positions stable and benefit from the skip.
     //
     // Edge case: a producer mutating a label's `text` while keeping
     // the same `id` will NOT trigger re-upload.  No current producer
-    // does this — youAreHere has constant text; pois derive text
-    // from POI name which is part of the id space.
+    // does this — youAreHere has constant text; structures derive text
+    // from the structure name which is part of the id space.
     const lIds = labels.map((l) => `${l.id}:${l.fadeAlpha ?? 1}`).join('|');
     const mIds = lines.map((m) => `${m.id}:${m.fadeAlpha ?? 1}`).join('|');
     return `L:${labels.length}:${lIds};M:${lines.length}:${mIds};O:${getLabelStyleOverrideVersion()}`;
diff --git a/src/services/engine/subsystems/selectionSubsystem.ts b/src/services/engine/subsystems/selectionSubsystem.ts
index b6bb4f8c3..01c87c43b 100644
--- a/src/services/engine/subsystems/selectionSubsystem.ts
+++ b/src/services/engine/subsystems/selectionSubsystem.ts
@@ -138,7 +138,7 @@ export function createSelectionSubsystem(input: CreateSelectionSubsystemInput):
    * Update the focus slot and fan out `cb.camera.onFocusChange`.
    * Symmetric with `setSelected`: the cluster-focus fade reads
    * `focused()` in `runFrame`, while React mirrors the same target
-   * into the `#focus=` / `#poi=` URL hash via the callback.  One
+   * into the `#focus=` URL hash via the callback.  One
    * setter for both consumers means they can't drift.  `prebuiltInfo`
    * short-circuits the cloud lookup for the `selectByAlias` race —
    * same escape hatch as `setSelected`; ignored for structure focuses.
diff --git a/src/services/engine/subsystems/structureFocusSubsystem.ts b/src/services/engine/subsystems/structureFocusSubsystem.ts
index 651d8d74d..29873fbef 100644
--- a/src/services/engine/subsystems/structureFocusSubsystem.ts
+++ b/src/services/engine/subsystems/structureFocusSubsystem.ts
@@ -1,7 +1,7 @@
 /**
  * structureFocusSubsystem — focus-driven structure "focus mode".
  *
- * When a cluster / supercluster / void / group POI is focused, non-member
+ * When a cluster / supercluster / void / group structure is focused, non-member
  * galaxies fade to ~8% alpha over ~400 ms (the shader does the
  * per-vertex membership test; this subsystem only supplies the centre,
  * radius, and the smoothstep blend). All four categories behave
@@ -12,7 +12,7 @@
  *
  * ### Why a `focusedId` separate from the display target
  *
- * `update` runs every frame with the live focused POI. The fade-in and
+ * `update` runs every frame with the live focused structure. The fade-in and
  * fade-out must each fire once, on the transition — re-calling
  * `fade.fadeTo` every frame would reset the ramp's clock and the blend
  * would never advance. `focusedId` records the id we are fading *toward*
@@ -57,36 +57,36 @@ export function createStructureFocusSubsystem(
   initialNowMs: number = performance.now(),
 ): StructureFocusSubsystem {
   const fade = createFadeController(0, initialNowMs);
-  // The POI we emit centre/radius for. Latched through fade-out.
+  // The structure we emit centre/radius for. Latched through fade-out.
   let active: ActiveFocus | null = null;
   // The id we are currently fading toward; null = fading out / at rest.
   let focusedId: string | null = null;
 
-  function update(poi: StructureRecord | null, nowMs: number): void {
-    // Narrow to a focus-eligible extended-structure POI. famousGalaxy has
+  function update(structure: StructureRecord | null, nowMs: number): void {
+    // Narrow to a focus-eligible extended structure. famousGalaxy has
     // no radius, so it (and null) drives a fade-out. Groups share the
     // same fade band mechanic as clusters — R0 > Rh gives a real band.
     let next: ActiveFocus | null = null;
     if (
-      poi !== null &&
-      (poi.category === 'cluster' ||
-        poi.category === 'supercluster' ||
-        poi.category === 'void' ||
-        poi.category === 'group')
+      structure !== null &&
+      (structure.category === 'cluster' ||
+        structure.category === 'supercluster' ||
+        structure.category === 'void' ||
+        structure.category === 'group')
     ) {
       // Pass the structure's two real radii; the shader ramps the fade
       // across the [physical, apparent] band (and supplies a soft band of
       // its own when the two are equal — SC/void have no wider extent).
       next = {
-        id: poi.id,
-        center: [poi.worldPos[0], poi.worldPos[1], poi.worldPos[2]],
-        apparentRadiusMpc: poi.apparentRadiusMpc ?? poi.physicalRadiusMpc,
-        physicalRadiusMpc: poi.physicalRadiusMpc,
+        id: structure.id,
+        center: [structure.worldPos[0], structure.worldPos[1], structure.worldPos[2]],
+        apparentRadiusMpc: structure.apparentRadiusMpc ?? structure.physicalRadiusMpc,
+        physicalRadiusMpc: structure.physicalRadiusMpc,
       };
     }
 
     const targetId = next?.id ?? null;
-    // No transition → no re-fade (covers same focused POI every frame AND
+    // No transition → no re-fade (covers same focused structure every frame AND
     // an already-in-flight fade-out being re-observed every frame).
     if (targetId === focusedId) return;
 
diff --git a/src/services/engine/wiring/assetWiring.ts b/src/services/engine/wiring/assetWiring.ts
index 2321a12d4..7515311e5 100644
--- a/src/services/engine/wiring/assetWiring.ts
+++ b/src/services/engine/wiring/assetWiring.ts
@@ -54,7 +54,7 @@
  */
 
 import type { AssetWiringRow } from '../../../@types/loading/AssetWiringRow';
-import type { PoiCategory } from '../../../@types/engine/data/PoiCategory';
+import type { StructureCategory } from '../../../@types/engine/data/StructureCategory';
 import { Source, SOURCE_REGISTRY } from '../../../data/sources';
 import { createFilamentSlot } from '../../loading/slots/filamentSlot';
 import { createFamousMetaSlot } from '../../loading/slots/famousMetaSlot';
@@ -70,10 +70,10 @@ import type { SourceType } from '../../../@types/data/SourceType';
  * gates the structure-catalog fetch. `famousGalaxy` is excluded (Famous
  * `.bin` + meta sidecar), and `group` is excluded (seed-only, no `.ccat`
  * — adding it here would trigger a pointless fetch when group visibility
- * toggles). Spelled as `PoiCategory` members so a type error surfaces
- * here rather than silently skipping a category on rename.
+ * toggles). Spelled as `StructureCategory` members so a type error
+ * surfaces here rather than silently skipping a category on rename.
  */
-const BULK_CATALOG_CATEGORIES: readonly PoiCategory[] = ['cluster', 'supercluster', 'void'];
+const BULK_CATALOG_CATEGORIES: readonly StructureCategory[] = ['cluster', 'supercluster', 'void'];
 
 /**
  * Volume-field handle ids, read from the registry rather than re-spelled, so
diff --git a/src/services/engine/wiring/registerOverlayFades.ts b/src/services/engine/wiring/registerOverlayFades.ts
index 8be32b87b..9f579cfc3 100644
--- a/src/services/engine/wiring/registerOverlayFades.ts
+++ b/src/services/engine/wiring/registerOverlayFades.ts
@@ -18,8 +18,8 @@
  * The three overlay handles come first (Milky Way at its settings gate,
  * procedural + textured disks unconditionally at 1), then the volumes-master
  * gate, then the category-less label-layer handles (youAreHere / galaxyNames /
- * scaleBar — poi is per-category only), then the per-category marker +
- * poi-label handles (one pair per structure category).  The order within each
+ * scaleBar — structure is per-category only), then the per-category marker +
+ * structure-label handles (one pair per structure category).  The order within each
  * group matches the order in the source catalog of concerns so diffs are easy
  * to audit.
  *
@@ -29,14 +29,14 @@
  * non-empty emit.  galaxyNames starts at 1 because the famous-galaxy labels
  * reuse that handle and consume its opacity directly — a 0 would render them
  * invisible.  scaleBar is React-side and tour-addressable but never auto-faded
- * by the engine, so it starts at 1.  There is no category-less poi handle:
- * structure labels use the per-category poi handles below, and
+ * by the engine, so it starts at 1.  There is no category-less structure handle:
+ * structure labels use the per-category structure handles below, and
  * `produceStructureLabels` fires each category's load-in on first emit.
  *
- * ### Per-category marker + poi-label handles
+ * ### Per-category marker + structure-label handles
  *
  * Every structure category (cluster / supercluster / void / group) gets its
- * own `markerLayer{category}` and `labelLayer{poi, category}` controller so a
+ * own `markerLayer{category}` and `labelLayer{structure, category}` controller so a
  * category's rings/labels can recede and fade independently.  Each is
  * registered at its persisted settings visibility (markerCategoryVisibility /
  * labelCategoryVisibility) so frame 1 honours what the user last turned off
@@ -81,15 +81,15 @@ export function registerOverlayFades(state: EngineState): void {
   // youAreHereSubsystem).  galaxyNames starts at 1 — famous-galaxy labels
   // reuse this handle and consume its opacity directly, so a 0 would hide
   // them.  scaleBar is React-side — registered at 1 for tour addressability
-  // but never auto-faded by the engine.  poi is per-category only (registered
+  // but never auto-faded by the engine.  structure is per-category only (registered
   // below); produceStructureLabels fires each category's load-in.
   state.subsystems.fades.register({ kind: 'labelLayer', layer: 'youAreHere' }, 0);
   state.subsystems.fades.register({ kind: 'labelLayer', layer: 'galaxyNames' }, 1);
   state.subsystems.fades.register({ kind: 'labelLayer', layer: 'scaleBar' }, 1);
 
-  // ── Per-category marker + poi-label handles ──────────────────────────
+  // ── Per-category marker + structure-label handles ──────────────────────────
   //
-  // One markerLayer + one poi labelLayer controller per structure category,
+  // One markerLayer + one structure labelLayer controller per structure category,
   // each seeded from the session's persisted per-category visibility so a
   // category the user turned off sits at 0 from frame 1 (no flash before a
   // producer's fadeTo).  Iterating STRUCTURE_CATEGORIES keeps this the single
@@ -100,7 +100,7 @@ export function registerOverlayFades(state: EngineState): void {
       state.settings.markerCategoryVisibility[category] ? 1 : 0,
     );
     state.subsystems.fades.register(
-      { kind: 'labelLayer', layer: 'poi', category },
+      { kind: 'labelLayer', layer: 'structure', category },
       state.settings.labelCategoryVisibility[category] ? 1 : 0,
     );
   }
diff --git a/src/services/gpu/renderers/createFocusUniformBuffer.ts b/src/services/gpu/renderers/createFocusUniformBuffer.ts
index 498c0e23f..27bdc5576 100644
--- a/src/services/gpu/renderers/createFocusUniformBuffer.ts
+++ b/src/services/gpu/renderers/createFocusUniformBuffer.ts
@@ -1,6 +1,6 @@
 /**
  * createFocusUniformBuffer — allocate the single engine-owned cluster-focus
- * uniform (buffer + bind group + scratch packer). One POI is focused at a
+ * uniform (buffer + bind group + scratch packer). One structure is focused at a
  * time, so one instance lives on `state.gpu.focusUniform`; `renderFrame`
  * writes it once per frame and every focus-aware pipeline (points, the
  * impostor disks, and the pick pass) binds its bind group.
diff --git a/src/services/gpu/renderers/pickRenderer.ts b/src/services/gpu/renderers/pickRenderer.ts
index f96492dec..769faa24d 100644
--- a/src/services/gpu/renderers/pickRenderer.ts
+++ b/src/services/gpu/renderers/pickRenderer.ts
@@ -73,7 +73,7 @@ export function createPickRenderer(
   // sees the same focus state the visual pass does and the shared vertex
   // shader can cull non-members of a focused structure from hit-testing.
   focusBindGroup: GPUBindGroup,
-  // Optional POI-ring pick provider.  When present, the pick pass
+  // Optional structure-ring pick provider.  When present, the pick pass
   // calls `structureMarkerRenderer.pickRing(pass)` after the galaxy
   // draws so cluster / supercluster / void ring hits land in the same
   // texture.  Shared depth state means a foreground galaxy still
@@ -239,7 +239,7 @@ export function createPickRenderer(
   /**
    * Record the shared per-source pick pass into `encoder`.  Both
    * `pick()` and `renderForDebug()` use this for the common middle —
-   * uniform overrides, bind groups, draw loop, POI ring picks.  The
+   * uniform overrides, bind groups, draw loop, structure ring picks.  The
    * two callers diverge only on the tail (readback vs return-texture).
    *
    * Reads `sharedUniformBuffer` lazily so a future PointRenderer
@@ -330,7 +330,7 @@ export function createPickRenderer(
       pass.draw(6, src.count);
     }
 
-    // POI ring picks share depth state with the galaxy draws, so a
+    // Structure ring picks share depth state with the galaxy draws, so a
     // foreground galaxy claims the pixel — clicks through a ring at a
     // galaxy select the galaxy.  Skipped when no marker renderer.
     if (structureMarkerRenderer) {
diff --git a/src/services/gpu/renderers/structureMarkerRenderer.ts b/src/services/gpu/renderers/structureMarkerRenderer.ts
index 9b9701216..9d844bb11 100644
--- a/src/services/gpu/renderers/structureMarkerRenderer.ts
+++ b/src/services/gpu/renderers/structureMarkerRenderer.ts
@@ -19,7 +19,7 @@
  * instanced draw per non-empty bucket, binding that category's
  * SourceUniforms at `@group(2)`.  The uniform carries the category's
  * 5-bit `sourceCode`, which the ringPick fragment composes into
- * `(sourceCode << 27) | poiIndex + PICK_SENTINEL_OFFSET` — the same
+ * `(sourceCode << 27) | structureIndex + PICK_SENTINEL_OFFSET` — the same
  * per-source pattern `pointRenderer` uses per survey.  Buckets are
  * data-driven from `STRUCTURE_CATEGORIES`, so a new structure source
  * needs no change here.
@@ -130,12 +130,12 @@ export function createStructureMarkerRenderer(
   // buffer (see growTo) to fit whatever descriptor count it's handed.
   //
   // Why grow rather than cap: produceMarkers emits one descriptor per
-  // marker-bearing POI of a visible category EVERY frame — including
+  // marker-bearing structure of a visible category EVERY frame — including
   // fully-faded ones (the emit-all-then-discard contract that keeps the
-  // ring-pick instance_index aligned with getPoisForCategory).  So the
+  // ring-pick instance_index aligned with getStructuresForCategory).  So the
   // count is data-driven (~660 with the M500 ≥ 1.0 cluster cut, more if
   // the catalog grows).  A fixed cap silently truncated the tail in
-  // `pois` order, which both dropped whole categories off-screen
+  // structure order, which both dropped whole categories off-screen
   // (clusters saturated the buffer, so superclusters and voids never got
   // packed — visible only when clusters were toggled off) AND desynced
   // the per-category pick index.  Growing keeps the renderer correct for
@@ -156,7 +156,7 @@ export function createStructureMarkerRenderer(
   // Ring-pick pipeline — same vertex source as ringPipeline, fragment
   // swapped to ringPick.wesl's fsRingPick + colour target swapped to
   // r32uint + depth24plus added.  See the pick pipeline build below for
-  // the full rationale; in short, this is the POI sibling of the
+  // the full rationale; in short, this is the structure-marker sibling of the
   // galaxy pick path in pickRenderer.ts.  The engine's pick pass will
   // call `pickRing(pass)` immediately after the per-source galaxy
   // draws, reusing the caller's @group(0) (CameraUniforms) binding.
@@ -306,7 +306,7 @@ export function createStructureMarkerRenderer(
     //   - No blend descriptor — integer formats don't support blending.
     //   - depthStencil enabled with `depth24plus` + `less`+writeEnabled
     //     so a closer galaxy pick fragment (running just before us in
-    //     the same pass) wins the pixel over an occluded POI ring.
+    //     the same pass) wins the pixel over an occluded structure ring.
     //     The depth attachment is the same texture the galaxy pick
     //     draws used; we are intentionally a second batch INSIDE the
     //     same pass, not a separate pass.
@@ -540,7 +540,7 @@ export function createStructureMarkerRenderer(
     // slide setVertexBuffer's byte-offset to the bucket start and
     // draw with firstInstance=0.  That way instance_index runs 0..count-1
     // per category — the index the CPU-side pick resolver expects when
-    // it does `categoryPois[poiIndex]`.  Functionally identical for
+    // it does `categoryStructures[structureIndex]`.  Functionally identical for
     // the visible draws (their shaders don't read instance_index for
     // visual output); load-bearing for the pick path.
     pass.setPipeline(haloPipeline);
@@ -571,7 +571,7 @@ export function createStructureMarkerRenderer(
   }
 
   /**
-   * Issue per-category POI ring pick draws into the caller-supplied
+   * Issue per-category structure ring pick draws into the caller-supplied
    * render pass.  See the docstring on StructureMarkerRenderer.pickRing
    * for the binding contract — short version: caller bound @group(0),
    * we bind @group(1) (dummy fade) + @group(2) (per-category source)
@@ -599,8 +599,8 @@ export function createStructureMarkerRenderer(
       passEncoder.setBindGroup(2, bg);
       // Per-category instance_index via vertex-buffer offset (NOT
       // firstInstance).  See the visible-draw block above for the
-      // rationale — keeps poiIndex 0..count-1 per category so the
-      // CPU-side resolver can do `categoryPois[poiIndex]` directly.
+      // rationale — keeps structureIndex 0..count-1 per category so the
+      // CPU-side resolver can do `categoryStructures[structureIndex]` directly.
       passEncoder.setVertexBuffer(0, instanceBuffer, bucketOffsets[cat] * MARKER_INSTANCE_BYTES);
       passEncoder.draw(6, bucketCounts[cat], 0, 0);
     }
diff --git a/src/services/gpu/shaders/lib/focusUniforms.wesl b/src/services/gpu/shaders/lib/focusUniforms.wesl
index 9af220dfd..870977b9a 100644
--- a/src/services/gpu/shaders/lib/focusUniforms.wesl
+++ b/src/services/gpu/shaders/lib/focusUniforms.wesl
@@ -1,4 +1,4 @@
-// lib/focusUniforms.wesl — shared 'which POI is focused' uniform, written
+// lib/focusUniforms.wesl — shared 'which structure is focused' uniform, written
 // once per frame from structureFocusSubsystem state. blend=0 collapses the
 // per-vertex multiplier to 1.0 (no effect); when active, galaxies in the
 // focused structure's core (within physicalRadiusMpc) keep alpha 1.0, and
diff --git a/src/services/gpu/shaders/lib/selectionEncoding.wesl b/src/services/gpu/shaders/lib/selectionEncoding.wesl
index bc4d0845a..80860f6c1 100644
--- a/src/services/gpu/shaders/lib/selectionEncoding.wesl
+++ b/src/services/gpu/shaders/lib/selectionEncoding.wesl
@@ -32,16 +32,16 @@ const SELECTION_NONE_SENTINEL: u32 = 0xffffffffu;
 /** Offset the pick fragment adds before writing into the r32uint texture. */
 const PICK_SENTINEL_OFFSET: u32 = 1u;
 
-/** Source code for cluster POIs — see TS Source.Cluster. */
+/** Source code for cluster structures — see TS Source.Cluster. */
 const SOURCE_CODE_CLUSTER: u32 = 5u;
 
-/** Source code for supercluster POIs — see TS Source.Supercluster. */
+/** Source code for supercluster structures — see TS Source.Supercluster. */
 const SOURCE_CODE_SUPERCLUSTER: u32 = 6u;
 
-/** Source code for void POIs — see TS Source.Void. */
+/** Source code for void structures — see TS Source.Void. */
 const SOURCE_CODE_VOID: u32 = 7u;
 
-/** Source code for nearby-galaxy-group POIs — see TS Source.Group (= 15). */
+/** Source code for nearby-galaxy-group structures — see TS Source.Group (= 15). */
 const SOURCE_CODE_GROUP: u32 = 15u;
 
 /** Pack a (sourceCode, localIdx) pair into the canonical u32 layout. */
diff --git a/src/services/gpu/shaders/pickDebugOverlay/fragment.wesl b/src/services/gpu/shaders/pickDebugOverlay/fragment.wesl
index eee167cd9..9fc6a840b 100644
--- a/src/services/gpu/shaders/pickDebugOverlay/fragment.wesl
+++ b/src/services/gpu/shaders/pickDebugOverlay/fragment.wesl
@@ -19,7 +19,7 @@
 //
 // The whole point of the overlay is to answer "what would a click
 // here hit?".  Distinct colours per survey make it obvious whether
-// the cursor is over an SDSS billboard, a 2MRS billboard, or a POI
+// the cursor is over an SDSS billboard, a 2MRS billboard, or a structure
 // ring.  The localIdx-hash brightness modulation keeps two adjacent
 // galaxies of the same survey from blurring into a single coloured
 // patch — they read as discrete instances with slightly different
@@ -58,7 +58,7 @@ fn fs(in: VSOut) -> @location(0) vec4<f32> {
 
   // Per-source debug palette.  Indexed by 'Source.*' enum value.
   // Codes ≥ 9 (Filaments, Cf4Density, Mcpm) never appear in the pick
-  // texture — picking is galaxy/POI only — so the palette stops at
+  // texture — picking is galaxy/structure only — so the palette stops at
   // Milliquas (8).  An out-of-range code falls back to neutral grey
   // so a future enum widening surfaces visually rather than
   // silently rendering black.
diff --git a/src/services/gpu/shaders/proceduralDisks/io.wesl b/src/services/gpu/shaders/proceduralDisks/io.wesl
index 8f56280b4..72de697d3 100644
--- a/src/services/gpu/shaders/proceduralDisks/io.wesl
+++ b/src/services/gpu/shaders/proceduralDisks/io.wesl
@@ -103,7 +103,7 @@ struct VsOut {
   // See 'ProceduralDiskInstance.d.ts' for the full semantic.
   @location(3) @interpolate(flat) procFadeOut: f32,
   // Per-instance cluster-focus dim in [0.08, 1.0]: 1.0 for members of the
-  // focused POI (and for everything at rest), 0.08 for non-members, ramped
+  // focused structure (and for everything at rest), 0.08 for non-members, ramped
   // by the focus blend. Computed once per instance in the vertex stage.
   @location(4) @interpolate(flat) focusDim: f32,
 };
diff --git a/src/services/gpu/shaders/proceduralDisks/vertex.wesl b/src/services/gpu/shaders/proceduralDisks/vertex.wesl
index be3d5852f..27f3835ee 100644
--- a/src/services/gpu/shaders/proceduralDisks/vertex.wesl
+++ b/src/services/gpu/shaders/proceduralDisks/vertex.wesl
@@ -60,7 +60,7 @@ import package::lib::focusUniforms::focusAlphaMultiplier;
 @group(0) @binding(0) var<uniform> u: Uniforms;
 // @group(1) cluster-focus uniform — the impostor pipelines have no fade /
 // source groups, so focus takes the first free slot (the points pipeline
-// parks it at @group(3)). Single shared binding: one POI focused at a time.
+// parks it at @group(3)). Single shared binding: one structure focused at a time.
 @group(1) @binding(0) var<uniform> focus: FocusUniforms;
 
 @vertex
diff --git a/src/services/gpu/shaders/structureMarker/halo.wesl b/src/services/gpu/shaders/structureMarker/halo.wesl
index fdec7a4d4..5ee3b5bf3 100644
--- a/src/services/gpu/shaders/structureMarker/halo.wesl
+++ b/src/services/gpu/shaders/structureMarker/halo.wesl
@@ -52,19 +52,19 @@ fn vs(
   // computes its own distance because halo and ring share the VsOut
   // struct.
   out.camDistMpc = 0.0;
-  // poiIndex is consumed only by the ringPick fragment.  Halo doesn't
+  // structureIndex is consumed only by the ringPick fragment.  Halo doesn't
   // need it but WGSL requires every field of a returned struct to be
   // initialised, so we pass 0u.  All six vertices of one instance share
   // the same value (flat-interpolated in io.wesl); never read here.
-  out.poiIndex = 0u;
+  out.structureIndex = 0u;
   return out;
 }
 
 @fragment
 fn fs(input: VsOut) -> @location(0) vec4<f32> {
   // Faded-out instances arrive at alpha 0.  produceMarkers now emits one
-  // instance per marker-bearing POI regardless of fade (to keep the ring
-  // pick instance_index aligned with the CPU getPoisForCategory list), so
+  // instance per marker-bearing structure regardless of fade (to keep the ring
+  // pick instance_index aligned with the CPU getStructuresForCategory list), so
   // most of the ~hundreds of per-frame instances may be alpha 0.  An
   // alpha-0 halo already adds nothing under the additive (one, one) blend;
   // discarding early skips the gradient math for those fragments.
diff --git a/src/services/gpu/shaders/structureMarker/io.wesl b/src/services/gpu/shaders/structureMarker/io.wesl
index cfab8b554..b4c6da44e 100644
--- a/src/services/gpu/shaders/structureMarker/io.wesl
+++ b/src/services/gpu/shaders/structureMarker/io.wesl
@@ -95,11 +95,11 @@ struct VsOut {
   // uniform.  Halo fragment ignores these.
   @location(3) radiusMpc: f32,
   @location(4) camDistMpc: f32,
-  // Per-instance POI index — assembled in the vertex stage from
+  // Per-instance structure index — assembled in the vertex stage from
   // @builtin(instance_index).  Consumed only by the ringPick fragment
   // (offscreen r32uint picking pass), which packs it together with
   // SourceUniforms.sourceCode into the canonical
-  // (sourceCode << 27) | (poiIndex + PICK_SENTINEL_OFFSET) identity.
+  // (sourceCode << 27) | (structureIndex + PICK_SENTINEL_OFFSET) identity.
   //
   // The visual halo + ring fragments ignore it; it costs one extra
   // flat-interpolated u32 per vertex output and lets both pipelines
@@ -107,5 +107,5 @@ struct VsOut {
   // because integers can't be linearly interpolated and all six
   // vertices of one instance share the same value — same idiom as
   // points/io.wesl's `instanceIdx`.
-  @location(5) @interpolate(flat) poiIndex: u32,
+  @location(5) @interpolate(flat) structureIndex: u32,
 };
diff --git a/src/services/gpu/shaders/structureMarker/ring.wesl b/src/services/gpu/shaders/structureMarker/ring.wesl
index 0e448575e..dc94175a3 100644
--- a/src/services/gpu/shaders/structureMarker/ring.wesl
+++ b/src/services/gpu/shaders/structureMarker/ring.wesl
@@ -60,12 +60,12 @@ const RING_QUAD_MARGIN: f32 = 1.1;
 @vertex
 fn vs(
   @builtin(vertex_index) vi: u32,
-  // ii (instance_index) is forwarded into VsOut.poiIndex so the
+  // ii (instance_index) is forwarded into VsOut.structureIndex so the
   // companion ringPick.wesl pick fragment can pack it into the pick
   // texture identity.  The visual ring fragment ignores the field;
   // it costs one flat-interpolated u32 per vertex output and lets
   // both pipelines share one VsOut struct (see io.wesl's docstring
-  // on the poiIndex slot).
+  // on the structureIndex slot).
   @builtin(instance_index) ii: u32,
   input: VsIn,
 ) -> VsOut {
@@ -110,18 +110,18 @@ fn vs(
   // pixel widths to UV widths.  Cheaper than adding another VsOut
   // slot for one scalar.  Rename when a second use appears.
   out.camDistMpc = sizePx;
-  // Per-instance POI index forwarded for the ringPick fragment.  The
+  // Per-instance structure index forwarded for the ringPick fragment.  The
   // visual fragment doesn't read it; the cost is one flat-interpolated
   // u32 per vertex output.
-  out.poiIndex = ii;
+  out.structureIndex = ii;
   return out;
 }
 
 @fragment
 fn fs(input: VsOut) -> @location(0) vec4<f32> {
   // Faded-out instances arrive at alpha 0.  produceMarkers now emits one
-  // instance per marker-bearing POI regardless of fade (to keep the ring
-  // pick instance_index aligned with the CPU getPoisForCategory list), so
+  // instance per marker-bearing structure regardless of fade (to keep the ring
+  // pick instance_index aligned with the CPU getStructuresForCategory list), so
   // most of the ~hundreds of per-frame instances may be alpha 0.  An
   // alpha-0 ring already contributes nothing under the premultiplied OVER
   // blend; discarding early skips the band + AA math for those fragments.
diff --git a/src/services/gpu/shaders/structureMarker/ringPick.wesl b/src/services/gpu/shaders/structureMarker/ringPick.wesl
index 0eaa57491..c7dbea5c8 100644
--- a/src/services/gpu/shaders/structureMarker/ringPick.wesl
+++ b/src/services/gpu/shaders/structureMarker/ringPick.wesl
@@ -31,12 +31,12 @@
 //
 // ## Pick encoding
 //
-// Same '(sourceCode << 27) | (poiIndex + PICK_SENTINEL_OFFSET)' packing
+// Same '(sourceCode << 27) | (structureIndex + PICK_SENTINEL_OFFSET)' packing
 // the galaxy path uses.  The per-category SourceUniforms block carries
 // the source code (5/6/7/15 for cluster/supercluster/void/group — see
-// sources.ts and lib/selectionEncoding.wesl).  'poiIndex' is the
+// sources.ts and lib/selectionEncoding.wesl).  'structureIndex' is the
 // @builtin(instance_index) of this draw, populated in the vertex stage
-// (ring.wesl) and forwarded through VsOut.poiIndex — flat-interpolated
+// (ring.wesl) and forwarded through VsOut.structureIndex — flat-interpolated
 // so the integer arrives unchanged across all six vertices of the
 // instance.
 //
@@ -86,17 +86,17 @@ fn fsRingPick(in: VsOut) -> @location(0) vec4<u32> {
   // Faded / invisible rings must not be pickable.  'in.alpha' carries
   // ringAlpha (the vertex stage in ring.wesl selects ringColorAndAlpha.w
   // into VsOut.alpha).  produceMarkers emits one instance per marker-
-  // bearing POI regardless of fade — faded ones at alpha 0 — so the
-  // CPU descriptor list stays index-aligned with getPoisForCategory and
-  // the @builtin(instance_index) packed below resolves to the right POI.
+  // bearing structure regardless of fade — faded ones at alpha 0 — so the
+  // CPU descriptor list stays index-aligned with getStructuresForCategory and
+  // the @builtin(instance_index) packed below resolves to the right structure.
   // We discard the alpha-0 instances here so those invisible rings don't
   // become pick targets while still occupying their instance slot.
   if (in.alpha <= 0.0) { discard; }
 
-  // 'in.poiIndex' was assembled in the vertex stage as
+  // 'in.structureIndex' was assembled in the vertex stage as
   // 'u32(@builtin(instance_index))'.  The shared VsOut carries it so
   // both the visible-ring fragment (which doesn't use it) and this
   // pick fragment can read from one interpolant set.
-  let packed: u32 = (source.sourceCode << 27u) | (in.poiIndex + PICK_SENTINEL_OFFSET);
+  let packed: u32 = (source.sourceCode << 27u) | (in.structureIndex + PICK_SENTINEL_OFFSET);
   return vec4<u32>(packed, 0u, 0u, 0u);
 }
diff --git a/src/services/gpu/shaders/texturedDisks/io.wesl b/src/services/gpu/shaders/texturedDisks/io.wesl
index a595a8277..5f9d1e0ad 100644
--- a/src/services/gpu/shaders/texturedDisks/io.wesl
+++ b/src/services/gpu/shaders/texturedDisks/io.wesl
@@ -87,7 +87,7 @@ struct VsOut {
   @location(3) @interpolate(flat) hiResLayerIdx:           i32,
   @location(4)                    hiResCrossfadeAlpha:     f32,
   // Per-instance cluster-focus dim in [0.08, 1.0]: 1.0 for members of the
-  // focused POI (and at rest), 0.08 for non-members, ramped by the focus
+  // focused structure (and at rest), 0.08 for non-members, ramped by the focus
   // blend. Computed once per instance in the vertex stage; flat because it
   // is constant across the quad.
   @location(5) @interpolate(flat) focusDim:                f32,
diff --git a/src/services/gpu/shaders/texturedDisks/vertex.wesl b/src/services/gpu/shaders/texturedDisks/vertex.wesl
index 6c3595b45..bd429135e 100644
--- a/src/services/gpu/shaders/texturedDisks/vertex.wesl
+++ b/src/services/gpu/shaders/texturedDisks/vertex.wesl
@@ -65,7 +65,7 @@ import package::lib::focusUniforms::focusAlphaMultiplier;
 @group(0) @binding(0) var<uniform> u: Uniforms;
 // @group(1) cluster-focus uniform — the impostor pipelines have no fade /
 // source groups, so focus takes the first free slot (the points pipeline
-// parks it at @group(3)). Single shared binding: one POI focused at a time.
+// parks it at @group(3)). Single shared binding: one structure focused at a time.
 @group(1) @binding(0) var<uniform> focus: FocusUniforms;
 
 @vertex
diff --git a/src/services/url/focusUrl.ts b/src/services/url/focusUrl.ts
index ddc8d66d1..718fcbc44 100644
--- a/src/services/url/focusUrl.ts
+++ b/src/services/url/focusUrl.ts
@@ -40,6 +40,7 @@
 import type { GalaxyInfo } from '../../@types/engine/GalaxyInfo';
 import type { FocusTarget } from '../../@types/camera/FocusTarget';
 import { Source } from '../../data/sources';
+import { STRUCTURE_CATEGORIES } from '../../data/structureCategories';
 
 /**
  * Build the `#focus=<id>` payload (the bit after `=`) for the given
@@ -66,9 +67,7 @@ export function selectionToFocusId(info: GalaxyInfo): string | null {
   // number (the GLADE parser writes PGC into objID, and the 2MRS
   // cross-match copies it across).
   if (info.objID > 0n) {
-    return info.source === Source.SDSS
-      ? `sdss-${info.objID}`
-      : `pgc-${info.objID}`;
+    return info.source === Source.SDSS ? `sdss-${info.objID}` : `pgc-${info.objID}`;
   }
 
   // Last resort: 4-decimal RA/Dec.  No URL-encoding needed — the
@@ -137,12 +136,25 @@ export function parseFocusHash(hash: string): FocusTarget | null {
     return { kind: 'pos', raDeg, decDeg };
   }
 
+  // Structure ids: `${category}-${seed.id}` where `category` is one of
+  // STRUCTURE_CATEGORIES ('cluster', 'supercluster', 'void', 'group').
+  // Must be checked before the famous-id fallback below — `cluster-virgo-m87`
+  // passes the `[a-z0-9_-]+` class and would otherwise route to `famous`.
+  // We derive the prefix set from the registry so adding a new structure
+  // category automatically extends the codec without touching this file.
+  for (const cat of STRUCTURE_CATEGORIES) {
+    if (raw.startsWith(`${cat}-`)) {
+      if (/^[a-z0-9_-]+$/i.test(raw)) return { kind: 'structure', id: raw };
+      return null;
+    }
+  }
+
   // Anything else: treat as a famous-id token.  Famous ids in the seed
   // JSON use lowercase letters, digits, `_`, and `-`; restricting to
   // that character class keeps the codec from accepting wild input
   // (e.g. raw spaces, query separators) that would never resolve
-  // anyway.  The downstream resolver (Task 2) is the authority on
-  // whether the id actually exists.
+  // anyway.  The downstream resolver is the authority on whether the
+  // id actually exists.
   if (/^[a-z0-9_-]+$/i.test(raw)) return { kind: 'famous', id: raw };
   return null;
 }
diff --git a/src/services/url/poiUrl.ts b/src/services/url/poiUrl.ts
deleted file mode 100644
index b07c3d578..000000000
--- a/src/services/url/poiUrl.ts
+++ /dev/null
@@ -1,88 +0,0 @@
-/**
- * poiUrl — codec for the `#poi=<id>` hash that makes a POI (cluster,
- * supercluster, void, wall) selection shareable.  Pure functions only —
- * no DOM access, no React, no engine coupling — so the codec is testable
- * in isolation and reusable from both the client mount path and
- * tooling/tests.
- *
- * Sister module to `focusUrl.ts` (the galaxy version); deliberately kept
- * as its own file so the two URL schemes can evolve independently.
- * E.g. a future `#poi=<id>&tour=play` query-like extension wouldn't
- * touch the galaxy hash, and vice versa.  The alternative — merging
- * both into a single `urlHash.ts` codec — would couple unrelated
- * features and force every change to reason about both schemes at once.
- *
- * The id is the literal `StructureRecord.id` (e.g. `virgo-m87`,
- * `hercules-sc`, `bootes-void`).  POI ids are curated and stable across
- * rebuilds (they live in `data/structure_anchors.seed.json`), so encoding
- * them directly is safe — unlike galaxies, there's no priority ladder to
- * navigate (no `famous > pgc > sdss > pos` cascade).
- *
- * Character class: `[a-z0-9_-]+`, matching `focusUrl`'s famous-id
- * fallback.  Rejects whitespace, angle brackets, percent-encoded payload
- * — anything that wouldn't appear in a legitimate POI id and that could
- * otherwise smuggle markup into the URL bar on shared links.
- *
- * Why a hash, not a query string?  Same reason as `focusUrl`: the app
- * is hosted on Cloudflare Workers Assets with a single static shell.
- * The hash never reaches the server, so it's pure-frontend with no
- * infra changes.
- */
-
-/**
- * Strict regex for the POI id body.  Anchored at both ends, so trailing
- * garbage (e.g. `virgo-m87?tour`) is rejected.  Matches the same
- * character class as `focusUrl`'s famous-id fallback for consistency.
- */
-const POI_ID_RE = /^[a-z0-9_-]+$/i;
-
-/**
- * Parse a `window.location.hash` string into a POI id.  Returns null
- * for anything we can't confidently route — the caller treats null as
- * "no deep link, render as if the URL were clean".
- *
- * Accepts hash strings with or without the leading `#`, so this is
- * easy to call from both `location.hash` (which includes `#`) and
- * test fixtures (which often don't).
- */
-export function parsePoiHash(hash: string): string | null {
-  if (!hash) return null;
-  const trimmed = hash.startsWith('#') ? hash.slice(1) : hash;
-  if (!trimmed) return null;
-
-  // We expect exactly `poi=<value>`.  The `=` split lets us validate
-  // the key without running a regex on every hash; non-poi hashes
-  // (e.g. `#about`, `#focus=m31`) bail out cheaply.
-  const eq = trimmed.indexOf('=');
-  if (eq < 0 || trimmed.slice(0, eq) !== 'poi') return null;
-
-  // `decodeURIComponent` throws `URIError` on malformed percent-escapes
-  // (e.g. a truncated `%E0%A4`).  Catch and return null so the codec's
-  // "null on anything we can't confidently route" contract holds even
-  // for users pasting half-copied URLs.
-  let raw: string;
-  try {
-    raw = decodeURIComponent(trimmed.slice(eq + 1));
-  } catch {
-    return null;
-  }
-  if (!raw || !POI_ID_RE.test(raw)) return null;
-  return raw;
-}
-
-/**
- * Build the `poi=<id>` payload (the bit after `#`) for the given POI id.
- *
- * The caller is responsible for prepending `#` when assigning to
- * `location.hash` directly — returning the bare body matches
- * `focusUrl`'s shape and keeps the codec composable (e.g. a future
- * caller wanting `#poi=<id>&tour=play` can append without splicing).
- *
- * No URL-encoding needed — the POI_ID_RE character class is entirely
- * hash-safe (no `#`, `?`, `&`, `%`, or whitespace).  If a future POI
- * id ever breaks that assumption, the parser-side regex will reject
- * the round-trip, so the test suite is the safety net.
- */
-export function poiIdToHash(poiId: string): string {
-  return `poi=${poiId}`;
-}
diff --git a/src/utils/math/galaxyType.ts b/src/utils/math/galaxyType.ts
index 92f7c2000..77e93b806 100644
--- a/src/utils/math/galaxyType.ts
+++ b/src/utils/math/galaxyType.ts
@@ -76,7 +76,7 @@ export function galaxyType(source: SourceType, mags: GalaxyTypeMags): GalaxyType
     case Source.DebugGaussian:
     case Source.DebugCartesian:
     case Source.DebugSpherical:
-      // Non-survey sources (POI markers, filaments, volumes) have no
+      // Non-survey sources (structure markers, filaments, volumes) have no
       // per-record photometry and no galaxy type. Reaching this branch
       // indicates the InfoCard is rendering a galaxy row for a
       // non-survey pick / handle; route those through their own info
diff --git a/src/utils/math/iauName.ts b/src/utils/math/iauName.ts
index 062de3598..b6ab0b047 100644
--- a/src/utils/math/iauName.ts
+++ b/src/utils/math/iauName.ts
@@ -29,15 +29,15 @@ import type { SourceType } from '../../@types/data/SourceType';
  * Survey-aware IAU designation.  Returns "<prefix> J<RA><Dec>" where the
  * prefix matches the source's canonical short name.
  *
- * Throws for POI sources (Cluster/Supercluster/Void) — those markers
+ * Throws for structure sources (Cluster/Supercluster/Void) — those markers
  * carry curated names (e.g. "Virgo Cluster") and have no IAU coordinate
- * designation. Reaching the throw means a POI pick is being formatted by
- * galaxy-headline code; route POI picks through their dedicated info path.
+ * designation. Reaching the throw means a structure pick is being formatted by
+ * galaxy-headline code; route structure picks through their dedicated info path.
  */
 export function iauName(source: SourceType, raDeg: number, decDeg: number): string {
   const entry = SOURCE_REGISTRY[source];
   if (entry.type !== 'survey') {
-    throw new Error(`iauName: POI source ${source} has no IAU designation`);
+    throw new Error(`iauName: structure source ${source} has no IAU designation`);
   }
   return `${entry.iauPrefix} ${iauRaDecSuffix(raDeg, decDeg)}`;
 }
diff --git a/src/utils/sourceMask.ts b/src/utils/sourceMask.ts
index b64156084..67332c249 100644
--- a/src/utils/sourceMask.ts
+++ b/src/utils/sourceMask.ts
@@ -9,12 +9,12 @@
  * far more than the four currently tracked.
  */
 
-import { SOURCE_REGISTRY, SURVEY_SOURCES, Source } from '../data/sources';
+import { SOURCE_REGISTRY, SURVEY_SOURCES } from '../data/sources';
 import type { SourceType } from '../@types/data/SourceType';
 
 /**
  * Startup visibility mask — `1` for every survey source whose registry
- * entry has `visible: true`. POI codes never participate (their bits
+ * entry has `visible: true`. Structure codes never participate (their bits
  * stay clear). Drives the engine's initial `drawMask`/`pickMask`.
  */
 export const ALL_VISIBLE_MASK: number = SURVEY_SOURCES.reduce<number>(
diff --git a/src/utils/structure/structureMemberCount.ts b/src/utils/structure/structureMemberCount.ts
index a19e93036..cd71c2f8b 100644
--- a/src/utils/structure/structureMemberCount.ts
+++ b/src/utils/structure/structureMemberCount.ts
@@ -44,11 +44,11 @@ import type { SourceType } from '../../@types/data/SourceType';
 import type { StructureRecord } from '../../@types/engine/data/StructureRecord';
 
 export function structureMemberCount(
-  poi: StructureRecord,
+  structure: StructureRecord,
   getCloud: (source: SourceType) => GalaxyCatalog | undefined,
   visibleSourceMask: number,
 ): number | null {
-  const radiusMpc = poi.apparentRadiusMpc ?? poi.physicalRadiusMpc;
+  const radiusMpc = structure.apparentRadiusMpc ?? structure.physicalRadiusMpc;
 
   const catalogs: CatalogWithSource[] = [];
   for (const source of SURVEY_SOURCES) {
@@ -61,5 +61,5 @@ export function structureMemberCount(
   // Nothing loaded/visible to search — "not computable yet", not zero.
   if (catalogs.length === 0) return null;
 
-  return structureMembership(catalogs, poi.worldPos, radiusMpc).count;
+  return structureMembership(catalogs, structure.worldPos, radiusMpc).count;
 }
diff --git a/src/utils/structure/structureMembership.ts b/src/utils/structure/structureMembership.ts
index c67cb8663..4d3bb475f 100644
--- a/src/utils/structure/structureMembership.ts
+++ b/src/utils/structure/structureMembership.ts
@@ -9,7 +9,7 @@
  *
  * The expensive bit is the cone search itself (one vec3 subtract + one
  * dot product per galaxy, ~2.5M ops for the full loaded catalog).
- * Memoising against `(poiId, dataRev)` belongs to the subsystem that
+ * Memoising against `(structureId, dataRev)` belongs to the subsystem that
  * owns the focus state — see spec §4.3 — because cache invalidation
  * needs to know when a tier swap has bumped `dataRev`, which this pure
  * function has no concept of. Keeping the function cache-free makes it
diff --git a/src/utils/url/hasDeepLink.ts b/src/utils/url/hasDeepLink.ts
index 5da51c84c..fcf61d50b 100644
--- a/src/utils/url/hasDeepLink.ts
+++ b/src/utils/url/hasDeepLink.ts
@@ -5,12 +5,12 @@
  * ### Rationale
  *
  * The splash UX (per the 2026-05-20 grill) treats deep-link arrivals as
- * "this user already knows what they want — get out of their way".  Three
+ * "this user already knows what they want — get out of their way".  Two
  * URL shapes qualify:
  *
- *   - `#focus=<galaxyId>` — pin a specific galaxy (set by the InfoCard
- *     deep-link drain in useUrlSync).
- *   - `#poi=<poiId>` — focus a specific cluster / supercluster / void.
+ *   - `#focus=<id>` — pin a specific galaxy or structure (set by the
+ *     InfoCard deep-link drain in useUrlSync; structures ride the same
+ *     prefix as galaxies).
  *   - `?tour=<name>` — request the tour at a specific anchor.
  *
  * Power-user gates (`?debug`, `?volumes`, `?anchors`, `?gpuTimings`)
@@ -42,10 +42,10 @@ export type DeepLinkInput = {
 const DEEP_LINK_QUERY_KEYS = new Set(['tour']);
 
 export function hasDeepLink({ hash, search }: DeepLinkInput): boolean {
-  // Hash: look for the two deep-link prefixes anywhere in the body.
+  // Hash: look for the #focus= prefix anywhere in the body.
   // (The hash always starts with `#` if present, so a prefix check is safe.)
+  // Both galaxies and structures share this prefix.
   if (hash.includes('#focus=') || hash.startsWith('#focus=')) return true;
-  if (hash.includes('#poi=') || hash.startsWith('#poi=')) return true;
 
   // Search: parse and look for known deep-link keys.  We strip a leading
   // `?` so callers can pass either `?tour=foo` or `tour=foo`.
diff --git a/tests/@types/engine/EngineCameraHandle.poi.test.ts b/tests/@types/engine/EngineCameraHandle.structure.test.ts
similarity index 80%
rename from tests/@types/engine/EngineCameraHandle.poi.test.ts
rename to tests/@types/engine/EngineCameraHandle.structure.test.ts
index 7e4cd3bb0..532ba6666 100644
--- a/tests/@types/engine/EngineCameraHandle.poi.test.ts
+++ b/tests/@types/engine/EngineCameraHandle.structure.test.ts
@@ -2,13 +2,13 @@ import { describe, it, expect } from 'vitest';
 import type { EngineCameraHandle } from '../../../src/@types/engine/handles/EngineCameraHandle';
 import type { StructureRecord } from '../../../src/@types/engine/data/StructureRecord';
 
-describe('EngineCameraHandle.focusOn (POI)', () => {
+describe('EngineCameraHandle.focusOn (structure)', () => {
   it('accepts a StructureRecord via the unified focusOn slot', () => {
     // Type-level assertion: the unified focusOn signature accepts both
     // GalaxyInfo and StructureRecord (see FocusableTarget).  This test
-    // pins the POI half of that contract; the galaxy half is implicit
+    // pins the structure half of that contract; the galaxy half is implicit
     // in every existing handle consumer.
-    const poi: StructureRecord = {
+    const structure: StructureRecord = {
       id: 'virgo-cluster',
       name: 'Virgo Cluster',
       category: 'cluster',
@@ -19,7 +19,7 @@ describe('EngineCameraHandle.focusOn (POI)', () => {
     const _stub: Pick<EngineCameraHandle, 'focusOn'> = {
       focusOn: (target): void => void target,
     };
-    _stub.focusOn(poi);
+    _stub.focusOn(structure);
     expect(_stub.focusOn).toBeTypeOf('function');
   });
 });
diff --git a/tests/@types/engineSettingsState.labelCategoryVisibility.test.ts b/tests/@types/engineSettingsState.labelCategoryVisibility.test.ts
index 930ccdaaa..7cf81bca7 100644
--- a/tests/@types/engineSettingsState.labelCategoryVisibility.test.ts
+++ b/tests/@types/engineSettingsState.labelCategoryVisibility.test.ts
@@ -1,14 +1,19 @@
 import { describe, expect, it } from 'vitest';
 import type { EngineSettingsState } from '../../src/@types/settings/EngineSettingsState';
-import type { PoiCategory } from '../../src/@types/engine/data/PoiCategory';
+import type { LabelCategory } from '../../src/@types/engine/data/LabelCategory';
+import type { StructureCategory } from '../../src/@types/engine/data/StructureCategory';
 
 /**
- * Type-level check: `EngineSettingsState.labelCategoryVisibility` is
- * keyed by every `PoiCategory` value.  If the union ever drifts from
- * the visibility record shape, this assignment stops compiling.
+ * Type-level checks on the two independent visibility axes:
+ *   - `labelCategoryVisibility` is keyed by `LabelCategory` (famousGalaxy +
+ *     structures);
+ *   - `markerCategoryVisibility` is keyed by `StructureCategory` only — famous
+ *     galaxies bear no ring marker, so a `famousGalaxy` key is a type error.
+ * If either union drifts from its record shape, these assignments stop
+ * compiling.
  */
-describe('EngineSettingsState.labelCategoryVisibility', () => {
-  it('is a Record keyed by PoiCategory', () => {
+describe('EngineSettingsState visibility records', () => {
+  it('labelCategoryVisibility is a Record keyed by LabelCategory (includes famousGalaxy)', () => {
     const v: EngineSettingsState['labelCategoryVisibility'] = {
       cluster: true,
       supercluster: true,
@@ -16,12 +21,25 @@ describe('EngineSettingsState.labelCategoryVisibility', () => {
       void: true,
       group: true,
     };
-    const c: PoiCategory = 'famousGalaxy';
+    const c: LabelCategory = 'famousGalaxy';
     expect(v[c]).toBe(true);
   });
 
-  it('all five categories default to true (compile-time check)', () => {
-    const all: Record<PoiCategory, boolean> = {
+  it('markerCategoryVisibility is a Record keyed by StructureCategory (no famousGalaxy key)', () => {
+    const v: EngineSettingsState['markerCategoryVisibility'] = {
+      cluster: true,
+      supercluster: true,
+      void: true,
+      group: true,
+    };
+    const c: StructureCategory = 'cluster';
+    expect(v[c]).toBe(true);
+    // 'famousGalaxy' is not a StructureCategory, so it is absent from the record.
+    expect('famousGalaxy' in v).toBe(false);
+  });
+
+  it('all label categories default to true (compile-time check)', () => {
+    const all: Record<LabelCategory, boolean> = {
       cluster: true,
       supercluster: true,
       famousGalaxy: true,
diff --git a/tests/@types/engineState.test.ts b/tests/@types/engineState.test.ts
index 358852e56..cd811990b 100644
--- a/tests/@types/engineState.test.ts
+++ b/tests/@types/engineState.test.ts
@@ -112,7 +112,6 @@ describe('EngineState type', () => {
       markerCategoryVisibility: {
         cluster: true,
         supercluster: true,
-        famousGalaxy: true,
         void: true,
         group: true,
       },
@@ -263,7 +262,6 @@ describe('EngineState type', () => {
       markerCategoryVisibility: {
         cluster: true,
         supercluster: true,
-        famousGalaxy: true,
         void: true,
         group: true,
       },
@@ -318,7 +316,6 @@ describe('EngineState type', () => {
         markerCategoryVisibility: {
           cluster: true,
           supercluster: true,
-          famousGalaxy: true,
           void: true,
           group: true,
         },
diff --git a/tests/components/InfoCard/CompactStructureCard.test.ts b/tests/components/InfoCard/CompactStructureCard.test.ts
index d97123b0a..df255453c 100644
--- a/tests/components/InfoCard/CompactStructureCard.test.ts
+++ b/tests/components/InfoCard/CompactStructureCard.test.ts
@@ -30,7 +30,7 @@ describe('CompactStructureCard', () => {
     render(createElement(CompactStructureCard, { structure: virgo }));
     expect(screen.getByText('Virgo Cluster')).toBeInTheDocument();
     // Category badge — exact-match "Cluster" with title-case from the
-    // inlined poiCategoryLabel helper.  Exact match (not /cluster/i)
+    // inlined category-label helper.  Exact match (not /cluster/i)
     // so the headline "Virgo Cluster" doesn't also satisfy this
     // assertion — the badge is the load-bearing surface here.
     expect(screen.getByText('Cluster')).toBeInTheDocument();
diff --git a/tests/components/InfoCard/InfoCard.structureHover.test.ts b/tests/components/InfoCard/InfoCard.structureHover.test.ts
index b1575370c..6984975bf 100644
--- a/tests/components/InfoCard/InfoCard.structureHover.test.ts
+++ b/tests/components/InfoCard/InfoCard.structureHover.test.ts
@@ -6,7 +6,7 @@
 // Since Task 5 of the unify-focus-clear refactor, InfoCard accepts a single
 // `hovered` and a single `selected` prop — each typed as
 // `GalaxyInfo | StructureRecord | null` (the `FocusableTarget` union).
-// The component dispatches via `isPoi` internally.  The old `hoveredStructure`
+// The component dispatches via `isStructure` internally.  The old `hoveredStructure`
 // / `selectedStructure` separate slots are gone.
 //
 // We assert on user-visible text rather than CSS-modules class fragments
diff --git a/tests/data/buildStaticAnchorStructures.test.ts b/tests/data/buildStaticAnchorStructures.test.ts
index 667e4a740..502c5d3cc 100644
--- a/tests/data/buildStaticAnchorStructures.test.ts
+++ b/tests/data/buildStaticAnchorStructures.test.ts
@@ -1,10 +1,10 @@
 /**
  * Tests for `buildStaticAnchorStructures` — the shared id + worldPos builder
  * that backs both the structure store's `anchors` group and the React-side
- * `#poi=<id>` deep-link drain.
+ * `#focus=<id>` deep-link drain.
  *
  * The interesting invariant is the id rule: the URL hash codec
- * (`parsePoiHash`) accepts `[a-z0-9_-]+`, and the drain looks up the
+ * accepts `[a-z0-9_-]+`, and the drain looks up the
  * pending id verbatim against the structure table.  We assert that the
  * emitted ids match the seed's curated `id` field prefixed by category,
  * including entries whose display names contain non-ASCII characters
@@ -22,19 +22,19 @@ import { raDecDistToEqCart } from '../../src/utils/math/raDecDistToEqCart';
 
 describe('buildStaticAnchorStructures', () => {
   it('emits one structure per seed entry across all four categories', () => {
-    const pois = buildStaticAnchorStructures();
-    expect(pois.length).toBe(structureSeedJson.length);
+    const structures = buildStaticAnchorStructures();
+    expect(structures.length).toBe(structureSeedJson.length);
   });
 
   it('produces URL-safe ids by prefixing the category to the seed id field', () => {
-    const pois = buildStaticAnchorStructures();
-    const byName = new Map(pois.map((p) => [p.name, p.id]));
+    const structures = buildStaticAnchorStructures();
+    const byName = new Map(structures.map((p) => [p.name, p.id]));
     // Ids come from the curated seed `id` field, not a runtime slug —
     // so they're stable regardless of display-name punctuation or encoding.
     expect(byName.get('Virgo (M87)')).toBe('cluster-virgo-m87');
     expect(byName.get('Coma (A1656)')).toBe('cluster-coma-a1656');
     expect(byName.get('Laniakea SC')).toBe('supercluster-laniakea-sc');
-    // The seed id is `bootes-void` (curated ASCII), so the POI id is
+    // The seed id is `bootes-void` (curated ASCII), so the structure id is
     // `void-bootes-void` — not the slug `bo-tes-void` that a naive
     // [^a-z0-9] strip of 'Boötes' would produce.
     expect(byName.get('Boötes Void')).toBe('void-bootes-void');
@@ -45,27 +45,27 @@ describe('buildStaticAnchorStructures', () => {
   });
 
   it('carries physicalRadiusMpc through from the seed', () => {
-    const pois = buildStaticAnchorStructures();
-    const virgo = pois.find((p) => p.id === 'cluster-virgo-m87');
+    const structures = buildStaticAnchorStructures();
+    const virgo = structures.find((p) => p.id === 'cluster-virgo-m87');
     // StructureRecord carries the radius on every arm — no narrowing needed.
     expect(virgo?.physicalRadiusMpc).toBe(2.2);
   });
 
   it('carries apparentRadiusMpc through from the seed', () => {
-    const pois = buildStaticAnchorStructures();
-    const virgo = pois.find((p) => p.id === 'cluster-virgo-m87');
+    const structures = buildStaticAnchorStructures();
+    const virgo = structures.find((p) => p.id === 'cluster-virgo-m87');
     expect(virgo?.apparentRadiusMpc).toBe(6);
   });
 
   it('carries the curated description through from the seed', () => {
-    const pois = buildStaticAnchorStructures();
+    const structures = buildStaticAnchorStructures();
     // Assert against the seed's own value (not a hardcoded string) so the
     // test stays green when the curated blurbs are rewritten — it verifies
     // the carry-through wiring, not the prose.
     const seedVirgo = (structureSeedJson as readonly { id: string; description?: string }[]).find(
       (e) => e.id === 'virgo-m87',
     )!;
-    const virgo = pois.find((p) => p.id === 'cluster-virgo-m87')!;
+    const virgo = structures.find((p) => p.id === 'cluster-virgo-m87')!;
     expect(virgo.description).toBe(seedVirgo.description);
     expect(virgo.description).toBeTruthy();
   });
@@ -80,29 +80,29 @@ describe('buildStaticAnchorStructures', () => {
   });
 
   it('surfaces the abell designation on a featured cluster', () => {
-    const pois = buildStaticAnchorStructures();
-    const coma = pois.find((p) => p.id === 'cluster-coma-a1656');
+    const structures = buildStaticAnchorStructures();
+    const coma = structures.find((p) => p.id === 'cluster-coma-a1656');
     // Narrow to the cluster arm — `abell` lives there alone.
     const abell = coma && coma.category === 'cluster' ? coma.abell : undefined;
     expect(abell).toBe('A1656');
     // Virgo has no seed `abell`, so the field is absent (not undefined-keyed)
     // even on the cluster arm.
-    const virgo = pois.find((p) => p.id === 'cluster-virgo-m87');
+    const virgo = structures.find((p) => p.id === 'cluster-virgo-m87');
     expect(virgo && 'abell' in virgo).toBe(false);
     // The non-cluster arms structurally cannot carry an `abell` field.
-    const aVoid = pois.find((p) => p.id === 'void-bootes-void');
+    const aVoid = structures.find((p) => p.id === 'void-bootes-void');
     expect(aVoid && 'abell' in aVoid).toBe(false);
   });
 
   it('marks every static anchor as featured', () => {
-    const pois = buildStaticAnchorStructures();
-    expect(pois.length).toBeGreaterThan(0);
-    expect(pois.every((p) => p.featured === true)).toBe(true);
+    const structures = buildStaticAnchorStructures();
+    expect(structures.length).toBeGreaterThan(0);
+    expect(structures.every((p) => p.featured === true)).toBe(true);
   });
 
   it('assigns the correct category per anchor list', () => {
-    const pois = buildStaticAnchorStructures();
-    const cats = new Set(pois.map((p) => p.category));
+    const structures = buildStaticAnchorStructures();
+    const cats = new Set(structures.map((p) => p.category));
     expect(cats.has('cluster')).toBe(true);
     expect(cats.has('supercluster')).toBe(true);
     expect(cats.has('void')).toBe(true);
@@ -149,16 +149,16 @@ describe('buildStaticAnchorStructures — group seed entry mapping', () => {
     const { buildStaticAnchorStructures: buildWithGroupSeed } =
       await import('../../src/data/buildStaticAnchorStructures');
 
-    const pois = buildWithGroupSeed();
-    expect(pois.length).toBe(1);
-    const poi = pois[0]!;
+    const structures = buildWithGroupSeed();
+    expect(structures.length).toBe(1);
+    const structure = structures[0]!;
 
-    expect(poi.id).toBe('group-local-group');
-    expect(poi.category).toBe('group');
-    expect(poi.featured).toBe(true);
+    expect(structure.id).toBe('group-local-group');
+    expect(structure.category).toBe('group');
+    expect(structure.featured).toBe(true);
     // worldPos must match the independent conversion of the same ra/dec/dist —
     // asserting this verifies the carry-through wiring, not just the discriminant.
-    expect(poi.worldPos).toEqual(raDecDistToEqCart(groupFixture));
+    expect(structure.worldPos).toEqual(raDecDistToEqCart(groupFixture));
 
     vi.doUnmock('../../data/structure_anchors.seed.json');
     vi.resetModules();
diff --git a/tests/data/categoryDisplayInfo.test.ts b/tests/data/categoryDisplayInfo.test.ts
new file mode 100644
index 000000000..a406761f8
--- /dev/null
+++ b/tests/data/categoryDisplayInfo.test.ts
@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { CATEGORY_DISPLAY_INFO } from '../../src/data/categoryDisplayInfo';
+import { LABEL_CATEGORIES } from '../../src/data/labelCategories';
+
+describe('CATEGORY_DISPLAY_INFO', () => {
+  it('has a row per LabelCategory', () => {
+    expect(Object.keys(CATEGORY_DISPLAY_INFO).sort()).toEqual([...LABEL_CATEGORIES].sort());
+  });
+
+  it("cluster renders 'Galaxy Cluster' / 'Cluster' / 'Clusters'", () => {
+    const info = CATEGORY_DISPLAY_INFO['cluster'];
+    expect(info.label).toBe('Galaxy Cluster');
+    expect(info.shortLabel).toBe('Cluster');
+    expect(info.plural).toBe('Clusters');
+  });
+
+  it("famousGalaxy renders 'Famous Galaxy' / 'Galaxy' / 'Famous Galaxies'", () => {
+    const info = CATEGORY_DISPLAY_INFO['famousGalaxy'];
+    expect(info.label).toBe('Famous Galaxy');
+    expect(info.shortLabel).toBe('Galaxy');
+    expect(info.plural).toBe('Famous Galaxies');
+  });
+});
diff --git a/tests/data/labelCategories.test.ts b/tests/data/labelCategories.test.ts
new file mode 100644
index 000000000..43a6104d6
--- /dev/null
+++ b/tests/data/labelCategories.test.ts
@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+import { LABEL_CATEGORIES } from '../../src/data/labelCategories';
+import { STRUCTURE_CATEGORIES } from '../../src/data/structureCategories';
+
+describe('LABEL_CATEGORIES', () => {
+  it('contains famousGalaxy and the four structure categories', () => {
+    expect([...LABEL_CATEGORIES].sort()).toEqual([
+      'cluster',
+      'famousGalaxy',
+      'group',
+      'supercluster',
+      'void',
+    ]);
+  });
+
+  it('is a superset of STRUCTURE_CATEGORIES', () => {
+    for (const cat of STRUCTURE_CATEGORIES) {
+      expect(LABEL_CATEGORIES).toContain(cat);
+    }
+  });
+
+  it('excludes bulk surveys', () => {
+    expect(LABEL_CATEGORIES).not.toContain('sdss');
+    expect(LABEL_CATEGORIES).not.toContain('glade');
+  });
+});
diff --git a/tests/data/selectionEncoding.test.ts b/tests/data/selectionEncoding.test.ts
index 39417fa9d..ef3005a1b 100644
--- a/tests/data/selectionEncoding.test.ts
+++ b/tests/data/selectionEncoding.test.ts
@@ -131,7 +131,7 @@ describe('selectionEncoding TS↔WESL parity', () => {
       ['SELECTION_LOCAL_IDX_MASK', SELECTION_LOCAL_IDX_MASK],
       ['SELECTION_NONE_SENTINEL', SELECTION_NONE_SENTINEL],
       ['PICK_SENTINEL_OFFSET', PICK_SENTINEL_OFFSET],
-      // POI category source codes — mirror of TS Source.Cluster /
+      // Structure category source codes — mirror of TS Source.Cluster /
       // Source.Supercluster / Source.Void / Source.Group. These appear
       // at the WESL side so the future structure-marker pick fragment can
       // refer to them by name instead of inlining a magic 5u/6u/7u/15u
diff --git a/tests/data/sources.test.ts b/tests/data/sources.test.ts
index 19e192596..20956cb60 100644
--- a/tests/data/sources.test.ts
+++ b/tests/data/sources.test.ts
@@ -68,16 +68,16 @@ describe('SOURCE_REGISTRY ids', () => {
   });
 });
 
-describe('Source enum — POI codes (cluster/supercluster/void)', () => {
+describe('Source enum — structure codes (cluster/supercluster/void)', () => {
   it('appends Cluster=5, Supercluster=6, Void=7 to the enum', () => {
     expect(Source.Cluster).toBe(5);
     expect(Source.Supercluster).toBe(6);
     expect(Source.Void).toBe(7);
   });
 
-  it('keeps POI codes OUT of SURVEY_SOURCES (POIs are not survey sources)', () => {
-    // The points-pipeline visibility bitmask iterates SURVEY_SOURCES. POIs
-    // render through their own renderer (future structureMarkerRenderer)
+  it('keeps structure codes OUT of SURVEY_SOURCES (structures are not survey sources)', () => {
+    // The points-pipeline visibility bitmask iterates SURVEY_SOURCES. Structures
+    // render through their own renderer (structureMarkerRenderer)
     // with its own per-category visibility logic, so listing them here
     // would muddy the meaning of "this bitmask filters survey galaxies."
     expect(SURVEY_SOURCES).not.toContain(Source.Cluster);
@@ -85,10 +85,10 @@ describe('Source enum — POI codes (cluster/supercluster/void)', () => {
     expect(SURVEY_SOURCES).not.toContain(Source.Void);
   });
 
-  it('ALL_VISIBLE_MASK covers default-visible survey sources only (no POI bits)', () => {
+  it('ALL_VISIBLE_MASK covers default-visible survey sources only (no structure bits)', () => {
     // Default-visible survey bits: 0 (Synthetic), 1 (SDSS), 2 (2MRS),
     // 3 (Glade), 4 (Famous), 8 (Milliquas) = 0b100011111.  Milliquas ships
-    // on by default now that the quasar source is stable.  POI codes 5/6/7
+    // on by default now that the quasar source is stable.  Structure codes 5/6/7
     // stay clear so the survey draw loop doesn't accidentally gate on them.
     expect(ALL_VISIBLE_MASK).toBe(0b100011111);
     expect(maskHas(ALL_VISIBLE_MASK, Source.Milliquas)).toBe(true);
@@ -105,6 +105,42 @@ describe('Source enum — POI codes (cluster/supercluster/void)', () => {
   });
 });
 
+describe('Registry capability flags — bearsLabel / bearsMarker', () => {
+  it('famousGalaxy row bears a label but no marker', () => {
+    const entry = SOURCE_REGISTRY[Source.FamousGalaxy];
+    expect(entry.bearsLabel).toBe(true);
+    expect(entry.bearsMarker).toBe(false);
+    expect(entry.labelLayer).toBe('galaxyNames');
+  });
+
+  it('famousGalaxy category copy is detail "Famous Galaxy" / short "Galaxy" / plural "Famous Galaxies"', () => {
+    const entry = SOURCE_REGISTRY[Source.FamousGalaxy];
+    expect(entry.detailLabel).toBe('Famous Galaxy');
+    expect(entry.shortLabel).toBe('Galaxy');
+    expect(entry.plural).toBe('Famous Galaxies');
+  });
+
+  it('structure rows bear both a label and a marker', () => {
+    // The four structure source ids — verified correct in STRUCTURE_CATEGORIES test above.
+    const structureIds = [Source.Cluster, Source.Supercluster, Source.Void, Source.Group] as const;
+    for (const id of structureIds) {
+      const entry = SOURCE_REGISTRY[id];
+      expect(entry.bearsLabel).toBe(true);
+      expect(entry.bearsMarker).toBe(true);
+      expect(entry.labelLayer).toBe('structure');
+    }
+  });
+
+  it('bulk survey rows bear neither a label nor a marker', () => {
+    const surveyIds = [Source.SDSS, Source.Glade] as const;
+    for (const id of surveyIds) {
+      const entry = SOURCE_REGISTRY[id];
+      expect(entry.bearsLabel).toBe(false);
+      expect(entry.bearsMarker).toBe(false);
+    }
+  });
+});
+
 describe('Famous-galaxy hi-res LOD constants', () => {
   it('HI_RES_LAYER_SIDE_BY_TIER pegs small to 512 and medium/large to 1024', () => {
     // Mobile (small) halves the layer dim to keep the GPU footprint at
diff --git a/tests/data/poiCategories.test.ts b/tests/data/structureMarkerStyles.test.ts
similarity index 67%
rename from tests/data/poiCategories.test.ts
rename to tests/data/structureMarkerStyles.test.ts
index 50872efac..e207be1db 100644
--- a/tests/data/poiCategories.test.ts
+++ b/tests/data/structureMarkerStyles.test.ts
@@ -1,17 +1,17 @@
 import { describe, expect, it } from 'vitest';
-import { STRUCTURE_POI_STYLES } from '../../src/services/engine/presentation/structurePoiStyles';
+import { STRUCTURE_MARKER_STYLES } from '../../src/services/engine/presentation/structureMarkerStyles';
 import { FAMOUS_LABEL_STYLE } from '../../src/services/engine/presentation/famousLabelStyle';
-import type { PoiCategory } from '../../src/@types/engine/data/PoiCategory';
+import type { LabelCategory } from '../../src/@types/engine/data/LabelCategory';
 
-describe('POI category styles (split into structure + famous tables)', () => {
-  it('STRUCTURE_POI_STYLES exposes the four structure category keys', () => {
-    expect(Object.keys(STRUCTURE_POI_STYLES).sort()).toEqual(
+describe('structure marker styles (per-category ring/halo/label style table)', () => {
+  it('STRUCTURE_MARKER_STYLES exposes the four structure category keys', () => {
+    expect(Object.keys(STRUCTURE_MARKER_STYLES).sort()).toEqual(
       ['cluster', 'supercluster', 'void', 'group'].sort(),
     );
   });
 
   it('every structure style entry has the required fields', () => {
-    for (const [key, style] of Object.entries(STRUCTURE_POI_STYLES)) {
+    for (const [key, style] of Object.entries(STRUCTURE_MARKER_STYLES)) {
       expect(style.labelColor, `${key}.labelColor`).toHaveLength(4);
       expect(style.minPixelSize, `${key}.minPixelSize`).toBeGreaterThan(0);
       expect(style.maxPixelSize, `${key}.maxPixelSize`).toBeGreaterThan(style.minPixelSize);
@@ -33,12 +33,12 @@ describe('POI category styles (split into structure + famous tables)', () => {
     expect(FAMOUS_LABEL_STYLE.fadeBandPx).toBeGreaterThan(0);
   });
 
-  it('PoiCategory is the five-category union (compile-time check)', () => {
-    const c1: PoiCategory = 'cluster';
-    const c2: PoiCategory = 'supercluster';
-    const c3: PoiCategory = 'famousGalaxy';
-    const c4: PoiCategory = 'void';
-    const c5: PoiCategory = 'group';
+  it('LabelCategory is the five-category union (compile-time check)', () => {
+    const c1: LabelCategory = 'cluster';
+    const c2: LabelCategory = 'supercluster';
+    const c3: LabelCategory = 'famousGalaxy';
+    const c4: LabelCategory = 'void';
+    const c5: LabelCategory = 'group';
     expect([c1, c2, c3, c4, c5]).toEqual([
       'cluster',
       'supercluster',
diff --git a/tests/data/tierTargets.test.ts b/tests/data/tierTargets.test.ts
index ec12cf432..2676473aa 100644
--- a/tests/data/tierTargets.test.ts
+++ b/tests/data/tierTargets.test.ts
@@ -38,7 +38,7 @@ describe('tierTarget', () => {
     expect(tierTarget(Source.Milliquas, 'large')).toBeUndefined();
   });
 
-  it('returns undefined for non-survey sources (POIs cannot be subsampled)', () => {
+  it('returns undefined for non-survey sources (structures cannot be subsampled)', () => {
     expect(tierTarget(Source.Cluster, 'medium')).toBeUndefined();
     expect(tierTarget(Source.Supercluster, 'small')).toBeUndefined();
     expect(tierTarget(Source.Void, 'large')).toBeUndefined();
diff --git a/tests/hooks/useUrlSync.test.ts b/tests/hooks/useUrlSync.test.ts
index afff38ddf..13397ae46 100644
--- a/tests/hooks/useUrlSync.test.ts
+++ b/tests/hooks/useUrlSync.test.ts
@@ -6,8 +6,8 @@
  * directly — `computeDesiredHash` and `initialPendingFromHash` — and rely
  * on manual smoke testing for the effect plumbing.
  *
- * `focused` is a FocusableTarget union (galaxy | POI | null); the body
- * shape is decided by isPoi() inside the helper.
+ * `focused` is a FocusableTarget union (galaxy | structure | null); the
+ * body shape is decided by isStructure() inside the helper.
  */
 import { describe, it, expect } from 'vitest';
 import { computeDesiredHash, initialPendingFromHash } from '../../src/hooks/useUrlSync';
@@ -22,7 +22,7 @@ function makeGalaxy(): GalaxyInfo {
   } as unknown as GalaxyInfo;
 }
 
-function makePoi(id: string): StructureRecord {
+function makeStructure(id: string): StructureRecord {
   return {
     id,
     name: id,
@@ -46,19 +46,19 @@ describe('computeDesiredHash (unified)', () => {
     expect(out.matches).toBe(false);
   });
 
-  it('returns poi=<id> when focused is a POI', () => {
+  it('writes focus=<id> when focused is a structure', () => {
     const out = computeDesiredHash({
-      focused: makePoi('virgo-cluster'),
+      focused: makeStructure('cluster-virgo-m87'),
       currentHash: '',
     });
-    expect(out.desiredHashBody).toBe('poi=virgo-cluster');
+    expect(out.desiredHashBody).toBe('focus=cluster-virgo-m87');
     expect(out.matches).toBe(false);
   });
 
-  it('short-circuits when currentHash already matches a poi body', () => {
+  it('short-circuits when currentHash already matches a structure body', () => {
     const out = computeDesiredHash({
-      focused: makePoi('virgo-cluster'),
-      currentHash: '#poi=virgo-cluster',
+      focused: makeStructure('cluster-virgo-m87'),
+      currentHash: '#focus=cluster-virgo-m87',
     });
     expect(out.matches).toBe(true);
   });
@@ -78,10 +78,10 @@ describe('initialPendingFromHash', () => {
     if (out.kind === 'galaxy') expect(out.target).not.toBeNull();
   });
 
-  it('parses #poi=… into a poi pending id', () => {
-    const out = initialPendingFromHash('#poi=virgo-cluster');
-    expect(out.kind).toBe('poi');
-    if (out.kind === 'poi') expect(out.poiId).toBe('virgo-cluster');
+  it('routes #focus=cluster-virgo-m87 to kind structure with the id', () => {
+    const out = initialPendingFromHash('#focus=cluster-virgo-m87');
+    expect(out.kind).toBe('structure');
+    if (out.kind === 'structure') expect(out.id).toBe('cluster-virgo-m87');
   });
 
   it('returns kind=null for an empty hash', () => {
diff --git a/tests/services/animation/fadeRegistry.test.ts b/tests/services/animation/fadeRegistry.test.ts
index 7178196b0..d1707b0fa 100644
--- a/tests/services/animation/fadeRegistry.test.ts
+++ b/tests/services/animation/fadeRegistry.test.ts
@@ -135,8 +135,8 @@ describe('createFadeRegistry', () => {
 
   it('serializeFadeHandle keeps a category-less labelLayer distinct from a per-category one', () => {
     const r = createFadeRegistry();
-    const bare: FadeHandle = { kind: 'labelLayer', layer: 'poi' };
-    const perCategory: FadeHandle = { kind: 'labelLayer', layer: 'poi', category: 'cluster' };
+    const bare: FadeHandle = { kind: 'labelLayer', layer: 'structure' };
+    const perCategory: FadeHandle = { kind: 'labelLayer', layer: 'structure', category: 'cluster' };
     r.register(bare, 0);
     r.register(perCategory, 0);
     r.fadeTo(bare, 0.2, 0, 0);
diff --git a/tests/services/biasCorrection/surveyConstants.test.ts b/tests/services/biasCorrection/surveyConstants.test.ts
index d0cda47f5..33610ac68 100644
--- a/tests/services/biasCorrection/surveyConstants.test.ts
+++ b/tests/services/biasCorrection/surveyConstants.test.ts
@@ -20,7 +20,7 @@ import type { SurveySource } from '../../../src/@types/data/SurveySource';
 // Reverse-lookup name from a Source value.  TS's old numeric enum
 // auto-generated this map; the `as const` replacement does not, so we
 // derive it locally for the test labels below. Keyed by `SurveySource`
-// — POI codes (Cluster/Supercluster/Void) have no flux limit or
+// — structure codes (Cluster/Supercluster/Void) have no flux limit or
 // Schechter triple, so this test never iterates them.
 const SOURCE_NAME: Record<SurveySource, string> = {
   [Source.Synthetic]: 'Synthetic',
diff --git a/tests/services/engine/helpers/commitFocus.test.ts b/tests/services/engine/helpers/commitFocus.test.ts
index 4fd25102d..091379d39 100644
--- a/tests/services/engine/helpers/commitFocus.test.ts
+++ b/tests/services/engine/helpers/commitFocus.test.ts
@@ -1,7 +1,7 @@
 /**
  * commitFocus — verifies the union-dispatching entry point routes
  * GalaxyInfo through commitGalaxyFocus and StructureRecord through
- * commitStructureFocus, using the isPoi predicate.
+ * commitStructureFocus, using the isStructure predicate.
  *
  * Mocks both underlying commit helpers and asserts the right one was
  * called. Deeper coverage lives in commitGalaxyFocus.test.ts /
@@ -28,7 +28,7 @@ import { commitFocus } from '../../../../src/services/engine/helpers/commitFocus
 function makeFixtures() {
   const state = {} as unknown as EngineState;
   const galaxy = { index: 0, x: 0, y: 0, z: 0 } as unknown as GalaxyInfo;
-  const poi: StructureRecord = {
+  const structure: StructureRecord = {
     id: 'virgo-cluster',
     name: 'Virgo Cluster',
     category: 'cluster',
@@ -36,7 +36,7 @@ function makeFixtures() {
     featured: true,
     physicalRadiusMpc: 2,
   };
-  return { state, galaxy, poi };
+  return { state, galaxy, structure };
 }
 
 describe('commitFocus', () => {
@@ -53,9 +53,9 @@ describe('commitFocus', () => {
   });
 
   it('routes a StructureRecord through commitStructureFocus', () => {
-    const { state, poi } = makeFixtures();
-    commitFocus(state, poi);
-    expect(commitStructureFocusSpy).toHaveBeenCalledWith(state, poi);
+    const { state, structure } = makeFixtures();
+    commitFocus(state, structure);
+    expect(commitStructureFocusSpy).toHaveBeenCalledWith(state, structure);
     expect(commitGalaxyFocusSpy).not.toHaveBeenCalled();
   });
 });
diff --git a/tests/services/engine/helpers/commitGalaxyFocus.test.ts b/tests/services/engine/helpers/commitGalaxyFocus.test.ts
index 5e99744be..1424db56c 100644
--- a/tests/services/engine/helpers/commitGalaxyFocus.test.ts
+++ b/tests/services/engine/helpers/commitGalaxyFocus.test.ts
@@ -68,7 +68,7 @@ describe('commitGalaxyFocus', () => {
 
   it('latches the focus slot so a galaxy focus supersedes a prior cluster focus', () => {
     // Focusing a galaxy must set the focus slot to the galaxy variant —
-    // runFrame resolves that to a null POI, collapsing any active
+    // runFrame resolves that to a null structure, collapsing any active
     // cluster-focus fade.  Leaving the slot on a stale cluster would
     // keep the structure faded after flying to a member galaxy.
     const { state, info, setFocused } = makeFixtures();
diff --git a/tests/services/engine/helpers/resolvePoiFromPick.test.ts b/tests/services/engine/helpers/resolveStructureFromPick.test.ts
similarity index 61%
rename from tests/services/engine/helpers/resolvePoiFromPick.test.ts
rename to tests/services/engine/helpers/resolveStructureFromPick.test.ts
index b5b97212a..e38912f51 100644
--- a/tests/services/engine/helpers/resolvePoiFromPick.test.ts
+++ b/tests/services/engine/helpers/resolveStructureFromPick.test.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 
-import { resolvePoiFromPick } from '../../../../src/services/engine/helpers/resolvePoiFromPick';
+import { resolveStructureFromPick } from '../../../../src/services/engine/helpers/resolveStructureFromPick';
 import type { StructureRecord } from '../../../../src/@types/engine/data/StructureRecord';
 import type { StructureCategory } from '../../../../src/@types/engine/data/StructureCategory';
 
@@ -31,7 +31,7 @@ const bootes: StructureRecord = {
   physicalRadiusMpc: 50,
 };
 
-// Minimal store stub mirroring the helper's `StoreForPickResolve` projection.
+// Minimal store stub mirroring the helper's `PickStructureStore` projection.
 // Only `byCategory` is needed.  We branch on the category so each test can
 // verify the helper indexes the RIGHT per-category bucket.
 const structures = {
@@ -42,32 +42,36 @@ const structures = {
   },
 };
 
-describe('resolvePoiFromPick', () => {
+describe('resolveStructureFromPick', () => {
   it('resolves the 0th cluster index to the first record', () => {
-    expect(resolvePoiFromPick(structures, { category: 'cluster', poiIndex: 0 })).toBe(virgo);
+    expect(resolveStructureFromPick(structures, { category: 'cluster', structureIndex: 0 })).toBe(
+      virgo,
+    );
   });
 
   it('resolves the 1st cluster index to the second record', () => {
-    expect(resolvePoiFromPick(structures, { category: 'cluster', poiIndex: 1 })).toBe(coma);
+    expect(resolveStructureFromPick(structures, { category: 'cluster', structureIndex: 1 })).toBe(
+      coma,
+    );
   });
 
   it('resolves a void index independently of the cluster bucket', () => {
-    // The per-category-local indexing invariant: a `poiIndex` of 0
+    // The per-category-local indexing invariant: a `structureIndex` of 0
     // means "the 0th of THIS category", not "the 0th globally".
-    expect(resolvePoiFromPick(structures, { category: 'void', poiIndex: 0 })).toBe(bootes);
+    expect(resolveStructureFromPick(structures, { category: 'void', structureIndex: 0 })).toBe(
+      bootes,
+    );
   });
 
   it('returns null for out-of-bounds indices', () => {
-    expect(resolvePoiFromPick(structures, { category: 'cluster', poiIndex: 99 })).toBe(null);
+    expect(resolveStructureFromPick(structures, { category: 'cluster', structureIndex: 99 })).toBe(
+      null,
+    );
   });
 
   it('returns null for a category with no entries', () => {
-    expect(resolvePoiFromPick(structures, { category: 'supercluster', poiIndex: 0 })).toBe(null);
-  });
-
-  it('returns null for a famousGalaxy category (rings are structure-only)', () => {
-    // famousGalaxy can never come from a ring pick; the guard returns null
-    // rather than indexing the structure store.
-    expect(resolvePoiFromPick(structures, { category: 'famousGalaxy', poiIndex: 0 })).toBe(null);
+    expect(
+      resolveStructureFromPick(structures, { category: 'supercluster', structureIndex: 0 }),
+    ).toBe(null);
   });
 });
diff --git a/tests/services/engine/isPoi.test.ts b/tests/services/engine/isStructure.test.ts
similarity index 75%
rename from tests/services/engine/isPoi.test.ts
rename to tests/services/engine/isStructure.test.ts
index 147335173..f843dd8a7 100644
--- a/tests/services/engine/isPoi.test.ts
+++ b/tests/services/engine/isStructure.test.ts
@@ -1,21 +1,21 @@
 /**
- * isPoi — type predicate distinguishing StructureRecord from GalaxyInfo
+ * isStructure — type predicate distinguishing StructureRecord from GalaxyInfo
  * inside a FocusableTarget union.
  *
  * The discriminant is the top-level `category` field, which StructureRecord
  * carries but GalaxyInfo doesn't.  GalaxyInfo *does* have a nested
  * `galaxyType.category`, but the predicate checks the top-level key only —
- * structural type-checking would otherwise widen GalaxyInfo into the POI
+ * structural type-checking would otherwise widen GalaxyInfo into the structure
  * branch and break the dispatcher.
  */
 import { describe, it, expect } from 'vitest';
-import { isPoi } from '../../../src/services/engine/isPoi';
+import { isStructure } from '../../../src/services/engine/isStructure';
 import type { GalaxyInfo } from '../../../src/@types/engine/GalaxyInfo';
 import type { StructureRecord } from '../../../src/@types/engine/data/StructureRecord';
 
-describe('isPoi', () => {
+describe('isStructure', () => {
   it('returns true for a StructureRecord', () => {
-    const poi: StructureRecord = {
+    const structure: StructureRecord = {
       id: 'virgo-cluster',
       name: 'Virgo Cluster',
       category: 'cluster',
@@ -23,7 +23,7 @@ describe('isPoi', () => {
       featured: true,
       physicalRadiusMpc: 2,
     };
-    expect(isPoi(poi)).toBe(true);
+    expect(isStructure(structure)).toBe(true);
   });
 
   it('returns false for a GalaxyInfo-shaped object (no top-level category)', () => {
@@ -34,6 +34,6 @@ describe('isPoi', () => {
       z: 3,
       galaxyType: { category: 'spiral' },
     } as unknown as GalaxyInfo;
-    expect(isPoi(fakeGalaxy)).toBe(false);
+    expect(isStructure(fakeGalaxy)).toBe(false);
   });
 });
diff --git a/tests/services/engine/phases/structureCatalogToStructures.test.ts b/tests/services/engine/phases/structureCatalogToStructures.test.ts
index 70c0bdab9..99d0162c6 100644
--- a/tests/services/engine/phases/structureCatalogToStructures.test.ts
+++ b/tests/services/engine/phases/structureCatalogToStructures.test.ts
@@ -1,14 +1,14 @@
 /**
  * structureCatalogToStructures — tests for the bulk cluster/supercluster
- * POI producer.
+ * structure producer.
  *
  * The producer turns the decoded `.ccat` + meta sidecar into the
- * non-featured POIs that render through the ring/halo marker pass. Four
+ * non-featured structures that render through the ring/halo marker pass. Four
  * invariants are load-bearing and easy to break:
  *
  *   1. The `category` byte → arm mapping (0 → cluster, 1 → supercluster),
  *      with unknown bytes skipped rather than crashed on.
- *   2. Every bulk POI is `featured: false` — featured gates labels +
+ *   2. Every bulk structure is `featured: false` — featured gates labels +
  *      deep-link eligibility, and a bulk catalog of ~375 structures must
  *      not flood the label layer.
  *   3. Significance normalises PER CATEGORY into [0,1] — clusters
@@ -113,33 +113,33 @@ function mixedPayload(): StructureCatalogPayload {
 
 describe('structureCatalogToStructures', () => {
   it('maps category bytes to cluster/supercluster', () => {
-    const pois = structureCatalogToStructures(mixedPayload());
-    expect(pois.filter((p) => p.category === 'cluster')).toHaveLength(2);
-    expect(pois.filter((p) => p.category === 'supercluster')).toHaveLength(2);
+    const structures = structureCatalogToStructures(mixedPayload());
+    expect(structures.filter((p) => p.category === 'cluster')).toHaveLength(2);
+    expect(structures.filter((p) => p.category === 'supercluster')).toHaveLength(2);
   });
 
-  it('marks every POI not featured', () => {
-    const pois = structureCatalogToStructures(mixedPayload());
-    expect(pois.every((p) => p.featured === false)).toBe(true);
+  it('marks every structure not featured', () => {
+    const structures = structureCatalogToStructures(mixedPayload());
+    expect(structures.every((p) => p.featured === false)).toBe(true);
   });
 
   it('carries worldPos + radii through from the catalog', () => {
-    const pois = structureCatalogToStructures(mixedPayload());
-    const low = pois.find((p) => p.id.includes('low-cluster'))!;
+    const structures = structureCatalogToStructures(mixedPayload());
+    const low = structures.find((p) => p.id.includes('low-cluster'))!;
     expect(low.worldPos).toEqual([1, 2, 3]);
     expect(low.category === 'cluster' && low.physicalRadiusMpc).toBe(1.5);
     expect(low.category === 'cluster' && low.apparentRadiusMpc).toBe(3);
   });
 
   it('normalizes significance per-category into [0,1] on independent scales', () => {
-    const pois = structureCatalogToStructures(mixedPayload());
+    const structures = structureCatalogToStructures(mixedPayload());
     const sig = (idFrag: string) => {
-      const p = pois.find((q) => q.id.includes(idFrag))!;
+      const p = structures.find((q) => q.id.includes(idFrag))!;
       // significance lives on the extended-structure arms.
       return p.category === 'cluster' || p.category === 'supercluster' ? p.significance : undefined;
     };
     // All normalized values within [0,1].
-    for (const p of pois) {
+    for (const p of structures) {
       const s = p.category === 'cluster' || p.category === 'supercluster' ? p.significance : 1;
       expect(s).toBeGreaterThanOrEqual(0);
       expect(s).toBeLessThanOrEqual(1);
@@ -160,23 +160,23 @@ describe('structureCatalogToStructures', () => {
   });
 
   it('ids are prefixed bulk and never collide with featured slugs', () => {
-    const pois = structureCatalogToStructures(mixedPayload());
-    for (const p of pois) {
+    const structures = structureCatalogToStructures(mixedPayload());
+    for (const p of structures) {
       expect(p.id).toMatch(/^(cluster|supercluster)-bulk-/);
     }
   });
 
   it('carries the abell designation from meta onto the cluster arm only', () => {
-    const pois = structureCatalogToStructures(mixedPayload());
-    const high = pois.find((p) => p.id.includes('high-cluster'))!;
+    const structures = structureCatalogToStructures(mixedPayload());
+    const high = structures.find((p) => p.id.includes('high-cluster'))!;
     expect(high.category).toBe('cluster');
     expect(high.category === 'cluster' && high.abell).toBe('A2670');
     // Superclusters never carry abell.
-    const sc = pois.find((p) => p.id.includes('rich-sc'))!;
+    const sc = structures.find((p) => p.id.includes('rich-sc'))!;
     expect('abell' in sc).toBe(false);
   });
 
-  it('carries the meta description through onto every bulk POI', () => {
+  it('carries the meta description through onto every bulk structure', () => {
     const payload = makePayload([
       {
         pos: [0, 0, 0],
@@ -187,8 +187,8 @@ describe('structureCatalogToStructures', () => {
         meta: meta('described-cluster', 'A1', 'X-ray cluster · M500 = 5.0×10¹⁴ M☉ · z = 0.040'),
       },
     ]);
-    const poi = structureCatalogToStructures(payload)[0]!;
-    expect(poi.description).toBe('X-ray cluster · M500 = 5.0×10¹⁴ M☉ · z = 0.040');
+    const structure = structureCatalogToStructures(payload)[0]!;
+    expect(structure.description).toBe('X-ray cluster · M500 = 5.0×10¹⁴ M☉ · z = 0.040');
   });
 
   it('omits abell when the meta entry has null (key absent, not undefined)', () => {
@@ -202,13 +202,13 @@ describe('structureCatalogToStructures', () => {
         meta: meta('no-abell-cluster', null),
       },
     ]);
-    const pois = structureCatalogToStructures(payload);
-    expect('abell' in pois[0]!).toBe(false);
+    const structures = structureCatalogToStructures(payload);
+    expect('abell' in structures[0]!).toBe(false);
   });
 
-  it('names the POI from meta.names[0]', () => {
-    const pois = structureCatalogToStructures(mixedPayload());
-    const high = pois.find((p) => p.id.includes('high-cluster'))!;
+  it('names the structure from meta.names[0]', () => {
+    const structures = structureCatalogToStructures(mixedPayload());
+    const high = structures.find((p) => p.id.includes('high-cluster'))!;
     expect(high.name).toBe('HIGH-CLUSTER');
   });
 
@@ -231,9 +231,9 @@ describe('structureCatalogToStructures', () => {
         meta: meta('reserved'),
       },
     ]);
-    const pois = structureCatalogToStructures(payload);
-    expect(pois).toHaveLength(1);
-    expect(pois[0]!.id).toContain('ok-cluster');
+    const structures = structureCatalogToStructures(payload);
+    expect(structures).toHaveLength(1);
+    expect(structures[0]!.id).toContain('ok-cluster');
   });
 
   it('maps a single-member subset to full weight (no divide-by-zero)', () => {
@@ -248,8 +248,8 @@ describe('structureCatalogToStructures', () => {
         meta: meta('solo-cluster'),
       },
     ]);
-    const pois = structureCatalogToStructures(payload);
-    const p = pois[0]!;
+    const structures = structureCatalogToStructures(payload);
+    const p = structures[0]!;
     expect(p.category === 'cluster' && p.significance).toBeCloseTo(1);
   });
 
diff --git a/tests/services/engine/phases/wireInput.poi.test.ts b/tests/services/engine/phases/wireInput.structure.test.ts
similarity index 82%
rename from tests/services/engine/phases/wireInput.poi.test.ts
rename to tests/services/engine/phases/wireInput.structure.test.ts
index f6a88c8fb..a63f72c0a 100644
--- a/tests/services/engine/phases/wireInput.poi.test.ts
+++ b/tests/services/engine/phases/wireInput.structure.test.ts
@@ -1,14 +1,14 @@
 /**
- * wireInput.poi — structural assertion that the wireInput phase wires
- * POI clicks through the click resolver's `resolvePoi` callback and
- * upgrades the pinned selection to a focus on dblclick.
+ * wireInput.structure — structural assertion that the wireInput phase wires
+ * structure clicks through the click resolver and upgrades the pinned
+ * selection to a focus on dblclick.
  *
  * ### Why a source-string assertion
  *
  * The click flow is hard to unit-test in isolation: it requires a real
  * pickRenderer (GPU device), real orbit controls, and a real mouse
  * device.  This is a crude source-string guard — it regresses loudly if
- * a future refactor drops the `resolvePoi` callback or stops reading the
+ * a future refactor drops the structure-click wiring or stops reading the
  * authoritative selection slot for the dblclick focus. End-to-end
  * behaviour (single-click opens InfoCard, double-click tweens camera) is
  * verified by manual smoke.
@@ -27,7 +27,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const wireInputPath = resolve(__dirname, '../../../../src/services/engine/phases/wireInput.ts');
 
-describe('wireInput POI wiring', () => {
+describe('wireInput structure wiring', () => {
   const src = readFileSync(wireInputPath, 'utf8');
 
   it('passes the structure store to createClickResolver', () => {
@@ -37,7 +37,7 @@ describe('wireInput POI wiring', () => {
   it('reads the authoritative selection slot for the dblclick focus', () => {
     // The dblclick handler resolves the pinned selection to its target via
     // the subsystem rather than caching a resolved copy — the selection
-    // slot is the single source of truth (galaxy OR POI).
+    // slot is the single source of truth (galaxy OR structure).
     expect(src).toContain('selection.selectedTarget()');
   });
 
@@ -49,7 +49,7 @@ describe('wireInput POI wiring', () => {
   });
 
   it('releases focus on an empty-space double-click', () => {
-    // Double-clicking the background (no cached galaxy/POI hit) is the
+    // Double-clicking the background (no cached galaxy/structure hit) is the
     // inverse of double-clicking a structure: it drops the focus slot so
     // the cluster-focus fade lifts and everything returns to full
     // visibility.  Guards against a refactor that turns the empty-space
diff --git a/tests/services/engine/phases/wireInput.test.ts b/tests/services/engine/phases/wireInput.test.ts
index d537a316f..bc51b6ac8 100644
--- a/tests/services/engine/phases/wireInput.test.ts
+++ b/tests/services/engine/phases/wireInput.test.ts
@@ -99,7 +99,7 @@ function makeState(): EngineState {
     },
     picking: { latestMouseCss: null, pointerDown: false } as never,
     // createClickResolver captures the structure store for pickToSelection;
-    // an empty store is enough — these tests don't exercise a POI pick.
+    // an empty store is enough — these tests don't exercise a structure pick.
     data: { structures: { byCategory: () => [] } } as never,
     gpu: {
       renderer: {
diff --git a/tests/services/engine/phases/wireSlots.test.ts b/tests/services/engine/phases/wireSlots.test.ts
index 9a2ee19fd..7e61f8a11 100644
--- a/tests/services/engine/phases/wireSlots.test.ts
+++ b/tests/services/engine/phases/wireSlots.test.ts
@@ -5,7 +5,7 @@
  * `bootstrap.test.ts` mocks this phase at module scope, so the orchestrator's
  * observable effects otherwise have no direct asserts — yet they gate "loading
  * screen ⇒ stars on canvas". The phase's internals (the synthetic-fallback
- * gate, the POI projection, the demand loop) each have their own unit tests
+ * gate, the structure projection, the demand loop) each have their own unit tests
  * (`createSyntheticFallback.test.ts`, `wireStructureProjection.test.ts`,
  * `reevaluateDemand.test.ts` / `demandTable.test.ts`); this file pins that
  * wireSlots composes them into the right boot behaviour:
@@ -513,7 +513,7 @@ describe('wireSlots', () => {
     expect(hasHandle({ kind: 'overlay', id: 'texturedDisks' })).toBe(true);
     expect(hasHandle({ kind: 'volumesMaster' })).toBe(true);
     expect(hasHandle({ kind: 'labelLayer', layer: 'youAreHere' })).toBe(true);
-    // No category-less poi handle: structure labels use per-category poi
+    // No category-less structure handle: structure labels use per-category
     // handles, and produceStructureLabels fires each category's load-in.
     expect(hasHandle({ kind: 'labelLayer', layer: 'galaxyNames' })).toBe(true);
     expect(hasHandle({ kind: 'labelLayer', layer: 'scaleBar' })).toBe(true);
@@ -750,7 +750,7 @@ describe('wireSlots', () => {
 
   it('emits per-category structure counts that grow when the bulk catalog lands', async () => {
     // The Structures panel reads these counts to annotate its toggles.
-    // rebuildAllPois fires onStructureCountsChange on every merge: once at
+    // rebuildAllStructures fires onStructureCountsChange on every merge: once at
     // boot (static anchors only) and again when the bulk .ccat resolves.
     // Asserting the DELTA (one extra cluster + one extra SC, voids
     // unchanged) keeps the test robust to seed-anchor count changes.
diff --git a/tests/services/engine/presentation/focusRecession.test.ts b/tests/services/engine/presentation/focusRecession.test.ts
index 18ed18e43..3e7e24f3b 100644
--- a/tests/services/engine/presentation/focusRecession.test.ts
+++ b/tests/services/engine/presentation/focusRecession.test.ts
@@ -52,8 +52,8 @@ describe('recessionTargetFor', () => {
     expect(recessionTargetFor({ kind: 'volumesMaster' })).toBe(VOLUME_RECESSION);
   });
 
-  it('tags poi and galaxyNames labels but not youAreHere or scaleBar', () => {
-    expect(recessionTargetFor({ kind: 'labelLayer', layer: 'poi' })).toBe(LABEL_RECESSION);
+  it('tags structure and galaxyNames labels but not youAreHere or scaleBar', () => {
+    expect(recessionTargetFor({ kind: 'labelLayer', layer: 'structure' })).toBe(LABEL_RECESSION);
     expect(recessionTargetFor({ kind: 'labelLayer', layer: 'galaxyNames' })).toBe(LABEL_RECESSION);
     expect(recessionTargetFor({ kind: 'labelLayer', layer: 'youAreHere' })).toBeUndefined();
     expect(recessionTargetFor({ kind: 'labelLayer', layer: 'scaleBar' })).toBeUndefined();
diff --git a/tests/services/engine/presentation/produceStructureLabels.test.ts b/tests/services/engine/presentation/produceStructureLabels.test.ts
index 7480a9648..69b389cef 100644
--- a/tests/services/engine/presentation/produceStructureLabels.test.ts
+++ b/tests/services/engine/presentation/produceStructureLabels.test.ts
@@ -35,7 +35,7 @@ function makeState(
   } as unknown as EngineState;
 }
 
-// Register every per-category poi label AND ring marker handle at full opacity.
+// Register every per-category structure label AND ring marker handle at full opacity.
 // The label handle backs the producer's load-in `fadeTo` (which THROWS on an
 // unregistered handle); the marker handle backs the anchor gate, which now reads
 // `opacityOf({markerLayer, category})` so a label fades in lock-step with its
@@ -43,7 +43,7 @@ function makeState(
 // mid-fade value) where they need a disabled / fading category.
 function registerAllCategories(fades: FadeRegistry): void {
   for (const category of STRUCTURE_CATEGORIES) {
-    fades.register({ kind: 'labelLayer', layer: 'poi', category }, 1);
+    fades.register({ kind: 'labelLayer', layer: 'structure', category }, 1);
     fades.register({ kind: 'markerLayer', category }, 1);
   }
 }
@@ -85,11 +85,11 @@ describe('produceStructureLabels', () => {
 
   it('hides labels for a category whose label axis is off', () => {
     // The per-category toggle now lives in the FadeRegistry (not the store's
-    // labelVisible flag): a category whose poi handle reads 0 is skipped
+    // labelVisible flag): a category whose structure handle reads 0 is skipped
     // wholesale.
     const fades = createFadeRegistry();
-    fades.register({ kind: 'labelLayer', layer: 'poi', category: 'cluster' }, 1);
-    fades.setImmediate({ kind: 'labelLayer', layer: 'poi', category: 'cluster' }, 0);
+    fades.register({ kind: 'labelLayer', layer: 'structure', category: 'cluster' }, 1);
+    fades.setImmediate({ kind: 'labelLayer', layer: 'structure', category: 'cluster' }, 0);
     const state = makeState({ fades });
     state.data.structures.setGroup('anchors', [rec('c1', { category: 'cluster' })]);
     expect(produceStructureLabels(state, makeCtx()).labels).toEqual([]);
@@ -100,7 +100,7 @@ describe('produceStructureLabels', () => {
     // handle), not an instant store flag. A category whose ring opacity is
     // exactly 0 carries no label.
     const fades = createFadeRegistry();
-    fades.register({ kind: 'labelLayer', layer: 'poi', category: 'cluster' }, 1);
+    fades.register({ kind: 'labelLayer', layer: 'structure', category: 'cluster' }, 1);
     fades.register({ kind: 'markerLayer', category: 'cluster' }, 1);
     fades.setImmediate({ kind: 'markerLayer', category: 'cluster' }, 0);
     const state = makeState({ fades });
@@ -114,7 +114,7 @@ describe('produceStructureLabels', () => {
     // popping the label while the ring was still visibly fading. Reading the
     // fade handle keeps them in lock-step.
     const fades = createFadeRegistry();
-    fades.register({ kind: 'labelLayer', layer: 'poi', category: 'cluster' }, 1);
+    fades.register({ kind: 'labelLayer', layer: 'structure', category: 'cluster' }, 1);
     fades.register({ kind: 'markerLayer', category: 'cluster' }, 1);
     fades.setImmediate({ kind: 'markerLayer', category: 'cluster' }, 0.5);
     const state = makeState({ fades });
@@ -159,7 +159,7 @@ describe('produceStructureLabels', () => {
     const atRestAlpha = produceStructureLabels(atRest, makeCtx()).labels[0]!.fadeAlpha!;
 
     const fades = createFadeRegistry();
-    fades.register({ kind: 'labelLayer', layer: 'poi', category: 'cluster' }, 0.5);
+    fades.register({ kind: 'labelLayer', layer: 'structure', category: 'cluster' }, 0.5);
     const dimmed = makeState({ fades });
     dimmed.data.structures.setGroup('anchors', [rec('a')]);
     const dimmedAlpha = produceStructureLabels(dimmed, makeCtx()).labels[0]!.fadeAlpha!;
@@ -209,7 +209,7 @@ describe('produceStructureLabels', () => {
 
   it('fires the per-category load-in fade on first emit, dedupes thereafter', () => {
     const fades = createFadeRegistry();
-    fades.register({ kind: 'labelLayer', layer: 'poi', category: 'cluster' }, 1);
+    fades.register({ kind: 'labelLayer', layer: 'structure', category: 'cluster' }, 1);
     const fadeToSpy = vi.spyOn(fades, 'fadeTo');
     const state = makeState({ fades });
     state.data.structures.setGroup('anchors', [rec('a', { category: 'cluster' })]);
@@ -217,7 +217,7 @@ describe('produceStructureLabels', () => {
     produceStructureLabels(state, makeCtx());
     expect(fadeToSpy).toHaveBeenCalledTimes(1);
     expect(fadeToSpy).toHaveBeenCalledWith(
-      { kind: 'labelLayer', layer: 'poi', category: 'cluster' },
+      { kind: 'labelLayer', layer: 'structure', category: 'cluster' },
       1,
       expect.any(Number),
     );
diff --git a/tests/services/engine/setCategoryVisibleFade.test.ts b/tests/services/engine/setCategoryVisibleFade.test.ts
index 6c689d8f3..bb4ae7d3c 100644
--- a/tests/services/engine/setCategoryVisibleFade.test.ts
+++ b/tests/services/engine/setCategoryVisibleFade.test.ts
@@ -10,7 +10,7 @@
  *
  * The contract under test: a category toggle drives the SAME per-category fade
  * handle the producers read (`markerLayer{category}` /
- * `labelLayer{poi,category}` / `labelLayer{galaxyNames}`), so on/off is a smooth
+ * `labelLayer{structure,category}` / `labelLayer{galaxyNames}`), so on/off is a smooth
  * fade instead of a pop. famousGalaxy has no ring marker, so a marker toggle for
  * it fires NO markerLayer fade — but still mirrors settings + requests a render.
  */
@@ -62,7 +62,6 @@ function makeFixture() {
         supercluster: true,
         void: true,
         group: true,
-        famousGalaxy: true,
       },
     },
     subsystems: {
@@ -110,30 +109,18 @@ describe('setCategoryMarkerVisible — fade orchestration', () => {
       },
     ]);
   });
-
-  it('famousGalaxy marker toggle fires NO markerLayer fade (no ring) but still mirrors + requests render', () => {
-    const fx = makeFixture();
-    setCategoryMarkerVisibleForTest(fx.state as never, fx.cb as never, 'famousGalaxy', false);
-
-    // No ring for famous galaxies → no markerLayer fade.
-    expect(fx.fadeCalls).toEqual([]);
-    // Settings mirror + callback + render still happen.
-    expect(fx.state.settings.markerCategoryVisibility.famousGalaxy).toBe(false);
-    expect(fx.cb.labels.onMarkerCategoryVisibilityChange).toHaveBeenCalledTimes(1);
-    expect(fx.state.subsystems.scheduler.requestRender).toHaveBeenCalledTimes(1);
-  });
 });
 
 // ── Label setter ───────────────────────────────────────────────────────────
 
 describe('setCategoryLabelVisible — fade orchestration', () => {
-  it('toggle OFF on a structure category fires fadeTo(labelLayer{poi,cluster}, 0, FADE_OUT)', () => {
+  it('toggle OFF on a structure category fires fadeTo(labelLayer{structure,cluster}, 0, FADE_OUT)', () => {
     const fx = makeFixture();
     setCategoryLabelVisibleForTest(fx.state as never, fx.cb as never, 'cluster', false);
 
     expect(fx.fadeCalls).toEqual([
       {
-        handle: { kind: 'labelLayer', layer: 'poi', category: 'cluster' },
+        handle: { kind: 'labelLayer', layer: 'structure', category: 'cluster' },
         target: 0,
         duration: FADE_OUT_DURATION_MS,
       },
diff --git a/tests/services/engine/subsystems/labelDirectorSubsystem.override.test.ts b/tests/services/engine/subsystems/labelDirectorSubsystem.override.test.ts
index d1e55027c..e30442f84 100644
--- a/tests/services/engine/subsystems/labelDirectorSubsystem.override.test.ts
+++ b/tests/services/engine/subsystems/labelDirectorSubsystem.override.test.ts
@@ -12,7 +12,7 @@ import type { ReadyFrameContext } from '../../../../src/@types/engine/frame/Read
 import type { EngineState } from '../../../../src/@types/engine/state/EngineState';
 
 function makeState(requestRender: () => void = () => {}): EngineState {
-  // The director fires a one-shot 'poi' layer fade on the first non-empty
+  // The director fires a one-shot 'structure' layer fade on the first non-empty
   // flush, so the stub state needs a `fades.fadeTo`.
   return {
     subsystems: { scheduler: { requestRender }, fades: { fadeTo: vi.fn() } },
diff --git a/tests/services/engine/subsystems/labelDirectorSubsystem.test.ts b/tests/services/engine/subsystems/labelDirectorSubsystem.test.ts
index 75a3aed81..d3c92cb93 100644
--- a/tests/services/engine/subsystems/labelDirectorSubsystem.test.ts
+++ b/tests/services/engine/subsystems/labelDirectorSubsystem.test.ts
@@ -210,7 +210,7 @@ describe('labelDirectorSubsystem', () => {
   });
 
   it('no longer fires any layer load-in fade on a non-empty flush', () => {
-    // The per-category poi load-in moved to produceStructureLabels; the
+    // The per-category structure load-in moved to produceStructureLabels; the
     // director must not call fades.fadeTo on its own anymore.
     const dir = createLabelDirectorSubsystem();
     const labelStub = makeLabelStub();
diff --git a/tests/services/engine/subsystems/selectionSubsystem.test.ts b/tests/services/engine/subsystems/selectionSubsystem.test.ts
index 1db6f1757..add067ed4 100644
--- a/tests/services/engine/subsystems/selectionSubsystem.test.ts
+++ b/tests/services/engine/subsystems/selectionSubsystem.test.ts
@@ -2,7 +2,7 @@
  * selectionSubsystem — unit tests for the hover/select façade.
  *
  * Pure JS — no GPU, no DOM, no async.  Drives the subsystem with
- * synthetic clouds + a POI lookup stub and vi-mocked callbacks.
+ * synthetic clouds + a structure lookup stub and vi-mocked callbacks.
  *
  * Coverage:
  *   - Dedup: redundant setHovered / setSelected calls fan out only on
@@ -140,7 +140,7 @@ describe('createSelectionSubsystem — structure variant', () => {
     expect(cb.selection.onHoverChange).toHaveBeenCalledWith(VIRGO);
   });
 
-  it('fires onSelectChange(StructureRecord) when a POI is selected', () => {
+  it('fires onSelectChange(StructureRecord) when a structure is selected', () => {
     const cb = makeCallbacks();
     const sub = makeSub(cb, { structures: [VIRGO] });
 
@@ -149,7 +149,7 @@ describe('createSelectionSubsystem — structure variant', () => {
     expect(cb.selection.onSelectChange).toHaveBeenCalledWith(VIRGO);
   });
 
-  it('fires onChange(null) for an unknown POI id (deep-link race defense)', () => {
+  it('fires onChange(null) for an unknown structure id (deep-link race defense)', () => {
     const cb = makeCallbacks();
     const sub = makeSub(cb, { structures: [VIRGO] });
 
@@ -158,7 +158,7 @@ describe('createSelectionSubsystem — structure variant', () => {
     expect(cb.selection.onSelectChange).toHaveBeenCalledWith(null);
   });
 
-  it('dedupes same-POI sets — fires only on real transitions', () => {
+  it('dedupes same-structure sets — fires only on real transitions', () => {
     const cb = makeCallbacks();
     const sub = makeSub(cb, { structures: [VIRGO, FORNAX] });
 
@@ -175,7 +175,7 @@ describe('createSelectionSubsystem — selectedTarget', () => {
     expect(makeSub(makeCallbacks()).selectedTarget()).toBeNull();
   });
 
-  it('resolves a pinned POI selection to its StructureRecord', () => {
+  it('resolves a pinned structure selection to its StructureRecord', () => {
     const sub = makeSub(makeCallbacks(), { structures: [VIRGO] });
     sub.setSelected({ kind: 'structure', id: 'virgo' });
     expect(sub.selectedTarget()).toBe(VIRGO);
@@ -197,7 +197,7 @@ describe('createSelectionSubsystem — selectedTarget', () => {
 });
 
 describe('createSelectionSubsystem — cross-kind transitions', () => {
-  it('galaxy → POI selection fires onSelectChange once with the POI', () => {
+  it('galaxy → structure selection fires onSelectChange once with the structure', () => {
     const cb = makeCallbacks();
     const sub = makeSub(cb, { cloud: makeCloud(10), structures: [VIRGO] });
 
@@ -209,7 +209,7 @@ describe('createSelectionSubsystem — cross-kind transitions', () => {
     expect(cb.selection.onSelectChange).toHaveBeenLastCalledWith(VIRGO);
   });
 
-  it('POI → galaxy hover fires onHoverChange with the GalaxyInfo path', () => {
+  it('structure → galaxy hover fires onHoverChange with the GalaxyInfo path', () => {
     const cb = makeCallbacks();
     const cloud = makeCloud(10);
     const sub = makeSub(cb, { cloud, structures: [VIRGO] });
diff --git a/tests/services/engine/subsystems/structureFocusSubsystem.test.ts b/tests/services/engine/subsystems/structureFocusSubsystem.test.ts
index 70de93f53..1b0d998c2 100644
--- a/tests/services/engine/subsystems/structureFocusSubsystem.test.ts
+++ b/tests/services/engine/subsystems/structureFocusSubsystem.test.ts
@@ -25,7 +25,7 @@ describe('structureFocusSubsystem', () => {
     expect(sub.isAwake(0)).toBe(false);
   });
 
-  it('update with a cluster POI fades blend 0→1 with correct center/radii', () => {
+  it('update with a cluster structure fades blend 0→1 with correct center/radii', () => {
     const sub = createStructureFocusSubsystem(0);
     sub.update(makeCluster({ worldPos: [3, 4, 5], physicalRadiusMpc: 7 }), 0);
     const mid = sub.produceFocusUniforms(200);
@@ -47,7 +47,7 @@ describe('structureFocusSubsystem', () => {
     expect(settled.physicalRadiusMpc).toBe(2);
   });
 
-  it('update with a void POI focuses it exactly like a cluster (no inversion)', () => {
+  it('update with a void structure focuses it exactly like a cluster (no inversion)', () => {
     // Voids share the cluster rule: galaxies inside the void's radius are
     // members (stay bright), everything else fades.  The uniform carries
     // no per-category bit — just center + the two radii + blend.
@@ -73,18 +73,18 @@ describe('structureFocusSubsystem', () => {
     expect(sub.produceFocusUniforms(900).blend).toBe(0);
   });
 
-  it('update with the same POI id is idempotent across frames (no re-fade restart)', () => {
+  it('update with the same structure id is idempotent across frames (no re-fade restart)', () => {
     const sub = createStructureFocusSubsystem(0);
-    const poi = makeCluster();
-    sub.update(poi, 0);
+    const structure = makeCluster();
+    sub.update(structure, 0);
     sub.produceFocusUniforms(100); // mid fade-in
     // Same selection re-observed each frame must not reset the ramp.
-    sub.update(poi, 100);
-    sub.update(poi, 200);
+    sub.update(structure, 100);
+    sub.update(structure, 200);
     expect(sub.produceFocusUniforms(500).blend).toBe(1);
   });
 
-  it('replacing the focused POI does not pass through blend 0', () => {
+  it('replacing the focused structure does not pass through blend 0', () => {
     const sub = createStructureFocusSubsystem(0);
     sub.update(makeCluster({ id: 'virgo', worldPos: [10, 0, 0] }), 0);
     sub.produceFocusUniforms(500); // settle at 1
diff --git a/tests/services/engine/wiring/assetWiring.test.ts b/tests/services/engine/wiring/assetWiring.test.ts
index df6a4387d..1d7d21a81 100644
--- a/tests/services/engine/wiring/assetWiring.test.ts
+++ b/tests/services/engine/wiring/assetWiring.test.ts
@@ -78,7 +78,7 @@ describe('ASSET_WIRING membership', () => {
     expect(keys.length).toBe(expected.length);
   });
 
-  it('does NOT include the non-fetched POI sources (Cluster/Supercluster/Void)', () => {
+  it('does NOT include the non-fetched structure sources (Cluster/Supercluster/Void)', () => {
     const keys = new Set<AssetKey>(ASSET_WIRING.map((r) => r.key));
     expect(keys.has(Source.Cluster)).toBe(false);
     expect(keys.has(Source.Supercluster)).toBe(false);
diff --git a/tests/services/engine/wiring/registerOverlayFades.test.ts b/tests/services/engine/wiring/registerOverlayFades.test.ts
index 85c3c9d41..f6257070c 100644
--- a/tests/services/engine/wiring/registerOverlayFades.test.ts
+++ b/tests/services/engine/wiring/registerOverlayFades.test.ts
@@ -14,7 +14,7 @@
  *      so a default-off session sits at 0 until toggled, and a default-on
  *      session starts drawing volumes from the first frame.
  *
- *   3. The four label-layer handles (youAreHere, poi, galaxyNames, scaleBar)
+ *   3. The four label-layer handles (youAreHere, structure, galaxyNames, scaleBar)
  *      are registered with the correct initial opacities: the first three at
  *      0 (their producers fire fadeTo(1) on first non-empty emit), scaleBar
  *      at 1 (React-side, tour-addressable but never auto-faded by the engine).
@@ -175,15 +175,15 @@ describe('registerOverlayFades', () => {
     // reuse that handle and consume its opacity, so a 0 would make them
     // invisible (Task 2.4).  scaleBar is React-side and tour-addressable but
     // never auto-faded by the engine, so it starts at 1.  There is no
-    // category-less poi handle — structure labels use the per-category poi
-    // handles and produceStructureLabels fires each category's load-in.
+    // category-less structure handle — structure labels use the per-category
+    // structure handles and produceStructureLabels fires each category's load-in.
     const { state, registerSpy } = makeState();
     registerOverlayFades(state);
 
     type LabelCall = [Extract<FadeHandle, { kind: 'labelLayer' }>, number | undefined];
-    // Filter to category-LESS label handles only: there are multiple poi
+    // Filter to category-LESS label handles only: there are multiple structure
     // labelLayer registrations (one per structure category), so collapsing by
-    // `layer` alone would be ambiguous for poi.  The category-less handles are
+    // `layer` alone would be ambiguous for structure.  The category-less handles are
     // exactly youAreHere/galaxyNames/scaleBar.
     const labelCalls = calls(registerSpy).filter(
       ([h]) =>
@@ -192,7 +192,7 @@ describe('registerOverlayFades', () => {
     const byLayer = Object.fromEntries(labelCalls.map(([h, op]) => [h.layer, op]));
 
     expect(byLayer['youAreHere']).toBe(0);
-    expect(byLayer['poi']).toBeUndefined();
+    expect(byLayer['structure']).toBeUndefined();
     expect(byLayer['galaxyNames']).toBe(1);
     expect(byLayer['scaleBar']).toBe(1);
   });
@@ -213,7 +213,7 @@ describe('registerOverlayFades', () => {
     expect(galaxyNamesCall![1]).toBe(1);
   });
 
-  // ── per-category marker + poi-label handles ──────────────────────
+  // ── per-category marker + structure-label handles ──────────────────────
 
   it('registers a markerLayer handle per structure category', () => {
     // Each structure category gets its own markerLayer fade controller so its
@@ -231,8 +231,8 @@ describe('registerOverlayFades', () => {
     }
   });
 
-  it('registers a per-category poi labelLayer handle per structure category', () => {
-    // Each structure category gets its own poi labelLayer controller so its
+  it('registers a per-category structure labelLayer handle per structure category', () => {
+    // Each structure category gets its own structure labelLayer controller so its
     // labels are addressable independently (Task 2.3 wires the producer).
     const { state, registerSpy } = makeState();
     registerOverlayFades(state);
@@ -241,10 +241,10 @@ describe('registerOverlayFades', () => {
       const labelCall = calls(registerSpy).find(
         ([h]) =>
           h.kind === 'labelLayer' &&
-          (h as Extract<FadeHandle, { kind: 'labelLayer' }>).layer === 'poi' &&
+          (h as Extract<FadeHandle, { kind: 'labelLayer' }>).layer === 'structure' &&
           (h as Extract<FadeHandle, { kind: 'labelLayer' }>).category === category,
       );
-      expect(labelCall, `labelLayer{poi,${category}} should be registered`).toBeDefined();
+      expect(labelCall, `labelLayer{structure,${category}} should be registered`).toBeDefined();
     }
   });
 
@@ -268,7 +268,7 @@ describe('registerOverlayFades', () => {
       calls(registerSpy).find(
         ([h]) =>
           h.kind === 'labelLayer' &&
-          (h as Extract<FadeHandle, { kind: 'labelLayer' }>).layer === 'poi' &&
+          (h as Extract<FadeHandle, { kind: 'labelLayer' }>).layer === 'structure' &&
           (h as Extract<FadeHandle, { kind: 'labelLayer' }>).category === category,
       )?.[1];
 
diff --git a/tests/services/engine/wiring/seedSettingsCallbacks.test.ts b/tests/services/engine/wiring/seedSettingsCallbacks.test.ts
index 8479f0dab..6ab8f613b 100644
--- a/tests/services/engine/wiring/seedSettingsCallbacks.test.ts
+++ b/tests/services/engine/wiring/seedSettingsCallbacks.test.ts
@@ -47,7 +47,6 @@ function makeSnapshot(): SettingsCallbackSeed {
     markerCategoryVisibility: {
       cluster: true,
       supercluster: true,
-      famousGalaxy: true,
       void: true,
       group: true,
     },
diff --git a/tests/services/engine/wiring/settingsTable.test.ts b/tests/services/engine/wiring/settingsTable.test.ts
index a1946bcd1..d78df97f2 100644
--- a/tests/services/engine/wiring/settingsTable.test.ts
+++ b/tests/services/engine/wiring/settingsTable.test.ts
@@ -82,7 +82,6 @@ function makeState(): Pick<EngineState, 'settings' | 'bias'> {
       markerCategoryVisibility: {
         cluster: true,
         supercluster: true,
-        famousGalaxy: true,
         void: true,
         group: true,
       },
diff --git a/tests/services/gpu/renderers/pickRenderer.poi.test.ts b/tests/services/gpu/renderers/pickRenderer.structure.test.ts
similarity index 91%
rename from tests/services/gpu/renderers/pickRenderer.poi.test.ts
rename to tests/services/gpu/renderers/pickRenderer.structure.test.ts
index f05bcb7ff..f2d5dd07a 100644
--- a/tests/services/gpu/renderers/pickRenderer.poi.test.ts
+++ b/tests/services/gpu/renderers/pickRenderer.structure.test.ts
@@ -1,5 +1,5 @@
 /**
- * pickRenderer.poi.test — type-level contract that `createPickRenderer`
+ * pickRenderer.structure.test — type-level contract that `createPickRenderer`
  * keeps `structureMarkerRenderer` as its OPTIONAL tail positional argument
  * (the 7th, index 6, after the required `focusBgl` at index 4 and the
  * required shared `focusBindGroup` at index 5).
@@ -15,7 +15,7 @@
 import { describe, it, expect } from 'vitest';
 import { createPickRenderer } from '../../../../src/services/gpu/renderers/pickRenderer';
 
-describe('createPickRenderer POI integration', () => {
+describe('createPickRenderer structure integration', () => {
   it('keeps structureMarkerRenderer optional as the 7th positional', () => {
     // Compile-time check: the 7th parameter must exist and must be
     // assignable from `undefined` (i.e. declared with `?`).  If a
diff --git a/tests/services/gpu/renderers/structureMarkerRenderer.pick.test.ts b/tests/services/gpu/renderers/structureMarkerRenderer.pick.test.ts
index 4cd96cecf..282597ff0 100644
--- a/tests/services/gpu/renderers/structureMarkerRenderer.pick.test.ts
+++ b/tests/services/gpu/renderers/structureMarkerRenderer.pick.test.ts
@@ -24,7 +24,7 @@ describe('StructureMarkerRenderer pick API', () => {
   });
 
   it('StructureMarkerDescriptor accepts category group (type gate)', () => {
-    // Compile-time guard: ensures `'group'` is a valid PoiCategory on
+    // Compile-time guard: ensures `'group'` is a valid StructureCategory on
     // StructureMarkerDescriptor so group descriptors can reach pickRing.
     // If the category union loses 'group' this assignment is a type error.
     const d: StructureMarkerDescriptor = {
diff --git a/tests/services/gpu/renderers/structureMarkerRenderer.test.ts b/tests/services/gpu/renderers/structureMarkerRenderer.test.ts
index 412bd25ab..e2b877b2a 100644
--- a/tests/services/gpu/renderers/structureMarkerRenderer.test.ts
+++ b/tests/services/gpu/renderers/structureMarkerRenderer.test.ts
@@ -70,7 +70,7 @@ describe('StructureMarkerRenderer (CPU state)', () => {
   });
 
   it('grows past the initial capacity instead of truncating', () => {
-    // Regression: a fixed cap dropped descriptors in `pois` order, so
+    // Regression: a fixed cap dropped descriptors in insertion order, so
     // clusters saturated the buffer and superclusters/voids never packed
     // (visible only when clusters were toggled off).  The buffer must
     // grow to hold the full set.
diff --git a/tests/services/gpu/shaders/structureMarker/ringPick.test.ts b/tests/services/gpu/shaders/structureMarker/ringPick.test.ts
index ffdf8215b..be131a1fb 100644
--- a/tests/services/gpu/shaders/structureMarker/ringPick.test.ts
+++ b/tests/services/gpu/shaders/structureMarker/ringPick.test.ts
@@ -30,9 +30,7 @@ describe('ringPick.wesl', () => {
     // A separate parity test already proves the lib constant matches the
     // TS constant — so if this shader imports from the lib, the value
     // is guaranteed correct.
-    expect(ringPickCode).toContain(
-      'import package::lib::selectionEncoding::PICK_SENTINEL_OFFSET',
-    );
+    expect(ringPickCode).toContain('import package::lib::selectionEncoding::PICK_SENTINEL_OFFSET');
     // Sanity: the TS constant is the value downstream readers subtract.
     // If this ever changes, both this shader and the lib will need to
     // update in lock-step.
@@ -46,7 +44,7 @@ describe('ringPick.wesl', () => {
   });
 
   it('emits the canonical pick packing in the fragment body', () => {
-    // (source.sourceCode << 27u) | (poiIndex + PICK_SENTINEL_OFFSET)
+    // (source.sourceCode << 27u) | (structureIndex + PICK_SENTINEL_OFFSET)
     expect(ringPickCode).toContain('source.sourceCode << 27u');
     expect(ringPickCode).toContain('PICK_SENTINEL_OFFSET');
   });
diff --git a/tests/services/url/focusUrl.test.ts b/tests/services/url/focusUrl.test.ts
index 041e22be9..2cd8cd772 100644
--- a/tests/services/url/focusUrl.test.ts
+++ b/tests/services/url/focusUrl.test.ts
@@ -179,4 +179,60 @@ describe('parseFocusHash', () => {
     // and returns null so a half-copied URL doesn't crash the app.
     expect(parseFocusHash('#focus=%E0%A4%A')).toBeNull();
   });
+
+  // ── Structure prefix routing ────────────────────────────────────────
+
+  it("routes 'focus=cluster-virgo-m87' to kind structure with the full id", () => {
+    expect(parseFocusHash('#focus=cluster-virgo-m87')).toEqual({
+      kind: 'structure',
+      id: 'cluster-virgo-m87',
+    });
+  });
+
+  it('routes a supercluster id to kind structure', () => {
+    expect(parseFocusHash('#focus=supercluster-coma-sc')).toEqual({
+      kind: 'structure',
+      id: 'supercluster-coma-sc',
+    });
+  });
+
+  it('routes a void id to kind structure', () => {
+    expect(parseFocusHash('#focus=void-bootes-void')).toEqual({
+      kind: 'structure',
+      id: 'void-bootes-void',
+    });
+  });
+
+  it('routes a group id to kind structure', () => {
+    expect(parseFocusHash('#focus=group-local-group')).toEqual({
+      kind: 'structure',
+      id: 'group-local-group',
+    });
+  });
+
+  // Regression: bare famous ids must not be swallowed by the structure branch
+  it("still routes a bare famous id (e.g. 'm31') to kind famous", () => {
+    expect(parseFocusHash('#focus=m31')).toEqual({ kind: 'famous', id: 'm31' });
+  });
+
+  // Regressions: pgc/sdss/pos@ must be unchanged (existing tests cover them;
+  // the assertions below confirm the structure branch doesn't interfere)
+  it('leaves pgc- decoding unchanged when a structure category prefix is absent', () => {
+    expect(parseFocusHash('#focus=pgc-2789')).toEqual({ kind: 'pgc', pgc: 2789n });
+  });
+
+  it('leaves sdss- decoding unchanged when a structure category prefix is absent', () => {
+    expect(parseFocusHash('#focus=sdss-1237665128253423687')).toEqual({
+      kind: 'sdss',
+      objID: 1237665128253423687n,
+    });
+  });
+
+  it('leaves pos@ decoding unchanged when a structure category prefix is absent', () => {
+    expect(parseFocusHash('#focus=pos@10.1235,-5.4567')).toEqual({
+      kind: 'pos',
+      raDeg: 10.1235,
+      decDeg: -5.4567,
+    });
+  });
 });
diff --git a/tests/services/url/poiUrl.test.ts b/tests/services/url/poiUrl.test.ts
deleted file mode 100644
index cd02e069a..000000000
--- a/tests/services/url/poiUrl.test.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-/**
- * Tests for the pure POI-id URL codec.
- *
- * The codec encodes a POI selection (cluster / supercluster / void / wall)
- * into the `#poi=<id>` hash and decodes the inverse.  Sister test file to
- * `focusUrl.test.ts`; deliberately separate because the two URL schemes
- * (galaxy `#focus=…` and POI `#poi=…`) evolve independently.
- */
-
-import { describe, it, expect } from 'vitest';
-import { parsePoiHash, poiIdToHash } from '../../../src/services/url/poiUrl';
-
-describe('parsePoiHash', () => {
-  it('parses #poi=virgo-m87 → virgo-m87', () => {
-    expect(parsePoiHash('#poi=virgo-m87')).toBe('virgo-m87');
-  });
-
-  it('accepts no leading #', () => {
-    expect(parsePoiHash('poi=virgo-m87')).toBe('virgo-m87');
-  });
-
-  it('returns null for unrelated hashes', () => {
-    expect(parsePoiHash('#focus=m31')).toBeNull();
-    expect(parsePoiHash('#about')).toBeNull();
-    expect(parsePoiHash('')).toBeNull();
-  });
-
-  it('rejects unsafe characters', () => {
-    // Same character-class as focusUrl: letters / digits / underscore / dash.
-    expect(parsePoiHash('#poi=virgo m87')).toBeNull();
-    expect(parsePoiHash('#poi=<script>')).toBeNull();
-  });
-});
-
-describe('poiIdToHash', () => {
-  it('builds #poi=<id>', () => {
-    expect(poiIdToHash('virgo-m87')).toBe('poi=virgo-m87');
-  });
-});
diff --git a/tests/utils/url/hasDeepLink.test.ts b/tests/utils/url/hasDeepLink.test.ts
index 56ff2e533..a8fdcd0c3 100644
--- a/tests/utils/url/hasDeepLink.test.ts
+++ b/tests/utils/url/hasDeepLink.test.ts
@@ -6,12 +6,18 @@ describe('hasDeepLink', () => {
     expect(hasDeepLink({ hash: '', search: '' })).toBe(false);
   });
 
-  it('detects #focus= in the hash', () => {
+  it('detects #focus= for a galaxy in the hash', () => {
     expect(hasDeepLink({ hash: '#focus=ngc224', search: '' })).toBe(true);
   });
 
-  it('detects #poi= in the hash', () => {
-    expect(hasDeepLink({ hash: '#poi=virgo-cluster', search: '' })).toBe(true);
+  it('detects #focus= for a structure in the hash', () => {
+    // Structures (clusters, superclusters) ride #focus= since #poi= was dropped.
+    expect(hasDeepLink({ hash: '#focus=cluster-virgo-m87', search: '' })).toBe(true);
+  });
+
+  it('#poi= is NOT a deep link — structures now use #focus=', () => {
+    // #poi= has been removed; old links with this prefix do not suppress the splash.
+    expect(hasDeepLink({ hash: '#poi=cluster-virgo-m87', search: '' })).toBe(false);
   });
 
   it('detects ?tour= in the search', () => {