feat(client): continuous zoom ladder — derived orbital mosaic to quarter cells (T-1152/T-1153) #192

2026-07-22T16:50:42+02:00

jpmschweitzer commented

2026-07-22 16:50:42 +02:00

Summary

The continuous zoom ladder — T-1152 (derived planetary rung) + T-1153 (continuous cursor-anchored zoom), migration steps 4–5 of the T-1143 design pass, implementing Jeroen's three rulings (D-226 amendment 2026-07-21). The Atlas now opens on a fully derived whole-planet mosaic (heightmap PNGs are invisible derivation input — the D-166 corollary is real), and a single wheel gesture descends continuously from orbit to 512 m quarter cells with information-refining rungs, no mode flips, and a full-zoom-out that resets to the canonical planetary frame.

Server half (T-1152, Dudley)

R1 measured first: a capped Region tile through the real production path costs 0.40–0.48 ms — faster than the shipped district window; the progressive-tiling ruling runs interactively on-demand. Raw orbital derive ~0.9 µs/cell.
R5 redesign: WindowGranularity enum on the wire (Quarter/District/Region, serde named variants per the RoadNodeKind precedent, spacing from scale:: — one source of truth), riding an additive window_granularity_v2 field; legacy u32 untouched and byte-compatible, with a reserved u32::MAX Region sentinel so the old slot can never lie about aliasing. Cache + coalescing keys carry the enum itself (Ord, D-010).
Orbital derivation: derive_orbital_at_metres — bilinear envelope + region-baseline only, provably never calls invent_primitives (pinned by test), routed through the shared classification tail so one colorizer family renders every rung. R2 stepped-categorical behavior documented at the function.
Same carrier throughout: Region serves through the identical queue/caches; n stays district-extent at every rung; Region's cell grid is a rounding division with a bounded halving-loop clamp (no closed form — mirrored client-side).

Client half (T-1153 + T-1152 client, Stig)

