From 0fee215e6f91df6a9b9ab45933638c855a945bc2 Mon Sep 17 00:00:00 2001
From: Jeremy Collins <jeremy.collins@beetlebug.org>
Date: Wed, 9 Sep 2026 21:07:37 -0400
Subject: [PATCH 1/2] Choose the antimeridian world copy per tile

Wide views rendered as horizontal bands stretched across the map, in
area fills and lines.

Each vertex stage computed world.x = p.x + rint(wrap_x - p.x), which
places a vertex at the world copy nearest the camera. That rule dates
from tile-local geometry, where p.x spans one tile and every vertex of a
tile gets the same result. The renderer builds one scene against one
origin, so p.x spans the whole view and the result changes halfway
across. A triangle lying over the half-world seam ended up with corners
a whole world apart. Six corners of a quad share one anchor, so label
quads were unaffected.

Camera.placeTileX picks the copy by the tile's centre.
Camera.wrappedCopy names the second copy when the view is wide enough to
see both, from around z1 down, and the tile is then listed and placed
twice. Camera.mvpOrigin wraps the origin-to-camera delta in x, so a
camera that crossed the antimeridian since the scene was built moves the
whole scene at once. The vertex stages now only project. Uniforms keeps
wrap_x as a reserved field to hold the block at 128 bytes.
---
 shaders/d3d12/fill.vert.hlsl    |  12 ++--
 shaders/d3d12/overlay.vert.hlsl |   8 +--
 shaders/d3d12/pattern.vert.hlsl |   3 +-
 shaders/d3d12/sprite.vert.hlsl  |   3 +-
 shaders/metal.metal             |  26 ++++-----
 shaders/vk/fill.vert            |  12 ++--
 shaders/vk/fill.vert.spv        | Bin 5368 -> 5080 bytes
 shaders/vk/overlay.vert         |   8 +--
 shaders/vk/overlay.vert.spv     | Bin 2196 -> 1844 bytes
 shaders/vk/pattern.vert         |   3 +-
 shaders/vk/pattern.vert.spv     | Bin 4292 -> 4004 bytes
 shaders/vk/sprite.vert          |   3 +-
 shaders/vk/sprite.vert.spv      | Bin 5568 -> 5280 bytes
 src/camera.zig                  |  97 +++++++++++++++++++++++++++++++-
 src/map.zig                     |  20 +++++--
 src/map_object.zig              |  53 ++++++++++++++---
 src/scene/types.zig             |   8 ++-
 17 files changed, 202 insertions(+), 54 deletions(-)

diff --git a/shaders/d3d12/fill.vert.hlsl b/shaders/d3d12/fill.vert.hlsl
index 5e27e13..74b41b1 100644
--- a/shaders/d3d12/fill.vert.hlsl
+++ b/shaders/d3d12/fill.vert.hlsl
@@ -37,13 +37,13 @@ struct VSOut {
     float4 color : TEXCOORD0;
 };
 
-// Longitude is cyclic: draw each vertex at the world instance nearest the
-// camera, so a view straddling the antimeridian is seamless. The world period
-// is exactly 1.0 in ANY translated frame, so this works on tile-local
-// coordinates as long as u_wrap_x is stated in the same frame.
+// Longitude is cyclic, so every tile has a world copy every 1.0 world units
+// and one of them has to be drawn. That choice belongs to the HOST, which
+// makes it once per tile (Camera.placeTileX) and again once per scene, in the
+// matrix (Camera.mvpOrigin takes the short way round in x). Deciding it here,
+// per vertex, tore every primitive lying across the half-world seam.
 float4 project(float2 p) {
-    float2 world = float2(p.x + round(u_wrap_x - p.x), p.y);
-    return mul(u_mvp, float4(world, 0.0, 1.0));
+    return mul(u_mvp, float4(p, 0.0, 1.0));
 }
 
 // The per-vertex zoom visibility window, quantized to 1/256 zoom steps and