Rung selection: unified per-rung coverage-ceiling walk (MAX_COVERAGE_M, finest-first) — supersedes the design doc's literal §5 formula, which had no legal District band at any real viewport (erratum recorded in the doc). Ladder: Quarter → District → Region → tile mode.
Tile mode: compute_tile_grid + AtlasWindowTileSet compose the whole body from capped Region windows (Lendel = 3×2), one tested AtlasWindowRequest per tile, genuinely progressive per-tile arrival, drawn as a mosaic under one view transform with nearest-wrap-image placement (canonical centers for requests/cache; nearest image for drawing — the antimeridian column renders where it belongs).
Continuous zoom: cursor-anchored, unclamped across rungs (MIN/MAX widened — the old 0.5 floor would have clamped a real body's fit zoom), progressive sharpen-in-place on crossings.
Full-zoom-out reset (the hard condition): restores the complete canonical transform — center, offset, and fit zoom — edge-triggered via an is-canonical-state predicate, with a zoom floor pinning continued zoom-out at the fit (no re-fire loop). Live-verified: post-reset zoom equals entry zoom to the last digit.
Entry seam: the atlas "regional" screen opens the ladder at the canonical orbital frame; the district_screen nav hop is deleted (D-013 restored — descent is a zoom gesture); AtlasViewer's heightmap-texture path is unreachable from nav (overlay surface deferred → T-1156; capture harness → T-1157).
Real bug fixed in passing: the overlay draw path conflated echoed n with the cell-grid side — only coincidentally correct at District granularity.

The live eyeball rounds (six of them)

The unit suites were green throughout (~3,530 tests); the live drives against a real server caught eight integration bugs the suites could not see, each now pinned by a revert-verified regression test: the held-n clamp drop, the legacy-sentinel guard veto, dead zoom-driven reselection + a third clamp-mirror instance at the reselect boundary, the missing tile-set model, the mosaic canvas-frame mismatch, the stale view-offset on crossings, the unstored ImageTexture RID race (screen white, CPU pixels correct), and the level-triggered reset loop (889-response request storm). A real-driver draw-smoke test (SubViewport + pixel assertions, skip-guarded under the gate's headless run, documented in DEVOPS.md) structurally closes the "nothing asserts pixels" gap that let two of these through.

Final live verification: whole-planet mosaic edge to edge, all rung crossings firing and accepted, exactly 6 requests at entry and at reset (no storm), reset frame pixel-identical to entry.

Verification

Full suite 3,530+ green through the gate; goldens byte-identical; gdlint clean; cold parse clean.
Live captures preserved: .cache/screenshots/zoom-ladder-eyeball/.

Tickets: T-1152, T-1153

## Summary The continuous zoom ladder — T-1152 (derived planetary rung) + T-1153 (continuous cursor-anchored zoom), migration steps 4–5 of the T-1143 design pass, implementing Jeroen's three rulings (D-226 amendment 2026-07-21). The Atlas now opens on a **fully derived whole-planet mosaic** (heightmap PNGs are invisible derivation input — the D-166 corollary is real), and a single wheel gesture descends continuously from orbit to 512 m quarter cells with information-refining rungs, no mode flips, and a full-zoom-out that resets to the canonical planetary frame. ### Server half (T-1152, Dudley) - **R1 measured first:** a capped Region tile through the real production path costs **0.40–0.48 ms** — faster than the shipped district window; the progressive-tiling ruling runs interactively on-demand. Raw orbital derive ~0.9 µs/cell. - **R5 redesign:** `WindowGranularity` enum on the wire (Quarter/District/Region, serde named variants per the RoadNodeKind precedent, spacing from `scale::` — one source of truth), riding an additive `window_granularity_v2` field; legacy u32 untouched and byte-compatible, with a reserved u32::MAX Region sentinel so the old slot can never lie about aliasing. Cache + coalescing keys carry the enum itself (Ord, D-010). - **Orbital derivation:** `derive_orbital_at_metres` — bilinear envelope + region-baseline only, provably never calls `invent_primitives` (pinned by test), routed through the shared classification tail so one colorizer family renders every rung. R2 stepped-categorical behavior documented at the function. - **Same carrier throughout:** Region serves through the identical queue/caches; `n` stays district-extent at every rung; Region's cell grid is a rounding *division* with a bounded halving-loop clamp (no closed form — mirrored client-side). ### Client half (T-1153 + T-1152 client, Stig) - **Rung selection:** unified per-rung coverage-ceiling walk (`MAX_COVERAGE_M`, finest-first) — supersedes the design doc's literal §5 formula, which had no legal District band at any real viewport (erratum recorded in the doc). Ladder: Quarter → District → Region → **tile mode**. - **Tile mode:** `compute_tile_grid` + `AtlasWindowTileSet` compose the whole body from capped Region windows (Lendel = 3×2), one tested `AtlasWindowRequest` per tile, genuinely progressive per-tile arrival, drawn as a mosaic under one view transform with **nearest-wrap-image** placement (canonical centers for requests/cache; nearest image for drawing — the antimeridian column renders where it belongs). - **Continuous zoom:** cursor-anchored, unclamped across rungs (MIN/MAX widened — the old 0.5 floor would have clamped a real body's fit zoom), progressive sharpen-in-place on crossings. - **Full-zoom-out reset (the hard condition):** restores the complete canonical transform — center, offset, and fit zoom — edge-triggered via an is-canonical-state predicate, with a **zoom floor** pinning continued zoom-out at the fit (no re-fire loop). Live-verified: post-reset zoom equals entry zoom to the last digit. - **Entry seam:** the atlas "regional" screen opens the ladder at the canonical orbital frame; the `district_screen` nav hop is deleted (D-013 restored — descent is a zoom gesture); AtlasViewer's heightmap-texture path is unreachable from nav (overlay surface deferred → T-1156; capture harness → T-1157). - **Real bug fixed in passing:** the overlay draw path conflated echoed `n` with the cell-grid side — only coincidentally correct at District granularity. ### The live eyeball rounds (six of them) The unit suites were green throughout (~3,530 tests); the live drives against a real server caught **eight integration bugs the suites could not see**, each now pinned by a revert-verified regression test: the held-n clamp drop, the legacy-sentinel guard veto, dead zoom-driven reselection + a third clamp-mirror instance at the reselect boundary, the missing tile-set model, the mosaic canvas-frame mismatch, the stale view-offset on crossings, the unstored ImageTexture RID race (screen white, CPU pixels correct), and the level-triggered reset loop (889-response request storm). A **real-driver draw-smoke test** (SubViewport + pixel assertions, skip-guarded under the gate's headless run, documented in DEVOPS.md) structurally closes the "nothing asserts pixels" gap that let two of these through. Final live verification: whole-planet mosaic edge to edge, all rung crossings firing and accepted, exactly 6 requests at entry and at reset (no storm), reset frame pixel-identical to entry. ### Verification - Full suite 3,530+ green through the gate; goldens byte-identical; gdlint clean; cold parse clean. - Live captures preserved: `.cache/screenshots/zoom-ladder-eyeball/`. Tickets: T-1152, T-1153

jpmschweitzer added 12 commits 2026-07-22 16:50:43 +02:00

chore(meta): activate zoom-ladder-continuous batch — T-1152/T-1153 in_progress 2a4597e108

feat(simulation): T-1152 server half — WindowGranularity enum, derive_orbital_at_metres, Region rung on the same carrier d356b09926

R1 measured first: a capped Region tile through the real production path
(build_district_window_layer + T-1151 par_iter) at the 64x64 wire cap
costs 0.40-0.48ms — faster than the shipped district n=64 window, so
Jeroen's progressive capped-density tiling ruling is comfortably
interactive on-demand. Raw orbital derive ~0.9µs/cell (~2.3x faster than
full derive; region_baseline dominates, not invent_primitives).

R5 redesign: WindowGranularity enum (Quarter/District/Region), serde
named-variant per the RoadNodeKind precedent, spacing from D-243 scale::
constants — the single source of truth. Additive serde-default
window_granularity_v2 request field (None = legacy u32 path; v2 wins when
Some); DistrictWindowLayer.granularity_v2 always echoed. Legacy u32 echo
for Region uses reserved WINDOW_GRANULARITY_REGION_KEY = u32::MAX (never
a legal input) so the old slot cannot lie about aliasing. Cache and
coalescing keys carry the enum itself (Ord by declaration order, D-010).

n stays district-extent at every rung; Region's cell grid is a DIVISION
(round(n/100), min 1) with its own per-axis ceiling
DISTRICT_WINDOW_MAX_N_REGION=6400 and a bounded halving-loop clamp (no
closed form under the rounding division — the client mirror must
replicate the loop).

derive_orbital_at_metres: bilinear envelope reads + region_baseline
temperature, NO invent_primitives (proven by test — slope_q pinned 0),
routed through the shared build_district_profile classification tail so
the existing colorizer family renders orbital cells unchanged. R2
stepped-categorical behavior documented at the function, not implied.

Region aliasing + clamp/echo tests mirror the T-1150 discipline. 1813
lib tests green; clippy clean; fixture regenerated (254->278 bytes, new
echoed field).

feat(client): T-1153 + T-1152 client half — continuous cursor-anchored zoom ladder, Region-rung orbital entry, click-through retired ce90d69ae8

The atlas 'regional' screen now opens the LADDER at the canonical orbital
frame (Region granularity, whole body fitted and centered) and wheel zoom
descends continuously — cursor-anchored, unclamped across rungs, with
progressive refinement (held composite keeps drawing, finer rung swaps in
place on arrival; no blank frame, no mode flip). Full-zoom-out resets to
the canonical planetary frame per Jeroen's HARD condition
(is_fully_zoomed_out = extent >= body circumference, not a zoom-value
heuristic). The district_screen nav hop is deleted — D-013 restored:
descent is a zoom gesture, not a nav push. AtlasViewer's heightmap-texture
path is unreachable from nav (code intact; overlay surface deferred, see
report/tickets).

Rung selection: design doc §5's literal formula has NO legal District band
at any real viewport (visual-tolerance band and n=64 coverage ceiling
never overlap — pinned by executable boundary tests at 1600x900);
select_rung() splits it into a coverage ceiling (decides Region) then the
2x visual tolerance (District vs Quarter), documented at the function.
In practice the ladder steps Region -> Quarter directly.

Wire: window_granularity_v2 encoded (omitted at District for byte-compat),
granularity_v2 echoed value keyed + staleness-guarded end to end; Region
clamp mirror replicates the server's bounded halving loop (no closed
form). MIN/MAX_ZOOM widened to [0.0005, 64] — the old 0.5 floor would
have clamped a real body's canonical fit zoom, violating the reset
condition.

Real pre-existing bug fixed in atlas_window_overlay.gd: the draw path used
echoed n as both cell-grid dimension and district extent — only
coincidentally correct at District granularity; Quarter/Region would have
read wrong array offsets. cell_grid_side_for_window() now mirrors the
server's WindowGranularity::cell_grid_side.

Tests: +26 pure-function geometry tests, new 30-test zoom-ladder suite,
extensions across the window cache/request/overlay/delivery suites.
Full suite 3518 green; cold-parse clean.

docs(docs): §5 erratum — rung-selection rule's literal form has no District band; two-gate split as implemented (T-1153) 55a2909386

fix(client): T-1153 — clamp _held_n at the viewer's single write site (live eyeball round blocker) 1c87b6a712

The live round against a real server caught what 3518 unit tests missed:
enter_orbital stored the UNCLAMPED n (Lendel: 19139 raw circumference
cols) into _held_n while AtlasWindowRequest clamped independently to
6400 before sending — every orbital response on a real-sized body was
dropped by the viewer's own w_n != _held_n staleness check. Permanently
blank ladder. The PR #191 C1 clamp-mirror lesson, one layer up: the
mirror must apply wherever held/expected state is recorded, not only at
the request layer.

_enter_at_rung now clamps via _clamp_window_n_mirror_v2 before storing
(the file's only _held_n write site — reselect/refloat read and forward).
Regression closes the coverage hole: the oversized-orbital RESPONSE
round-trip (enter_orbital on GJ380c -> deliver echo n=6400 Region ->
assert accepted). Both new tests verified to fail against the reverted
fix before trusting green. Full suite 3520/3520.

fix(client): T-1153 — v2 granularity is authoritative in the staleness guard; legacy compared only when v2 absent 11f7927f24

Second live-round blocker: the T-1150 legacy granularity comparison
stayed armed alongside the v2 check, and the server ALWAYS sends the
u32::MAX Region sentinel in the legacy slot — which can never equal the
client's pinned legacy value, so every Region response was stale-dropped
after the v2 check passed. _echoed_granularity_matches() now branches on
PRESENCE of granularity_v2: present -> v2 is the only comparison; absent
(old server) -> legacy fallback.

Mock-fleet audit while fixing: three tests had responses diverging from
the real wire — the oversized-orbital round-trip omitted the legacy
sentinel (passed for the wrong reason), the Region-accept test used
legacy=1, and the mismatch-drop test left v2 at a masking default that
would have inverted under the new rule. All wire-accurate now with a
named SERVER_LEGACY_GRANULARITY_REGION_SENTINEL const; +2 tests (legacy-
only old-server acceptance; v2-wins-regardless-of-legacy precedence
proof). All three verified to fail against the reverted fix. Full suite
3524/3524.

fix(client): T-1153/T-1152 round 3 — unified rung coverage model, reselect clamp mirror, orbital tile-set mosaic 6195fd28b3

Bug A (zoom reselection dead): select_rung() redesigned from the two-gate
split to a unified per-rung coverage-ceiling walk (MAX_COVERAGE_M,
finest-first) — which also restores District as a reachable rung
(33-131km extent band; the two-gate model had made it structurally
unreachable). Plus the THIRD instance of the PR #191 C1 clamp-mirror bug
class: _maybe_reselect_rung fed the old rung's _held_n raw into the new
rung's request — the server clamped, the held value didn't, every
cross-rung response stale-dropped. Re-clamped at the boundary; the
leaving_tile_mode flag also fixes a stale request-granularity edge case.

Bug B (orbital = whole body): genuine tile-set model. compute_tile_grid
composes ceil-divided Region-tile centers (canonicalized column wrap,
row clamp, Dictionary-set dedup; Lendel = 3x2 = 6 tiles);
AtlasWindowTileSet owns one AtlasWindowRequest per tile (reusing all
tested request/cache/debounce machinery), fans responses out, per-tile
tile_ready — genuinely progressive; the overlay draws arrived tiles as a
mosaic under the one view transform. enter_orbital branches to tile mode
when >1 tile; single-window path unchanged below the coverage ceiling.
E/W wrap at tile seams live-confirmed (col -6400 wraps to 12739). Pole-
row dedup verified correct but flagged honestly as currently-unreachable
defensive logic (no real radius triggers row collision).

All fixes + fallout verified via revert/confirm-fails/restore. Targeted
suites 256/256; gdlint clean; new 20-test tile-set suite.

docs(docs): §5 erratum superseded — unified coverage-ceiling rung model + tile mode as merged (T-1153 round 3) 9ffda88e57

fix(client): T-1153/T-1152 round 4 — mosaic canvas-local frame, offset recompute on rung crossing, tile texture RID lifetime; real-driver draw smoke 493a7345d3

Three live-found rendering bugs, all invisible to green unit suites:
- _draw_tile_mosaic placed tiles from absolute district (0,0); canvas-
  local (0,0) is held_center - held_n/2 everywhere else, and tile-mode
  held_n is the whole-body extent — the entire mosaic drew tens of
  thousands of px off-canvas. New pure district_to_canvas_local() +
  viewer accessors route every tile through the shared frame.
- _maybe_reselect_rung updated held_n across crossings without
  recomputing _view_offset — the single-window composite landed off-
  canvas the moment any crossing happened (why District/Quarter were
  black too). New pure recompute_offset_for_held_n_change().
- _build_tile_texture created an unstored ImageTexture per _draw,
  racing the RenderingServer's deferred upload — CPU pixels correct,
  screen white. Per-tile-index texture cache, same reference-identity
  discipline as the single-window _cached_texture.

Structural close of the twice-bitten 'nothing asserts pixels' gap:
test_atlas_window_overlay_draw_smoke.gd renders overlay output into a
SubViewport and asserts visible pixels for both modes — runs under a
real driver (invocation documented in DEVOPS.md, visual_capture
precedent; migration to the T-1157 harness noted on that ticket), skips
loud-but-green under the gate's headless run (verified green-with-skips
AND genuinely red with detection forced off). +7 geometry/crossing
tests, all revert-verified. Targeted suites 270 green; gdlint clean.

fix(client): T-1153/T-1152 round 5 — nearest-wrap-image tile draw placement; canonical reset restores the fit zoom and re-fires ccedba4f24

The wrapped tile column (Lendel: -6400 canonicalized to 12739) drew at
its canonical column — off-canvas right — leaving the mosaic's left
third black. nearest_wrap_image() re-expresses a tile column as the
wrap-image closest to held_center for DRAWING only (requests/cache keys
stay canonical). The draw-position test asserts overlap FRACTION, not
bare intersects() — the buggy placement still clipped ~2px of viewport
edge at Lendel scale, so intersects() alone would false-pass.

The full-zoom-out reset restored center but not the fit zoom, and its
'already there' guard keyed on a lagging field so it could only ever
fire once. The guard now also matches tile mode and compares _view_zoom
against the freshly computed fit — restoring the FULL canonical
transform (center, offset, fit zoom) and re-firing as a continued
gesture keeps zooming out (Jeroen's hard condition, both live shapes).

+8 revert-verified tests incl. the continued-gesture reset repro; smoke
stub gained get_body_radius_km (crash confirmed real under a real
driver before fixing). Suites 286 green; gdlint clean.

fix(client): T-1153 round 6 — zoom floor at the canonical frame; reset guard purely edge-triggered 8414b0fd18

The round-5 per-tick zoom comparison inside the reset guard was level-
triggered: at the canonical frame every continued zoom-out tick drifted
_view_zoom a hair below fit, read as 'not there', and re-fired
enter_orbital — tile set torn down/recreated per tick, in-flight
responses orphaned (black entry), server flooded (889 of 897 responses
in one drive phase). The drift concern now lives in _zoom_at as a ZOOM
FLOOR (once at the canonical frame, zoom-out clamps at fit); the guard
keys only on fields that never drift (_held_center/_held_granularity_v2/
_tile_mode) — genuinely edge-triggered. Three shared helpers keep the
guard and the floor on one definition of 'canonical frame'.

Anti-storm regression drives 100 real _zoom_at ticks past the first
reset and asserts tile-set child node identities never change; the
black-entry repro interleaves Lendel's six wire-accurate tile responses
with continued ticks and asserts all six held. Both revert-verified with
the exact live symptoms. Round-5 reset tests pass unchanged. Live-
verified twice: exactly 6 requests at entry and at reset, no storm.

fix(client): draw smoke — guarded early-return instead of fuzzer-arg skip (gdUnit leaks one internal Node per skipped test, exit 101 bounced the gate at 0 failures) 8517cae66f

jpmschweitzer referenced this issue from a commit

2026-07-22 17:27:10 +02:00

fix(client): PR #192 review round — per-rung legend, Region coalescing + clamp boundary tests, halving-loop honesty

jpmschweitzer added 1 commit 2026-07-22 17:27:10 +02:00

fix(client): PR #192 review round — per-rung legend, Region coalescing + clamp boundary tests, halving-loop honesty da15261276

All Hoshe/Araminta findings addressed (Tyre approved outright), none
retracted — plus a Dudley stop-and-flag discovery that improved on the
asked-for fix:

- Legend 100x lie (Araminta, blocking): subtitle computed via
  spacing_for_rung() and refreshed at all three _held_granularity_v2
  write sites. Region test asserts 204.800 km/cell; the District
  direction needed a stale-header-aware helper — a District-only test
  spuriously passes against the old literal by coincidence.
- Region coalescing coverage (Hoshe 1): both directions tested
  (Region-vs-District separate slots; Region-vs-Region coalesces).
- Clamp boundary tests + dangling citations (Hoshe 2): writing the
  requested halving-loop-fires test surfaced that the loop is PROVABLY
  UNREACHABLE at current constants (per-axis clamp forecloses it —
  brute-forced independently on both server and client sides). Ruling:
  the loop stays as defensive code; the test became a property sweep
  pinning both the wire-cap invariant and the loop's no-op status (a
  future constant change breaks it loudly); doc comments on both sides
  drop the load-bearing framing and state the truth; the old client
  mirror test that claimed the loop fires (passing on the per-axis
  clamp alone) is replaced the same way. Client citations now name the
  real server tests verbatim.
- Governance (Tyre): D-226 amendment note — progressive cross-rung
  refinement EXTENDS T-1124 §4 (not supersedes); legacy u32 field
  scheduled for retirement (T-1159).

Server: 1818 lib tests green, clippy/fmt clean. Client: zoom_ladder
48/48, window_request 26/26, viewer 74/74; gdlint clean. Every fix
revert-verified.

jpmschweitzer commented

2026-07-22 17:40:09 +02:00

Review: zoom-ladder-continuous → main (type: code + visual)

Reviewers: Hoshe (QA) + Tyre (architecture) + Araminta (visual/§6 encoding continuity — with the five live captures in evidence). Reviewed at 8517cae66; fix round da1526127 re-confirmed.

Tyre (Architecture): APPROVE (outright)

No blocking findings. Assessment highlights: the R5 resolution "genuinely elegant" — enum + v2 field + sentinel honor his own PR #191 C2 prohibition exactly, u32::MAX sentinel "defensible long-term, not a trap"; the merged coverage-ceiling rung model satisfies the D-166 amendment's intent with the erratum accurately describing the code; the canonical-frame contract sound against re-entry, rapid gestures, and body switching; all three Jeroen rulings compliant (derived-invisible heightmaps, capped tiling with no dense raster, reset matching the ruling wording precisely). Bonus note: derive_orbital_at_metres's bilinear-only path resolves design risk R1 (unmeasured planetary cost) and mandate compliance in one move. Follow-ups requested and delivered: T-1158 (viewer decomposition before the 1000-line cap forces it), T-1159 (legacy u32 retirement), and a governance line recording that progressive cross-rung refinement extends T-1124 §4 (in the fix-round commit).

Hoshe (QA): APPROVE (after fix round)

Primary focus — the clamp-mirror discipline that bit three times — verified solid across all four expected-state sites with no fifth site lurking; wire-accurate mock discipline verified (real sentinels, revert-verified fixes). Two findings, both fixed:

#	Location	Issue	Resolution
1	gen_queue.rs	WindowGranularity::Region — the highest-fan-out path (6 concurrent tile requests) — had zero coalescing coverage	Both directions tested: Region-vs-District separate slots; Region-vs-Region coalesces
2	layer_proxy.rs / test_atlas_window_request.gd	Region clamp boundary had no direct server tests, and the client cited server test names that don't exist	See below — the fix improved on the ask

The finding-2 twist: writing the requested "halving-loop fires at n≈6450" test surfaced that the loop is provably unreachable at current constants — the per-axis clamp to 6400 forecloses it (brute-forced independently by both Dudley and Stig; max reachable cell_grid_side is exactly 64 = √WIRE_CAP_CELLS). Dudley stopped and flagged rather than shipping a test that passes without exercising what it claims. Ruling: the loop stays as defensive code for future rungs/cap retunes; the landed test is a property sweep pinning the wire-cap invariant AND the loop's no-op status (a future constant change breaks it loudly); doc comments on both sides state the truth; the pre-existing client mirror test that claimed the loop fires — itself passing on the per-axis clamp alone — was replaced the same way.

Araminta (Visual/§6): APPROVE (after fix round)

Core contract verified: one colorizer family genuinely serves every rung including the orbital mosaic; §6 no-mode-flip hold semantics verified in code; zoom-out reset pixel-verified (captures 01 vs 05 identical). One blocking finding, fixed:

#	Location	Issue	Resolution
1	atlas_window_legend.gd	Legend hardcoded "2.048 km/cell" — a 100× lie at Region rung; a stale mode label in §6's terms	Subtitle computed per rung via spacing_for_rung(), refreshed at all three granularity write sites; regression tests in both directions (the District direction needs a stale-header-aware helper — it spuriously passes against the old literal otherwise)

Follow-ups ticketed with her findings quoted: T-1160 (orbital coastline audit — derive_orbital_at_metres skips coast_warp_px, so the orbital coastline position structurally differs from finer rungs; includes her coastal-Quarter validation capture requirement) and T-1161 (per-rung composite filter policy — Region-rung bilinear smoothing honors the letter but not the spirit of "never magnified interpolation").

Verdict: APPROVED

Runtime verification: six live eyeball rounds against a real spawned server caught eight integration bugs invisible to ~3,530 green unit tests, each now pinned by a revert-verified regression; a real-driver draw-smoke test closes the pixels-assertion gap structurally. Final drive: whole-planet derived mosaic edge to edge, all rung crossings firing and accepted, exactly 6 requests at entry/reset, reset frame pixel-identical to entry. Captures preserved in .cache/screenshots/zoom-ladder-eyeball/.

Tickets: T-1152, T-1153 · Follow-ups: T-1158, T-1159, T-1160, T-1161

# Review: zoom-ladder-continuous → main (type: code + visual) Reviewers: Hoshe (QA) + Tyre (architecture) + Araminta (visual/§6 encoding continuity — with the five live captures in evidence). Reviewed at `8517cae66`; fix round `da1526127` re-confirmed. ## Tyre (Architecture): APPROVE (outright) No blocking findings. Assessment highlights: the R5 resolution "genuinely elegant" — enum + v2 field + sentinel honor his own PR #191 C2 prohibition exactly, u32::MAX sentinel "defensible long-term, not a trap"; the merged coverage-ceiling rung model satisfies the D-166 amendment's intent with the erratum accurately describing the code; the canonical-frame contract sound against re-entry, rapid gestures, and body switching; all three Jeroen rulings compliant (derived-invisible heightmaps, capped tiling with no dense raster, reset matching the ruling wording precisely). Bonus note: `derive_orbital_at_metres`'s bilinear-only path resolves design risk R1 (unmeasured planetary cost) and mandate compliance in one move. Follow-ups requested and delivered: T-1158 (viewer decomposition before the 1000-line cap forces it), T-1159 (legacy u32 retirement), and a governance line recording that progressive cross-rung refinement extends T-1124 §4 (in the fix-round commit). ## Hoshe (QA): APPROVE (after fix round) Primary focus — the clamp-mirror discipline that bit three times — verified solid across all four expected-state sites with no fifth site lurking; wire-accurate mock discipline verified (real sentinels, revert-verified fixes). Two findings, both fixed: | # | Location | Issue | Resolution | |---|----------|-------|------------| | 1 | gen_queue.rs | WindowGranularity::Region — the highest-fan-out path (6 concurrent tile requests) — had zero coalescing coverage | Both directions tested: Region-vs-District separate slots; Region-vs-Region coalesces | | 2 | layer_proxy.rs / test_atlas_window_request.gd | Region clamp boundary had no direct server tests, and the client cited server test names that don't exist | See below — the fix improved on the ask | **The finding-2 twist:** writing the requested "halving-loop fires at n≈6450" test surfaced that the loop is **provably unreachable** at current constants — the per-axis clamp to 6400 forecloses it (brute-forced independently by both Dudley and Stig; max reachable cell_grid_side is exactly 64 = √WIRE_CAP_CELLS). Dudley stopped and flagged rather than shipping a test that passes without exercising what it claims. Ruling: the loop stays as defensive code for future rungs/cap retunes; the landed test is a property sweep pinning the wire-cap invariant AND the loop's no-op status (a future constant change breaks it loudly); doc comments on both sides state the truth; the pre-existing client mirror test that claimed the loop fires — itself passing on the per-axis clamp alone — was replaced the same way. ## Araminta (Visual/§6): APPROVE (after fix round) Core contract verified: one colorizer family genuinely serves every rung including the orbital mosaic; §6 no-mode-flip hold semantics verified in code; zoom-out reset pixel-verified (captures 01 vs 05 identical). One blocking finding, fixed: | # | Location | Issue | Resolution | |---|----------|-------|------------| | 1 | atlas_window_legend.gd | Legend hardcoded "2.048 km/cell" — a 100× lie at Region rung; a stale mode label in §6's terms | Subtitle computed per rung via spacing_for_rung(), refreshed at all three granularity write sites; regression tests in both directions (the District direction needs a stale-header-aware helper — it spuriously passes against the old literal otherwise) | Follow-ups ticketed with her findings quoted: **T-1160** (orbital coastline audit — `derive_orbital_at_metres` skips `coast_warp_px`, so the orbital coastline *position* structurally differs from finer rungs; includes her coastal-Quarter validation capture requirement) and **T-1161** (per-rung composite filter policy — Region-rung bilinear smoothing honors the letter but not the spirit of "never magnified interpolation"). ## Verdict: APPROVED Runtime verification: six live eyeball rounds against a real spawned server caught eight integration bugs invisible to ~3,530 green unit tests, each now pinned by a revert-verified regression; a real-driver draw-smoke test closes the pixels-assertion gap structurally. Final drive: whole-planet derived mosaic edge to edge, all rung crossings firing and accepted, exactly 6 requests at entry/reset, reset frame pixel-identical to entry. Captures preserved in `.cache/screenshots/zoom-ladder-eyeball/`. Tickets: T-1152, T-1153 · Follow-ups: T-1158, T-1159, T-1160, T-1161

jpmschweitzer closed this pull request

2026-07-22 17:41:10 +02:00

jpmschweitzer referenced this issue from a commit

2026-07-22 17:45:04 +02:00

chore(meta): T-1152/T-1153 to review — PR #192 up (zoom ladder); T-1157 smoke-scenario migration note (Stig)

jpmschweitzer referenced this issue from a commit

2026-07-22 17:45:04 +02:00

chore(meta): PR #192 review follow-ups — T-1158 (viewer decomposition), T-1159 (legacy u32 retirement), T-1160 (orbital coastline audit), T-1161 (per-rung filter policy)

jpmschweitzer referenced this issue from a commit

2026-07-22 17:45:04 +02:00

chore(meta): zoom ladder shipped — T-1152/T-1153 closed (PR #192 merged, triple review, six live rounds, eight integration bugs pinned)

jpmschweitzer referenced this issue from a commit