diff --git a/shaders/d3d12/overlay.vert.hlsl b/shaders/d3d12/overlay.vert.hlsl
index a476cad..52532c1 100644
--- a/shaders/d3d12/overlay.vert.hlsl
+++ b/shaders/d3d12/overlay.vert.hlsl
@@ -28,10 +28,10 @@ struct VSOut {
 
 VSOut main(VSIn i) {
     VSOut o;
-    // The chart shader's antimeridian wrap: draw at the world instance nearest
-    // the camera. A whole world width is 1.0 in the relative frame too.
-    float2 world = float2(i.a_world.x + round(u_wrap_x - i.a_world.x), i.a_world.y);
-    float4 clip = mul(u_mvp, float4(world, 0.0, 1.0));
+    // No antimeridian wrap here: the host turns the whole frame at once, in
+    // the matrix (Camera.mvpOrigin). Wrapping per vertex tore any primitive
+    // lying across the half-world seam.
+    float4 clip = mul(u_mvp, float4(i.a_world, 0.0, 1.0));
     // z = 0 is the near plane. The chart's paint-order depths are all in (0,1)
     // and this pass writes no depth, so host content is never hidden by the
     // chart and never hides it from a later pass.
diff --git a/shaders/d3d12/pattern.vert.hlsl b/shaders/d3d12/pattern.vert.hlsl
index 604b983..acca866 100644
--- a/shaders/d3d12/pattern.vert.hlsl
+++ b/shaders/d3d12/pattern.vert.hlsl
@@ -34,8 +34,7 @@ struct VSOut {
 
 VSOut main(VSIn i) {
     VSOut o;
-    float2 world = float2(i.a_pos.x + round(u_wrap_x - i.a_pos.x), i.a_pos.y);
-    float4 clip = mul(u_mvp, float4(world, 0.0, 1.0));
+    float4 clip = mul(u_mvp, float4(i.a_pos, 0.0, 1.0));
     float2 off = i.a_off;
     if ((i.a_flags & 1) != 0) {
         off = float2(off.x * u_rot_cos - off.y * u_rot_sin,
diff --git a/shaders/d3d12/sprite.vert.hlsl b/shaders/d3d12/sprite.vert.hlsl
index 332b43d..adb09dc 100644
--- a/shaders/d3d12/sprite.vert.hlsl
+++ b/shaders/d3d12/sprite.vert.hlsl
@@ -45,8 +45,7 @@ VSOut main(VSIn i) {
     bool flip = ((i.a_pack >> 8) & 0xFF) != 0;
     float tangent = float((i.a_pack >> 16) & 0xFF) / 256.0 * 6.2831853071795864;
 
-    float2 world = float2(i.a_pos.x + round(u_wrap_x - i.a_pos.x), i.a_pos.y);
-    float4 clip = mul(u_mvp, float4(world, 0.0, 1.0));
+    float4 clip = mul(u_mvp, float4(i.a_pos, 0.0, 1.0));
 
     float2 off = i.a_off;
     // Keep a tangent-rotated run (line-following text) upright: if the run,
diff --git a/shaders/metal.metal b/shaders/metal.metal
index 3eb45bf..21fc447 100644
--- a/shaders/metal.metal
+++ b/shaders/metal.metal
@@ -25,7 +25,7 @@ struct U {
     float    size_scale; // pixel density x symbol size multiplier
     float    zoom;       // fractional zoom * 256, tested against zmin/zmax
     float    zoom_t;     // fract(zoom): mix factor for zoom-interpolated paint
-    float    wrap_x;     // camera centre x IN THE VERTEX FRAME (antimeridian)
+    float    wrap_x;     // RESERVED: the host now wraps per tile and per scene
     float    rot_sin;
     float    rot_cos;
     float4   color;      // SDF halo background; SDF fragment stage only
@@ -72,14 +72,15 @@ static_assert(sizeof(Quad) == 40, "Quad must match scene.Quad (40 B)");
 
 constant uint FLAG_MAP_ALIGN = 1u;
 
-// Longitude is cyclic: draw each vertex at the world instance nearest the
-// camera (x, x-1 or x+1), so a view straddling the antimeridian is seamless.
-// The world period is exactly 1.0 world unit in ANY translated frame, so this
-// works on tile-local coordinates as long as u.wrap_x is stated in the same
-// frame (host: camera.center.x - tile_origin.x).
+// Longitude is cyclic, so every tile has a world copy every 1.0 world units
+// and one of them has to be drawn. That choice belongs to the HOST, which
+// makes it once per tile (Camera.placeTileX) and again once per scene, in the
+// matrix (Camera.mvpOrigin takes the short way round in x). Deciding it here,
+// per vertex, tore every primitive lying across the half-world seam: the
+// corners on one side moved a whole world and the corners on the other did
+// not, so a coastline came out as a band stretched across the map.
 static inline float4 project(constant U &u, float2 p) {
-    float2 world = float2(p.x + rint(u.wrap_x - p.x), p.y);
-    return u.mvp * float4(world, 0.0, 1.0);
+    return u.mvp * float4(p, 0.0, 1.0);
 }
 
 // The per-vertex zoom visibility window: zmin/zmax quantized to 1/256 zoom
@@ -276,7 +277,7 @@ fragment float4 sdf_frag(QuadOut in [[stage_in]],
 //
 // The stream is world-space positions relative to the frame's own origin, with
 // a colour per vertex. The host supplies the matching uniform (an mvp built
-// for that origin), so this shader reads only mvp and wrap_x.
+// for that origin), so this shader reads only mvp.
 struct OverlayVertex {          // scene.OverlayVertex, 24 B
     // packed_float2/4 hold the stride at 24; natural alignment would pad to 32
     // and shear the stream.
@@ -294,10 +295,9 @@ vertex OverlayOut overlay_vert(uint vid [[vertex_id]],
                                const device OverlayVertex *verts [[buffer(0)]],
                                constant U &u [[buffer(2)]]) {
     OverlayVertex v = verts[vid];
-    // The same antimeridian wrap the scene shaders apply: draw at the world
-    // instance nearest the camera, so an overlay across the seam is seamless.
-    float2 world = float2(v.world.x + rint(u.wrap_x - v.world.x), v.world.y);
-    float4 clip = u.mvp * float4(world, 0.0, 1.0);
+    // No antimeridian wrap here either: the host turns the whole frame at
+    // once, in the matrix (Camera.mvpOrigin). See project() above.
+    float4 clip = u.mvp * float4(v.world, 0.0, 1.0);
     // z = 0 is the near plane. Every paint-order depth the scene writes is in
     // (0,1), so a depth-test-only overlay pass is never hidden by the map it
     // annotates — and it writes no depth, so it cannot hide the map either.
diff --git a/shaders/vk/fill.vert b/shaders/vk/fill.vert
index 4922a19..6a75bea 100644
--- a/shaders/vk/fill.vert
+++ b/shaders/vk/fill.vert
@@ -34,13 +34,13 @@ layout(set = 1, binding = 0) uniform U {
 
 layout(location = 0) out vec4 v_color;
 
-// Longitude is cyclic: draw each vertex at the world instance nearest the
-// camera, so a view straddling the antimeridian is seamless. The world period
-// is exactly 1.0 in ANY translated frame, so this works on tile-local
-// coordinates as long as u.wrap_x is stated in the same frame.
+// Longitude is cyclic, so every tile has a world copy every 1.0 world units
+// and one of them has to be drawn. That choice belongs to the HOST, which
+// makes it once per tile (Camera.placeTileX) and again once per scene, in the
+// matrix (Camera.mvpOrigin takes the short way round in x). Deciding it here,
+// per vertex, tore every primitive lying across the half-world seam.
 vec4 project(vec2 p) {
-    vec2 world = vec2(p.x + round(u.wrap_x - p.x), p.y);
-    return u.mvp * vec4(world, 0.0, 1.0);
+    return u.mvp * vec4(p, 0.0, 1.0);
 }
 
 // The per-vertex zoom visibility window, quantized to 1/256 zoom steps and
diff --git a/shaders/vk/fill.vert.spv b/shaders/vk/fill.vert.spv
index 984df9e49a5e66228b944597a7bde900ade5a736..089cb3783ed51d8fba775ce665e93626bbe33d11 100644
GIT binary patch
literal 5080
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

literal 5368
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

diff --git a/shaders/vk/overlay.vert b/shaders/vk/overlay.vert
index 03a3986..824004e 100644
--- a/shaders/vk/overlay.vert
+++ b/shaders/vk/overlay.vert
@@ -32,10 +32,10 @@ layout(set = 1, binding = 0) uniform U {
 layout(location = 0) out vec4 v_color;
 
 void main() {
-    // The chart shader's antimeridian wrap: draw at the world instance nearest
-    // the camera. A whole world width is 1.0 in the relative frame too.
-    vec2 world = vec2(a_world.x + round(u.wrap_x - a_world.x), a_world.y);
-    vec4 clip = u.mvp * vec4(world, 0.0, 1.0);
+    // No antimeridian wrap here: the host turns the whole frame at once, in
+    // the matrix (Camera.mvpOrigin). Wrapping per vertex tore any primitive
+    // lying across the half-world seam.
+    vec4 clip = u.mvp * vec4(a_world, 0.0, 1.0);
     // z = 0 is the near plane. The chart's paint-order depths are all in (0,1)
     // and this pass writes no depth, so plugin content is never hidden by the
     // chart and never hides it from a later pass.
diff --git a/shaders/vk/overlay.vert.spv b/shaders/vk/overlay.vert.spv
index 857bd55c7c269c626748289420fd88db399418e7..fd0c06be6050642d224023d81353c26adb4e27ad 100644
GIT binary patch
literal 1844
zcmZ9L%Wl&^6o#islN1UqrSt-nkhDN4fr<qnB*aZ1C5tSA3Wx=gv0Mu*oH(+bwqnIA
z@Jc)t8zla3;z=x~IyrOxbDjUV)yiJOm<6+Jmdpb)J!_^S#0aZf-R&Rs53~IE@X_Ok
zM68&q4J2mOoU`{u{SN(Tgs~~PEjf^MBvt)Yq<<@+W)}4~kHw}!5JzJv`K#ul^an{@
zKJJ|1$yj#X+VmZtd3oYZvm8#3Ecy|8S>VSZ`3)P-w811z!%^;Bvs%m&__;Uqv+ueJ
zui2cM?x(3g_Ri*5U09l^hMwu-M4rWhB%5JN!h$4DQfW6EZ}dmOw<Pt(DmjZiPiz>+
zpuBxm_Cx|N@aTJ|Ng5x^uA4pCUt@0&rXRyJ4=H2ogLCjDS(HZ!^EGTdTv<FC<wxR%
zIOl^e`QC{7w^5dBym01&GklXcp81%My>gh3{hoN!mtwPPzp%T-9_i65?Gavk%65B&
zzf1pN?maG!H-Nn=#ZecmSHhSXtY5;|FW8`jF$38962@-9K9w+L1N&UU*e%$X62@-9
z_<-Ha>=le9b@hJs+Lmyfy{kKK!)Dh_2?y@TopM*RckpF?bm)PfTrjl5$N{UCFz#S*
zK`-_;?={^UHg(q3l^ShTAdmZ|Zt&BRY$+dJu&LM5FPwlO+p>8(cl^ZDn|Nw%$i5)m
zl5m>(68IL#adE^FgLXna{0Kc)q^U>lv%-dB*Mo1WC0USk<i}o<aLB(bO)Pz}H>8QB
zKJ~EKiOXk>Z3%~Z*jKIf^CdR(!XY)OcT<{~iF5w8?$q0nf4A^~H5J7^T|7R7I=7_R
z1AgYh=6?_j|9){N7e6-pb^d$0)6@B}I|cSc-x2e&Ck{D(gz*1CE%wT{P3~)<aJDXi
zXSjT>82Gy)0mp{FEeYJcQx5OHR$x*y?0SJQ+dv)Yu_GZCA6&!lFV(<zLqZ>7UT9M0
x0%I<?Zb`t{0e)<1FcbNAB>0Knm%b~3N8Uj^HZd;#zV7gZ??4*+ub6x)`3E<ndQ<=a

literal 2196
zcmZ9M+fLL_6ow1K3@9fNIjD#O2p&)b1w;|iXaW~pj6sbTCbcPzHkRq6Er)oe@d<n-
zpUN8(|8KXuH0;Tmz5ah4_S$RhnOgT;uj6z%{Z5~=?c{63=@#RNYnXj!Z+~wo%?_4U
z*Ou`Za%#pApJC^M(R=iL=!I=SzvPKzQ?ezg>C>(Kj{@pWk3MI<U^1M<NpzqcOuXmj
zOkJ^~!tW&w+0a>s#~tB@!PL<?b+g#@qp*Wt&U0oOeh=K#_o4v4*Z5Ptf0QIaJF})T
zhT42Da}T}rn^f_26H}Ldl6W2W^o(nWOJe2FwXL6;X*fSlORi6xA4hSb-PXpPy|(`~
zPTY=CmcAG94WbB^yN?MUN$ATwHgiL8!&wvl61lA)`4A*oKpK-Do`o$=!z_%cuh;m~
zE5nEFY+t>>&)VphY_E01n=s8(UQpWT8MdP+Ds9xqoLSVzypP@dreJ386?jLOxlT)1
zJH=c%b5}MySNgoGY!=hcOXs*bVV3pdPH-<P9C_h(D;#%#+pBQQ8?II1r~&R>g=5xm
zA1fTS!F{T5%o^@<g=5xmdYWa;%o&cM(HrJGBVk!QE1kR1D`uMas%~^a(@%E#fE{0Y
z%x*bi;A#~P9ge$m7IQnBOFlO+c}8_AIcAiBIP`I8^rI=6P&|DAV`~c212_cCUC9OB
zEU>L}OnAWf=}T*|z=Jt7@k7#y=M2spDRk<e6uzt-4m|A)nzsXI>mrUb*sb7St?`O5
z_4Dqi5zI{BsBv6-Q$iio2%eDeR=DG&c6`Zi@6eQvKlWSNIgfK~{DO2A_S@Qtr*7<d
z9)SwJZ_tlzn}0=^7~&skxA&bAUKJ)sQ!*`$_rck4*bw5@wKG@j+#Aeq8V>u@LMIkG
znD=7s&!u-stR2kn9&TOTp+4rqBId6cdPXkZ3BL{M2GgVY0>6?Mb03!QR(KCv@}YkI
z58&~k?^h+vig{R{YXxufTo*o{XG$FWFXbWc4GD4Z17hIp?|}PY|5^CnlujMk?HM!D
zIio4Db<9eKZz+y@&Pj-cf1!@p{|0jK2JT3>%YuX)yob9IcrZEcNr-z})bgO<w3Xaa
z!BKZhQOxI|1Yc~665i8q<-oQq;T(LZi#fni7jNsa1a3uw9ZU{tB7Q@H9e>`)GYRjA
Xd*Bbo$NIl8dT!%Af&b~%Y)JkC&Qy%r

diff --git a/shaders/vk/pattern.vert b/shaders/vk/pattern.vert
index b0d8af7..e51a40f 100644
--- a/shaders/vk/pattern.vert
+++ b/shaders/vk/pattern.vert
@@ -29,8 +29,7 @@ layout(location = 0) out vec2 v_anchor;
 layout(location = 1) out vec2 v_cell;
 
 void main() {
-    vec2 world = vec2(a_pos.x + round(u.wrap_x - a_pos.x), a_pos.y);
-    vec4 clip = u.mvp * vec4(world, 0.0, 1.0);
+    vec4 clip = u.mvp * vec4(a_pos, 0.0, 1.0);
     vec2 off = a_off;
     if ((a_flags & 1u) != 0u) {
         off = vec2(off.x * u.rot_cos - off.y * u.rot_sin,
diff --git a/shaders/vk/pattern.vert.spv b/shaders/vk/pattern.vert.spv
index b805fd29b89c87892107d0f381e206162e8e2740..6b3bada45fa88cd4181ee67bbf7d0c9ee61a83a5 100644
GIT binary patch
literal 4004
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
ICU-aZAJkhP9RL6T

literal 4292
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
RpONMDzs9QmACub!{s)lKJrn={

diff --git a/shaders/vk/sprite.vert b/shaders/vk/sprite.vert
index ef93742..2f49e09 100644
--- a/shaders/vk/sprite.vert
+++ b/shaders/vk/sprite.vert
@@ -41,8 +41,7 @@ void main() {
     bool flip  = ((a_pack >> 8) & 0xFFu) != 0u;
     float tangent = float((a_pack >> 16) & 0xFFu) / 256.0 * 6.2831853071795864;
 
-    vec2 world = vec2(a_pos.x + round(u.wrap_x - a_pos.x), a_pos.y);
-    vec4 clip = u.mvp * vec4(world, 0.0, 1.0);
+    vec4 clip = u.mvp * vec4(a_pos, 0.0, 1.0);
 
     vec2 off = a_off;
     // Keep a tangent-rotated run (line-following text) upright: if the run,
diff --git a/shaders/vk/sprite.vert.spv b/shaders/vk/sprite.vert.spv
index fb017580d190640f6071ba7d3a1e3f82aaeed94a..634a8937c691fdd5f18f82d0a440c86e337b7160 100644
GIT binary patch
literal 5280
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

literal 5568
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
Coa(y(

diff --git a/src/camera.zig b/src/camera.zig
index 2a1cdc4..d5d4d80 100644
--- a/src/camera.zig
+++ b/src/camera.zig
@@ -23,6 +23,38 @@ pub fn wrapDx(a: f64, b: f64) f64 {
     return d - std.math.round(d);
 }
 
+/// Where a tile's left edge sits in a frame whose origin is `origin_x`,
+/// choosing the world copy nearest that origin.
+///
+/// Longitude is cyclic, so every tile has a copy each 1.0 world units and the
+/// renderer has to pick one, for the tile as a whole. Nearest is measured at
+/// the tile's CENTRE: judged by its left edge, a tile a whole span wide counts
+/// as near when only its far corner is, and the body of it lands a world away
+/// from what the view is looking at.
+pub fn placeTileX(x0: f64, span: f64, origin_x: f64) f64 {
+    return wrapDx(x0 + span * 0.5, origin_x) - span * 0.5;
+}
+
+/// The other world copy of a tile that a view can also see, as the offset to
+/// add to its placement (`-1` or `+1`), or null when one copy is enough.
+///
+/// `dx` is the placement placeTileX chose and `span` the tile's width, both in
+/// world units in a frame centred on the view; `half_w` is the view's own half
+/// width there. Longitude is cyclic, so a tile recurs every 1.0 world units:
+/// once the view is wider than the gap between two copies -- which happens
+/// from about z1 down, where a tile is a large fraction of the world -- the
+/// same tile is visible on both sides and has to be DRAWN on both sides. One
+/// placement per tile leaves a wedge of empty ocean instead.
+///
+/// At most one copy can qualify: a tile is at most one world wide, so its
+/// copies are at least that far apart.
+pub fn wrappedCopy(dx: f64, span: f64, half_w: f64) ?f64 {
+    for ([2]f64{ -1, 1 }) |k| {
+        if (dx + k < half_w and dx + k + span > -half_w) return k;
+    }
+    return null;
+}
+
 /// lon/lat (degrees) -> normalized web-mercator [0,1], y down.
 pub fn lonLatToWorld(lon: f64, lat: f64) Vec2 {
     const x = wrapX((lon + 180.0) / 360.0);
@@ -90,7 +122,13 @@ pub const Camera = struct {
         const b: f64 = 2.0 * s / @as(f64, self.vh);
         const c = std.math.cos(self.rotation);
         const sn = std.math.sin(self.rotation);
-        const dx = origin.x - self.center.x; // added before rotate/scale
+        // SHORT WAY in x: the camera and a scene origin are both world x in
+        // [0,1), so a camera that has crossed the antimeridian since the
+        // scene was built is a whole world away by subtraction and next door
+        // by longitude. Wrapping here turns the whole scene at once, which is
+        // the only place the turn can happen without splitting geometry: a
+        // per-vertex wrap tears any primitive lying across the seam.
+        const dx = wrapDx(origin.x, self.center.x); // added before rotate/scale
         const dy = origin.y - self.center.y;
         var m = [_]f32{0} ** 16;
         m[0] = @floatCast(a * c);
@@ -361,3 +399,60 @@ test "halfExtents holds the corners of a rotated viewport" {
         }
     }
 }
+
+// The seamap style over a wide view came out as horizontal bands stretched
+// across the map: the vertex stages chose a world copy PER VERTEX, so a
+// triangle lying across the half-world seam had corners a whole world apart.
+// The choice is the host's now, and these are the two halves of it.
+test "placeTileX puts a whole tile on its nearest copy" {
+    const std_testing = std.testing;
+    // z2: four columns, a quarter of the world each.
+    const span = 0.25;
+    inline for (.{ 0.0, 0.1234, 0.2361, 0.5, 0.75, 0.9999 }) |origin_x| {
+        var col: usize = 0;
+        while (col < 4) : (col += 1) {
+            const x0 = @as(f64, @floatFromInt(col)) * span;
+            const dx = placeTileX(x0, span, origin_x);
+            // Still the same geography: a whole number of worlds from where
+            // the tile actually is.
+            const worlds = dx - (x0 - origin_x);
+            try std_testing.expectApproxEqAbs(@round(worlds), worlds, 1e-12);
+            // And the nearest copy of it, measured where the tile IS rather
+            // than at its left edge -- which is what keeps the body of a tile
+            // on the near side instead of a corner of it.
+            try std_testing.expect(@abs(dx + span * 0.5) <= 0.5);
+        }
+    }
+}
+
+test "wrappedCopy asks for the second copy only when the view can see it" {
+    const std_testing = std.testing;
+    // z1: two columns, half the world each, and a view of the whole world.
+    // The column placed off to the west is visible in the east as well, and
+    // has to be drawn there too or that side is empty ocean.
+    try std_testing.expectEqual(@as(?f64, 1), wrappedCopy(-0.7361, 0.5, 0.5));
+    // The same tile under a view half that wide is off screen on both sides.
+    try std_testing.expect(wrappedCopy(-0.7361, 0.5, 0.25) == null);
+    // A tile under the camera never needs a second copy: its other copies are
+    // a world away, and no view is that wide.
+    try std_testing.expect(wrappedCopy(-0.1, 0.25, 0.5) == null);
+}
+
+// mvpOrigin's x delta takes the short way round. Without that a camera that
+// crossed the antimeridian since the scene was built is a whole world from
+// its origin by subtraction, and the scene is translated off screen.
+test "mvpOrigin turns the whole scene at the antimeridian" {
+    const std_testing = std.testing;
+    const cam = Camera{
+        .origin = .{ .x = 0.99, .y = 0.5 },
+        .center = .{ .x = 0.01, .y = 0.5 },
+        .zoom = 4,
+        .vw = 1024,
+        .vh = 768,
+    };
+    const near = cam.mvpOrigin(cam.origin);
+    // 0.99 is 0.02 WEST of 0.01, not 0.98 east: the translation is the small
+    // one, and of the sign that puts the origin left of centre.
+    const a = 2.0 * cam.worldToPx() / @as(f64, cam.vw);
+    try std_testing.expectApproxEqAbs(@as(f32, @floatCast(a * -0.02)), near[12], 1e-3);
+}
diff --git a/src/map.zig b/src/map.zig
index 14b6746..65190d7 100644
--- a/src/map.zig
+++ b/src/map.zig
@@ -42,6 +42,11 @@ pub const SourcedTile = struct {
     /// Empty means unlabeled, which matches any layer: a caller with one
     /// source has nothing to disambiguate.
     source: []const u8 = "",
+    /// Which world copy to draw this tile at: 0 for the one nearest the view
+    /// origin, -1 or +1 for the copy a world away. Longitude is cyclic, and a
+    /// view wide enough sees the same tile on both sides (Camera.wrappedCopy),
+    /// so the same tile is listed twice with different values here.
+    wrap: f64 = 0,
 };
 
 /// The build's output: everything Gpu.SceneData borrows, plus the effective
@@ -289,6 +294,8 @@ pub const RasterTile = struct {
     /// the starting alpha (in: 0, out: opaque) and records the quad span in
     /// Built.fades; the Map animates it through the quad paint stream.
     fade: Fade = .none,
+    /// Which world copy to draw at — see SourcedTile.wrap.
+    wrap: f64 = 0,
 
     pub const Fade = enum(u2) { none, in, out };
 };
@@ -896,7 +903,12 @@ pub fn buildSceneWithRasters(
             // that column's own world position puts it on the wrong side of
             // the map. Harmless while the viewport is a sliver of the world;
             // at low zoom it scrambles the geography.
-            const dx: f32 = @floatCast(cameras.wrapDx(rect.x0, view.origin.x));
+            //
+            // By the tile's CENTRE, so the whole tile lands on one copy. The
+            // left edge alone leaves the body reaching a full tile span past
+            // the half-world seam, and at low zoom -- where a tile is a large
+            // fraction of the world -- that is most of the tile.
+            const dx: f32 = @floatCast(cameras.placeTileX(rect.x0, tile_span, view.origin.x) + st.wrap);
             const dy: f32 = @floatCast(rect.y0 - view.origin.y);
             const tile_quads_first: u32 = @intCast(quads.items.len);
             var text_scratch: std.ArrayList(types.Quad) = .empty;
@@ -1230,7 +1242,7 @@ fn layoutDemLayer(
         }
 
         const rect = rt.id.worldRect();
-        const x0: f32 = @floatCast(cameras.wrapDx(rect.x0, view.origin.x));
+        const x0: f32 = @floatCast(cameras.placeTileX(rect.x0, rect.x1 - rect.x0, view.origin.x) + rt.wrap);
         const y0: f32 = @floatCast(rect.y0 - view.origin.y);
         const x1: f32 = x0 + @as(f32, @floatCast(rect.x1 - rect.x0));
         const y1: f32 = @floatCast(rect.y1 - view.origin.y);
@@ -1364,7 +1376,7 @@ fn layoutRasterLayer(
         if (rt.rgba.len < @as(usize, rt.w) * rt.h * 4) continue;
 
         const rect = rt.id.worldRect();
-        const x0: f32 = @floatCast(cameras.wrapDx(rect.x0, view.origin.x));
+        const x0: f32 = @floatCast(cameras.placeTileX(rect.x0, rect.x1 - rect.x0, view.origin.x) + rt.wrap);
         const y0: f32 = @floatCast(rect.y0 - view.origin.y);
         const x1: f32 = x0 + @as(f32, @floatCast(rect.x1 - rect.x0));
         const y1: f32 = @floatCast(rect.y1 - view.origin.y);
@@ -2641,7 +2653,7 @@ test "concatScenes: per-tile geometry plus a global symbol pass equals one build
         }, .{});
         try parts.append(a, .{
             .built = part,
-            .dx = @floatCast(cameras.wrapDx(rect.x0, view.origin.x)),
+            .dx = @floatCast(cameras.placeTileX(rect.x0, rect.x1 - rect.x0, view.origin.x)),
             .dy = @floatCast(rect.y0 - view.origin.y),
         });
     }
diff --git a/src/map_object.zig b/src/map_object.zig
index a09db76..9ba9bd0 100644
--- a/src/map_object.zig
+++ b/src/map_object.zig
@@ -1696,6 +1696,10 @@ pub const Map = struct {
         // would outlive the eviction that frees it.
         var parts: std.ArrayListUnmanaged(map.ScenePart) = .empty;
         defer parts.deinit(self.gpa);
+        // How far the scene has to reach either side of the origin, so a tile
+        // the view sees on BOTH sides of the world can be drawn on both.
+        const half_w = self.extentsAt(zoom).x;
+        var tile_parts: usize = 0;
         var vector_tiles: std.ArrayListUnmanaged(map.SourcedTile) = .empty;
         var rasters: std.ArrayListUnmanaged(map.RasterTile) = .empty;
         // How many tiles this pass may TESSELLATE. Cached buckets are free
@@ -1728,11 +1732,26 @@ pub const Map = struct {
             switch (self.cache.sourceKind(key)) {
                 .vector => {
                     const tile = self.cache.get(key) orelse continue;
+                    const rect = key.tileId().worldRect();
+                    const span = rect.x1 - rect.x0;
+                    // The nearest world copy: see the note in map.zig. A view
+                    // wide enough sees the same tile on both sides of the
+                    // world, and then it is listed -- and placed -- twice.
+                    const dx = cameras.placeTileX(rect.x0, span, origin.x);
+                    const second = cameras.wrappedCopy(dx, span, half_w);
                     try vector_tiles.append(a, .{
                         .id = key.tileId(),
                         .tile = tile,
                         .source = self.sourceName(key.source),
                     });
+                    if (second) |copy_dx| {
+                        try vector_tiles.append(a, .{
+                            .id = key.tileId(),
+                            .tile = tile,
+                            .source = self.sourceName(key.source),
+                            .wrap = copy_dx,
+                        });
+                    }
                     if (!self.bucketReady(key, zoom)) {
                         if (budget == 0) {
                             deferred += 1;
@@ -1741,17 +1760,26 @@ pub const Map = struct {
                         budget -= 1;
                     }
                     const bucket = (try self.bucketFor(style, key, zoom)) orelse continue;
-                    const rect = key.tileId().worldRect();
+                    const dy: f32 = @floatCast(rect.y0 - origin.y);
                     try parts.append(self.gpa, .{
                         .built = bucket.built,
-                        // The nearest world copy: see the note in map.zig.
-                        .dx = @floatCast(cameras.wrapDx(rect.x0, origin.x)),
-                        .dy = @floatCast(rect.y0 - origin.y),
+                        .dx = @floatCast(dx),
+                        .dy = dy,
                     });
+                    tile_parts += 1;
+                    // The same bucket, placed a world over: the second copy
+                    // costs a rebase at concatenation, not a tessellation.
+                    if (second) |copy_dx| {
+                        try parts.append(self.gpa, .{
+                            .built = bucket.built,
+                            .dx = @floatCast(dx + copy_dx),
+                            .dy = dy,
+                        });
+                    }
                 },
                 .raster => {
                     const img = self.cache.getRaster(key) orelse continue;
-                    try rasters.append(a, .{
+                    const rt = map.RasterTile{
                         .id = key.tileId(),
                         .source = self.sourceName(key.source),
                         .w = img.w,
@@ -1760,7 +1788,16 @@ pub const Map = struct {
                         // A source whose level swapped fades its new tiles
                         // in from invisible over the outgoing ones.
                         .fade = if (self.build_fade_sources & (@as(u8, 1) << key.source) != 0) .in else .none,
-                    });
+                    };
+                    try rasters.append(a, rt);
+                    const rect = key.tileId().worldRect();
+                    const span = rect.x1 - rect.x0;
+                    const dx = cameras.placeTileX(rect.x0, span, origin.x);
+                    if (cameras.wrappedCopy(dx, span, half_w)) |copy_dx| {
+                        var copy = rt;
+                        copy.wrap = copy_dx;
+                        try rasters.append(a, copy);
+                    }
                 },
             }
         }
@@ -1797,7 +1834,9 @@ pub const Map = struct {
             // Tiles whose geometry is actually IN the scene: `have` less
             // whatever the budget deferred. The gap is what a test can watch
             // to catch the scene silently losing ground.
-            .scene_tiles = parts.items.len - 1, // less the global pass
+            // Distinct tiles, not parts: a tile the view sees on both sides
+            // of the world is placed twice and is still one tile.
+            .scene_tiles = tile_parts,
             .partial = deferred > 0,
             .origin = origin,
             .zoom = zoom,
diff --git a/src/scene/types.zig b/src/scene/types.zig
index 2b4620a..fb524c1 100644
--- a/src/scene/types.zig
+++ b/src/scene/types.zig
@@ -262,7 +262,13 @@ pub const Uniforms = extern struct {
     /// slope is the continuous answer and snapping back to a bracket end is
     /// exactly the jump this field exists to remove.
     zoom_t: f32,
-    wrap_x: f32, // camera centre world-x (antimeridian wrap)
+    /// RESERVED. It carried the antimeridian wrap the vertex stages used to
+    /// apply per vertex — which tore every primitive lying across the
+    /// half-world seam, because the corners on one side moved a whole world
+    /// and the corners on the other did not. The choice of world copy is the
+    /// host's now: once per tile in Camera.placeTileX, once per scene in
+    /// Camera.mvpOrigin. Kept so the block stays 128 bytes.
+    wrap_x: f32,
     rot_sin: f32,
     rot_cos: f32,
     color: [4]f32, // SDF halo background; SDF fragment stage only

From 1a7fa4031c8f72aa20e3edb5d3773cc8daaecdc3 Mon Sep 17 00:00:00 2001
From: Jeremy Collins <jeremy.collins@beetlebug.org>
Date: Wed, 9 Sep 2026 21:07:37 -0400
Subject: [PATCH 2/2] Drop the retired wrap from the overlay uniform

charttable's vertex stages placed each vertex at the world copy nearest
the camera, and wanted that offset stated beside the MVP. Applied per
vertex it split any primitive lying across the half-world seam, so the
choice moved to the host, per tile and per scene. Camera.mvpOrigin,
which the overlay already builds its MVP with, wraps the x delta itself.
The wrap_x field is gone from Uniforms.
---
 DESIGN.md                       |  12 +++--
 examples/macos/main.m           |   1 +
 shaders/d3d12/README.md         |   2 +-
 shaders/d3d12/fill.frag.hlsl    |  28 +++++++++++
 shaders/d3d12/fill.vert.hlsl    |  29 ++++++++---
 shaders/d3d12/overlay.vert.hlsl |   9 ++--
 shaders/d3d12/pattern.frag.hlsl |  28 +++++++++++
 shaders/d3d12/pattern.vert.hlsl |  12 ++++-
 shaders/d3d12/sdf.frag.hlsl     |   3 +-
 shaders/d3d12/sprite.vert.hlsl  |   3 +-
 shaders/metal.metal             |  57 +++++++++++++++++-----
 shaders/vk/README.md            |   4 +-
 shaders/vk/fill.frag            |  31 +++++++++++-
 shaders/vk/fill.frag.spv        | Bin 372 -> 2240 bytes
 shaders/vk/fill.vert            |  29 ++++++++---
 shaders/vk/fill.vert.spv        | Bin 5080 -> 6164 bytes
 shaders/vk/overlay.vert         |   9 ++--
 shaders/vk/overlay.vert.spv     | Bin 1844 -> 1900 bytes
 shaders/vk/pattern.frag         |  23 +++++++++
 shaders/vk/pattern.frag.spv     | Bin 1248 -> 3012 bytes
 shaders/vk/pattern.vert         |  12 ++++-
 shaders/vk/pattern.vert.spv     | Bin 4004 -> 5072 bytes
 shaders/vk/sdf.frag             |   3 +-
 shaders/vk/sdf.frag.spv         | Bin 3032 -> 3088 bytes
 shaders/vk/sprite.vert          |   3 +-
 shaders/vk/sprite.vert.spv      | Bin 5280 -> 5336 bytes
 src/camera.zig                  |  82 ++++++++++++++++----------------
 src/gpu/gpu_d3d12.zig           |   9 +++-
 src/gpu/gpu_metal.zig           |  25 +++++++---
 src/gpu/gpu_vk.zig              |  18 +++++--
 src/gpu/metal_shim.m            |   3 +-
 src/layout/fill.zig             |   4 +-
 src/map.zig                     |  40 ++++++++++++----
 src/map_object.zig              |  19 ++++----
 src/scene/batch.zig             |  26 ++++++++++
 src/scene/types.zig             |  50 +++++++++++++++----
 36 files changed, 446 insertions(+), 128 deletions(-)

diff --git a/DESIGN.md b/DESIGN.md
index a89b017..d05a840 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -115,10 +115,16 @@ independently, so the unit of tessellation is the tile:
 
 - **Layout** runs per (tile × style-layer) on worker threads: decode →
   filter → evaluate data-driven properties → tessellate into *buckets*.
-  A bucket's vertices are **tile-local f32** (origin at tile corner); each
-  tile draws with its own tile→clip matrix (lookout's origin-relative rule:
+  A bucket's vertices are **tile-local f32** (origin at tile corner), so a
+  cached bucket is reusable at any camera (lookout's origin-relative rule:
   absolute world f32 quantizes visibly at depth; `overlay.zig` proved the
-  fix).
+  fix). At CONCATENATION the buckets are rebased onto one scene origin, and
+  the scene draws with one matrix, one draw per (tile × layer). The host
+  therefore picks the world copy at the antimeridian, per tile and per scene,
+  because a per-vertex choice splits a primitive lying across the seam
+  (`Camera.placeTileX`). A tile's own bounds also travel with its geometry,
+  because a merged scene has no per-tile draw state to clip against
+  (`scene.CLIP_NONE`).
 - **Fills and lines** draw straight from resident buckets — pan/zoom/rotate
   never re-tessellates; a zoom change is a matrix change until the tile set
   itself changes (then new tiles lay out async while old ones keep drawing —
diff --git a/examples/macos/main.m b/examples/macos/main.m
index 40e2bc8..ee23bea 100644
--- a/examples/macos/main.m
+++ b/examples/macos/main.m
@@ -823,6 +823,7 @@ int main(int argc, const char *argv[]) {
         if ((ev = getenv("CHARTTABLE_LON"))) v.lon = atof(ev);
         if ((ev = getenv("CHARTTABLE_LAT"))) v.lat = atof(ev);
         if ((ev = getenv("CHARTTABLE_ZOOM"))) v.zoom = atof(ev);
+        if ((ev = getenv("CHARTTABLE_BEARING"))) v.bearing_deg = atof(ev);
 
         BOOL composing = NO;
 #ifdef USE_TILE57_COMPOSE
diff --git a/shaders/d3d12/README.md b/shaders/d3d12/README.md
index d711237..e64cdce 100644
--- a/shaders/d3d12/README.md
+++ b/shaders/d3d12/README.md
@@ -54,7 +54,7 @@ Three root parameters and one static sampler, shared by all five pipelines:
 
 Both CBVs are root descriptors pointed at a per-draw slice of one upload-heap
 ring, so a draw costs one address write and no descriptor allocation. The block
-is `scene.Uniforms`, 128 bytes; HLSL's constant-buffer packing lands every field
+is `scene.Uniforms`, 144 bytes; HLSL's constant-buffer packing lands every field
 at the offset the struct declares.
 
 ## Conventions this backend does not have to correct for
diff --git a/shaders/d3d12/fill.frag.hlsl b/shaders/d3d12/fill.frag.hlsl
index 4079b1b..113ab34 100644
--- a/shaders/d3d12/fill.frag.hlsl
+++ b/shaders/d3d12/fill.frag.hlsl
@@ -1,11 +1,39 @@
 // Flat color straight from stream B, blended in paint order by the
 // fixed-function blend state.
 
+// b0 is visible to both stages (the root signature says ALL), so the pixel
+// stage reads the same block the vertex stage did.
+cbuffer U : register(b0) {
+    column_major float4x4 u_mvp;
+    float2 u_px_to_clip;
+    float  u_size_scale;
+    float  u_zoom;
+    float  u_zoom_t;
+    float  u_world_per_px;
+    float  u_rot_sin;
+    float  u_rot_cos;
+    float4 u_color;
+    float2 u_anchor_px;
+    float2 u_cell_px;
+    float4 u_clip_rect;
+};
+
+// A tile's triangles paint their own tile. The geometry keeps the buffered
+// overhang a line's joins are built from, and the draw trims it
+// (scene.CLIP_NONE). A draw with no tile of its own is set to CLIP_NONE and
+// pays one compare.
+bool clipped(float2 world) {
+    return world.x < u_clip_rect.x || world.y < u_clip_rect.y ||
+           world.x > u_clip_rect.z || world.y > u_clip_rect.w;
+}
+
 struct PSIn {
     float4 pos   : SV_Position;
     float4 color : TEXCOORD0;
+    float2 world : TEXCOORD1;
 };
 
 float4 main(PSIn i) : SV_Target {
+    if (clipped(i.world)) discard;
     return i.color;
 }
diff --git a/shaders/d3d12/fill.vert.hlsl b/shaders/d3d12/fill.vert.hlsl
index 74b41b1..b05ee8a 100644
--- a/shaders/d3d12/fill.vert.hlsl
+++ b/shaders/d3d12/fill.vert.hlsl
@@ -11,12 +11,13 @@ cbuffer U : register(b0) {
     float  u_size_scale;
     float  u_zoom;       // fractional zoom * 256
     float  u_zoom_t;
-    float  u_wrap_x;
+    float  u_world_per_px;
     float  u_rot_sin;
     float  u_rot_cos;
     float4 u_color;
     float2 u_anchor_px;
     float2 u_cell_px;
+    float4 u_clip_rect; // the tile a triangle draw may paint: x0, y0, x1, y1
 };
 
 struct VSIn {
@@ -35,13 +36,14 @@ struct VSIn {
 struct VSOut {
     float4 pos   : SV_Position;
     float4 color : TEXCOORD0;
+    float2 world : TEXCOORD1;
 };
 
-// Longitude is cyclic, so every tile has a world copy every 1.0 world units
-// and one of them has to be drawn. That choice belongs to the HOST, which
-// makes it once per tile (Camera.placeTileX) and again once per scene, in the
-// matrix (Camera.mvpOrigin takes the short way round in x). Deciding it here,
-// per vertex, tore every primitive lying across the half-world seam.
+// Longitude is cyclic, so a tile has a world copy every 1.0 world units and
+// one of them is drawn. The host picks it, once per tile (Camera.placeTileX)
+// and once per scene in the matrix (Camera.mvpOrigin wraps its x delta).
+// Picking it here, per vertex, split every primitive lying across the
+// half-world seam.
 float4 project(float2 p) {
     return mul(u_mvp, float4(p, 0.0, 1.0));
 }
@@ -57,6 +59,20 @@ bool gate(uint zwin) {
 // (ox, oy) is added AFTER projection, in reference px. map_align means it is
 // stated in the MAP frame: a rotated view must turn it, or the pen shears to
 // |cos(rotation)| of its width.
+// The world position a vertex's fragments cover: the vertex position plus its
+// screen-space (ox, oy) converted to world units. The offset is applied after
+// projection, so a line's stroke reaches ground its anchor does not, and a
+// clip test against the anchor alone cuts the stroke along its length.
+//
+// Undoing the projection needs no inverse. The linear part of mvp is scale
+// times rotation, so R(-view) applied to the offset and divided by pixels per
+// world unit gives the world delta of the clip-space offset.
+float2 world_of(float2 p, float2 off) {
+    float2 back = float2( off.x * u_rot_cos + off.y * u_rot_sin,
+                         -off.x * u_rot_sin + off.y * u_rot_cos);
+    return p + back * u_size_scale * u_world_per_px;
+}
+
 float2 screen_offset(float2 off, uint flags) {
     if ((flags & 1) != 0) {
         off = float2(off.x * u_rot_cos - off.y * u_rot_sin,
@@ -82,5 +98,6 @@ VSOut main(VSIn i) {
     // Clamped: mid-gesture zoom_t can leave [0,1]; hold the end color
     // rather than wrapping to the far one.
     o.color = lerp(i.a_color, i.a_color_hi, saturate(u_zoom_t));
+    o.world = world_of(i.a_pos, off);
     return o;
 }
diff --git a/shaders/d3d12/overlay.vert.hlsl b/shaders/d3d12/overlay.vert.hlsl
index 52532c1..0cefce1 100644
--- a/shaders/d3d12/overlay.vert.hlsl
+++ b/shaders/d3d12/overlay.vert.hlsl
@@ -8,12 +8,13 @@ cbuffer U : register(b0) {
     float  u_size_scale;
     float  u_zoom;
     float  u_zoom_t;
-    float  u_wrap_x;
+    float  u_world_per_px;
     float  u_rot_sin;
     float  u_rot_cos;
     float4 u_color;
     float2 u_anchor_px;
     float2 u_cell_px;
+    float4 u_clip_rect; // the tile a triangle draw may paint: x0, y0, x1, y1
 };
 
 struct VSIn {
@@ -28,9 +29,9 @@ struct VSOut {
 
 VSOut main(VSIn i) {
     VSOut o;
-    // No antimeridian wrap here: the host turns the whole frame at once, in
-    // the matrix (Camera.mvpOrigin). Wrapping per vertex tore any primitive
-    // lying across the half-world seam.
+    // The host places the whole frame at once, in the matrix
+    // (Camera.mvpOrigin). A per-vertex wrap split any primitive lying across
+    // the half-world seam.
     float4 clip = mul(u_mvp, float4(i.a_world, 0.0, 1.0));
     // z = 0 is the near plane. The chart's paint-order depths are all in (0,1)
     // and this pass writes no depth, so host content is never hidden by the
diff --git a/shaders/d3d12/pattern.frag.hlsl b/shaders/d3d12/pattern.frag.hlsl
index a031779..cb51c24 100644
--- a/shaders/d3d12/pattern.frag.hlsl
+++ b/shaders/d3d12/pattern.frag.hlsl
@@ -7,13 +7,41 @@
 Texture2D    cell_tex : register(t0);
 SamplerState cell_smp : register(s0);
 
+// b0 is visible to both stages (the root signature says ALL), so the pixel
+// stage reads the same block the vertex stage did.
+cbuffer U : register(b0) {
+    column_major float4x4 u_mvp;
+    float2 u_px_to_clip;
+    float  u_size_scale;
+    float  u_zoom;
+    float  u_zoom_t;
+    float  u_world_per_px;
+    float  u_rot_sin;
+    float  u_rot_cos;
+    float4 u_color;
+    float2 u_anchor_px;
+    float2 u_cell_px;
+    float4 u_clip_rect;
+};
+
+// A tile's triangles paint their own tile. The geometry keeps the buffered
+// overhang a line's joins are built from, and the draw trims it
+// (scene.CLIP_NONE). A draw with no tile of its own is set to CLIP_NONE and
+// pays one compare.
+bool clipped(float2 world) {
+    return world.x < u_clip_rect.x || world.y < u_clip_rect.y ||
+           world.x > u_clip_rect.z || world.y > u_clip_rect.w;
+}
+
 struct PSIn {
     float4 pos    : SV_Position;
     float2 anchor : TEXCOORD0;
     float2 cell   : TEXCOORD1;
+    float2 world  : TEXCOORD2;
 };
 
 float4 main(PSIn i) : SV_Target {
+    if (clipped(i.world)) discard;
     float2 sz = max(i.cell, float2(1.0, 1.0));
     float2 uv = frac((i.pos.xy - i.anchor) / sz);
     float4 c = cell_tex.Sample(cell_smp, uv);
diff --git a/shaders/d3d12/pattern.vert.hlsl b/shaders/d3d12/pattern.vert.hlsl
index acca866..e88cedf 100644
--- a/shaders/d3d12/pattern.vert.hlsl
+++ b/shaders/d3d12/pattern.vert.hlsl
@@ -10,12 +10,13 @@ cbuffer U : register(b0) {
     float  u_size_scale;
     float  u_zoom;
     float  u_zoom_t;
-    float  u_wrap_x;
+    float  u_world_per_px;
     float  u_rot_sin;
     float  u_rot_cos;
     float4 u_color;
     float2 u_anchor_px;
     float2 u_cell_px;
+    float4 u_clip_rect; // the tile a triangle draw may paint: x0, y0, x1, y1
 };
 
 struct VSIn {
@@ -30,8 +31,16 @@ struct VSOut {
     float4 pos    : SV_Position;
     float2 anchor : TEXCOORD0;
     float2 cell   : TEXCOORD1;
+    float2 world  : TEXCOORD2;
 };
 
+// See fill.vert.hlsl: the world position a vertex's fragments actually land on.
+float2 world_of(float2 p, float2 off) {
+    float2 back = float2( off.x * u_rot_cos + off.y * u_rot_sin,
+                         -off.x * u_rot_sin + off.y * u_rot_cos);
+    return p + back * u_size_scale * u_world_per_px;
+}
+
 VSOut main(VSIn i) {
     VSOut o;
     float4 clip = mul(u_mvp, float4(i.a_pos, 0.0, 1.0));
@@ -49,5 +58,6 @@ VSOut main(VSIn i) {
     o.pos = vis ? clip : float4(0.0, 0.0, 2.0, 1.0);
     o.anchor = u_anchor_px;
     o.cell = u_cell_px;
+    o.world = world_of(i.a_pos, off);
     return o;
 }
diff --git a/shaders/d3d12/sdf.frag.hlsl b/shaders/d3d12/sdf.frag.hlsl
index bdfa9d0..7bd022f 100644
--- a/shaders/d3d12/sdf.frag.hlsl
+++ b/shaders/d3d12/sdf.frag.hlsl
@@ -18,12 +18,13 @@ cbuffer U : register(b1) {
     float  u_size_scale;
     float  u_zoom;
     float  u_zoom_t;
-    float  u_wrap_x;
+    float  u_world_per_px;
     float  u_rot_sin;
     float  u_rot_cos;
     float4 u_color;      // the SDF halo color for this draw
     float2 u_anchor_px;
     float2 u_cell_px;
+    float4 u_clip_rect; // the tile a triangle draw may paint: x0, y0, x1, y1
 };
 
 struct PSIn {
diff --git a/shaders/d3d12/sprite.vert.hlsl b/shaders/d3d12/sprite.vert.hlsl
index adb09dc..a48551a 100644
--- a/shaders/d3d12/sprite.vert.hlsl
+++ b/shaders/d3d12/sprite.vert.hlsl
@@ -12,12 +12,13 @@ cbuffer U : register(b0) {
     float  u_size_scale;
     float  u_zoom;
     float  u_zoom_t;
-    float  u_wrap_x;
+    float  u_world_per_px;
     float  u_rot_sin;
     float  u_rot_cos;
     float4 u_color;
     float2 u_anchor_px;
     float2 u_cell_px;
+    float4 u_clip_rect; // the tile a triangle draw may paint: x0, y0, x1, y1
 };
 
 struct VSIn {
diff --git a/shaders/metal.metal b/shaders/metal.metal
index 21fc447..0d9e380 100644
--- a/shaders/metal.metal
+++ b/shaders/metal.metal
@@ -25,14 +25,15 @@ struct U {
     float    size_scale; // pixel density x symbol size multiplier
     float    zoom;       // fractional zoom * 256, tested against zmin/zmax
     float    zoom_t;     // fract(zoom): mix factor for zoom-interpolated paint
-    float    wrap_x;     // RESERVED: the host now wraps per tile and per scene
+    float    world_per_px; // world units per reference px (offset -> world)
     float    rot_sin;
     float    rot_cos;
     float4   color;      // SDF halo background; SDF fragment stage only
     float2   anchor_px;  // pattern phase origin, framebuffer px
     float2   cell_px;    // pattern cell period, framebuffer px
+    float4   clip_rect;  // the tile a triangle draw may paint: x0, y0, x1, y1
 };
-static_assert(sizeof(U) == 128, "U must match scene.Uniforms (128 B)");
+static_assert(sizeof(U) == 144, "U must match scene.Uniforms (144 B)");
 
 // ---- vertex streams (== scene/types.zig structs) ----------------------------
 struct Vertex {                 // scene.Vertex, 28 B
@@ -72,13 +73,13 @@ static_assert(sizeof(Quad) == 40, "Quad must match scene.Quad (40 B)");
 
 constant uint FLAG_MAP_ALIGN = 1u;
 
-// Longitude is cyclic, so every tile has a world copy every 1.0 world units
-// and one of them has to be drawn. That choice belongs to the HOST, which
-// makes it once per tile (Camera.placeTileX) and again once per scene, in the
-// matrix (Camera.mvpOrigin takes the short way round in x). Deciding it here,
-// per vertex, tore every primitive lying across the half-world seam: the
-// corners on one side moved a whole world and the corners on the other did
-// not, so a coastline came out as a band stretched across the map.
+// Longitude is cyclic, so a tile has a world copy every 1.0 world units and
+// one of them is drawn. The host picks it, once per tile (Camera.placeTileX)
+// and once per scene in the matrix (Camera.mvpOrigin wraps its x delta).
+// Picking it here, per vertex, split every primitive lying across the
+// half-world seam: the corners on one side moved a whole world and the
+// corners on the other did not, so a coastline drew as a band stretched
+// across the map.
 static inline float4 project(constant U &u, float2 p) {
     return u.mvp * float4(p, 0.0, 1.0);
 }
@@ -107,6 +108,7 @@ static inline float2 screen_offset(constant U &u, float2 off, uchar flags) {
 struct FillOut {
     float4 pos [[position]];
     float4 color;
+    float2 world;
 };
 
 // The zoom-interpolated pair: buffer(3) is the same property one integer
@@ -122,6 +124,29 @@ static inline float4 paint_of(const device Paint *lo, const device Paint *hi,
     return mix(a, b, clamp(u.zoom_t, 0.0, 1.0));
 }
 
+// The world position a vertex's fragments cover: the vertex position plus its
+// screen-space (ox, oy) converted to world units. The offset is applied after
+// projection, so a line's stroke reaches ground its anchor does not, and a
+// clip test against the anchor alone cuts the stroke along its length.
+//
+// Undoing the projection needs no inverse. The linear part of mvp is scale
+// times rotation, so R(-view) applied to the offset and divided by pixels per
+// world unit gives the world delta of the clip-space offset.
+static inline float2 world_of(constant U &u, float2 p, float2 off) {
+    float2 back = float2(off.x * u.rot_cos + off.y * u.rot_sin,
+                        -off.x * u.rot_sin + off.y * u.rot_cos);
+    return p + back * u.size_scale * u.world_per_px;
+}
+
+// A tile's triangles paint their own tile. The geometry keeps the buffered
+// overhang a line's joins are built from, and the draw trims it
+// (scene.CLIP_NONE). A draw with no tile of its own is set to CLIP_NONE and
+// pays one compare.
+static inline bool clipped(constant U &u, float2 world) {
+    return world.x < u.clip_rect.x || world.y < u.clip_rect.y ||
+           world.x > u.clip_rect.z || world.y > u.clip_rect.w;
+}
+
 vertex FillOut fill_vert(uint vid [[vertex_id]],
                          const device Vertex *verts [[buffer(0)]],
                          const device Paint *paint [[buffer(1)]],
@@ -141,10 +166,12 @@ vertex FillOut fill_vert(uint vid [[vertex_id]],
     FillOut out;
     out.pos = gate(u, v.zmin, v.zmax) ? clip : float4(0.0, 0.0, 2.0, 1.0); // z=2 -> clipped
     out.color = paint_of(paint, paint_hi, vid, u);
+    out.world = world_of(u, v.pos, off);
     return out;
 }
 
-fragment float4 fill_frag(FillOut in [[stage_in]]) {
+fragment float4 fill_frag(FillOut in [[stage_in]], constant U &u [[buffer(1)]]) {
+    if (clipped(u, in.world)) discard_fragment();
     return in.color;
 }
 
@@ -156,6 +183,7 @@ struct PatternOut {
     float4 pos [[position]];
     float2 anchor;
     float2 cell;
+    float2 world;
 };
 
 vertex PatternOut pattern_vert(uint vid [[vertex_id]],
@@ -170,6 +198,7 @@ vertex PatternOut pattern_vert(uint vid [[vertex_id]],
     out.pos = gate(u, v.zmin, v.zmax) ? clip : float4(0.0, 0.0, 2.0, 1.0);
     out.anchor = u.anchor_px;
     out.cell = u.cell_px;
+    out.world = world_of(u, v.pos, off);
     return out;
 }
 
@@ -177,7 +206,9 @@ vertex PatternOut pattern_vert(uint vid [[vertex_id]],
 // both by the same amount, so the pattern is fixed to the map, not the screen.
 fragment float4 pattern_frag(PatternOut in [[stage_in]],
                              texture2d<float> cell [[texture(0)]],
-                             sampler smp [[sampler(0)]]) {
+                             sampler smp [[sampler(0)]],
+                             constant U &u [[buffer(1)]]) {
+    if (clipped(u, in.world)) discard_fragment();
     float2 sz = max(in.cell, float2(1.0));
     float2 uv = fract((in.pos.xy - in.anchor) / sz);
     float4 c = cell.sample(smp, uv);
@@ -295,8 +326,8 @@ vertex OverlayOut overlay_vert(uint vid [[vertex_id]],
                                const device OverlayVertex *verts [[buffer(0)]],
                                constant U &u [[buffer(2)]]) {
     OverlayVertex v = verts[vid];
-    // No antimeridian wrap here either: the host turns the whole frame at
-    // once, in the matrix (Camera.mvpOrigin). See project() above.
+    // The host places the whole frame at once, in the matrix
+    // (Camera.mvpOrigin). See project() above.
     float4 clip = u.mvp * float4(v.world, 0.0, 1.0);
     // z = 0 is the near plane. Every paint-order depth the scene writes is in
     // (0,1), so a depth-test-only overlay pass is never hidden by the map it
diff --git a/shaders/vk/README.md b/shaders/vk/README.md
index c9fcc5f..53bf703 100644
--- a/shaders/vk/README.md
+++ b/shaders/vk/README.md
@@ -51,7 +51,9 @@ are not negotiable — they are the struct layouts in scene/types.zig.
 lookout's SDL_GPU convention, kept so a port lands on familiar ground:
 set 1 binding 0 = the vertex-stage uniform block, set 2 binding 0 = the
 fragment sampler, set 3 binding 0 = the fragment-stage uniform block. The
-block is `scene.Uniforms`, 128 bytes, std140-compatible in this field order.
+block is `scene.Uniforms`, 144 bytes, std140-compatible in this field order.
+The fill and pattern FRAGMENT stages read it from set 3 as well as sdf: every
+triangle draw is clipped to `clip_rect`.
 
 ## Two contract changes from lookout, called out
 
diff --git a/shaders/vk/fill.frag b/shaders/vk/fill.frag
index e2a8091..c15a867 100644
--- a/shaders/vk/fill.frag
+++ b/shaders/vk/fill.frag
@@ -2,5 +2,34 @@
 // Flat color straight from stream B, blended in paint order by the
 // fixed-function blend state. Matches metal.metal fill_frag.
 layout(location = 0) in  vec4 v_color;
+layout(location = 1) in  vec2 v_world;
 layout(location = 0) out vec4 o_color;
-void main() { o_color = v_color; }
+
+layout(set = 3, binding = 0) uniform U {
+    mat4  mvp;
+    vec2  px_to_clip;
+    float size_scale;
+    float zoom;
+    float zoom_t;
+    float world_per_px;
+    float rot_sin;
+    float rot_cos;
+    vec4  color;
+    vec2  anchor_px;
+    vec2  cell_px;
+    vec4  clip_rect;
+} u;
+
+// A tile's triangles paint their own tile. The geometry keeps the buffered
+// overhang a line's joins are built from, and the draw trims it
+// (scene.CLIP_NONE). A draw with no tile of its own is set to CLIP_NONE and
+// pays one compare.
+bool clipped(vec2 world) {
+    return world.x < u.clip_rect.x || world.y < u.clip_rect.y ||
+           world.x > u.clip_rect.z || world.y > u.clip_rect.w;
+}
+
+void main() {
+    if (clipped(v_world)) discard;
+    o_color = v_color;
+}
diff --git a/shaders/vk/fill.frag.spv b/shaders/vk/fill.frag.spv
index ac9d2fcda7d1d96f3bd071871e952309f259ba95..4d7f1838e34303fda66d882f42e83a83044174d9 100644
GIT binary patch
literal 2240
zcmZ9O*=`e242B2NmVKv`orJO%N?FSyAO%DU^a2TxxIh}BG>A$m6D6e}u6P_C0ddJY
zAr=AR`zGUR)FZjJfBV?KeWq0_Ysc3m$(m$SvOam749<>ZEl2`3lIzCY)49q1(){G*
zD^q4{O)7b!Ior55gjN=t3vUhFK^n+IWIMUWXo6Lta*}-G;xK6W&M>_;6Ki!Ay508t
zspZ!fZ{p^8o6zsGUS~e{E6FJOIWj^8ZO`Iz7k?!8<<<R=E@i3J%p2hL?k{|7r~Ov5
z(-t4j^PT2nmMx-IFu94POJeKtykW4MN7`-o((Z?H{s>MlTT1(^AnH1^SS#zVVC%tJ
zStskEgVzS^=G)ertSB1yH=5h-bZiy5?!u|kUb_V~Ca5H1=y$n2l<$5y9c;@T*TK8Z
zUen?9eHZqUGtl>qmJ7c@E%)i3W=p$u?%85jnE6|7Uxkeu;6$EpAXYD7))kvAVeVdR
zu7tUJu_q-=4r0$rm^&AHQNrB0*vk^;&c$ApFn2D-=dr@seT(_9F^BsW`-C*uiMy^L
zp74)iR|?;6|1jeG#@)BRN8f#izl%+~lNz_Zue}G$xvIz*`Oc$ntcvd}V#;n%=cs|p
zUEBC5{#JAq@k|u{wt<`1@%^H<eRkp7$KCJc=Weu^{$Z;5U5LdUb61P`!A)Dfd(d+C
z{>{R7hXZVgUIU(M(DKyZhq!m|??;<!ub88T9r@0A4lyU<)7b9Q`?t~N%FF)xzLA*m
z2WWHUYh1rkV8;Dc&5gLeZzy(^-wFG=Bad}{g7~dk%eSZ__P&L$o<Zz?o9uewU+0Ez
zcNg(*U>*5E{65<Ao4dyDA!7E>{sRkbG3(3m5h6e9JBR*X@~$EBwU0eKelyeL$<uvX
zYYTdYJim_}1@3oaecxbbfzROiHU|*j(>E*U9V}vBik^q?y(|8iTJrGsK-^iYXpggs
zA3>^!oV0_}QEa)^kl-|qEgqbXVF#yj-f?ha!RZ9Hcg26vr;4_p`a7>B$CHR0-HZ8h
z3I3<Bjm!TG+9QAQ(}<Y$w1fWyw*1SxI*TtJ{3o%4zu$Juc^=!?*J7tr*xnVFfAmua
z{|nf1tRm*iCHP;&HZK3mXpj8GFCk*`*AD(yuvhQ@DwufizlI(Br?G?ob!=n7{|2^q
Z#pNIU)WP3>0_5mS=F8<Dx#E7){{ge8m~H?7

literal 372
zcmYk1%MQU%5Qc|pi@HX_PKbSDfk=dHH{E#v5jGMuK|G+RvXS_|qr^$3Gyi2S^@^j=
ztYDFqt!|&!wxSpl7r30H>omUJ_VHvo#?dg(8SykNw30G$+8)jb6-A_I$p^0msyt0K
zd#K45`|k(SlWlg{F}paO{(Fv-T<?qHfziLXqsh!3x-I7FuIfPCK+%(*8^G)x=v!9i
uFW?tB<_0+Qs<KY~>0oxk&2%CAn8l;#DaKb`ie+X^fqx~Hx!{+&=ZZJ<K@>;;

diff --git a/shaders/vk/fill.vert b/shaders/vk/fill.vert
index 6a75bea..f0b89c5 100644
--- a/shaders/vk/fill.vert
+++ b/shaders/vk/fill.vert
@@ -24,25 +24,41 @@ layout(set = 1, binding = 0) uniform U {
     float size_scale;
     float zoom;       // fractional zoom * 256
     float zoom_t;
-    float wrap_x;
+    float world_per_px;
     float rot_sin;
     float rot_cos;
     vec4  color;
     vec2  anchor_px;
     vec2  cell_px;
+    vec4  clip_rect;
 } u;
 
 layout(location = 0) out vec4 v_color;
+layout(location = 1) out vec2 v_world;
 
-// Longitude is cyclic, so every tile has a world copy every 1.0 world units
-// and one of them has to be drawn. That choice belongs to the HOST, which
-// makes it once per tile (Camera.placeTileX) and again once per scene, in the
-// matrix (Camera.mvpOrigin takes the short way round in x). Deciding it here,
-// per vertex, tore every primitive lying across the half-world seam.
+// Longitude is cyclic, so a tile has a world copy every 1.0 world units and
+// one of them is drawn. The host picks it, once per tile (Camera.placeTileX)
+// and once per scene in the matrix (Camera.mvpOrigin wraps its x delta).
+// Picking it here, per vertex, split every primitive lying across the
+// half-world seam.
 vec4 project(vec2 p) {
     return u.mvp * vec4(p, 0.0, 1.0);
 }
 
+// The world position a vertex's fragments cover: the vertex position plus its
+// screen-space (ox, oy) converted to world units. The offset is applied after
+// projection, so a line's stroke reaches ground its anchor does not, and a
+// clip test against the anchor alone cuts the stroke along its length.
+//
+// Undoing the projection needs no inverse. The linear part of mvp is scale
+// times rotation, so R(-view) applied to the offset and divided by pixels per
+// world unit gives the world delta of the clip-space offset.
+vec2 world_of(vec2 p, vec2 off) {
+    vec2 back = vec2( off.x * u.rot_cos + off.y * u.rot_sin,
+                     -off.x * u.rot_sin + off.y * u.rot_cos);
+    return p + back * u.size_scale * u.world_per_px;
+}
+
 // The per-vertex zoom visibility window, quantized to 1/256 zoom steps and
 // inclusive at both ends. This replaces lookout's scamin / cat_mask gates.
 bool gate(uint zwin) {
@@ -78,4 +94,5 @@ void main() {
     // Clamped: mid-gesture zoom_t can leave [0,1]; hold the end color
     // rather than wrapping to the far one.
     v_color = mix(a_color, a_color_hi, clamp(u.zoom_t, 0.0, 1.0));
+    v_world = world_of(a_pos, off);
 }
diff --git a/shaders/vk/fill.vert.spv b/shaders/vk/fill.vert.spv
index 089cb3783ed51d8fba775ce665e93626bbe33d11..f3d08c263f9e497d0190a9e2ee5100aff9c5f322 100644
GIT binary patch
literal 6164
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
b)aE;5Z8`5>oTICA^<G^C^zqIqd*}WKw1!JK

literal 5080
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

diff --git a/shaders/vk/overlay.vert b/shaders/vk/overlay.vert
index 824004e..9e245a9 100644
--- a/shaders/vk/overlay.vert
+++ b/shaders/vk/overlay.vert
@@ -21,20 +21,21 @@ layout(set = 1, binding = 0) uniform U {
     float size_scale;
     float current_scale;
     uint  cat_mask;
-    float wrap_x;
+    float world_per_px;
     float rot_sin;
     float rot_cos;
     vec4  color;
     vec2  anchor_px;
     vec2  cell_px;
+    vec4  clip_rect;
 } u;
 
 layout(location = 0) out vec4 v_color;
 
 void main() {
-    // No antimeridian wrap here: the host turns the whole frame at once, in
-    // the matrix (Camera.mvpOrigin). Wrapping per vertex tore any primitive
-    // lying across the half-world seam.
+    // The host places the whole frame at once, in the matrix
+    // (Camera.mvpOrigin). A per-vertex wrap split any primitive lying across
+    // the half-world seam.
     vec4 clip = u.mvp * vec4(a_world, 0.0, 1.0);
     // z = 0 is the near plane. The chart's paint-order depths are all in (0,1)
     // and this pass writes no depth, so plugin content is never hidden by the
diff --git a/shaders/vk/overlay.vert.spv b/shaders/vk/overlay.vert.spv
index fd0c06be6050642d224023d81353c26adb4e27ad..7d4b3878947fb69e24a7db424f7260f5b9e101e4 100644
GIT binary patch
delta 101
zcmdnO_l9qS5TgV;11|#u11k`h=NILq#22I%#TQgCFicir%o1l~U;|5Y1ErI5G7I91
tQj<#<7&dn^-eeT?0O|ti1xYFcal__BW<^FuzRArjhK%f+H?lM{0RTBM6p#P_

delta 49
zcmaFEw}o$m5TgJq11|#u11k`h7bO<NS4`Go%-Xz$@do4O8O(BwjJ%V#vlwoE!_vS6
E05;JLxBvhE

diff --git a/shaders/vk/pattern.frag b/shaders/vk/pattern.frag
index 593a56d..bbf9771 100644
--- a/shaders/vk/pattern.frag
+++ b/shaders/vk/pattern.frag
@@ -6,9 +6,32 @@ layout(set = 2, binding = 0) uniform sampler2D cell;
 
 layout(location = 0) in  vec2 v_anchor;
 layout(location = 1) in  vec2 v_cell;
+layout(location = 2) in  vec2 v_world;
 layout(location = 0) out vec4 o_color;
 
+layout(set = 3, binding = 0) uniform U {
+    mat4  mvp;
+    vec2  px_to_clip;
+    float size_scale;
+    float zoom;
+    float zoom_t;
+    float world_per_px;
+    float rot_sin;
+    float rot_cos;
+    vec4  color;
+    vec2  anchor_px;
+    vec2  cell_px;
+    vec4  clip_rect;
+} u;
+
+// See fill.frag: a tile's triangles paint their own tile and no more.
+bool clipped(vec2 world) {
+    return world.x < u.clip_rect.x || world.y < u.clip_rect.y ||
+           world.x > u.clip_rect.z || world.y > u.clip_rect.w;
+}
+
 void main() {
+    if (clipped(v_world)) discard;
     vec2 sz = max(v_cell, vec2(1.0));
     vec2 uv = fract((gl_FragCoord.xy - v_anchor) / sz);
     vec4 c = texture(cell, uv);
diff --git a/shaders/vk/pattern.frag.spv b/shaders/vk/pattern.frag.spv
index 9b163dc2c662adf774fe73dcb7bf05027e0b00d9..f3525c4fd6cf89b20a8bbff67b35576e278f51cf 100644
GIT binary patch
literal 3012
zcmZ9O+j3M@5QaBQ5@LuP<PZ^wGsFW5L_{DU3KOw1QKP7cc-|Q%V-jn^o|*|Gl`E>e
z@jblZ5iBo#37>@WP-^*odv>RGWmR>$`(M4f|JA+rR4Th?_9V%!WN$K_e4h;0!DKf`
z0ydWG#?q~&+5YCr?1hWxjM$e{@<3zuClkpCTG?o>-*e+S(m*~$K1SA%1Dr92VptU_
zB*||i7zHh#9i`?Zd#%oTx7%JhHTdrQRopyoFZze9*ICK^N^%5!8yO>mwrgY1#UIOk
z`E?(pn^|f$<A%7k`|DfnwBKrW+Tx>mytmrQvJKQWCO5HkQ*2KjHwu>XNW1M`+I>)t
zAH(Ton`xg`L|*SK*2?<Z*f>}#>tsE2@OlEfd9SsW6-nd#gt6^T$5Ih%FT7RSYqy}r
z4JyeL`hISY<TDtg!*1E*I(WC)YkE0j7tsB!VPBoqAhp79ZwdeYKzl5o;c6#c=rvbw
zWLeMFgOBEO9i&6HL#&c~j?v2ZN0P6#^Nhn9z5(Wt-?%}2=j9w0OS7}Di{y@3+P4Ec
zuo-+;#5rTJdI>YH*kTE*6qt95v(DDIk4l&v#6B%y&Q#3%#aX$DdC$O{sn~J}bEaZE
zzwJ2ZDdxk8v(8iOA=02H&a#HM!as>!DSW@NX~es_?+o?rhrZvQIrkU7-=X_1_vKyA
zuW$ay=e#2R5U6;K>ekmjie+D_$Q1ePhrWANe0w3L90s)yHE{2)?fwz`edsFUI$ij3
zcA3ZdM{esJ!ncmIdz!z8(PH}3Wb^Ha#TjFFit)is+d4<la`*hz!gmHkY=l}vp1aWU
z)IWyUW6wW>Hr85kj~aHwd(X3oF|j{~Z9hGK4Q;Hvtgr8k#lmkCzUQs;E|Me<ub<(Y
z@!Wfem}1Tk(4O~>=Fs<Dlymwn^o_rRHjnYgn9>($>$qQD;U9<nmuwj4`LBu~G3)93
zu3W+SF80LlKfh`GDz^6ze)_&Uu}j>^UO88n*q<PNpXT=c)DiiHzp%siTaSJ3=J%`r
z7U$LTh&{eW_Ilx8p@Q%8ZDbOuBY&{}4%+oMXWhGjh{;L&AG)M17Wo&k8^|QptoJ@*
z?@l4^IWKF=+da?Oi<^jZx>=m__eo4~nImd^g6#}{EZ)E^Y~#fv#@{k){8Yr;#x_oT
zk_pT0GsL`ppYF@c{)wB%nSO&f&&c~NwlR0eEAJFBM%?rETWp?vzvE>@%y(}N-&PY@
zMt&j2zPAvuyNG>nqh0phy%j{vUTa6+#mp&>b;LSySS$R0x!q;NcV!)C>+-&H#Eql<
zmd*PlIyfIJaDS76^HbR3^W4Di{x~v)_<K-}d$!n%yPd%ItoS3i%3~T4_pVj6%e#s{
zhg1<cX$Pm1*mA8Q!D$9tJUBg%9h}N>FMzujoL<ECtoUElsiLi?e$2~|<4cGf?Thhp
z3I4ui_vQZz+9iMSmk}}ZX$Sw)*zzy;>I}Yk@SnvF{%5h{p08rN_iHi7bJ(60mw(h#
z2mjZw<yb|GmrL+JkL|wvFQ8rW7k?cQlfQQGzlgoF|ChkTga2jh;6H~Q{I6iU7yRGA
a_N=)4qn<kW`wy@jy_4~B`Hxs}-}L_lf6~wZ

literal 1248
zcmYk4%W70X5Qb}VGLzew7;`g5%}k<3O&p9j1aF97HUSqdTn@t|L}AQ<iO#~6;Kujx
zC0zRwK8hj=e&0ELAPq&=|JUDDUDch9ZB9hgVkRczZj@_2#$W=jQS5vBulGAA9}YVA
z?%!518(AS#GZ#}a&aS=hy*oBAgDqgo*e-S!y>SZRWn_=|!QndW>2q~rQ^Za_l`->-
zy8Xk!K%9{$;^RoaQRF`wbYBj8M=$bxct8lgUep|Qd&m8^`LN`&xP;R$;^WcQFEW-j
zykFk!=L6(>+{T)hF?$o+humDk_GH{;+<cm=!W;PZC^mnkUx1Zw7gH!T%lHkr7Pf-k
z8Hv@kz?1B9ns}PMmhhv5y`S7R*t2J_h|kY<n1|<PF*(f|^X%%Jy*baZdtTn0V*8e>
zYS_0}{Y7^3s$b>B?9Y70Pp=BE(c?M+b)Ih}k(~L(?ZhpCuj0$O>`8nL^VfNPi{1Lx
zta`qQKmGID<3%R7jjztn>Y1u9@owTCFdJv=3|#7d!_?WmlXLekTBpMPzY048|CRU&
zdiN&gTQosp|4a?LUU20*Jf)I(jd{+yEn?35RXVqnIC+;jsv0Z!zQvdHw&(HH%U7CJ
zd~1A7nhW^q<eN;*yRBj7^*<T+UiK$%9^YmIYbWfPO-#)j@_O$pm>PM{I}f?%#JAY(
zTh6yLr|)$GlmCv!ciKsu@Ar!w9d_3r^u}&sa=wlJUv8~0XHM^N2eXcM@O{Pq&^^Td
E1DAh3m;e9(

diff --git a/shaders/vk/pattern.vert b/shaders/vk/pattern.vert
index e51a40f..4a19319 100644
--- a/shaders/vk/pattern.vert
+++ b/shaders/vk/pattern.vert
@@ -17,16 +17,25 @@ layout(set = 1, binding = 0) uniform U {
     float size_scale;
     float zoom;
     float zoom_t;
-    float wrap_x;
+    float world_per_px;
     float rot_sin;
     float rot_cos;
     vec4  color;
     vec2  anchor_px;
     vec2  cell_px;
+    vec4  clip_rect;
 } u;
 
 layout(location = 0) out vec2 v_anchor;
 layout(location = 1) out vec2 v_cell;
+layout(location = 2) out vec2 v_world;
+
+// See fill.vert: the world position a vertex's fragments actually land on.
+vec2 world_of(vec2 p, vec2 off) {
+    vec2 back = vec2( off.x * u.rot_cos + off.y * u.rot_sin,
+                     -off.x * u.rot_sin + off.y * u.rot_cos);
+    return p + back * u.size_scale * u.world_per_px;
+}
 
 void main() {
     vec4 clip = u.mvp * vec4(a_pos, 0.0, 1.0);
@@ -44,4 +53,5 @@ void main() {
     gl_Position = vis ? clip : vec4(0.0, 0.0, 2.0, 1.0);
     v_anchor = u.anchor_px;
     v_cell = u.cell_px;
+    v_world = world_of(a_pos, off);
 }
diff --git a/shaders/vk/pattern.vert.spv b/shaders/vk/pattern.vert.spv
index 6b3bada45fa88cd4181ee67bbf7d0c9ee61a83a5..164ef0de35fb56b288908e5ee2384524cbfe479d 100644
GIT binary patch
literal 5072
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
Bp`!o*

literal 4004
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
ICU-aZAJkhP9RL6T

diff --git a/shaders/vk/sdf.frag b/shaders/vk/sdf.frag
index 398e635..7e65d64 100644
--- a/shaders/vk/sdf.frag
+++ b/shaders/vk/sdf.frag
@@ -16,12 +16,13 @@ layout(set = 3, binding = 0) uniform U {
     float size_scale;
     float zoom;
     float zoom_t;
-    float wrap_x;
+    float world_per_px;
     float rot_sin;
     float rot_cos;
     vec4  color;      // the SDF halo color for this draw
     vec2  anchor_px;
     vec2  cell_px;
+    vec4  clip_rect;
 } u;
 
 layout(location = 0) in  vec2  v_uv;
diff --git a/shaders/vk/sdf.frag.spv b/shaders/vk/sdf.frag.spv
index 61de35cc5c9451d8b233f523455208b584e07fd3..05d3473c0f5b191e42b8900d47250398e35a874e 100644
GIT binary patch
delta 101
zcmca1K0#tb6Qcw>gA)S-11k`h=NILq#22I%#TQgCFif7rm?h4}zy_A)21+OAWER91
tr6!j!Fl_$KSji~p0n`Q33zAd@;)czI%yStT`6lzT8ZruPwq>2o1^}K_6~_Po

delta 67
zcmbOraYKAV6QcktgA)S-11k`h7bO<NS4^J8n6+7kse*Cy3g%gi+`M3EN1!y{<Um&O
S$qB41lQUR(HdnCDU;_X!2oMqg

diff --git a/shaders/vk/sprite.vert b/shaders/vk/sprite.vert
index 2f49e09..3a01ffd 100644
--- a/shaders/vk/sprite.vert
+++ b/shaders/vk/sprite.vert
@@ -24,12 +24,13 @@ layout(set = 1, binding = 0) uniform U {
     float size_scale;
     float zoom;
     float zoom_t;
-    float wrap_x;
+    float world_per_px;
     float rot_sin;
     float rot_cos;
     vec4  color;
     vec2  anchor_px;
     vec2  cell_px;
+    vec4  clip_rect;
 } u;
 
 layout(location = 0) out vec2  v_uv;
diff --git a/shaders/vk/sprite.vert.spv b/shaders/vk/sprite.vert.spv
index 634a8937c691fdd5f18f82d0a440c86e337b7160..b2557ffcce7d456686c6f5713b0ba826689ba573 100644
GIT binary patch
delta 101
zcmZ3Wc|&tU7NZ0^gC+w511k`h=NILq#22I%#TQgCFifsu%o1l~U;|5Y1ErI5G7I91
tQj<#<7&bp<T+1Zr0n`Q33zAd@;)cz=ESXG<e3QSk88WJDR%Nf|1pu6O7E%BJ

delta 49
zcmcbixj=J67NY<wgC+w511k`h7bO<NS4?hV%-YPtw1#Q(5tcM2M&8NV?1q~Y*eiGe
DM5+xZ

diff --git a/src/camera.zig b/src/camera.zig
index d5d4d80..3751b47 100644
--- a/src/camera.zig
+++ b/src/camera.zig
@@ -23,31 +23,31 @@ pub fn wrapDx(a: f64, b: f64) f64 {
     return d - std.math.round(d);
 }
 
-/// Where a tile's left edge sits in a frame whose origin is `origin_x`,
-/// choosing the world copy nearest that origin.
+/// The x of a tile's left edge in a frame with origin `origin_x`, at the
+/// world copy nearest that origin.
 ///
-/// Longitude is cyclic, so every tile has a copy each 1.0 world units and the
-/// renderer has to pick one, for the tile as a whole. Nearest is measured at
-/// the tile's CENTRE: judged by its left edge, a tile a whole span wide counts
-/// as near when only its far corner is, and the body of it lands a world away
-/// from what the view is looking at.
+/// Longitude is cyclic, so a tile has a copy every 1.0 world units and the
+/// renderer picks one for the whole tile. Nearest is measured at the tile's
+/// CENTRE. Measured at the left edge, a tile one span wide counts as near
+/// when only its far corner is near, and the rest of it draws a world away
+/// from the view.
 pub fn placeTileX(x0: f64, span: f64, origin_x: f64) f64 {
     return wrapDx(x0 + span * 0.5, origin_x) - span * 0.5;
 }
 
-/// The other world copy of a tile that a view can also see, as the offset to
-/// add to its placement (`-1` or `+1`), or null when one copy is enough.
+/// The second world copy of a tile the view can see, as the offset to add to
+/// its placement (-1 or +1), or null when one copy covers the view.
 ///
-/// `dx` is the placement placeTileX chose and `span` the tile's width, both in
-/// world units in a frame centred on the view; `half_w` is the view's own half
-/// width there. Longitude is cyclic, so a tile recurs every 1.0 world units:
-/// once the view is wider than the gap between two copies -- which happens
-/// from about z1 down, where a tile is a large fraction of the world -- the
-/// same tile is visible on both sides and has to be DRAWN on both sides. One
-/// placement per tile leaves a wedge of empty ocean instead.
+/// `dx` is the placement placeTileX returned and `span` the tile's width,
+/// both in world units in a frame centred on the view. `half_w` is the view's
+/// half width there. A tile recurs every 1.0 world units, so a view wider
+/// than the gap between two copies shows the same tile on both sides and has
+/// to draw it on both. That starts around z1, where a tile is a large
+/// fraction of the world. One placement per tile leaves a wedge of empty
+/// ocean at one edge.
 ///
-/// At most one copy can qualify: a tile is at most one world wide, so its
-/// copies are at least that far apart.
+/// At most one copy qualifies, because a tile is at most one world wide and
+/// its copies are at least that far apart.
 pub fn wrappedCopy(dx: f64, span: f64, half_w: f64) ?f64 {
     for ([2]f64{ -1, 1 }) |k| {
         if (dx + k < half_w and dx + k + span > -half_w) return k;
@@ -122,12 +122,11 @@ pub const Camera = struct {
         const b: f64 = 2.0 * s / @as(f64, self.vh);
         const c = std.math.cos(self.rotation);
         const sn = std.math.sin(self.rotation);
-        // SHORT WAY in x: the camera and a scene origin are both world x in
-        // [0,1), so a camera that has crossed the antimeridian since the
-        // scene was built is a whole world away by subtraction and next door
-        // by longitude. Wrapping here turns the whole scene at once, which is
-        // the only place the turn can happen without splitting geometry: a
-        // per-vertex wrap tears any primitive lying across the seam.
+        // Short way in x. The camera and a scene origin are both world x in
+        // [0,1), so a camera that crossed the antimeridian since the scene
+        // was built is a whole world away by subtraction and adjacent by
+        // longitude. Wrapping here moves the whole scene at once. A
+        // per-vertex wrap splits any primitive lying across the seam.
         const dx = wrapDx(origin.x, self.center.x); // added before rotate/scale
         const dy = origin.y - self.center.y;
         var m = [_]f32{0} ** 16;
@@ -400,10 +399,10 @@ test "halfExtents holds the corners of a rotated viewport" {
     }
 }
 
-// The seamap style over a wide view came out as horizontal bands stretched
-// across the map: the vertex stages chose a world copy PER VERTEX, so a
-// triangle lying across the half-world seam had corners a whole world apart.
-// The choice is the host's now, and these are the two halves of it.
+// A wide view rendered as horizontal bands stretched across the map: the
+// vertex stages picked a world copy per vertex, so a triangle lying across
+// the half-world seam had corners a whole world apart. The host picks it now,
+// in these two functions.
 test "placeTileX puts a whole tile on its nearest copy" {
     const std_testing = std.testing;
     // z2: four columns, a quarter of the world each.
@@ -413,13 +412,12 @@ test "placeTileX puts a whole tile on its nearest copy" {
         while (col < 4) : (col += 1) {
             const x0 = @as(f64, @floatFromInt(col)) * span;
             const dx = placeTileX(x0, span, origin_x);
-            // Still the same geography: a whole number of worlds from where
-            // the tile actually is.
+            // The same geography: a whole number of worlds from where the
+            // tile is.
             const worlds = dx - (x0 - origin_x);
             try std_testing.expectApproxEqAbs(@round(worlds), worlds, 1e-12);
-            // And the nearest copy of it, measured where the tile IS rather
-            // than at its left edge -- which is what keeps the body of a tile
-            // on the near side instead of a corner of it.
+            // The nearest copy, measured at the tile's centre. Measured at
+            // the left edge, one corner of the tile decides the placement.
             try std_testing.expect(@abs(dx + span * 0.5) <= 0.5);
         }
     }
@@ -428,19 +426,19 @@ test "placeTileX puts a whole tile on its nearest copy" {
 test "wrappedCopy asks for the second copy only when the view can see it" {
     const std_testing = std.testing;
     // z1: two columns, half the world each, and a view of the whole world.
-    // The column placed off to the west is visible in the east as well, and
-    // has to be drawn there too or that side is empty ocean.
+    // The column placed to the west is visible in the east as well. Without
+    // a second placement that side is empty ocean.
     try std_testing.expectEqual(@as(?f64, 1), wrappedCopy(-0.7361, 0.5, 0.5));
     // The same tile under a view half that wide is off screen on both sides.
     try std_testing.expect(wrappedCopy(-0.7361, 0.5, 0.25) == null);
-    // A tile under the camera never needs a second copy: its other copies are
-    // a world away, and no view is that wide.
+    // A tile under the camera needs no second copy. Its other copies are a
+    // world away, and no view is that wide.
     try std_testing.expect(wrappedCopy(-0.1, 0.25, 0.5) == null);
 }
 
-// mvpOrigin's x delta takes the short way round. Without that a camera that
-// crossed the antimeridian since the scene was built is a whole world from
-// its origin by subtraction, and the scene is translated off screen.
+// mvpOrigin wraps its x delta. Without that, a camera that crossed the
+// antimeridian since the scene was built is a whole world from its origin by
+// subtraction, and the scene translates off screen.
 test "mvpOrigin turns the whole scene at the antimeridian" {
     const std_testing = std.testing;
     const cam = Camera{
@@ -451,8 +449,8 @@ test "mvpOrigin turns the whole scene at the antimeridian" {
         .vh = 768,
     };
     const near = cam.mvpOrigin(cam.origin);
-    // 0.99 is 0.02 WEST of 0.01, not 0.98 east: the translation is the small
-    // one, and of the sign that puts the origin left of centre.
+    // 0.99 is 0.02 west of 0.01. The translation is the small one, with the
+    // sign that places the origin left of centre.
     const a = 2.0 * cam.worldToPx() / @as(f64, cam.vw);
     try std_testing.expectApproxEqAbs(@as(f32, @floatCast(a * -0.02)), near[12], 1e-3);
 }
diff --git a/src/gpu/gpu_d3d12.zig b/src/gpu/gpu_d3d12.zig
index dda62f6..42ca595 100644
--- a/src/gpu/gpu_d3d12.zig
+++ b/src/gpu/gpu_d3d12.zig
@@ -288,7 +288,7 @@ pub const Gpu = struct {
     overlay_buf: Buffer = .{},
     overlay_count: u32 = 0,
     overlay_gen: u64 = 0, // 0 = nothing uploaded yet (a built store is >= 1)
-    /// The overlay pass's own frame uniform: the chart's, with the MVP and wrap
+    /// The overlay pass's own frame uniform: the chart's, with the MVP
     /// rebuilt for the overlay's origin. setOverlay writes it, and it is the
     /// only thing that fills overlay_buf, so a buffer to draw always has a
     /// uniform to draw it with.
@@ -1516,6 +1516,11 @@ pub const Gpu = struct {
         for (self.batchScene(s)) |dr| {
             const tri = dr.prim == .triangles;
             var uu = u;
+            // Tile geometry paints only its own tile. The buffered
+            // overhang two neighbours share must not blend twice
+            // (scene.CLIP_NONE). Quads are set to CLIP_NONE and draw
+            // unclipped.
+            uu.clip_rect = dr.clip;
             var pso: ?*d3d.ID3D12PipelineState = null;
             var tex_gpu: u64 = 0;
             const halo = dr.pipeline == .sdf;
@@ -1616,7 +1621,7 @@ pub const Gpu = struct {
 
     /// Draw the overlay LAST — after the whole chart, in the same command list.
     /// The overlay carries its OWN uniform (setOverlay): the shader reads mvp
-    /// and wrap_x, and both are built for the overlay's origin, not the
+    /// and it is built for the overlay's origin rather than the
     /// chart's. It goes in the ring like every other draw's.
     fn recordOverlay(self: *Gpu, cmd: *d3d.ID3D12GraphicsCommandList) void {
         if (self.overlay_count == 0 or self.overlay_buf.res == null) return;
diff --git a/src/gpu/gpu_metal.zig b/src/gpu/gpu_metal.zig
index a654189..c73fbad 100644
--- a/src/gpu/gpu_metal.zig
+++ b/src/gpu/gpu_metal.zig
@@ -476,9 +476,15 @@ pub const Gpu = struct {
     }
 
     // One merged front-to-back run of the opaque pre-pass.
-    const OpaqueRun = struct { first: u32, count: u32, pattern: u32 };
-
-    fn flushOpaque(self: *const Gpu, f: *mc.ctm_frame, s: *const Scene, run: OpaqueRun, last_u: *?Uniforms, u: *const Uniforms) void {
+    const OpaqueRun = struct { first: u32, count: u32, pattern: u32, clip: [4]f32 };
+
+    fn flushOpaque(self: *const Gpu, f: *mc.ctm_frame, s: *const Scene, run: OpaqueRun, last_u: *?Uniforms, u_in: *const Uniforms) void {
+        // Phase A clips as phase B does. A tile paints its own tile in both
+        // passes, so the depth this pass writes describes the same ground the
+        // blended pass reads.
+        var uv = u_in.*;
+        uv.clip_rect = run.clip;
+        const u = &uv;
         if (run.pattern == scene.NO_PATTERN) {
             mc.ctm_set_pipeline(f, mc.CTM_PIPE_FILL);
             mc.ctm_bind_vbuf(f, s.vbuf.?);
@@ -581,14 +587,16 @@ pub const Gpu = struct {
                 const r = s.ranges[i];
                 if (r.count == 0 or r.prim != .triangles or (r.flags & scene.Range.FLAG_OPAQUE) == 0) continue;
                 if (run) |*a| {
-                    if (a.pattern == r.pattern and r.first + r.count == a.first) {
+                    if (a.pattern == r.pattern and std.mem.eql(f32, &a.clip, &r.clip) and
+                        r.first + r.count == a.first)
+                    {
                         a.first = r.first;
                         a.count += r.count;
                         continue;
                     }
                     self.flushOpaque(f, s, a.*, &last_u, &u);
                 }
-                run = .{ .first = r.first, .count = r.count, .pattern = r.pattern };
+                run = .{ .first = r.first, .count = r.count, .pattern = r.pattern, .clip = r.clip };
             }
             if (run) |a| self.flushOpaque(f, s, a, &last_u, &u);
         }
@@ -605,6 +613,11 @@ pub const Gpu = struct {
         const draws: []const scene.Draw = if (n > s.draws.len) &.{} else s.draws[0..n];
         for (draws) |d| {
             var uu = u;
+            // Tile geometry paints only its own tile. The buffered
+            // overhang two neighbours share must not blend twice
+            // (scene.CLIP_NONE). Quads are set to CLIP_NONE and draw
+            // unclipped.
+            uu.clip_rect = d.clip;
             switch (d.prim) {
                 .triangles => {
                     if (!tris_ready) continue;
@@ -810,7 +823,7 @@ test "metal offscreen smoke: paint stream draws, zoom gate culls" {
     });
 
     var u = std.mem.zeroes(Uniforms);
-    u.mvp[0] = 2; // scale x2 into clip; verts stay within the wrap-stable half-world
+    u.mvp[0] = 2; // scale x2 into clip
     u.mvp[5] = 2;
     u.mvp[15] = 1;
     u.px_to_clip = .{ 2.0 / 256.0, -2.0 / 256.0 };
diff --git a/src/gpu/gpu_vk.zig b/src/gpu/gpu_vk.zig
index b75c458..56b3887 100644
--- a/src/gpu/gpu_vk.zig
+++ b/src/gpu/gpu_vk.zig
@@ -322,8 +322,8 @@ pub const Gpu = struct {
     overlay_buf: Buffer = .{},
     overlay_count: u32 = 0,
     overlay_gen: u64 = 0, // 0 = nothing uploaded yet (a built store is >= 1)
-    /// The overlay pass's own frame uniform — the chart's, with the MVP and
-    /// wrap rebuilt for the overlay's origin. setOverlay writes it, and it is
+    /// The overlay pass's own frame uniform: the chart's, with the MVP
+    /// rebuilt for the overlay's origin. setOverlay writes it, and it is
     /// the only thing that fills overlay_buf, so a buffer to draw always has a
     /// uniform to draw it with.
     overlay_u: Uniforms = std.mem.zeroes(Uniforms),
@@ -1685,8 +1685,8 @@ pub const Gpu = struct {
 
     /// Draw the overlay LAST — after the raster underlay and the whole chart,
     /// in the same render pass. The overlay carries its OWN uniform
-    /// (setOverlay): the shader reads mvp and wrap_x, and both are built for
-    /// the overlay's origin, not the chart's. It goes in the ring like every
+    /// (setOverlay): the shader reads mvp, and it is built for
+    /// the overlay's origin rather than the chart's. It goes in the ring like every
     /// other draw's, on set 1.
     fn recordOverlay(self: *Gpu, cmd: vk.VkCommandBuffer) void {
         if (self.overlay_count == 0 or self.overlay_buf.buf == null) return;
@@ -2025,6 +2025,11 @@ pub const Gpu = struct {
         for (self.batchScene(s)) |d| {
             const tri = d.prim == .triangles;
             var uu = u;
+            // Tile geometry paints only its own tile. The buffered
+            // overhang two neighbours share must not blend twice
+            // (scene.CLIP_NONE). Quads are set to CLIP_NONE and draw
+            // unclipped.
+            uu.clip_rect = d.clip;
             var pipe: vk.VkPipeline = null;
             var tex_set: vk.VkDescriptorSet = null;
             const halo = d.pipeline == .sdf;
@@ -2099,6 +2104,11 @@ pub const Gpu = struct {
                 uu.color = d.color;
                 const foff = self.pushUniform(&uu) orelse continue;
                 vk.vkCmdBindDescriptorSets(cmd, vk.VK_PIPELINE_BIND_POINT_GRAPHICS, self.pipe_layout, 3, 1, &self.frag_uni_set, 1, &foff);
+            } else if (tri) {
+                // fill.frag and pattern.frag read clip_rect from set 3. The
+                // bytes are the vertex stage's, so the ring entry is reused.
+                var voff2 = voff;
+                vk.vkCmdBindDescriptorSets(cmd, vk.VK_PIPELINE_BIND_POINT_GRAPHICS, self.pipe_layout, 3, 1, &self.frag_uni_set, 1, &voff2);
             }
             if (tri) {
                 vk.vkCmdDrawIndexed(cmd, d.count, 1, d.first, 0, 0);
diff --git a/src/gpu/metal_shim.m b/src/gpu/metal_shim.m
index c13c48d..d4f2d97 100644
--- a/src/gpu/metal_shim.m
+++ b/src/gpu/metal_shim.m
@@ -540,7 +540,8 @@ void ctm_bind_texture(ctm_frame *f, ctm_tex *t) {
 void ctm_set_uniforms(ctm_frame *f, const void *bytes, size_t len) {
     if (!f) return;
     [f->enc setVertexBytes:bytes length:len atIndex:2];
-    // The SDF text fragment stage reads the uniform too (halo color).
+    // Fragment stages read it too, for the SDF halo colour and for the clip
+    // rect a triangle draw is trimmed to.
     [f->enc setFragmentBytes:bytes length:len atIndex:1];
 }
 
diff --git a/src/layout/fill.zig b/src/layout/fill.zig
index 9482a80..770d5c6 100644
--- a/src/layout/fill.zig
+++ b/src/layout/fill.zig
@@ -21,7 +21,9 @@
 //!   tile57 fed libtess2 for area fills.
 //! - Output positions are tile-local world units: tile_span * coord / extent.
 //!   The 64-unit buffer overhang stays in the geometry — clipping is the
-//!   renderer's job (per-tile clip rects), never layout's.
+//!   renderer's job (every triangle draw holds the bounds of the tile it came
+//!   from, and the fragment stage trims to them: scene.CLIP_NONE), never
+//!   layout's.
 //! - Fill vertices carry no screen offset: ox/oy zero, flags 0. Zoom window
 //!   and paint-order depth pass through Options.
 //! - Degenerate rings (< 3 distinct points, zero area) draw nothing and are
diff --git a/src/map.zig b/src/map.zig
index 65190d7..18da714 100644
--- a/src/map.zig
+++ b/src/map.zig
@@ -44,8 +44,9 @@ pub const SourcedTile = struct {
     source: []const u8 = "",
     /// Which world copy to draw this tile at: 0 for the one nearest the view
     /// origin, -1 or +1 for the copy a world away. Longitude is cyclic, and a
-    /// view wide enough sees the same tile on both sides (Camera.wrappedCopy),
-    /// so the same tile is listed twice with different values here.
+    /// wide enough view shows the same tile on both sides
+    /// (Camera.wrappedCopy), so that tile is listed twice with different
+    /// values here.
     wrap: f64 = 0,
 };
 
@@ -294,7 +295,7 @@ pub const RasterTile = struct {
     /// the starting alpha (in: 0, out: opaque) and records the quad span in
     /// Built.fades; the Map animates it through the quad paint stream.
     fade: Fade = .none,
-    /// Which world copy to draw at — see SourcedTile.wrap.
+    /// Which world copy to draw at. See SourcedTile.wrap.
     wrap: f64 = 0,
 
     pub const Fade = enum(u2) { none, in, out };
@@ -904,12 +905,22 @@ pub fn buildSceneWithRasters(
             // the map. Harmless while the viewport is a sliver of the world;
             // at low zoom it scrambles the geography.
             //
-            // By the tile's CENTRE, so the whole tile lands on one copy. The
-            // left edge alone leaves the body reaching a full tile span past
-            // the half-world seam, and at low zoom -- where a tile is a large
-            // fraction of the world -- that is most of the tile.
+            // Measured at the tile's CENTRE, so the whole tile goes on one
+            // copy. Measured at the left edge, the body of the tile reaches a
+            // full span past the half-world seam, and at low zoom that is
+            // most of the tile.
             const dx: f32 = @floatCast(cameras.placeTileX(rect.x0, tile_span, view.origin.x) + st.wrap);
             const dy: f32 = @floatCast(rect.y0 - view.origin.y);
+            // What this tile's triangles may paint. An MVT tile is buffered,
+            // so the geometry reaches past these bounds and two neighbours
+            // both hold the strip along the edge they share. See
+            // types.CLIP_NONE.
+            const tile_clip = [4]f32{
+                dx,
+                dy,
+                dx + @as(f32, @floatCast(tile_span)),
+                dy + @as(f32, @floatCast(rect.y1 - rect.y0)),
+            };
             const tile_quads_first: u32 = @intCast(quads.items.len);
             var text_scratch: std.ArrayList(types.Quad) = .empty;
             var text_paint_scratch: std.ArrayList(types.PaintVertex) = .empty;
@@ -1006,6 +1017,7 @@ pub fn buildSceneWithRasters(
                                     .count = @intCast(indices.items.len - run_first),
                                     .paint_key = @intCast(layer_i),
                                     .pattern = run_pattern,
+                                    .clip = tile_clip,
                                     .kind = .pattern,
                                     .prim = .triangles,
                                 });
@@ -1144,6 +1156,7 @@ pub fn buildSceneWithRasters(
                 .count = count,
                 .paint_key = @intCast(layer_i),
                 .pattern = run_pattern,
+                .clip = tile_clip,
                 .kind = if (is_pattern) .pattern else if (sl.kind == .fill) .area else .line,
                 .prim = .triangles,
                 // A pattern cell is mostly transparent: it must blend over
@@ -1525,6 +1538,15 @@ pub fn concatScenes(arena: std.mem.Allocator, parts: []const ScenePart) !Built {
                 .triangles => ibase,
                 .quads => qbase,
             };
+            // The clip is stated in the part's own frame, like its vertices.
+            if (!std.mem.eql(f32, &r.clip, &types.CLIP_NONE)) {
+                moved.clip = .{
+                    r.clip[0] + part.dx,
+                    r.clip[1] + part.dy,
+                    r.clip[2] + part.dx,
+                    r.clip[3] + part.dy,
+                };
+            }
             if (r.pattern != types.NO_PATTERN) moved.pattern = r.pattern + pbase;
             ranges.appendAssumeCapacity(moved);
         }
@@ -1998,7 +2020,7 @@ test "first light: style to pixels through the GPU backend" {
         .size_scale = 1,
         .zoom = @floatFromInt(types.zq(cam.zoom)),
         .zoom_t = 0,
-        .wrap_x = @floatCast(cam.center.x - origin.x),
+        .world_per_px = @floatCast(1.0 / cam.worldToPx()),
         .rot_sin = 0,
         .rot_cos = 1,
         .color = .{ 0, 0, 0, 0 },
@@ -2163,7 +2185,7 @@ test "real chart: Annapolis first light" {
         .size_scale = 1,
         .zoom = @floatFromInt(types.zq(cam.zoom)),
         .zoom_t = 0,
-        .wrap_x = 0,
+        .world_per_px = 0,
         .rot_sin = 0,
         .rot_cos = 1,
         .color = .{ 0, 0, 0, 0 },
diff --git a/src/map_object.zig b/src/map_object.zig
index 9ba9bd0..c4bfd99 100644
--- a/src/map_object.zig
+++ b/src/map_object.zig
@@ -1203,7 +1203,9 @@ pub const Map = struct {
             // extrapolates smoothly and the color mix clamps at the end it
             // was already approaching (scene/types.zig Uniforms.zoom_t).
             .zoom_t = @floatCast(self.cam.zoom - (if (self.built) |b| b.paint_zoom_floor else @floor(self.cam.zoom))),
-            .wrap_x = @floatCast(cameras.wrapDx(self.cam.center.x, origin.x)),
+            // World units per reference pixel, for turning a vertex's screen
+            // offset back into a world delta at clip time.
+            .world_per_px = @floatCast(1.0 / self.cam.worldToPx()),
             .rot_sin = rs[0],
             .rot_cos = rs[1],
             .color = .{ 0, 0, 0, 0 },
@@ -1734,9 +1736,9 @@ pub const Map = struct {
                     const tile = self.cache.get(key) orelse continue;
                     const rect = key.tileId().worldRect();
                     const span = rect.x1 - rect.x0;
-                    // The nearest world copy: see the note in map.zig. A view
-                    // wide enough sees the same tile on both sides of the
-                    // world, and then it is listed -- and placed -- twice.
+                    // The nearest world copy: see the note in map.zig. A
+                    // wide enough view shows the same tile on both sides of
+                    // the world, and it is then listed and placed twice.
                     const dx = cameras.placeTileX(rect.x0, span, origin.x);
                     const second = cameras.wrappedCopy(dx, span, half_w);
                     try vector_tiles.append(a, .{
@@ -1767,8 +1769,9 @@ pub const Map = struct {
                         .dy = dy,
                     });
                     tile_parts += 1;
-                    // The same bucket, placed a world over: the second copy
-                    // costs a rebase at concatenation, not a tessellation.
+                    // The same bucket, placed a world over. The second copy
+                    // costs a rebase at concatenation rather than a
+                    // tessellation.
                     if (second) |copy_dx| {
                         try parts.append(self.gpa, .{
                             .built = bucket.built,
@@ -1834,8 +1837,8 @@ pub const Map = struct {
             // Tiles whose geometry is actually IN the scene: `have` less
             // whatever the budget deferred. The gap is what a test can watch
             // to catch the scene silently losing ground.
-            // Distinct tiles, not parts: a tile the view sees on both sides
-            // of the world is placed twice and is still one tile.
+            // Distinct tiles rather than parts. A tile the view sees on both
+            // sides of the world is placed twice and is still one tile.
             .scene_tiles = tile_parts,
             .partial = deferred > 0,
             .origin = origin,
diff --git a/src/scene/batch.zig b/src/scene/batch.zig
index 300a6da..379ea4d 100644
--- a/src/scene/batch.zig
+++ b/src/scene/batch.zig
@@ -60,9 +60,16 @@ pub fn batch(ranges: []const t.Range, opts: t.BatchOpts, out: []t.Draw) usize {
             @as(f32, @floatFromInt(r.halo[3])) / 255.0,
         } else opts.halo;
 
+        // The clip joins the merge key, because two tiles' ranges paint
+        // different ground and cannot share a draw (types.CLIP_NONE). The
+        // draw count is unchanged in practice: parts concatenate tile-major,
+        // so one layer's ranges from two tiles are adjacent in paint order
+        // and far apart in the index buffer, where the contiguity test
+        // already separates them.
         if (last) |d| {
             if (d.prim == r.prim and d.pipeline == pipe and d.atlas == atlas and
                 d.pattern == r.pattern and std.mem.eql(f32, &d.color, &color) and
+                std.mem.eql(f32, &d.clip, &r.clip) and
                 d.first + d.count == r.first)
             {
                 d.count += r.count;
@@ -78,6 +85,7 @@ pub fn batch(ranges: []const t.Range, opts: t.BatchOpts, out: []t.Draw) usize {
                 .atlas = atlas,
                 .pattern = r.pattern,
                 .color = color,
+                .clip = r.clip,
             };
             last = &out[n];
         } else {
@@ -176,6 +184,24 @@ test "a range's own halo color wins over the scene background" {
     try expectEqual([4]f32{ 0, 0, 0, 0 }, out[0].color);
 }
 
+// Tile geometry paints only its own tile (types.CLIP_NONE), so two tiles'
+// ranges do not merge even when their index spans are contiguous.
+test "ranges from different tiles do not merge" {
+    var a = tri(0, 30, false);
+    a.clip = .{ 0, 0, 1, 1 };
+    var b = tri(30, 12, false);
+    b.clip = .{ 1, 0, 2, 1 };
+    var out: [2]t.Draw = undefined;
+    const n = batch(&.{ a, b }, .{ .atlas_have = all_atlases, .halo = halo }, &out);
+    try expectEqual(@as(usize, 2), n);
+    try expectEqual([4]f32{ 0, 0, 1, 1 }, out[0].clip);
+    try expectEqual([4]f32{ 1, 0, 2, 1 }, out[1].clip);
+    // Two ranges from the same tile still merge.
+    var c = tri(30, 12, false);
+    c.clip = a.clip;
+    try expectEqual(@as(usize, 1), batch(&.{ a, c }, .{ .atlas_have = all_atlases, .halo = halo }, &out));
+}
+
 test "pattern ranges classify to the pattern pipeline and split on cell change" {
     var a = tri(0, 12, false);
     a.pattern = 0;
diff --git a/src/scene/types.zig b/src/scene/types.zig
index fb524c1..8fba85d 100644
--- a/src/scene/types.zig
+++ b/src/scene/types.zig
@@ -205,6 +205,10 @@ pub const Range = extern struct {
     count: u32,
     paint_key: u32,
     pattern: u32 = NO_PATTERN, // into the scene's patterns, pattern ranges only
+    /// The bounds of the tile this range's geometry came from, world units
+    /// in the scene frame. See CLIP_NONE. Triangle ranges only. Every other
+    /// range is set to CLIP_NONE.
+    clip: [4]f32 = CLIP_NONE,
     kind: Kind,
     prim: Prim,
     atlas: Atlas = .none,
@@ -244,11 +248,15 @@ pub const Draw = extern struct {
     _pad: u8 = 0,
     pattern: u32, // look up YOUR cell texture; derive cell_px from its size
     color: [4]f32, // the uniform's color (halo on SDF draws)
+    /// Copied into Uniforms.clip_rect. The batcher resolves it, so a backend
+    /// does not look it up.
+    clip: [4]f32 = CLIP_NONE,
 };
 
 /// The per-draw uniform block the shaders read, byte for byte. The layout is
 /// not the host's to choose: it is the other half of the vertex contract.
-/// std140 and C agree on this order: color at byte 96, the block 128 bytes.
+/// std140 and C agree on this order: color at byte 96, clip_rect at 128, the
+/// block 144 bytes.
 pub const Uniforms = extern struct {
     mvp: [16]f32, // column-major tile-local -> clip (Camera.mvpOrigin)
     px_to_clip: [2]f32, // reference-px -> clip delta (the ox/oy channel)
@@ -262,28 +270,50 @@ pub const Uniforms = extern struct {
     /// slope is the continuous answer and snapping back to a bracket end is
     /// exactly the jump this field exists to remove.
     zoom_t: f32,
-    /// RESERVED. It carried the antimeridian wrap the vertex stages used to
-    /// apply per vertex — which tore every primitive lying across the
-    /// half-world seam, because the corners on one side moved a whole world
-    /// and the corners on the other did not. The choice of world copy is the
-    /// host's now: once per tile in Camera.placeTileX, once per scene in
-    /// Camera.mvpOrigin. Kept so the block stays 128 bytes.
-    wrap_x: f32,
+    /// World units per reference pixel, the reciprocal of Camera.worldToPx.
+    /// It converts a vertex's screen-space (ox, oy) into a world delta, so the
+    /// fragment stage tests the position a line's stroke covers against
+    /// clip_rect instead of the position of its anchor.
+    ///
+    /// This slot held a per-vertex antimeridian wrap until it split every
+    /// primitive lying across the half-world seam. The host picks the world
+    /// copy now, in Camera.placeTileX and Camera.mvpOrigin.
+    world_per_px: f32,
     rot_sin: f32,
     rot_cos: f32,
     color: [4]f32, // SDF halo background; SDF fragment stage only
     anchor_px: [2]f32, // pattern phase origin, framebuffer px
     cell_px: [2]f32, // pattern cell period, framebuffer px
+    /// The tile a triangle draw belongs to, in the scene frame: (x0, y0, x1,
+    /// y1). The fragment stage drops fragments outside it. See CLIP_NONE.
+    clip_rect: [4]f32 = CLIP_NONE,
 };
 
+/// The clip_rect that admits every fragment.
+///
+/// A triangle draw's clip is the bounds of the tile its geometry came from,
+/// in world units in the scene frame. An MVT tile holds its features clipped
+/// to its own bounds plus an overhang, so two neighbours both hold the strip
+/// along the edge they share. A line's joins and caps are built from that
+/// overhang, so it stays in the geometry. Painting it twice blends a
+/// translucent fill twice, and the tile grid then shows through the map as a
+/// lattice of darker strips, so the draw trims it. The test is in world space
+/// because a scissor rect cannot express a tile under a rotated view.
+///
+/// CLIP_NONE covers the ranges with no tile of their own: symbols, whose
+/// labels may overhang the tile holding the anchor, raster quads, which are
+/// already one tile with no overhang, and the host overlay.
+pub const CLIP_NONE: [4]f32 = .{ -1e30, -1e30, 1e30, 1e30 };
+
 comptime {
     std.debug.assert(@sizeOf(Vertex) == 28);
     std.debug.assert(@sizeOf(Quad) == 40);
     std.debug.assert(@sizeOf(PaintVertex) == 4);
-    std.debug.assert(@sizeOf(Range) == 24);
-    std.debug.assert(@sizeOf(Uniforms) == 128);
+    std.debug.assert(@sizeOf(Range) == 40);
+    std.debug.assert(@sizeOf(Uniforms) == 144);
     std.debug.assert(@offsetOf(Uniforms, "color") == 96);
     std.debug.assert(@offsetOf(Uniforms, "anchor_px") == 112);
+    std.debug.assert(@offsetOf(Uniforms, "clip_rect") == 128);
 }
 
 /// Layout guard: packs the sizes the shaders and backends assume so an ABI