diff --git a/build.zig b/build.zig
index 81798bce..3813445c 100644
--- a/build.zig
+++ b/build.zig
@@ -585,10 +585,10 @@ pub fn build(b: *std.Build) void {
         .root_source_file = b.path("src/lib_root.zig"),
         .target = target,
         .optimize = optimize,
-        // iOS: std.debug's stack-trace machinery references
-        // _dyld_get_image_header_containing_address, which iOS' libdyld doesn't
-        // export — strip so the panic path never pulls it in.
-        .strip = target.result.os.tag == .ios,
+        // iOS and visionOS: std.debug's stack-trace machinery references
+        // _dyld_get_image_header_containing_address, which those libdylds do
+        // not export. Strip so the panic path never pulls it in.
+        .strip = target.result.os.tag == .ios or target.result.os.tag == .visionos,
         .pic = true, // links into a PIE C++ host
         .link_libc = true, // Lua needs the C runtime
     });
@@ -703,27 +703,25 @@ pub fn build(b: *std.Build) void {
     else
         target;
 
-    const bake = b.addExecutable(.{
-        .name = "tile57",
-        .root_module = b.createModule(.{
-            .root_source_file = b.path("tools/main.zig"),
-            .target = bake_target,
-            .optimize = optimize,
-            .link_libc = true,
-            .imports = &.{
-                .{ .name = "engine", .module = engine_full },
-                .{ .name = "style", .module = style_mod },
-                .{ .name = "sprite", .module = sprite_mod },
-                .{ .name = "catalog", .module = catalog_embed },
-                .{ .name = "bundle", .module = bundle_mod },
-                .{ .name = "compose", .module = compose_mod }, // compose-tile CLI
-                .{ .name = "geometry", .module = geometry_mod }, // compose-tile --scan reads the boolean diagnostics
-                .{ .name = "render", .module = render_mod }, // renderpng pixel path
-                .{ .name = "chart", .module = chart_mod }, // ENC_ROOT view renders
-                .{ .name = "raster", .module = raster_mod }, // `raster info`
-            },
-        }),
+    const bake_mod = b.createModule(.{
+        .root_source_file = b.path("tools/main.zig"),
+        .target = bake_target,
+        .optimize = optimize,
+        .link_libc = true,
+        .imports = &.{
+            .{ .name = "engine", .module = engine_full },
+            .{ .name = "style", .module = style_mod },
+            .{ .name = "sprite", .module = sprite_mod },
+            .{ .name = "catalog", .module = catalog_embed },
+            .{ .name = "bundle", .module = bundle_mod },
+            .{ .name = "compose", .module = compose_mod }, // compose-tile CLI
+            .{ .name = "geometry", .module = geometry_mod }, // compose-tile --scan reads the boolean diagnostics
+            .{ .name = "render", .module = render_mod }, // renderpng pixel path
+            .{ .name = "chart", .module = chart_mod }, // ENC_ROOT view renders
+            .{ .name = "raster", .module = raster_mod }, // `raster info`
+        },
     });
+    const bake = b.addExecutable(.{ .name = "tile57", .root_module = bake_mod });
     b.installArtifact(bake);
 
     const run_bake = b.addRunArtifact(bake);
@@ -808,6 +806,10 @@ pub fn build(b: *std.Build) void {
     // module import does NOT pull another module's `test {}` blocks in.
     const test_step = b.step("test", "Run unit tests");
     test_step.dependOn(&b.addRunArtifact(b.addTest(.{ .root_module = mod })).step);
+    // The CLI's own tests. They had never run: nothing but the executable
+    // referenced tools/*.zig, and an executable does not collect tests — so a
+    // test written beside the code it checks was silently dead.
+    test_step.dependOn(&b.addRunArtifact(b.addTest(.{ .root_module = bake_mod })).step);
     // The sprite module (SDF glyph atlas lives here): needs the C glue
     // (stb_truetype/nanosvg) + libc + render.
     const sprite_test = addPkgTest(b, test_step, "src/sprite/sprite.zig", target, optimize, &.{
diff --git a/include/tile57.h b/include/tile57.h
index 67b02243..9c9b915b 100644
--- a/include/tile57.h
+++ b/include/tile57.h
@@ -244,6 +244,31 @@ tile57_status tile57_bake_tree(const char *in_dir, const char *out_dir, uint32_t
                                tile57_bake_progress progress, void *progress_ctx,
                                uint32_t *out_baked, tile57_error *err);
 
+/* tile57_bake_tree for an exchange set STILL IN ITS .zip: find the cells, name
+ * every output, bake. Nothing is unpacked — each cell is inflated as its turn
+ * comes, so importing an 800 MB archive never costs the disk a second copy of
+ * the source.
+ *
+ * Outputs mirror each entry's path BELOW the directory the archive wraps
+ * everything in. NOAA's All_ENCs.zip puts every cell under `ENC_ROOT/`, and
+ * that name belongs to the archive rather than to the library being built: an
+ * `out_dir` of `.../ENC_ROOT` writes `.../ENC_ROOT/US5MD12M/US5MD12M.pmtiles`,
+ * NOT a second ENC_ROOT inside the first. The prefix is computed from what the
+ * cells actually share, so an archive holding two districts keeps them apart —
+ * two districts carrying the same boundary cell keep their own copies, and
+ * each cell's referenced text lands beside the right chart. A cell sharing its
+ * directory with no other gets a directory named for itself.
+ *
+ * Same contract as tile57_bake_tree otherwise: `workers` is a MEMORY bound,
+ * `progress` (NULL to skip) fires per chart and may CANCEL by returning false,
+ * *out_baked (NULL to ignore) counts what was written. An archive holding no
+ * .000 is TILE57_OK with *out_baked 0 — nothing to do is not a failure. A host
+ * that wants each finished chart NAMED owns the list itself and calls
+ * tile57_bake_zip_charts. */
+tile57_status tile57_bake_zip(const char *zip_path, const char *out_dir, uint32_t workers,
+                              tile57_bake_progress progress, void *progress_ctx,
+                              uint32_t *out_baked, tile57_error *err);
+
 /* Names the chart that just finished, by its INDEX into the caller's in_paths.
  * Charts bake concurrently, so the count in tile57_bake_progress cannot say
  * which chart a step belongs to. Called from worker threads, out of order, so
@@ -1442,6 +1467,29 @@ tile57_status tile57_compose_tile(tile57_compose *c, uint8_t z, uint32_t x, uint
                                    uint8_t **out, size_t *out_len, bool *out_owned,
                                    tile57_error *err);
 
+/* How wide YOU draw a tile: 256 (the default, the native convention) or 512 (the
+ * MapLibre style spec's world tile).
+ *
+ * A vector tile from tile57_compose_tile has its complex (symbolised) linestyles
+ * WALKED into plain geometry — each dash "on" run a solid line, each embedded
+ * symbol a point rotated to the local tangent at its own offset in the period,
+ * phased from the run's arc origin. S-101 lays those figures out in
+ * 256-px-per-tile space, so this is what the rhythm is restated in. It moves
+ * spacing only: never stroke width, never symbol size. The wrong value is
+ * invisible in the geometry and plain on the chart, as the right rhythm at the
+ * wrong spacing.
+ *
+ * A composed tile is drawn from a style, and a style cannot say where in a
+ * period a symbol sits, which is why the walk is not optional: ACHARE51 places
+ * four symbols at 5, 13.1, 21.2 and 29.3 mm of its 32.3 mm period, and a style
+ * can only ask for "one per period". The archives are untouched — they keep the
+ * stored run, which is display-independent, and the engine's own replay walks it
+ * at whatever scale it draws at.
+ *
+ * 0 is ignored. A raster compositor ignores this entirely; pictures carry no
+ * linestyles. */
+void tile57_compose_set_px_per_tile(tile57_compose *c, uint32_t px_per_tile);
+
 /* The composed view outputs — tile57_chart_png / tile57_chart_pdf / tile57_chart_canvas /
  * tile57_chart_surface across the WHOLE composed set: every covering tile is
  * composed on demand (stitched through the ownership partition) and
@@ -1582,6 +1630,17 @@ tile57_status tile57_bake_assets(const char *catalog_dir, tile57_assets *out,
 tile57_status tile57_bake_sprite_mln(const char *catalog_dir, double pixel_ratio,
                                      tile57_scheme scheme,
                                      tile57_assets *out, tile57_error *err);
+/* Render ONE comma-joined symbol run (a sounding digit stack such as
+ * "SOUNDG11,SOUNDG53") to a pivot-centred RGBA image at pixel_ratio, coloured
+ * for `scheme`. The runtime path behind a map client's missing-image event: a
+ * chart library carries more distinct runs than any prebaked sheet can
+ * enumerate, so the host renders exactly the ones the display asks for.
+ * TILE57_OK with *out_rgba NULL when the run names no known glyph (absent,
+ * not an error). Free *out_rgba with tile57_free. */
+tile57_status tile57_render_symbol_run(const char *catalog_dir, const char *run,
+                                       double pixel_ratio, int scheme,
+                                       uint8_t **out_rgba, uint32_t *out_w,
+                                       uint32_t *out_h, tile57_error *err);
 /* SDF glyph atlas for GPU text: sprite_png is the RGBA signed-distance-field atlas
  * of the label font; sprite_json is {"em_px","pad","glyphs":{codepoint:[u0,v0,u1,
  * v1,off_x,off_y,w,h,advance]}} with the quad geometry in EM units (multiply by the
diff --git a/src/bake_root.zig b/src/bake_root.zig
index f6eae77b..1510b535 100644
--- a/src/bake_root.zig
+++ b/src/bake_root.zig
@@ -33,3 +33,12 @@ pub const zipsrc = root.zipsrc; // charts read straight out of a .zip
 pub const geometry = @import("geometry"); // integer geometry: boolean, plane, partition
 
 pub const portray = @import("portray");
+
+// A test binary rooted on a consumer of this module links lua_shim.c through
+// `portray` but analyses only what its tests reach. Reference the accessor
+// files here so their tgp_* / tgc_* / tg_embedded_lua exports are emitted into
+// every binary that carries the shim, as lib_root.zig does for the archive.
+comptime {
+    _ = portray;
+    _ = catalogue;
+}
diff --git a/src/bundle.zig b/src/bundle.zig
index f7186968..648fd0e9 100644
--- a/src/bundle.zig
+++ b/src/bundle.zig
@@ -234,6 +234,19 @@ pub fn spriteMlnBytes(io: std.Io, a: std.mem.Allocator, catalog_dir: []const u8,
     return sprite.spriteMln(a, symbols, fills, css, soundings, ratio);
 }
 
+/// Render one comma-joined symbol run (sounding digit stack) to a
+/// pivot-centred RGBA image — the runtime answer to MapLibre's missing-image
+/// event, for the runs no prebaked sheet can enumerate. Null when the run
+/// names no known glyph. Caller owns the pixels (allocated in `a`).
+pub fn symbolRunImage(io: std.Io, a: std.mem.Allocator, catalog_dir: []const u8, css_name: []const u8, run: []const u8, ratio: f64) !?sprite.RunImage {
+    var arena = std.heap.ArenaAllocator.init(a);
+    defer arena.deinit();
+    const ar = arena.allocator();
+    const symbols = try readSymbols(io, ar, catalog_dir);
+    const css = try readCss(io, ar, catalog_dir, css_name);
+    return sprite.renderSymbolRun(a, symbols, css, run, ratio);
+}
+
 // Emit sprite-mln.{json,png} + identical @2x copies (MapLibre requests @2x on
 // HiDPI; a missing @2x sheet fails the whole sprite load).
 pub fn emitSpriteMln(io: std.Io, a: std.mem.Allocator, catalog_dir: []const u8, css_name: []const u8, out_dir: []const u8, base: []const u8, soundings: []const []const u8) !sprite.Atlas {
@@ -527,3 +540,10 @@ fn emitFacesZoom(sw: *engine.pmtiles.StreamWriter, sa: std.mem.Allocator, faces:
         try sw.add(z, kv.key_ptr.x, kv.key_ptr.y, enc);
     }
 }
+
+test {
+    // A test binary rooted here links lua_shim.c through engine's portray
+    // module but analyses only what its tests reach. Referencing engine scans
+    // bake_root.zig, whose comptime block emits the shim's C-ABI accessors.
+    _ = engine;
+}
diff --git a/src/capi.zig b/src/capi.zig
index d3e615e9..8c5b6156 100644
--- a/src/capi.zig
+++ b/src/capi.zig
@@ -10,6 +10,8 @@
 const std = @import("std");
 const chart = @import("chart.zig");
 const auxfiles = @import("engine").auxfiles; // via the named module: engine owns the file
+const scene = @import("engine").scene; // tile surface + the complex-linestyle walk
+const mlt_dec = @import("tiles").mlt; // decoding a verbatim composed tile
 const s57 = @import("s57");
 const bundle = @import("bundle"); // portrayal-asset emitters + the partition debug bake
 const compose = @import("compose"); // the runtime tile compositor (tile57_compose_*)
@@ -20,7 +22,9 @@ const raster = @import("raster"); // raster charts (tile57_raster_chart_*)
 const zipsrc = @import("zipsrc"); // charts read straight out of a .zip
 // The S-52 ColorProfiles/colorProfile.xml baked into the library (build.zig), so
 // the style C ABI generates colortables + a base style template with no on-disk
-// catalogue. Symbols/linestyles are NOT embedded here (only the bake exe needs them).
+// catalogue. The full catalogue (symbols, linestyles, css) is embedded too, via
+// the `catalog` module bundle.zig imports — tile57_style_template reads the
+// analysed linestyles from it and tile57_bake_sprite_mln the symbol SVGs.
 const colorprofile_registry = @import("colorprofile_registry");
 
 // c_allocator, not smp_allocator: smp never returns freed slabs to the OS, so
@@ -386,6 +390,29 @@ export fn tile57_bake_tree(
     return OK;
 }
 
+/// Bake a whole exchange set out of its .zip in one call — the archive twin of
+/// tile57_bake_tree, naming every output itself. See tile57.h.
+export fn tile57_bake_zip(
+    zip_path: ?[*:0]const u8,
+    out_dir: ?[*:0]const u8,
+    workers: u32,
+    progress: chart.BakeProgress,
+    progress_ctx: ?*anyopaque,
+    out_baked: ?*u32,
+    err: ?*CError,
+) callconv(.c) c_int {
+    if (out_baked) |p| p.* = 0;
+    const zp = spanOpt(zip_path) orelse return failWith(err, .badarg, "zip_path must not be null");
+    const out_d = spanOpt(out_dir) orelse return failWith(err, .badarg, "out_dir must not be null");
+    // No label callback, for the same reason tile57_bake_tree has none: this
+    // ABI reports progress as a count, and naming a chart would put a string
+    // across the seam. A caller that wants names owns the list and calls
+    // tile57_bake_zip_charts instead.
+    const baked = chart.bakeZip(sharedIo(), zp, out_d, null, workers, progress, progress_ctx, null) catch |e| return failCtx(err, e, zp);
+    if (out_baked) |p| p.* = @intCast(baked);
+    return OK;
+}
+
 /// Bake the cells at `in_paths` to the archives at `out_paths`, in parallel.
 /// The CALLER owns the list, so `label` names each finished chart by its index
 /// into it and no string crosses the ABI. See tile57.h.
@@ -1706,16 +1733,63 @@ export fn tile57_compose_tile(
     const o, const n = bytesOut(out, out_len) catch return failWith(err, .badarg, bad_out);
     if (out_owned) |p| p.* = false;
     const src = handle orelse return failWith(err, .badarg, "compose handle must not be null");
+    // Pictures carry no linestyles, so a raster compositor takes the plain path.
+    if (src.kind == .vector) return composeWalked(src, z, x, y, o, n, out_owned, err);
     const res = src.tile(gpa, z, x, y) catch |e| return fail(err, e);
     if (out_owned) |p| p.* = res.owned;
     if (res.tile) |t| return exportOut(err, o, n, t);
     return OK;
 }
 
-/// Render a VIEW over the compositor to PNG — the composed twin of tile57_chart_png:
-/// every covering tile is composed on demand (seams stitched through the
-/// ownership partition) and replayed through the native S-52 pixel path. See
-/// tile57.h.
+/// tile57_compose_tile's body for a vector compositor: compose to FEATURES,
+/// step every complex linestyle into plain geometry, re-encode.
+///
+/// Always, rather than on request. A composed tile is drawn from a STYLE, and a
+/// style cannot say where in a linestyle period a symbol sits — so the
+/// un-walked form draws every symbol of a style at one phase and loses the S-52
+/// rhythm. The only thing that can re-walk a stored run is the engine's own
+/// replay, which reads tileContent directly and never comes through here.
+///
+/// The compositor answers `.layers` where a tile seam-composes and `.bytes`
+/// where one cell owns the whole tile and its stored blob passes through
+/// verbatim. Both must be walked, or every tile away from a cell boundary
+/// silently goes missing.
+fn composeWalked(
+    src: *compose.ComposeSource,
+    z: u8,
+    x: u32,
+    y: u32,
+    o: *?[*]u8,
+    n: *usize,
+    out_owned: ?*bool,
+    err: ?*CError,
+) c_int {
+    // The decoded features live only long enough to be walked: an arena for
+    // the compose and the walk's scratch, the encoded tile alone in gpa.
+    var arena = std.heap.ArenaAllocator.init(gpa);
+    defer arena.deinit();
+    const ta = arena.allocator();
+    const px: f64 = @floatFromInt(src.draw_px_per_tile);
+
+    const res = src.tileContent(ta, z, x, y) catch |e| return fail(err, e);
+    const layers = switch (res.content) {
+        .layers => |l| l,
+        .bytes => |b| mlt_dec.decode(ta, b) catch |e| return fail(err, e),
+        .none => return OK,
+    };
+    const bytes = scene.walkTile(ta, gpa, layers, .mlt, z, px) catch |e| return fail(err, e);
+    if (out_owned) |p| p.* = true;
+    return exportOut(err, o, n, bytes);
+}
+
+/// How wide the caller draws a tile: 256 for the native convention, 512 for the
+/// MapLibre style spec's world tile. Sets what composed linestyle rhythms are
+/// restated in. See tile57.h.
+export fn tile57_compose_set_px_per_tile(handle: ?*compose.ComposeSource, px_per_tile: u32) void {
+    const src = handle orelse return;
+    if (px_per_tile != 0) src.draw_px_per_tile = px_per_tile;
+}
+
 export fn tile57_compose_png(
     handle: ?*compose.ComposeSource,
     lon: f64,
@@ -1999,6 +2073,46 @@ export fn tile57_bake_sprite_mln(catalog_dir: ?[*:0]const u8, pixel_ratio: f64,
     return OK;
 }
 
+/// Render one comma-joined symbol run (a sounding digit stack like
+/// "SOUNDG11,SOUNDG53") to a pivot-centred RGBA image at `pixel_ratio`, in
+/// the palette of `scheme`. The runtime path behind MapLibre's missing-image
+/// event: a chart library carries more distinct runs than a prebaked sheet
+/// can enumerate, so the host renders exactly the ones the map asks for.
+/// TILE57_OK with *out_rgba NULL when the run names no known glyph (absent,
+/// not an error). Free *out_rgba with tile57_free.
+export fn tile57_render_symbol_run(
+    catalog_dir: ?[*:0]const u8,
+    run: ?[*:0]const u8,
+    pixel_ratio: f64,
+    scheme: c_int,
+    out_rgba: ?*?[*]u8,
+    out_w: ?*u32,
+    out_h: ?*u32,
+    err: ?*CError,
+) callconv(.c) c_int {
+    const o = out_rgba orelse return failWith(err, .badarg, "out_rgba must not be null");
+    const ow = out_w orelse return failWith(err, .badarg, "out_w must not be null");
+    const oh = out_h orelse return failWith(err, .badarg, "out_h must not be null");
+    o.* = null;
+    ow.* = 0;
+    oh.* = 0;
+    const r = run orelse return failWith(err, .badarg, "run must not be null");
+    const cd = spanOpt(catalog_dir) orelse "";
+    const ratio = if (pixel_ratio > 0) pixel_ratio else 1;
+    const img = bundle.symbolRunImage(sharedIo(), gpa, cd, svgCssFor(scheme), std.mem.span(r), ratio) catch |e| return fail(err, e);
+    if (img) |i| {
+        // Through the export-header convention (exportAlloc/tile57_free) like
+        // every other buffer this ABI hands out; the engine copy is freed here.
+        defer gpa.free(i.rgba);
+        const p = exportAlloc(i.rgba.len) orelse return failWith(err, .nomem, "out of memory");
+        @memcpy(p[0..i.rgba.len], i.rgba);
+        o.* = p;
+        ow.* = i.w;
+        oh.* = i.h;
+    }
+    return OK;
+}
+
 const glyph_sdf = @import("sprite").glyph;
 
 // Glyph metrics as compact JSON: {"em_px","pad","glyphs":{cp:[u0,v0,u1,v1,ox,oy,w,h,adv]}}.
diff --git a/src/chart.zig b/src/chart.zig
index 07c747e5..c5b6f611 100644
--- a/src/chart.zig
+++ b/src/chart.zig
@@ -228,6 +228,7 @@ const CellBackend = struct {
     portrayal: ?[]const ?[]const u8 = null, // per-feature default S-101 instruction stream
     portrayal_plain: ?[]const ?[]const u8 = null, // PlainBoundaries variant (areas)
     portrayal_simplified: ?[]const ?[]const u8 = null, // SimplifiedSymbols variant (points)
+    portrayal_lights: ?[]const ?[]const u8 = null, // FullLightLines variant (sectored lights)
     portray_arena: ?*std.heap.ArenaAllocator = null,
     coverage: []const []const []const s57.LonLat = &.{}, // M_COVR (in portray_arena)
     cscl: i32 = 0, // compilation scale (DSPM CSCL, 1:N)
@@ -264,6 +265,7 @@ fn cellRef(cb: *CellBackend) scene.CellRef {
         .portrayal = cb.portrayal,
         .portrayal_plain = cb.portrayal_plain,
         .portrayal_simplified = cb.portrayal_simplified,
+        .portrayal_lights = cb.portrayal_lights,
         .geo = cb.geo,
         .geo_world = cb.geo_world,
         .feat_bbox = cb.feat_bbox,
@@ -286,6 +288,7 @@ const LazyCell = struct {
     portrayal: ?[]const ?[]const u8 = null,
     portrayal_plain: ?[]const ?[]const u8 = null,
     portrayal_simplified: ?[]const ?[]const u8 = null,
+    portrayal_lights: ?[]const ?[]const u8 = null,
     arena: ?*std.heap.ArenaAllocator = null,
     tick: u64 = 0, // LRU: last tile that used this cell
     // M_COVR(CATCOV=1) coverage polygons, assembled once from `cell` for best-band
@@ -519,6 +522,7 @@ fn lazyEnsureLoaded(ls: *LazySource, lc: *LazyCell) void {
             lc.portrayal = cp.base;
             lc.portrayal_plain = cp.plain;
             lc.portrayal_simplified = cp.simplified;
+            lc.portrayal_lights = cp.lights;
             lc.arena = p;
         } else |_| {
             p.deinit();
@@ -547,6 +551,7 @@ fn lazyUnload(lc: *LazyCell) void {
     lc.scamins = &.{}; // ditto (cell.arena)
     lc.portrayal_plain = null;
     lc.portrayal_simplified = null;
+    lc.portrayal_lights = null;
     if (lc.arena) |p| {
         p.deinit();
         gpa.destroy(p);
@@ -687,6 +692,7 @@ fn buildCellBackend(base: []const u8, updates: []const []const u8, dir: []const
         cb.portrayal = cp.base;
         cb.portrayal_plain = cp.plain;
         cb.portrayal_simplified = cp.simplified;
+        cb.portrayal_lights = cp.lights;
     } else |_| {}
     // Assemble geometry + its projection + per-feature bboxes ONCE (the baker's
     // per-cell caches) so live per-view rendering reuses them across the view's tiles
@@ -1194,11 +1200,177 @@ pub fn bakeTree(io: std.Io, in_dir: []const u8, out_dir: []const u8, rules_dir:
     return bakeChartsToFiles(io, in_paths.items, out_paths.items, rules_dir, workers, progress, progress_ctx, label, true);
 }
 
+/// Bake a whole exchange set STILL IN ITS ARCHIVE: find the cells, name every
+/// output, bake. The zip twin of `bakeTree`, and for the same reason — working
+/// out where each chart goes is this engine's job, not a thing every host
+/// reinvents. It had been reinvented three times before this existed (the CLI,
+/// the macOS shell, an Android path), and two of the three carried the
+/// archive's own wrapper directory into the output.
+///
+/// THE NAMING RULE. Mirror each entry's path BELOW the directory the archive
+/// wraps everything in. NOAA's All_ENCs.zip puts every cell under `ENC_ROOT/`;
+/// that name belongs to the archive, not to the library being built, so an
+/// `out_dir` of `.../ENC_ROOT` must not produce `.../ENC_ROOT/ENC_ROOT/`. The
+/// prefix is COMPUTED — the longest whole-component prefix the cells share —
+/// rather than assumed to be one level, so an archive holding two districts
+/// keeps them apart. That is what the mirroring is for: two districts carrying
+/// the same boundary cell keep their own copies instead of overwriting each
+/// other, and each cell's referenced text lands beside the right chart.
+///
+/// A cell sharing its directory with no other (a single-cell archive) gets a
+/// directory named for itself — the layout the aux manifest needs, and what a
+/// bake from a loose `.000` already writes.
+pub fn bakeZip(io: std.Io, zip_path: []const u8, out_dir: []const u8, rules_dir: ?[]const u8, workers: usize, progress: BakeProgress, progress_ctx: ?*anyopaque, label: BakeLabel) !usize {
+    var arena = std.heap.ArenaAllocator.init(gpa);
+    defer arena.deinit();
+    const a = arena.allocator();
+
+    var arc = try zipsrc.Archive.open(a, io, zip_path);
+    defer arc.deinit();
+
+    var names = std.ArrayList([]const u8).empty;
+    for (arc.entries) |e| {
+        if (std.mem.endsWith(u8, e.name, ".000")) names.append(a, e.name) catch continue;
+    }
+    if (names.items.len == 0) return 0;
+
+    // Say the count the moment it is known, before the pass below decides what
+    // is already done. That pass stats one file per chart, which on a phone or
+    // tablet is slow enough to look like a hang — and until this fired the host
+    // had no denominator to draw anything but a spinner with.
+    if (progress) |p| {
+        if (!p(progress_ctx, 0, @intCast(names.items.len))) return 0;
+    }
+
+    const root = archiveRootPrefix(names.items);
+
+    // The cells this run will actually bake, and where each goes. `kept` is a
+    // subset of `names` once the incremental skip below has had its say, and
+    // the two lists must stay index-aligned: `label` names a chart by its index
+    // into what was HANDED to the bake, not into the archive.
+    var kept = std.ArrayList([]const u8).empty;
+    var out_paths = std.ArrayList([]const u8).empty;
+    for (names.items) |n| {
+        const base = std.fs.path.basename(n);
+        const stem = base[0 .. std.mem.lastIndexOfScalar(u8, base, '.') orelse base.len];
+        const dir = zipDirOf(n);
+        var rel = dir[@min(root.len, dir.len)..];
+        while (rel.len != 0 and rel[0] == '/') rel = rel[1..];
+        const chart_dir = if (rel.len == 0)
+            std.fs.path.join(a, &.{ out_dir, stem }) catch continue
+        else
+            std.fs.path.join(a, &.{ out_dir, rel }) catch continue;
+        const name = std.fmt.allocPrint(a, "{s}.pmtiles", .{stem}) catch continue;
+        const out_path = std.fs.path.join(a, &.{ chart_dir, name }) catch continue;
+        // INCREMENTAL, as bakeTree is: an archive already newer than the zip it
+        // came from is done. A national exchange set is hours of work on a
+        // tablet and WILL be interrupted — the app is backgrounded, the battery
+        // goes, the mariner stops it to sail — and without this every resume
+        // starts from the first cell again and never finishes.
+        if (fileModNs(io, out_path)) |out_ns| {
+            if (fileModNs(io, zip_path)) |zip_ns| {
+                if (out_ns >= zip_ns) continue;
+            }
+        }
+        std.Io.Dir.cwd().createDirPath(io, chart_dir) catch {};
+        kept.append(a, n) catch continue;
+        out_paths.append(a, out_path) catch continue;
+    }
+    if (out_paths.items.len != kept.items.len) return error.OutOfMemory;
+    if (kept.items.len == 0) return 0; // everything already prepared
+
+    // Correct the count to the work actually left. A resumed import skips what
+    // it already baked, so the number from the listing was the archive's size,
+    // not this run's.
+    if (progress) |p| {
+        if (!p(progress_ctx, 0, @intCast(kept.items.len))) return 0;
+    }
+
+    return bakeZipChartsToFiles(io, &arc, kept.items, out_paths.items, rules_dir, workers, progress, progress_ctx, label, true);
+}
+
+/// Zip entry names always use '/', whatever the platform, so these split on
+/// that rather than on the host separator.
+fn zipDirOf(path: []const u8) []const u8 {
+    const at = std.mem.lastIndexOfScalar(u8, path, '/') orelse return "";
+    return path[0..at];
+}
+
+/// The directory every one of `paths` sits under, as whole path components.
+pub fn archiveRootPrefix(paths: []const []const u8) []const u8 {
+    if (paths.len == 0) return "";
+    var pre: []const u8 = zipDirOf(paths[0]);
+    for (paths[1..]) |p| {
+        pre = commonComponents(pre, zipDirOf(p));
+        if (pre.len == 0) break;
+    }
+    return pre;
+}
+
+/// The longest common prefix of `a` and `b` ending on a component boundary, so
+/// `ENC_ROOT/US5` and `ENC_ROOT/US4` share `ENC_ROOT`, not `ENC_ROOT/US`.
+fn commonComponents(a: []const u8, b: []const u8) []const u8 {
+    var i: usize = 0;
+    var boundary: usize = 0;
+    while (i < a.len and i < b.len and a[i] == b[i]) : (i += 1) {
+        if (a[i] == '/') boundary = i;
+    }
+    if (i == a.len and (i == b.len or b[i] == '/')) return a;
+    if (i == b.len and a[i] == '/') return b;
+    return a[0..boundary];
+}
+
+test "an archive's own root directory is not part of the output path" {
+    // NOAA's All_ENCs.zip: every cell under one ENC_ROOT/. Carrying that
+    // through made `-o ~/Charts/ENC_ROOT` write ~/Charts/ENC_ROOT/ENC_ROOT/ — a
+    // second library beside the real one, which a host that opens the parent
+    // then composes together with it, one vintage silently winning per tile.
+    const noaa = [_][]const u8{ "ENC_ROOT/US5MD12M/US5MD12M.000", "ENC_ROOT/US4MD11M/US4MD11M.000" };
+    try std.testing.expectEqualStrings("ENC_ROOT", archiveRootPrefix(&noaa));
+
+    // What the mirroring is FOR survives it: two districts carrying the same
+    // boundary cell keep their own copies.
+    const districts = [_][]const u8{ "ENC_ROOT/D1/US5MD12M/US5MD12M.000", "ENC_ROOT/D2/US5MD12M/US5MD12M.000" };
+    try std.testing.expectEqualStrings("ENC_ROOT", archiveRootPrefix(&districts));
+
+    // A near-miss must not split mid-component.
+    const near = [_][]const u8{ "ENC_ROOT/US5/a.000", "ENC_ROOT/US4/b.000" };
+    try std.testing.expectEqualStrings("ENC_ROOT", archiveRootPrefix(&near));
+
+    // A flat archive shares nothing; one cell under one directory shares all of
+    // it, and both fall back to a directory named for the chart.
+    const flat = [_][]const u8{ "a.000", "b.000" };
+    try std.testing.expectEqualStrings("", archiveRootPrefix(&flat));
+    const one = [_][]const u8{"ENC_ROOT/US5MD12M/US5MD12M.000"};
+    try std.testing.expectEqualStrings("ENC_ROOT/US5MD12M", archiveRootPrefix(&one));
+}
+
+test "the GPU atlas declares the scale its cells were baked at" {
+    // A sprite quad is sized cell px x scale/ppm, so the ppm buildGpuAtlases
+    // declares must be the one spriteMlnOpts rasterized the cells at.
+    for ([_]f64{ 1.0, 2.0, 3.0 }) |ratio| {
+        try std.testing.expectApproxEqRel(
+            sprite.mlnPpm(ratio),
+            sprite.px_per_unit * 100.0 * ratio * sprite.mln_drawn_scale,
+            1e-12,
+        );
+    }
+    // The drawn scale is the engine's symbol scale, so a cell measured through
+    // that ppm is the size drawSymbol tessellates.
+    try std.testing.expectApproxEqRel(
+        sprite.mln_drawn_scale * sprite.px_per_unit,
+        render.sndfrm.SYMBOL_SCALE,
+        1e-12,
+    );
+}
+
 /// The file's modification time in nanoseconds, or null if it doesn't exist / can't be statted.
 fn fileModNs(io: std.Io, path: []const u8) ?i96 {
-    var f = std.Io.Dir.cwd().openFile(io, path, .{}) catch return null;
-    defer f.close(io);
-    const st = f.stat(io) catch return null;
+    // statFile, not open+fstat+close: this runs once per chart before any bake
+    // starts, and on Android's FUSE-backed storage those three syscalls are
+    // three round trips each. Over a 7,217-cell exchange set that was minutes
+    // of the import spent deciding what was already done.
+    const st = std.Io.Dir.cwd().statFile(io, path, .{}) catch return null;
     return st.mtime.nanoseconds;
 }
 
@@ -1292,8 +1464,11 @@ fn buildGpuAtlases(a: std.mem.Allocator, ratio: f64) !struct { sprites: render.g
     // Layout only: the scene consumer reads cells + dims, never the pixels —
     // the full bake here (composite + zlib) was ~2/3 of the render path's
     // cycles in a field profile whenever the shared atlases (re)built.
+    // The ppm must be the one the cells were rasterized at: render/gpu.zig
+    // sizes a sprite quad as cell px x scale/ppm, so a mismatch draws every
+    // symbol, sounding and linestyle brick at the ratio between the two.
     var atlas = try sprite.spriteMlnOpts(a, sym_srcs, fill_srcs, css_data, &[_][]const u8{}, ratio, false);
-    var sprites = render.gpu.SpriteAtlas{ .width = atlas.width, .height = atlas.height, .ppm = @floatCast(sprite.px_per_unit * 100.0 * ratio) };
+    var sprites = render.gpu.SpriteAtlas{ .width = atlas.width, .height = atlas.height, .ppm = @floatCast(sprite.mlnPpm(ratio)) };
     var cit = atlas.cells.iterator();
     while (cit.next()) |e| {
         const r = e.value_ptr.*;
@@ -2664,6 +2839,7 @@ pub const Chart = struct {
                     .portrayal = cb.portrayal,
                     .portrayal_plain = cb.portrayal_plain,
                     .portrayal_simplified = cb.portrayal_simplified,
+                    .portrayal_lights = cb.portrayal_lights,
                 }};
                 return scene.generateView(&ps, a, gpa, &one, lon, lat, zoom, self.pick_attrs) catch error.TileGen;
             },
@@ -2925,6 +3101,7 @@ pub const Chart = struct {
                     .portrayal = cb2.portrayal,
                     .portrayal_plain = cb2.portrayal_plain,
                     .portrayal_simplified = cb2.portrayal_simplified,
+                    .portrayal_lights = cb2.portrayal_lights,
                     .geo = cb2.geo,
                     .geo_world = cb2.geo_world,
                     .feat_bbox = cb2.feat_bbox,
@@ -3086,6 +3263,7 @@ pub const Chart = struct {
                         .portrayal = cb2.portrayal,
                         .portrayal_plain = cb2.portrayal_plain,
                         .portrayal_simplified = cb2.portrayal_simplified,
+                        .portrayal_lights = cb2.portrayal_lights,
                     }};
                     scene.appendTile(surf, a, &one, z, qt.tx, qt.ty, self.pick_attrs) catch continue;
                 },
@@ -3138,6 +3316,7 @@ pub const Chart = struct {
                     .portrayal = cb.portrayal,
                     .portrayal_plain = cb.portrayal_plain,
                     .portrayal_simplified = cb.portrayal_simplified,
+                    .portrayal_lights = cb.portrayal_lights,
                 }};
                 return scene.generateView(&as, a, gpa, &one, lon, lat, zoom, self.pick_attrs) catch error.TileGen;
             },
@@ -3712,6 +3891,7 @@ const BakeWork = struct {
         var portrayal: ?[]const ?[]const u8 = null;
         var portrayal_plain: ?[]const ?[]const u8 = null;
         var portrayal_simplified: ?[]const ?[]const u8 = null;
+        var portrayal_lights: ?[]const ?[]const u8 = null;
         var geo: ?scene.GeoParts = null;
         var geo_world: ?scene.GeoWorld = null;
         var feat_bbox: ?[]const ?[4]f64 = null;
@@ -3722,6 +3902,7 @@ const BakeWork = struct {
                 portrayal = cp.base;
                 portrayal_plain = cp.plain;
                 portrayal_simplified = cp.simplified;
+                portrayal_lights = cp.lights;
             } else |_| {}
             // Build the geometry cache for EVERY cell, unconditionally.
             // `build_geo` (cacheGeoForBand) gated it to the finer bands, but coarse cells are
@@ -3760,7 +3941,7 @@ const BakeWork = struct {
         // Sector-figure reach (exact, from the portrayal streams): buildTileMap
         // addresses the neighbouring tiles the cell's light legs/arcs cross.
         const lr = scene.collectLightReach(&cell, portrayal);
-        c.outs[i] = .{ .cell = cell, .portrayal = portrayal, .portrayal_plain = portrayal_plain, .portrayal_simplified = portrayal_simplified, .geo = geo, .geo_world = geo_world, .feat_bbox = feat_bbox, .bounds = b, .cscl = cscl, .coverage = coverage, .scamins = scamins, .light_bbox = lr.bbox, .light_range_m = lr.range_m };
+        c.outs[i] = .{ .cell = cell, .portrayal = portrayal, .portrayal_plain = portrayal_plain, .portrayal_simplified = portrayal_simplified, .portrayal_lights = portrayal_lights, .geo = geo, .geo_world = geo_world, .feat_bbox = feat_bbox, .bounds = b, .cscl = cscl, .coverage = coverage, .scamins = scamins, .light_bbox = lr.bbox, .light_range_m = lr.range_m };
         c.arenas[i] = pa;
     }
 };
diff --git a/src/compose/compose.zig b/src/compose/compose.zig
index ecd4f2c9..1da74760 100644
--- a/src/compose/compose.zig
+++ b/src/compose/compose.zig
@@ -291,6 +291,10 @@ fn composeLayers(ra: std.mem.Allocator, part: *const geometry.partition.Partitio
     const compose = clip;
     var buckets: [N_COMPOSE_LAYERS]std.ArrayList(mvt.Feature) = undefined;
     for (&buckets) |*b| b.* = std.ArrayList(mvt.Feature).empty;
+    // tile57/3 splits linestyle-decorated lines into per-style
+    // `lines-ls-<STYLE>` source-layers; the split survives a seam compose by
+    // bucketing those layers by NAME beside the fixed canonical set.
+    var ls_buckets: std.StringArrayHashMapUnmanaged(std.ArrayList(mvt.Feature)) = .empty;
     // EVERY contribution arrives with its region already rect-clipped to the
     // tile, so projection, clipping and memory here are bounded by the TILE —
     // never by the face (whole-cell faces at coarse tiers are hundreds of
@@ -323,10 +327,19 @@ fn composeLayers(ra: std.mem.Allocator, part: *const geometry.partition.Partitio
         var fgrid = try geometry.plane.EdgeGrid.init(sa2, face_px, 512);
         defer fgrid.deinit();
         for (layers) |layer| {
-            const li = layerIndex(layer.name) orelse continue;
+            const bucket: *std.ArrayList(mvt.Feature) = if (layerIndex(layer.name)) |li|
+                &buckets[li]
+            else if (std.mem.startsWith(u8, layer.name, "lines-ls-")) blk: {
+                const g = try ls_buckets.getOrPut(ra, layer.name);
+                if (!g.found_existing) {
+                    g.key_ptr.* = try ra.dupe(u8, layer.name);
+                    g.value_ptr.* = .empty;
+                }
+                break :blk g.value_ptr;
+            } else continue;
             var tmpb = std.ArrayList(mvt.Feature).empty;
             for (layer.features) |feat| try compose.clipFeatureToFace(sa2, &tmpb, feat, face_px, &fgrid);
-            for (tmpb.items) |f| try buckets[li].append(ra, try dupeFeature(ra, f));
+            for (tmpb.items) |f| try bucket.append(ra, try dupeFeature(ra, f));
         }
     }
     // Reach-ring cells: no owned ground in this tile, but their light sector
@@ -352,6 +365,24 @@ fn composeLayers(ra: std.mem.Allocator, part: *const geometry.partition.Partitio
         if (bucket.items.len == 0) continue;
         const feats = try orientPolys(ra, bucket.items);
         try out_layers.append(ra, .{ .name = mvt.VECTOR_LAYERS[li], .features = feats });
+        // The per-style line layers ride right after their base layer, keeping
+        // the canonical order around them.
+        if (std.mem.eql(u8, mvt.VECTOR_LAYERS[li], "lines")) {
+            var it = ls_buckets.iterator();
+            while (it.next()) |e| {
+                if (e.value_ptr.items.len == 0) continue;
+                try out_layers.append(ra, .{ .name = e.key_ptr.*, .features = e.value_ptr.items });
+            }
+        }
+    }
+    // A tile can carry ls layers with an empty base `lines` bucket; they must
+    // not vanish with it.
+    if (buckets[layerIndex("lines").?].items.len == 0) {
+        var it = ls_buckets.iterator();
+        while (it.next()) |e| {
+            if (e.value_ptr.items.len == 0) continue;
+            try out_layers.append(ra, .{ .name = e.key_ptr.*, .features = e.value_ptr.items });
+        }
     }
     if (out_layers.items.len == 0) return null;
     return out_layers.items;
@@ -669,6 +700,17 @@ pub const ComposeSource = struct {
     render_cache: ?*anyopaque = null,
     render_cache_free: ?*const fn (*anyopaque) void = null,
 
+    /// How wide the CONSUMER draws a tile. Complex linestyles are walked into
+    /// plain geometry on the way out, and S-101 lays their figures out in
+    /// 256-px-per-tile space, so this is what the rhythm is restated in: 256
+    /// for that native convention, 512 for the MapLibre style spec's world
+    /// tile. It moves spacing only, never stroke width or symbol size.
+    ///
+    /// Held as a plain number because the compositor sits below the render
+    /// path and cannot name what does the walking; the C entry point reads
+    /// this and does the work.
+    draw_px_per_tile: u32 = 256,
+
     /// Compose one tile → raw (decompressed) MLT + the ownership flag (gpa-owned bytes; null when
     /// nothing rendered — `owned` then says whether a cell SHOULD have). This is what a live tile
     /// server hands its HTTP layer, which gzips on the wire. Byte-faithful to the batch.
diff --git a/src/geometry/boolean.zig b/src/geometry/boolean.zig
index 426c400c..adc7f516 100644
--- a/src/geometry/boolean.zig
+++ b/src/geometry/boolean.zig
@@ -58,17 +58,18 @@ pub const Op = enum { intersect, unite, diff, sym_diff };
 /// marks a boolean bug at the exact tile being composed. Callers snapshot
 /// before/after; updates are atomic (computes run concurrently in the
 /// partition sweep) but snapshot-delta reads assume no concurrent compute.
-pub var open_chain_walks: u64 = 0;
+/// usize, not u64: a 32-bit target has no 64-bit atomic add.
+pub var open_chain_walks: usize = 0;
 /// Diagnostic: how many compute() calls fell back to the region-sampled
 /// in_result recomputation because the sweep-flag pass dead-ended a walk.
-pub var robust_retries: u64 = 0;
+pub var robust_retries: usize = 0;
 /// Diagnostic: how many micro-stitch edges closed a snap-divergence gap (two
 /// crossings of near-parallel edges snapping to adjacent lattice points leave
 /// the survivor graph with odd-degree vertex pairs a few units apart).
-pub var stitched_gaps: u64 = 0;
+pub var stitched_gaps: usize = 0;
 /// Diagnostic: open chains whose implicit closing chord exceeds 32 units — the
 /// visible-artifact subset of open_chain_walks (micro chords are sub-pixel).
-pub var large_open_chains: u64 = 0;
+pub var large_open_chains: usize = 0;
 
 // ---------------------------------------------------------------------------
 // Exact predicates (i128).
@@ -534,7 +535,7 @@ pub fn compute(gpa: Allocator, subject: Polygon, clip: Polygon, op: Op) ![][]Pt
         return first;
     }
     freePolygon(gpa, first);
-    _ = @atomicRmw(u64, &robust_retries, .Add, 1, .monotonic);
+    _ = @atomicRmw(usize, &robust_retries, .Add, 1, .monotonic);
     for (sw.processed.items) |e| {
         if (!(e.left and e.edge_type == .normal)) continue;
         const other: Polygon = if (e.subject) clip else subject;
@@ -565,15 +566,15 @@ pub fn compute(gpa: Allocator, subject: Polygon, clip: Polygon, op: Op) ![][]Pt
 /// Per-compute walk outcome; folded into the shared counters at the end of the
 /// call so concurrent computes never read each other's in-flight state.
 const WalkStats = struct {
-    chains: u64 = 0,
-    large: u64 = 0,
-    stitched: u64 = 0,
+    chains: usize = 0,
+    large: usize = 0,
+    stitched: usize = 0,
 };
 
 fn publishWalkStats(s: WalkStats) void {
-    if (s.chains != 0) _ = @atomicRmw(u64, &open_chain_walks, .Add, s.chains, .monotonic);
-    if (s.large != 0) _ = @atomicRmw(u64, &large_open_chains, .Add, s.large, .monotonic);
-    if (s.stitched != 0) _ = @atomicRmw(u64, &stitched_gaps, .Add, s.stitched, .monotonic);
+    if (s.chains != 0) _ = @atomicRmw(usize, &open_chain_walks, .Add, s.chains, .monotonic);
+    if (s.large != 0) _ = @atomicRmw(usize, &large_open_chains, .Add, s.large, .monotonic);
+    if (s.stitched != 0) _ = @atomicRmw(usize, &stitched_gaps, .Add, s.stitched, .monotonic);
 }
 
 /// Add one operand's rings to the sweep with its self-overlapping collinear
diff --git a/src/portray/lua_shim.c b/src/portray/lua_shim.c
index 38d4c374..97b0128e 100644
--- a/src/portray/lua_shim.c
+++ b/src/portray/lua_shim.c
@@ -231,6 +231,77 @@ static void register_host_stubs(lua_State *L) {
  * directory is present — i.e. when tile57 runs as a standalone binary. Returns 2
  * (loader chunk + the module name) on a hit, or 1 (an explanatory string Lua
  * folds into the "module 'X' not found" message) on a miss. */
+/* COMPILED-ONCE module cache.
+ *
+ * The searcher below compiles Lua source: lexer, parser, code generator. The
+ * bake stands up a fresh VM up to three times per chart (base, plain
+ * boundaries, simplified symbols) and each one `require`s the five framework
+ * modules, so a 7,224-cell exchange set compiled them about 100,000 times.
+ * Lua's code generator was the largest single item in an Android bake profile,
+ * ahead of every piece of chart work.
+ *
+ * Keeping the VM itself would be faster still, and is wrong: the framework
+ * carries per-dataset state, and the golden Part-9 streams change when a second
+ * chart runs in a state the first one used. So the STATE stays per pass and only
+ * the compiled bytecode is kept — `lua_dump` once, undump after. Same isolation,
+ * without the compiler.
+ *
+ * Thread-local: the bake runs a worker per core, and this way the cache needs no
+ * lock. It costs one copy of the bytecode per worker.
+ */
+/* The catalogue is not five modules: the framework requires a rule module per
+ * feature class on demand, and a national bake touches hundreds of them. Sized
+ * at 16 this cached the framework and recompiled every rule — 3,741 misses
+ * against 2,031 hits over sixty charts, which is why it bought nothing. */
+#define TG_BC_MAX 1024
+
+typedef struct {
+    char name[64];
+    size_t nlen;
+    unsigned char *buf;
+    size_t len;
+} tg_bc_entry;
+
+static _Thread_local tg_bc_entry tg_bc_cache[TG_BC_MAX];
+static _Thread_local int tg_bc_count = 0;
+
+static int tg_bc_writer(lua_State *L, const void *p, size_t sz, void *ud) {
+    (void)L;
+    tg_bc_entry *e = (tg_bc_entry *)ud;
+    unsigned char *nb = (unsigned char *)realloc(e->buf, e->len + sz);
+    if (!nb) return 1; /* out of memory: the caller drops the entry */
+    memcpy(nb + e->len, p, sz);
+    e->buf = nb;
+    e->len += sz;
+    return 0;
+}
+
+static const tg_bc_entry *tg_bc_find(const char *name, size_t nlen) {
+    for (int i = 0; i < tg_bc_count; i++) {
+        if (tg_bc_cache[i].nlen == nlen && memcmp(tg_bc_cache[i].name, name, nlen) == 0)
+            return &tg_bc_cache[i];
+    }
+    return NULL;
+}
+
+/* Dump the loader sitting on top of the stack. Leaves it there: the searcher
+ * still has to return it. Debug info is kept (strip = 0) so a rule error still
+ * names its file and line. */
+static void tg_bc_store(lua_State *L, const char *name, size_t nlen) {
+    if (tg_bc_count >= TG_BC_MAX || nlen >= sizeof(tg_bc_cache[0].name)) return;
+    tg_bc_entry *e = &tg_bc_cache[tg_bc_count];
+    e->buf = NULL;
+    e->len = 0;
+    memcpy(e->name, name, nlen);
+    e->nlen = nlen;
+    if (lua_dump(L, tg_bc_writer, e, 0) == 0 && e->buf != NULL) {
+        tg_bc_count++;
+    } else {
+        free(e->buf);
+        e->buf = NULL;
+    }
+}
+
 static int embedded_lua_searcher(lua_State *L) {
     size_t nlen = 0;
     const char *name = luaL_checklstring(L, 1, &nlen);
@@ -250,8 +321,18 @@ static int embedded_lua_searcher(lua_State *L) {
     memcpy(chunk + 1, name, n);
     memcpy(chunk + 1 + n, ".lua", 4);
     chunk[1 + n + 4] = '\0';
+    /* Already compiled on this thread: undump rather than recompile. Lua reads
+     * the binary signature and skips the whole front end. */
+    const tg_bc_entry *hit = tg_bc_find(name, nlen);
+    if (hit != NULL) {
+        if (luaL_loadbuffer(L, (const char *)hit->buf, hit->len, chunk) != LUA_OK)
+            return lua_error(L);
+        lua_pushstring(L, name);
+        return 2;
+    }
     if (luaL_loadbuffer(L, src, len, chunk) != LUA_OK)
         return lua_error(L); /* loader error already on the stack */
+    tg_bc_store(L, name, nlen);
     lua_pushstring(L, name); /* passed to the loader as its 2nd arg, like the file searcher */
     return 2;
 }
@@ -858,6 +939,34 @@ static int lp_store(lua_State *L) { /* tg_store(index, instr) */
  * (PlainBoundaries §8.6.1 / SimplifiedSymbols §11.2.2) plus the mariner
  * depth/light/danger parameters. NULL reproduces the fixed bake context
  * unchanged. Returns 0 on success. */
+/* One VM per thread, reused across charts.
+ *
+ * The expensive half of a pass was standing the VM up: a fresh state, the
+ * standard libraries, thirty-odd host bindings, and the five framework modules.
+ * Only the last of those is cheap now (bytecode cache above), and the rest was
+ * still the largest item in an Android bake profile.
+ *
+ * What makes reuse safe is reloading the FRAMEWORK per pass. PortrayalAPI keeps
+ * featureCache / informationCache / spatialCache at module level, keyed by ID,
+ * and our IDs are feature indices — they repeat from one chart to the next, so a
+ * second chart in a used state reads the first chart's features back out of the
+ * cache. That is not theoretical: it changed six golden Part-9 streams.
+ * Dropping the modules from package.loaded and requiring them again rebuilds
+ * those caches, and costs no compilation.
+ *
+ * Thread-local: a lua_State is not thread-safe and the bake runs a worker per
+ * core. */
+static _Thread_local lua_State *tg_cached_L = NULL;
+static _Thread_local char tg_cached_dir[4096];
+
+/* Re-executes the framework so its per-dataset caches start empty. */
+static const char *tg_reset_chunk =
+    "for _,m in ipairs{'S100Scripting','PortrayalModel','PortrayalAPI','Default','main'} do\n"
+    "  package.loaded[m] = nil\n"
+    "end\n"
+    "require 'S100Scripting'; require 'PortrayalModel'; require 'PortrayalAPI';\n"
+    "require 'Default'; require 'main'\n";
+
 int tg_portray_run(const char *dir, size_t dir_len, const tg_portray_ctx *ctx) {
     char dbuf[4096];
     if (dir_len >= sizeof dbuf) return -1;
diff --git a/src/portray/portray.zig b/src/portray/portray.zig
index a2774888..8f1c78b4 100644
--- a/src/portray/portray.zig
+++ b/src/portray/portray.zig
@@ -423,6 +423,9 @@ pub const CellPortrayal = struct {
     base: []const ?[]const u8,
     plain: ?[]const ?[]const u8 = null,
     simplified: ?[]const ?[]const u8 = null,
+    /// FullLightLines=true pass over sectored-light points only (S-52 §12.2.4
+    /// full-length sector legs); the sect tag's variant axis.
+    lights: ?[]const ?[]const u8 = null,
 };
 
 /// Portray a cell three ways so the client can toggle boundary style (areas) and
@@ -447,11 +450,16 @@ pub fn portrayCellVariantsAdapted(arena: std.mem.Allocator, cell: *const s57.Cel
     // (SOUNDG is already excluded from `adapted`, and "Curve" varies under neither).
     var areas = std.ArrayList(adapter.Adapted).empty;
     var points = std.ArrayList(adapter.Adapted).empty;
+    // The sectored lights alone: LightSectored is the one rule that reads
+    // FullLightLines, so the variant pass is bounded to the features whose
+    // legs it lengthens.
+    var lights = std.ArrayList(adapter.Adapted).empty;
     for (adapted) |ad| {
         if (std.mem.eql(u8, ad.primitive, "Surface")) {
             try areas.append(arena, ad);
         } else if (std.mem.eql(u8, ad.primitive, "Point")) {
             try points.append(arena, ad);
+            if (std.mem.eql(u8, ad.code, "LightSectored")) try lights.append(arena, ad);
         }
     }
 
@@ -460,5 +468,7 @@ pub fn portrayCellVariantsAdapted(arena: std.mem.Allocator, cell: *const s57.Cel
         cp.plain = runAdapted(arena, cell, areas.items, rules_dir, .{ .plain_boundaries = true }) catch null;
     if (points.items.len > 0)
         cp.simplified = runAdapted(arena, cell, points.items, rules_dir, .{ .simplified_symbols = true }) catch null;
+    if (lights.items.len > 0)
+        cp.lights = runAdapted(arena, cell, lights.items, rules_dir, .{ .full_light_lines = true }) catch null;
     return cp;
 }
diff --git a/src/render/gpu.zig b/src/render/gpu.zig
index 99097701..e74620d2 100644
--- a/src/render/gpu.zig
+++ b/src/render/gpu.zig
@@ -124,7 +124,9 @@ pub const NO_PATTERN: u32 = std.math.maxInt(u32);
 pub const SpriteAtlas = struct {
     width: u32,
     height: u32,
-    /// Atlas px per mm the cells were rasterized at (px_per_mm × display ratio).
+    /// Atlas px per mm the cells were rasterized at. The builder states it
+    /// (sprite.mlnPpm). It is not px_per_mm x ratio, because the sheet is baked
+    /// at the drawn scale.
     /// A sprite quad is sized from its CELL — cell px × (draw scale / ppm) — not
     /// re-derived from the vector outline, so the on-screen artwork is exactly the
     /// rasterized cell (stroke and all), and every glyph of a multi-part mark (a
diff --git a/src/render/surface.zig b/src/render/surface.zig
index cf3c4f14..39fbec99 100644
--- a/src/render/surface.zig
+++ b/src/render/surface.zig
@@ -109,6 +109,9 @@ pub const FeatureMeta = struct {
     //   0/1 = plain/symbolized boundary or paper/simplified point pass.
     bnd: i64 = 2,
     pts: i64 = 2,
+    /// Sector-leg length variant (S-52 §12.2.4 full sector lines): 2 =
+    /// length-independent, 0 = the 25 mm legs, 1 = the full-length pass.
+    sect: i64 = 2,
     // S-52 §8.6.2 suppressed boundary piece: geometry the producer masked as a
     // cell-limit edge (MASK/USAG), baked anyway so the meta-bounds inspection
     // view can outline meta objects; the standard display never shows it (the
diff --git a/src/scene/bake_enc.zig b/src/scene/bake_enc.zig
index d68751dd..00237a95 100644
--- a/src/scene/bake_enc.zig
+++ b/src/scene/bake_enc.zig
@@ -33,6 +33,7 @@ pub const Backend = struct {
     portrayal: ?[]const ?[]const u8 = null,
     portrayal_plain: ?[]const ?[]const u8 = null, // PlainBoundaries variant (areas)
     portrayal_simplified: ?[]const ?[]const u8 = null, // SimplifiedSymbols variant (points)
+    portrayal_lights: ?[]const ?[]const u8 = null, // FullLightLines variant (sectored lights)
     geo: ?scene.GeoParts = null, // line/area geometry assembled once (buildGeoCache)
     geo_world: ?scene.GeoWorld = null, // world coords parallel to geo (cheap reprojection)
     feat_bbox: ?[]const ?[4]f64 = null, // per-feature bbox for the per-tile spatial cull
@@ -752,7 +753,7 @@ const TileGenCtx = struct {
             // property — the renderer gates symbol declutter on it (render/gpu.zig
             // belowBandWindow). A cell with no compilation scale gets bandOf's 1:50k
             // default, the same default effScaminFloor uses above.
-            refs[nrefs] = .{ .cell = &be.cell, .portrayal = be.portrayal, .portrayal_plain = be.portrayal_plain, .portrayal_simplified = be.portrayal_simplified, .geo = be.geo, .geo_world = be.geo_world, .feat_bbox = be.feat_bbox, .band = @intFromEnum(bandOf(be.cscl)), .suppress_fills = false, .suppress_patterns = false, .cover_clip = cover_clip, .suppress_lines = false, .suppress_points = false, .oscl = oscl, .overscale_hatch = !reach_only[j] and !holefill[j] and be.cscl > 0 and gf_tile < be.cscl and wins_somewhere, .eff_scamin_floor = effScaminFloor(be.cscl), .sounding_scamin = scene.soundingScamin(be.cscl), .light_range_m = be.light_range_m };
+            refs[nrefs] = .{ .cell = &be.cell, .portrayal = be.portrayal, .portrayal_plain = be.portrayal_plain, .portrayal_simplified = be.portrayal_simplified, .portrayal_lights = be.portrayal_lights, .geo = be.geo, .geo_world = be.geo_world, .feat_bbox = be.feat_bbox, .band = @intFromEnum(bandOf(be.cscl)), .suppress_fills = false, .suppress_patterns = false, .cover_clip = cover_clip, .suppress_lines = false, .suppress_points = false, .oscl = oscl, .overscale_hatch = !reach_only[j] and !holefill[j] and be.cscl > 0 and gf_tile < be.cscl and wins_somewhere, .eff_scamin_floor = effScaminFloor(be.cscl), .sounding_scamin = scene.soundingScamin(be.cscl), .light_range_m = be.light_range_m };
             nrefs += 1;
         }
         const mvt_bytes = scene.encodeTile(scratch, scratch, refs[0..nrefs], z, x, y, c.format, c.pick_attrs) catch return;
@@ -1878,7 +1879,7 @@ test "ground-length directional leg bakes across every tile it crosses" {
         const layers = try mvt.decode(a, raw);
         var legs: usize = 0;
         for (layers) |L| {
-            if (std.mem.eql(u8, L.name, "lines")) legs += L.features.len;
+            if (std.mem.startsWith(u8, L.name, "lines")) legs += L.features.len;
         }
         try std.testing.expect(legs > 0);
     }
diff --git a/src/scene/scene.zig b/src/scene/scene.zig
index 4290ae44..51f0060a 100644
--- a/src/scene/scene.zig
+++ b/src/scene/scene.zig
@@ -519,6 +519,27 @@ pub const TileSurface = struct {
     pick_areas: std.ArrayList(mvt.Feature) = .empty,
     /// Current feature meta, set by beginFeature; the draw methods read it.
     cur: Meta = .{ .display_priority = 0 },
+    /// Latitude (degrees) the v3 gate-zoom precomputes correct for — the
+    /// tile's centre. 0 (the equator) when the producer doesn't set it; the
+    /// gates then err late by the cos(lat) factor, exactly like the old
+    /// equator-only DENOM_Z0 did.
+    gate_lat: f64 = 0,
+    /// Walk complex linestyles into plain geometry instead of storing the run
+    /// un-tessellated. See `walk_vtable`; set by walkTile, never by the bake.
+    walk_linestyles: bool = false,
+    /// What the walk multiplies its period, dash offsets and symbol offsets by
+    /// — reported through the Surface's size_scale, which is the only channel
+    /// drawComplexRun reads. It scales the RHYTHM only: the stroke width comes
+    /// from the run's own width_px and the symbol size from SYMBOL_SCALE, and
+    /// neither passes through here.
+    ///
+    /// It exists because S-101 lays its linestyle figures out in 256-px-per-tile
+    /// space, and a consumer that draws a tile WIDER needs the period in FEWER
+    /// tile units to come out the same size on glass: 1.0 for a 256 px tile,
+    /// 0.5 for the style spec's 512. Getting it wrong is invisible in the
+    /// geometry and obvious on the chart — the rhythm is right, the spacing is
+    /// doubled (or halved).
+    linestyle_scale: f64 = 1.0,
 
     const mvt_vtable = rs.Surface.VTable{
         .beginScene = beginScene,
@@ -539,12 +560,37 @@ pub const TileSurface = struct {
         .draw_depth_text = drawDepthText,
     };
 
+    /// The same table with `store_complex_run` withheld, which is how
+    /// drawComplexLine is told to WALK a complex linestyle instead of storing
+    /// it: the period is stepped here and the tile receives the result as
+    /// ordinary geometry — each dash on-run a solid line, each embedded symbol
+    /// a rotated point at its own offset in the period.
+    ///
+    /// The bake never wants this (a stored run keeps the archive
+    /// display-independent, so spacing and symbol size scale together at
+    /// render). A COMPOSE does: it runs per session at a known display scale,
+    /// and its consumer may be a style-driven renderer with no way to express
+    /// where in a period a symbol sits — S-52 puts several at different
+    /// offsets (ACHARE51: 5, 13.1, 21.2, 29.3 mm) and the MapLibre style spec
+    /// has no property for it. Walking here settles it in the geometry, which
+    /// is the same answer tile57's own renderer draws.
+    const walk_vtable = blk: {
+        var v = mvt_vtable;
+        v.store_complex_run = null;
+        v.size_scale = walkSizeScale;
+        break :blk v;
+    };
+
+    fn walkSizeScale(ctx: *anyopaque) f64 {
+        return sp(ctx).linestyle_scale;
+    }
+
     pub fn init(a: Allocator, format: TileFormat) TileSurface {
         return .{ .a = a, .format = format };
     }
 
     pub fn asSurface(self: *TileSurface) rs.Surface {
-        return .{ .ptr = self, .vtable = &mvt_vtable };
+        return .{ .ptr = self, .vtable = if (self.walk_linestyles) &walk_vtable else &mvt_vtable };
     }
 
     fn sp(ctx: *anyopaque) *TileSurface {
@@ -587,6 +633,7 @@ pub const TileSurface = struct {
             .date_end = meta.date_end,
             .bnd = meta.bnd,
             .pts = meta.pts,
+            .sect = meta.sect,
         };
     }
 
@@ -783,10 +830,43 @@ pub const TileSurface = struct {
         try s.lines.appendSlice(s.a, s.lines_scamin.items);
         try s.points.appendSlice(s.a, s.points_scamin.items);
         try s.texts.appendSlice(s.a, s.texts_scamin.items);
+        // v3 tile schema (tile57/3): pre-evaluate, per feature, everything the
+        // MapLibre style otherwise re-derives per feature PER LAYER at tile
+        // layout — the gate zooms (vz/oz), the resolved filter flags (mq/iso),
+        // and the sort keys (ep/lsk). See augmentV3.
+        try augmentV3(s.a, s.areas.items, .area, s.gate_lat);
+        try augmentV3(s.a, s.area_patterns.items, .area, s.gate_lat);
+        try augmentV3(s.a, s.lines.items, .line, s.gate_lat);
+        try augmentV3(s.a, s.points.items, .point, s.gate_lat);
+        try augmentV3(s.a, s.soundings.items, .point, s.gate_lat);
+        try augmentV3(s.a, s.texts.items, .text, s.gate_lat);
         var layers = std.ArrayList(mvt.Layer).empty;
         if (s.areas.items.len > 0) try layers.append(s.a, .{ .name = "areas", .features = s.areas.items });
         if (s.area_patterns.items.len > 0) try layers.append(s.a, .{ .name = "area_patterns", .features = s.area_patterns.items });
-        if (s.lines.items.len > 0) try layers.append(s.a, .{ .name = "lines", .features = s.lines.items });
+        // v3: linestyle-decorated lines split out of `lines` into one
+        // `lines-ls-<STYLE>` source-layer per linestyle. MapLibre's layout
+        // evaluates every style layer against every feature of that layer's
+        // source-layer — with all decorated lines in one bucket, ~130 ls
+        // layers each scanned every line feature of every tile. Split, a
+        // linestyle's two or three layers see only their own features, and a
+        // tile without the style doesn't carry the source-layer at all. The
+        // name keeps the `lines` prefix: the native replay/query paths
+        // dispatch on startsWith("lines") and portray them unchanged.
+        var base_lines = std.ArrayList(mvt.Feature).empty;
+        var ls_split: std.StringArrayHashMapUnmanaged(std.ArrayList(mvt.Feature)) = .empty;
+        for (s.lines.items) |f| {
+            const ls_id = propString(f.properties, "ls_style") orelse {
+                try base_lines.append(s.a, f);
+                continue;
+            };
+            const name = try std.fmt.allocPrint(s.a, "lines-ls-{s}", .{ls_id});
+            const g = try ls_split.getOrPut(s.a, name);
+            if (!g.found_existing) g.value_ptr.* = .empty else s.a.free(name);
+            try g.value_ptr.append(s.a, f);
+        }
+        if (base_lines.items.len > 0) try layers.append(s.a, .{ .name = "lines", .features = base_lines.items });
+        var ls_it = ls_split.iterator();
+        while (ls_it.next()) |e| try layers.append(s.a, .{ .name = e.key_ptr.*, .features = e.value_ptr.items });
         if (s.points.items.len > 0) try layers.append(s.a, .{ .name = "point_symbols", .features = s.points.items });
         if (s.soundings.items.len > 0) try layers.append(s.a, .{ .name = "soundings", .features = s.soundings.items });
         if (s.texts.items.len > 0) try layers.append(s.a, .{ .name = "text", .features = s.texts.items });
@@ -799,6 +879,102 @@ pub const TileSurface = struct {
     }
 };
 
+fn propValue(props: []const mvt.Prop, key: []const u8) ?mvt.Value {
+    for (props) |p| if (std.mem.eql(u8, p.key, key)) return p.value;
+    return null;
+}
+
+fn propString(props: []const mvt.Prop, key: []const u8) ?[]const u8 {
+    return switch (propValue(props, key) orelse return null) {
+        .string => |v| v,
+        else => null,
+    };
+}
+
+fn propInt(props: []const mvt.Prop, key: []const u8) ?i64 {
+    return switch (propValue(props, key) orelse return null) {
+        .int => |v| v,
+        .uint => |v| @intCast(v),
+        else => null,
+    };
+}
+
+fn propNum(props: []const mvt.Prop, key: []const u8) ?f64 {
+    return switch (propValue(props, key) orelse return null) {
+        .int => |v| @floatFromInt(v),
+        .uint => |v| @floatFromInt(v),
+        .float => |v| v,
+        .double => |v| v,
+        else => null,
+    };
+}
+
+const AugmentKind = enum { area, line, point, text };
+
+/// v3 (tile57/3) per-feature precomputes. MapLibre evaluates every style
+/// layer's filter, sort key and data-driven layout against every feature of
+/// the layer's source-layer, on every tile layout — so an expression node
+/// there runs |features| × |layers| times. Everything here is a pure function
+/// of properties the feature already carries, folded once at bake:
+///  - vz (f32): the fractional display zoom at which the feature's SCAMIN
+///    admits it — `["<=",["get","vz"],["zoom"]]` replaces the
+///    coalesce/divide/pow clause. Latitude-corrected with the TILE's centre
+///    latitude (finer than the style's one archive-centre latitude).
+///  - oz (f32): the display zoom above which the cell is overscaled — the
+///    same fold of the oscl denominator gate.
+///  - mq (int 1): present on M_QUAL features; the data-quality clause becomes
+///    an int check instead of a string compare.
+///  - iso (int 1): present on ISODGR01 danger symbols; the isolated-danger
+///    category override stops string-comparing symbol_name per feature.
+///  - lt (int 1): present on LIGHTS points; the point-family partition stops
+///    string-comparing class per feature.
+///  - ep (int): the effective DrawingPriority sort value the point layers
+///    order by — display_plane*64 + display_priority, with the S-52
+///    danger-over-sounding deviation (OBSTRN/WRECKS/UWTROC → 19) folded in.
+///  - lsk (int): the line z-order sort value — priority*1000 - width_px, so
+///    an S-52 outline+ink pair keeps the wide outline underneath.
+fn augmentV3(a: Allocator, feats: []mvt.Feature, kind: AugmentKind, gate_lat: f64) !void {
+    for (feats) |*f| {
+        var extra = std.ArrayList(mvt.Prop).empty;
+        if (propNum(f.properties, "scamin")) |sc| if (sc > 0) {
+            const vz: f32 = @floatCast(style.scaminDisplayZoom(sc, gate_lat));
+            try extra.append(a, .{ .key = "vz", .value = .{ .float = vz } });
+        };
+        if (propNum(f.properties, "oscl")) |osc| if (osc > 0) {
+            const oz: f32 = @floatCast(style.scaminDisplayZoom(osc, gate_lat));
+            try extra.append(a, .{ .key = "oz", .value = .{ .float = oz } });
+        };
+        const class = propString(f.properties, "class") orelse "";
+        if (std.mem.eql(u8, class, "M_QUAL"))
+            try extra.append(a, .{ .key = "mq", .value = .{ .int = 1 } });
+        switch (kind) {
+            .point => {
+                if (propString(f.properties, "symbol_name")) |sn| if (std.mem.eql(u8, sn, "ISODGR01"))
+                    try extra.append(a, .{ .key = "iso", .value = .{ .int = 1 } });
+                if (std.mem.eql(u8, class, "LIGHTS"))
+                    try extra.append(a, .{ .key = "lt", .value = .{ .int = 1 } });
+                const danger = std.mem.eql(u8, class, "OBSTRN") or
+                    std.mem.eql(u8, class, "WRECKS") or std.mem.eql(u8, class, "UWTROC");
+                const ep: i64 = if (danger) 19 else (propInt(f.properties, "display_plane") orelse 0) * 64 +
+                    (propInt(f.properties, "display_priority") orelse 0);
+                try extra.append(a, .{ .key = "ep", .value = .{ .int = ep } });
+            },
+            .line => {
+                const w = propNum(f.properties, "width_px") orelse 1;
+                const lsk: i64 = (propInt(f.properties, "display_priority") orelse 0) * 1000 -
+                    @as(i64, @intFromFloat(@round(w)));
+                try extra.append(a, .{ .key = "lsk", .value = .{ .int = lsk } });
+            },
+            .area, .text => {},
+        }
+        if (extra.items.len == 0) continue;
+        var all = try a.alloc(mvt.Prop, f.properties.len + extra.items.len);
+        @memcpy(all[0..f.properties.len], f.properties);
+        @memcpy(all[f.properties.len..], extra.items);
+        f.properties = all;
+    }
+}
+
 /// SCAMIN (1:N) denominator the feature carries, or null when absent/invalid.
 pub fn featureScamin(f: s57.Feature) ?i64 {
     const v = f.attr(ATTR_SCAMIN) orelse return null;
@@ -968,6 +1144,9 @@ const Meta = struct {
     // 2), 0/1 = the plain/symbolized boundary or paper/simplified point pass.
     bnd: i64 = 2,
     pts: i64 = 2,
+    /// Sector-leg length (S-52 §12.2.4): 2 = length-independent, 0/1 = the
+    /// 25 mm / full-length pass; the client's sectorFilter keys off it.
+    sect: i64 = 2,
 };
 
 /// Append the shared metadata tags: S-52 draw priority + display category + band
@@ -1197,6 +1376,7 @@ fn appendMeta(a: Allocator, props: *std.ArrayList(mvt.Prop), m: Meta) !void {
     // (2) is left off so the client coalesces to 2 (always shown) — keeping every
     // unvarying feature's tile footprint unchanged.
     if (m.bnd != 2) try props.append(a, .{ .key = "bnd", .value = .{ .int = m.bnd } });
+    if (m.sect != 2) try props.append(a, .{ .key = "sect", .value = .{ .int = m.sect } });
     if (m.pts != 2) try props.append(a, .{ .key = "pts", .value = .{ .int = m.pts } });
     // §8.6.2-suppressed boundary piece — present only on the meta-bounds extras,
     // so every normally-drawn feature's tile footprint is unchanged.
@@ -1513,25 +1693,32 @@ fn variantDiffers(base: []const u8, variant: ?[]const u8) bool {
 /// display variants) through the Surface: parse each pass and hand it to
 /// processFeatureParsed, splitting into two passes only when a variant differs
 /// (S-52 boundary §8.6.1 / point-symbol §11.2.2 axes -> the bnd/pts tags).
-fn processFeatureInstr(a: Allocator, cell: s57.Cell, f: s57.Feature, fi: usize, geo: ?GeoParts, geo_world: ?GeoWorld, instr: []const u8, plain: ?[]const u8, simplified: ?[]const u8, z: u8, x: u32, y: u32, tb: [4]f64, box: tile.Box, opts: CellOpts, surf: rs.Surface) !void {
+fn processFeatureInstr(a: Allocator, cell: s57.Cell, f: s57.Feature, fi: usize, geo: ?GeoParts, geo_world: ?GeoWorld, instr: []const u8, plain: ?[]const u8, simplified: ?[]const u8, lights: ?[]const u8, z: u8, x: u32, y: u32, tb: [4]f64, box: tile.Box, opts: CellOpts, surf: rs.Surface) !void {
     const base = try instructions.parse(a, instr);
     if (f.prim == 1) {
-        if (variantDiffers(instr, simplified)) {
-            try processFeatureParsed(a, cell, f, fi, geo, geo_world, base, 2, 0, z, x, y, tb, box, opts, surf);
+        // The sector-leg axis first: only LightSectored features carry a
+        // lights variant, and none of those carries a simplified one, so the
+        // two point axes never need a four-way split.
+        if (variantDiffers(instr, lights)) {
+            try processFeatureParsed(a, cell, f, fi, geo, geo_world, base, 2, 2, 0, z, x, y, tb, box, opts, surf);
+            const lp = try instructions.parse(a, lights.?);
+            try processFeatureParsed(a, cell, f, fi, geo, geo_world, lp, 2, 2, 1, z, x, y, tb, box, opts, surf);
+        } else if (variantDiffers(instr, simplified)) {
+            try processFeatureParsed(a, cell, f, fi, geo, geo_world, base, 2, 0, 2, z, x, y, tb, box, opts, surf);
             const sp2 = try instructions.parse(a, simplified.?);
-            try processFeatureParsed(a, cell, f, fi, geo, geo_world, sp2, 2, 1, z, x, y, tb, box, opts, surf);
+            try processFeatureParsed(a, cell, f, fi, geo, geo_world, sp2, 2, 1, 2, z, x, y, tb, box, opts, surf);
         } else {
-            try processFeatureParsed(a, cell, f, fi, geo, geo_world, base, 2, 2, z, x, y, tb, box, opts, surf);
+            try processFeatureParsed(a, cell, f, fi, geo, geo_world, base, 2, 2, 2, z, x, y, tb, box, opts, surf);
         }
         return;
     }
     if (f.prim == 3 and variantDiffers(instr, plain)) {
-        try processFeatureParsed(a, cell, f, fi, geo, geo_world, base, 1, 2, z, x, y, tb, box, opts, surf);
+        try processFeatureParsed(a, cell, f, fi, geo, geo_world, base, 1, 2, 2, z, x, y, tb, box, opts, surf);
         const pl = try instructions.parse(a, plain.?);
-        try processFeatureParsed(a, cell, f, fi, geo, geo_world, pl, 0, 2, z, x, y, tb, box, opts, surf);
+        try processFeatureParsed(a, cell, f, fi, geo, geo_world, pl, 0, 2, 2, z, x, y, tb, box, opts, surf);
         return;
     }
-    try processFeatureParsed(a, cell, f, fi, geo, geo_world, base, 2, 2, z, x, y, tb, box, opts, surf);
+    try processFeatureParsed(a, cell, f, fi, geo, geo_world, base, 2, 2, 2, z, x, y, tb, box, opts, surf);
 }
 
 // Web-mercator equatorial circumference (m): converts a ground-distance sector leg
@@ -1660,7 +1847,7 @@ fn pickJson(a: Allocator, cell: s57.Cell, f: s57.Feature, fi: usize, pick: bool)
     return encodeS57Attrs(a, f) catch "";
 }
 
-fn processFeatureParsed(a: Allocator, cell: s57.Cell, f: s57.Feature, fi: usize, geo: ?GeoParts, geo_world: ?GeoWorld, p: instructions.Portrayal, bnd: i64, pts: i64, z: u8, x: u32, y: u32, tb: [4]f64, box: tile.Box, opts: CellOpts, surf: rs.Surface) !void {
+fn processFeatureParsed(a: Allocator, cell: s57.Cell, f: s57.Feature, fi: usize, geo: ?GeoParts, geo_world: ?GeoWorld, p: instructions.Portrayal, bnd: i64, pts: i64, sect: i64, z: u8, x: u32, y: u32, tb: [4]f64, box: tile.Box, opts: CellOpts, surf: rs.Surface) !void {
     const scamin = effScamin(f, opts);
     const cell_name = if (opts.pick_attrs) cell.name else "";
     const fmeta = rs.FeatureMeta{
@@ -1678,6 +1865,7 @@ fn processFeatureParsed(a: Allocator, cell: s57.Cell, f: s57.Feature, fi: usize,
         .date_end = p.date_end,
         .bnd = bnd,
         .pts = pts,
+        .sect = sect,
     };
 
     // ── Point features ──────────────────────────────────────────────────────────
@@ -2166,6 +2354,7 @@ pub const CellRef = struct {
     portrayal: ?[]const ?[]const u8 = null,
     portrayal_plain: ?[]const ?[]const u8 = null,
     portrayal_simplified: ?[]const ?[]const u8 = null,
+    portrayal_lights: ?[]const ?[]const u8 = null,
     geo: ?GeoParts = null,
     /// World coords parallel to `geo` (precomputed projection) — lets the baker
     /// reproject line/area geometry per tile without per-point tan/log.
@@ -2226,6 +2415,7 @@ pub fn encodeTile(scratch: Allocator, out: Allocator, cells: []const CellRef, z:
     const box = tile.Box.default(tile.EXTENT, tile.BUFFER);
 
     var mvt_surf = TileSurface.init(a, format);
+    mvt_surf.gate_lat = (tb[1] + tb[3]) * 0.5;
     const surf = mvt_surf.asSurface();
     try surf.beginScene(z);
 
@@ -2245,12 +2435,43 @@ pub fn encodeTile(scratch: Allocator, out: Allocator, cells: []const CellRef, z:
             .light_range_m = cr.light_range_m,
             .only_fi = cr.only_fi,
         };
-        try appendCellFeatures(a, surf, &mvt_surf, opts, cr.cell, cr.portrayal, cr.portrayal_plain, cr.portrayal_simplified, cr.geo, cr.geo_world, cr.feat_bbox, z, x, y, tb, box);
+        try appendCellFeatures(a, surf, &mvt_surf, opts, cr.cell, cr.portrayal, cr.portrayal_plain, cr.portrayal_simplified, cr.portrayal_lights, cr.geo, cr.geo_world, cr.feat_bbox, z, x, y, tb, box);
     }
 
     return surf.endScene(out);
 }
 
+/// Re-encode a decoded tile with every complex linestyle WALKED into plain
+/// geometry: each dash on-run becomes a solid line, each embedded symbol a
+/// point rotated to the local tangent, at its own offset in the period and
+/// phased from the run's `ls_arc0`. Everything else replays verbatim.
+///
+/// This is the same walk tile57's own renderer does — replay.zig routes an
+/// `ls_style` run through linestyle.drawComplexRun — pointed at a tile
+/// surface instead of a pixel one. It exists for a consumer that draws from a
+/// MapLibre style: the style spec cannot say where in a period a symbol sits,
+/// so a style-driven renderer stacks every symbol of a linestyle on one phase.
+/// Walking here puts the answer in the geometry, where any renderer can read
+/// it, and the `lines-ls-*` decoration layers become unnecessary.
+///
+/// The archive is untouched and stays display-independent; only this composed
+/// copy is walked.
+///
+/// `px_per_tile` is how wide the CONSUMER draws a tile, because S-101 lays its
+/// linestyle figures out in 256-px-per-tile space and the walk has to restate
+/// the period in the consumer's: 256 for the native path, 512 for a MapLibre
+/// style-spec renderer. It moves the rhythm only, never the stroke width or
+/// the symbol size.
+pub fn walkTile(scratch: Allocator, out: Allocator, layers: []const mvt.DecodedLayer, format: TileFormat, z: u8, px_per_tile: f64) ![]u8 {
+    var ts = TileSurface.init(scratch, format);
+    ts.walk_linestyles = true;
+    ts.linestyle_scale = if (px_per_tile > 0) 256.0 / px_per_tile else 1.0;
+    const surf = ts.asSurface();
+    try surf.beginScene(z);
+    try replay.replayTile(scratch, surf, layers);
+    return surf.endScene(out);
+}
+
 /// Append one tile's worth of every cell's features into an already-begun
 /// Surface scene — the composable core of the pixel path (a view scene calls
 /// this once per covering tile between beginScene/endScene). The classify()
@@ -2275,7 +2496,7 @@ pub fn appendTile(surf: rs.Surface, scratch: Allocator, cells: []const CellRef,
             .light_range_m = cr.light_range_m,
             .only_fi = cr.only_fi,
         };
-        try appendCellFeatures(scratch, surf, null, opts, cr.cell, cr.portrayal, cr.portrayal_plain, cr.portrayal_simplified, cr.geo, cr.geo_world, cr.feat_bbox, z, x, y, tb, box);
+        try appendCellFeatures(scratch, surf, null, opts, cr.cell, cr.portrayal, cr.portrayal_plain, cr.portrayal_simplified, cr.portrayal_lights, cr.geo, cr.geo_world, cr.feat_bbox, z, x, y, tb, box);
     }
 }
 
@@ -2453,6 +2674,7 @@ fn appendCellFeatures(
     portrayal: ?[]const ?[]const u8,
     portrayal_plain: ?[]const ?[]const u8,
     portrayal_simplified: ?[]const ?[]const u8,
+    portrayal_lights: ?[]const ?[]const u8,
     geo: ?GeoParts,
     geo_world: ?GeoWorld,
     feat_bbox: ?[]const ?[4]f64,
@@ -2579,7 +2801,7 @@ fn appendCellFeatures(
         }
         if (f.objl == 163) {
             if (try symins.buildSyminsPortrayal(a, f)) |sp| {
-                try processFeatureParsed(a, cell.*, f, fi, geo, geo_world, sp, 2, 2, z, x, y, tb, box, fopts, surf);
+                try processFeatureParsed(a, cell.*, f, fi, geo, geo_world, sp, 2, 2, 2, z, x, y, tb, box, fopts, surf);
                 continue;
             }
         }
@@ -2589,7 +2811,8 @@ fn appendCellFeatures(
             if (!errored) {
                 const plain: ?[]const u8 = if (portrayal_plain) |pp| (if (fi < pp.len) pp[fi] else null) else null;
                 const simplified: ?[]const u8 = if (portrayal_simplified) |pp| (if (fi < pp.len) pp[fi] else null) else null;
-                try processFeatureInstr(a, cell.*, f, fi, geo, geo_world, s, plain, simplified, z, x, y, tb, box, fopts, surf);
+                const lights: ?[]const u8 = if (portrayal_lights) |pp| (if (fi < pp.len) pp[fi] else null) else null;
+                try processFeatureInstr(a, cell.*, f, fi, geo, geo_world, s, plain, simplified, lights, z, x, y, tb, box, fopts, surf);
                 continue;
             }
         }
@@ -2849,7 +3072,7 @@ test "processFeatureInstr routes SCAMIN point to the bucket + carries display_pr
         .refs = &.{.{ .name = .{ .rcnm = s57.RCNM_VI, .rcid = 1 }, .ornt = 255 }},
         .attrs = &.{.{ .code = ATTR_SCAMIN, .value = "22000" }},
     };
-    try processFeatureInstr(a, cell, f_sc, 0, null, null, "DrawingPriority:7;PointInstruction:BOYLAT01", null, null, 0, 0, 0, tb, box, .{}, surf);
+    try processFeatureInstr(a, cell, f_sc, 0, null, null, "DrawingPriority:7;PointInstruction:BOYLAT01", null, null, null, 0, 0, 0, tb, box, .{}, surf);
     try std.testing.expectEqual(@as(usize, 0), ms.points.items.len);
     try std.testing.expectEqual(@as(usize, 1), ms.points_scamin.items.len);
     try std.testing.expectEqual(@as(i64, 7), findProp(ms.points_scamin.items[0].properties, "display_priority").?.int);
@@ -2863,7 +3086,7 @@ test "processFeatureInstr routes SCAMIN point to the bucket + carries display_pr
         .objl = 14,
         .refs = &.{.{ .name = .{ .rcnm = s57.RCNM_VI, .rcid = 1 }, .ornt = 255 }},
     };
-    try processFeatureInstr(a, cell, f_base, 0, null, null, "PointInstruction:BOYLAT01", null, null, 0, 0, 0, tb, box, .{}, surf);
+    try processFeatureInstr(a, cell, f_base, 0, null, null, "PointInstruction:BOYLAT01", null, null, null, 0, 0, 0, tb, box, .{}, surf);
     try std.testing.expectEqual(@as(usize, 1), ms.points.items.len);
     try std.testing.expectEqual(@as(i64, 0), findProp(ms.points.items[0].properties, "display_priority").?.int);
     try std.testing.expectEqual(@as(?mvt.Value, null), findProp(ms.points.items[0].properties, "scamin"));
@@ -2917,7 +3140,7 @@ test "processFeatureInstr tags pts 0/1 when a point's simplified symbol differs"
         .refs = &.{.{ .name = .{ .rcnm = s57.RCNM_VI, .rcid = 1 }, .ornt = 255 }},
     };
     // Paper -> BOYLAT01; simplified -> BOYLAT11. Two passes: pts=0 then pts=1.
-    try processFeatureInstr(a, cell, f, 0, null, null, "PointInstruction:BOYLAT01", null, "PointInstruction:BOYLAT11", 0, 0, 0, tb, box, .{}, surf);
+    try processFeatureInstr(a, cell, f, 0, null, null, "PointInstruction:BOYLAT01", null, "PointInstruction:BOYLAT11", null, 0, 0, 0, tb, box, .{}, surf);
     try std.testing.expectEqual(@as(usize, 2), ms.points.items.len);
     try std.testing.expectEqual(@as(i64, 0), findProp(ms.points.items[0].properties, "pts").?.int);
     try std.testing.expectEqualStrings("BOYLAT01", findProp(ms.points.items[0].properties, "symbol_name").?.string);
@@ -2966,7 +3189,7 @@ test "processFeatureInstr tags bnd 1/0 when an area's plain boundary differs" {
     // Symbolized boundary draws a complex line; plain draws a simple stroke.
     const symbolized = "ColorFill:DEPMS;LineStyle:CTNARE51,,1,CHMGD;LineInstruction:CTNARE51";
     const plain = "ColorFill:DEPMS;LineStyle:_simple_,,1,CHMGD;LineInstruction:_simple_";
-    try processFeatureInstr(a, cell, f, 0, geo_one, null, symbolized, plain, null, 0, 0, 0, tb, box, .{}, surf);
+    try processFeatureInstr(a, cell, f, 0, geo_one, null, symbolized, plain, null, null, 0, 0, 0, tb, box, .{}, surf);
     // Both passes emit the fill: one tagged bnd=1 (symbolized), one bnd=0 (plain).
     try std.testing.expectEqual(@as(usize, 2), ms.areas.items.len);
     try std.testing.expectEqual(@as(i64, 1), findProp(ms.areas.items[0].properties, "bnd").?.int);
@@ -3148,7 +3371,7 @@ test "DANGER01/02 on a VALSOU danger normalizes + tags danger_depth/sym_deep for
         .refs = &.{.{ .name = .{ .rcnm = s57.RCNM_VI, .rcid = 1 }, .ornt = 255 }},
         .attrs = &.{.{ .code = s57.ATTR_VALSOU, .value = "15.1" }},
     };
-    try processFeatureInstr(a, cell, f_wreck, 0, null, null, "DrawingPriority:12;PointInstruction:DANGER02", null, null, 0, 0, 0, tb, box, .{}, surf);
+    try processFeatureInstr(a, cell, f_wreck, 0, null, null, "DrawingPriority:12;PointInstruction:DANGER02", null, null, null, 0, 0, 0, tb, box, .{}, surf);
     try std.testing.expectEqual(@as(usize, 1), ms.points.items.len);
     try std.testing.expectEqualStrings("DANGER01", findProp(ms.points.items[0].properties, "symbol_name").?.string);
     try std.testing.expectEqual(@as(f64, 15.1), findProp(ms.points.items[0].properties, "danger_depth").?.double);
@@ -3162,7 +3385,7 @@ test "DANGER01/02 on a VALSOU danger normalizes + tags danger_depth/sym_deep for
         .objl = 159,
         .refs = &.{.{ .name = .{ .rcnm = s57.RCNM_VI, .rcid = 1 }, .ornt = 255 }},
     };
-    try processFeatureInstr(a, cell, f_nodep, 0, null, null, "PointInstruction:DANGER01", null, null, 0, 0, 0, tb, box, .{}, surf);
+    try processFeatureInstr(a, cell, f_nodep, 0, null, null, "PointInstruction:DANGER01", null, null, null, 0, 0, 0, tb, box, .{}, surf);
     try std.testing.expectEqual(@as(usize, 2), ms.points.items.len);
     try std.testing.expectEqualStrings("DANGER01", findProp(ms.points.items[1].properties, "symbol_name").?.string);
     try std.testing.expectEqual(@as(?mvt.Value, null), findProp(ms.points.items[1].properties, "danger_depth"));
@@ -3176,7 +3399,7 @@ test "DANGER01/02 on a VALSOU danger normalizes + tags danger_depth/sym_deep for
         .refs = &.{.{ .name = .{ .rcnm = s57.RCNM_VI, .rcid = 1 }, .ornt = 255 }},
         .attrs = &.{.{ .code = s57.ATTR_VALSOU, .value = "4" }},
     };
-    try processFeatureInstr(a, cell, f_buoy, 0, null, null, "PointInstruction:DANGER01", null, null, 0, 0, 0, tb, box, .{}, surf);
+    try processFeatureInstr(a, cell, f_buoy, 0, null, null, "PointInstruction:DANGER01", null, null, null, 0, 0, 0, tb, box, .{}, surf);
     try std.testing.expectEqual(@as(usize, 3), ms.points.items.len);
     try std.testing.expectEqual(@as(?mvt.Value, null), findProp(ms.points.items[2].properties, "sym_deep"));
 }
@@ -3188,3 +3411,85 @@ test {
     _ = linestyle;
     _ = replay;
 }
+
+test "endScene v3: ls_style lines split into per-style source-layers" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const a = arena.allocator();
+    var ms = TileSurface.init(a, .mvt);
+    const mk = struct {
+        fn line(al: Allocator, props: []const mvt.Prop) !mvt.Feature {
+            const parts = try al.alloc([]const mvt.Point, 1);
+            const pts = try al.alloc(mvt.Point, 2);
+            pts[0] = .{ .x = 0, .y = 0 };
+            pts[1] = .{ .x = 100, .y = 100 };
+            parts[0] = pts;
+            return .{ .geom_type = .linestring, .parts = parts, .properties = props };
+        }
+    };
+    try ms.lines.append(a, try mk.line(a, &.{.{ .key = "class", .value = .{ .string = "DEPCNT" } }}));
+    try ms.lines.append(a, try mk.line(a, &.{ .{ .key = "class", .value = .{ .string = "CBLSUB" } }, .{ .key = "ls_style", .value = .{ .string = "CBLSUB06" } } }));
+    try ms.lines.append(a, try mk.line(a, &.{ .{ .key = "class", .value = .{ .string = "ACHARE" } }, .{ .key = "ls_style", .value = .{ .string = "ACHARE51" } } }));
+    const bytes = try TileSurface.endScene(&ms, a);
+    const layers = try mvt.decode(a, bytes);
+    var names = std.ArrayList([]const u8).empty;
+    for (layers) |l| try names.append(a, l.name);
+    // One base lines layer (the undecorated contour) + one layer per ls style.
+    var have_lines = false;
+    var have_cbl = false;
+    var have_ach = false;
+    for (layers) |l| {
+        if (std.mem.eql(u8, l.name, "lines")) {
+            have_lines = true;
+            try std.testing.expectEqual(@as(usize, 1), l.features.len);
+        }
+        if (std.mem.eql(u8, l.name, "lines-ls-CBLSUB06")) have_cbl = true;
+        if (std.mem.eql(u8, l.name, "lines-ls-ACHARE51")) have_ach = true;
+    }
+    try std.testing.expect(have_lines and have_cbl and have_ach);
+}
+
+test "augmentV3: vz/ep/lt/iso/mq/lsk precomputes" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const a = arena.allocator();
+    const findP = struct {
+        fn f(props: []const mvt.Prop, key: []const u8) ?mvt.Value {
+            return propValue(props, key);
+        }
+    }.f;
+
+    // A SCAMIN'd point at the equator: vz must equal the style's display zoom.
+    var pts = [_]mvt.Feature{.{ .geom_type = .point, .parts = &.{}, .properties = &.{
+        .{ .key = "scamin", .value = .{ .int = 45000 } },
+        .{ .key = "class", .value = .{ .string = "LIGHTS" } },
+        .{ .key = "display_priority", .value = .{ .int = 24 } },
+    } }};
+    try augmentV3(a, &pts, .point, 0);
+    const style_mod = @import("style");
+    const want_vz: f32 = @floatCast(style_mod.scaminDisplayZoom(45000, 0));
+    try std.testing.expectEqual(want_vz, findP(pts[0].properties, "vz").?.float);
+    try std.testing.expectEqual(@as(i64, 1), findP(pts[0].properties, "lt").?.int);
+    try std.testing.expectEqual(@as(i64, 24), findP(pts[0].properties, "ep").?.int);
+
+    // A danger class folds to the ep 19 deviation; ISODGR01 carries iso.
+    var dgr = [_]mvt.Feature{.{ .geom_type = .point, .parts = &.{}, .properties = &.{
+        .{ .key = "class", .value = .{ .string = "WRECKS" } },
+        .{ .key = "symbol_name", .value = .{ .string = "ISODGR01" } },
+        .{ .key = "display_priority", .value = .{ .int = 12 } },
+    } }};
+    try augmentV3(a, &dgr, .point, 0);
+    try std.testing.expectEqual(@as(i64, 19), findP(dgr[0].properties, "ep").?.int);
+    try std.testing.expectEqual(@as(i64, 1), findP(dgr[0].properties, "iso").?.int);
+    try std.testing.expectEqual(@as(?mvt.Value, null), findP(dgr[0].properties, "lt"));
+
+    // A line: lsk = priority*1000 - width; M_QUAL carries mq.
+    var lns = [_]mvt.Feature{.{ .geom_type = .linestring, .parts = &.{}, .properties = &.{
+        .{ .key = "class", .value = .{ .string = "M_QUAL" } },
+        .{ .key = "display_priority", .value = .{ .int = 3 } },
+        .{ .key = "width_px", .value = .{ .double = 2.0 } },
+    } }};
+    try augmentV3(a, &lns, .line, 0);
+    try std.testing.expectEqual(@as(i64, 2998), findP(lns[0].properties, "lsk").?.int);
+    try std.testing.expectEqual(@as(i64, 1), findP(lns[0].properties, "mq").?.int);
+}
diff --git a/src/sprite/glyphpbf.zig b/src/sprite/glyphpbf.zig
index 4a6a2192..f223f4e7 100644
--- a/src/sprite/glyphpbf.zig
+++ b/src/sprite/glyphpbf.zig
@@ -4,9 +4,11 @@
 //! SDF path as the GPU atlas (`glyph.zig`), only with the SDF encoding a GL
 //! client expects (fontnik's 24 px em, 3 px buffer, edge 191, 255/8 per px).
 //!
-//! Metric fields are plain varints (matching the reference stacks a GL client
-//! already consumes — a zigzag `top` would place glyphs below the baseline);
-//! `left`/`top` clamp at 0, as every Latin glyph in the reference does.
+//! `left`/`top` are sint32 on the wire (zigzag), exactly as glyphs.proto says:
+//! MapLibre Native's parser (text/glyph_pbf.cpp) reads them with get_sint32().
+//! Encoding them as plain varints halves every even value and NEGATES every odd
+//! one on decode, which scatters letters vertically by parity — tall glyphs land
+//! below the baseline and words render with characters apparently missing.
 
 const std = @import("std");
 const Allocator = std.mem.Allocator;
@@ -30,6 +32,10 @@ fn putVarintField(buf: *std.ArrayList(u8), a: Allocator, field: u32, v: u64) !vo
     try putVarint(buf, a, (@as(u64, field) << 3) | 0); // wire type 0
     try putVarint(buf, a, v);
 }
+fn putSintField(buf: *std.ArrayList(u8), a: Allocator, field: u32, v: i32) !void {
+    const zz = (@as(u64, @bitCast(@as(i64, v))) << 1) ^ @as(u64, @bitCast(@as(i64, v) >> 63));
+    try putVarintField(buf, a, field, zz);
+}
 fn putBytesField(buf: *std.ArrayList(u8), a: Allocator, field: u32, bytes: []const u8) !void {
     try putVarint(buf, a, (@as(u64, field) << 3) | 2); // wire type 2
     try putVarint(buf, a, bytes.len);
@@ -59,14 +65,14 @@ fn appendGlyph(a: Allocator, glyphs: *std.ArrayList(u8), font: []const u8, cp: u
         try putBytesField(&g, a, 2, sdf.?[0..@intCast(w * h)]);
         try putVarintField(&g, a, 3, gw);
         try putVarintField(&g, a, 4, gh);
-        try putVarintField(&g, a, 5, @intCast(@max(left, 0)));
-        try putVarintField(&g, a, 6, @intCast(@max(top, 0)));
+        try putSintField(&g, a, 5, left);
+        try putSintField(&g, a, 6, top);
     } else {
         // Blank glyph (space): advance only, no bitmap.
         try putVarintField(&g, a, 3, 0);
         try putVarintField(&g, a, 4, 0);
-        try putVarintField(&g, a, 5, 0);
-        try putVarintField(&g, a, 6, 0);
+        try putSintField(&g, a, 5, 0);
+        try putSintField(&g, a, 6, 0);
     }
     try putVarintField(&g, a, 7, @intFromFloat(@round(adv))); // advance
     try putBytesField(glyphs, a, 3, g.items); // fontstack.glyphs (field 3)
@@ -93,6 +99,91 @@ pub fn encodeRange(a: Allocator, font: []const u8, name: []const u8, start: u21)
 
 // ---- tests -------------------------------------------------------------------
 
+const TestReader = struct {
+    buf: []const u8,
+    i: usize = 0,
+
+    fn varint(self: *TestReader) u64 {
+        var shift: u6 = 0;
+        var v: u64 = 0;
+        while (true) {
+            const b = self.buf[self.i];
+            self.i += 1;
+            v |= @as(u64, b & 0x7f) << shift;
+            if (b < 0x80) return v;
+            shift += 7;
+        }
+    }
+
+    fn skipOrSlice(self: *TestReader, wire: u3) ?[]const u8 {
+        switch (wire) {
+            0 => _ = self.varint(),
+            2 => {
+                const len = self.varint();
+                const s = self.buf[self.i .. self.i + len];
+                self.i += len;
+                return s;
+            },
+            else => unreachable,
+        }
+        return null;
+    }
+};
+
+fn zigzagDecode(v: u64) i64 {
+    return @as(i64, @intCast(v >> 1)) ^ -@as(i64, @intCast(v & 1));
+}
+
+test "glyphpbf: left/top are sint32 on the wire, as glyph_pbf.cpp decodes them" {
+    // MapLibre Native reads fields 5/6 with get_sint32() (zigzag). Encoded as
+    // plain varints they decode halved (even) or negated (odd) — glyphs land
+    // below the baseline and letters vanish from words. Lock the wire format.
+    const a = std.testing.allocator;
+    const font = @import("render").font.notosans;
+    const pbf = try encodeRange(a, font, "Noto Sans Regular", 0);
+    defer a.free(pbf);
+
+    var found_cap = false;
+    var outer = TestReader{ .buf = pbf };
+    while (outer.i < outer.buf.len) {
+        const key = outer.varint();
+        const stack_msg = outer.skipOrSlice(@intCast(key & 7)) orelse continue;
+        if (key >> 3 != 1) continue;
+        var st = TestReader{ .buf = stack_msg };
+        while (st.i < st.buf.len) {
+            const skey = st.varint();
+            const gmsg = st.skipOrSlice(@intCast(skey & 7)) orelse continue;
+            if (skey >> 3 != 3) continue;
+            var g = TestReader{ .buf = gmsg };
+            var id: u64 = 0;
+            var left: i64 = 0;
+            var top: i64 = 0;
+            var adv: u64 = 0;
+            while (g.i < g.buf.len) {
+                const gkey = g.varint();
+                switch (gkey >> 3) {
+                    1 => id = g.varint(),
+                    5 => left = zigzagDecode(g.varint()),
+                    6 => top = zigzagDecode(g.varint()),
+                    7 => adv = g.varint(),
+                    else => _ = g.skipOrSlice(@intCast(gkey & 7)),
+                }
+            }
+            if (id == 'A') {
+                found_cap = true;
+                // 'A' at the 24px fontnik em: cap top sits well above the
+                // baseline. Decoded THROUGH ZIGZAG it must come out in a
+                // plausible band; a plain-varint encoding would fail this for
+                // any odd top (negative) and halve the rest.
+                try std.testing.expect(top >= 10 and top <= 25);
+                try std.testing.expect(left >= -5 and left <= 10);
+                try std.testing.expect(adv >= 8 and adv <= 22);
+            }
+        }
+    }
+    try std.testing.expect(found_cap);
+}
+
 test "glyphpbf: range encodes a well-formed fontstack with 'A'" {
     const a = std.testing.allocator;
     const font = @import("render").font.notosans;
diff --git a/src/sprite/sprite.zig b/src/sprite/sprite.zig
index 42a55905..28ac81e3 100644
--- a/src/sprite/sprite.zig
+++ b/src/sprite/sprite.zig
@@ -500,6 +500,23 @@ const MlnCell = struct { name: []const u8, w: u32, h: u32, ratio: f64, rgba: []c
 /// The GPU-scene cell-map (chart.buildGpuAtlases) and a host's uploaded texture
 /// (tile57_bake_sprite_mln) MUST pass the SAME ratio, or the normalized UVs the
 /// scene emits will not index the texture the host uploaded.
+/// Every MapLibre-drawn symbol renders at the engine SYMBOL_SCALE (0.0283…),
+/// measured across a full ENC library (134k features, 4.5k distinct names,
+/// not one above it). The sheet used to rasterize at the 0.08 catalogue scale
+/// — 8x the area anything ever drew at — and the oversize was both the
+/// resident-memory floor (the map clones every image per style) and the
+/// frame-time floor (its atlas churn ran renderUpdate at 60+ ms during a
+/// zoom). Baked at drawn scale, icon-size 1.0 samples the artwork 1:1.
+/// maplibre.zig's icon-size divisor must equal SYMBOL_SCALE for that to hold.
+pub const mln_drawn_scale: f64 = 0.02834627777338028 / 0.08;
+
+/// The px per mm this builder rasterizes at, for `ratio`. A consumer that
+/// converts a cell back to a size reads this, and does not recompute it. The
+/// two must be the same number or symbols draw at the difference.
+pub fn mlnPpm(ratio: f64) f64 {
+    return px_per_mm * ratio * mln_drawn_scale;
+}
+
 pub fn spriteMln(a: std.mem.Allocator, symbols: []const SvgSrc, fills: []const AreaFillSrc, css_data: []const u8, soundings: []const []const u8, ratio: f64) !Atlas {
     return spriteMlnOpts(a, symbols, fills, css_data, soundings, ratio, true);
 }
@@ -512,7 +529,10 @@ pub fn spriteMlnOpts(a: std.mem.Allocator, symbols: []const SvgSrc, fills: []con
     defer arena_state.deinit();
     const ar = arena_state.allocator();
     var css = try loadCss(ar, css_data);
-    const ppm = px_per_mm * ratio; // device px per mm at this display ratio
+    // Drawn scale folded in: cells carry exactly the pixels the display uses
+    // (see mln_drawn_scale). The GPU-scene atlas comes through this same
+    // builder, so it reads the scale from mlnPpm rather than restating it.
+    const ppm = mlnPpm(ratio); // device px per mm as DRAWN
     const cell_cap: f64 = @as(f64, @floatFromInt(max_cell_side)) * ratio;
     const atlas_w: u32 = @intFromFloat(@round(@as(f64, @floatFromInt(sprite_atlas_width)) * ratio));
 
@@ -574,6 +594,57 @@ pub fn spriteMlnOpts(a: std.mem.Allocator, symbols: []const SvgSrc, fills: []con
     return packMlnOpts(a, ar, cells.items, atlas_w, want_pixels);
 }
 
+/// Render ONE comma-joined glyph run (a sounding digit stack, a contour label
+/// composite) to a pivot-centred RGBA image at `ratio`, from the symbol SVG
+/// set + palette css. The runtime path behind MapLibre's missing-image event:
+/// a library carries far more distinct runs than any prebaked sheet can, so
+/// the host renders each one the map actually asks for. Caller owns rgba.
+pub const RunImage = struct { w: u32, h: u32, rgba: []u8 };
+pub fn renderSymbolRun(a: std.mem.Allocator, symbols: []const SvgSrc, css_data: []const u8, run: []const u8, ratio: f64) !?RunImage {
+    var arena_state = std.heap.ArenaAllocator.init(a);
+    defer arena_state.deinit();
+    const ar = arena_state.allocator();
+    var css = try loadCss(ar, css_data);
+    const ppm = px_per_mm * ratio;
+
+    var rendered = std.StringHashMap(RenderedSym).init(ar);
+    var it = std.mem.tokenizeScalar(u8, run, ',');
+    while (it.next()) |name| {
+        if (rendered.contains(name)) continue;
+        for (symbols) |s| {
+            if (!std.mem.eql(u8, s.id, name)) continue;
+            const sym = renderSymAt(ar, s.svg, &css, ppm * mln_drawn_scale) orelse break;
+            try rendered.put(s.id, sym);
+            break;
+        }
+    }
+    const t = compositeSounding(ar, &rendered, run) orelse return null;
+    return .{ .w = t.w, .h = t.h, .rgba = try a.dupe(u8, t.rgba) };
+}
+
+test "renderSymbolRun composites a two-glyph run pivot-centred" {
+    const a = std.testing.allocator;
+    // Two tiny synthetic glyphs with distinct pivots; the composite must be
+    // non-empty and sized to hold both about the shared pivot.
+    const svg1 =
+        \\<svg width="4mm" height="4mm" viewBox="0 0 4 4"><rect x="0" y="0" width="4" height="4" class="sl"/><circle id="p" cx="1" cy="2" r="0"/></svg>
+    ;
+    const svg2 =
+        \\<svg width="4mm" height="4mm" viewBox="0 0 4 4"><rect x="0" y="0" width="4" height="4" class="sl"/><circle id="p" cx="3" cy="2" r="0"/></svg>
+    ;
+    const syms = [_]SvgSrc{ .{ .id = "GA", .svg = svg1 }, .{ .id = "GB", .svg = svg2 } };
+    const css = ".sl{fill:#112233}";
+    const img = try renderSymbolRun(a, &syms, css, "GA,GB", 1.0);
+    if (img) |i| {
+        defer a.free(i.rgba);
+        try std.testing.expect(i.w > 0 and i.h > 0);
+        try std.testing.expect(i.rgba.len == @as(usize, i.w) * i.h * 4);
+    }
+    // A run of unknown glyphs renders nothing rather than failing.
+    const none = try renderSymbolRun(a, &syms, css, "NOPE1,NOPE2", 1.0);
+    try std.testing.expect(none == null);
+}
+
 // Composite a comma-joined glyph list (e.g. "SOUNDSC3,SOUNDS12,SOUNDS54") into
 // one pivot-centred image — each glyph self-positions by its pivot. Port of
 // build_sprite.py compositeSounding. null if no glyph is known.
diff --git a/src/style/maplibre.zig b/src/style/maplibre.zig
index b7ef2750..9e1c327b 100644
--- a/src/style/maplibre.zig
+++ b/src/style/maplibre.zig
@@ -126,11 +126,14 @@ const FILL_SORT = .{ "-", .{ "*", .{ "coalesce", .{ "get", "display_priority" },
 // solid lines EXCLUDE the un-tessellated complex-linestyle runs (tagged ls_style):
 // those get their own dasharray + line-placed symbol layers (linestyleLayers), so a
 // run must not also paint as a plain solid stroke here.
-const FILT_SOLID = .{ "all", .{ "==", .{ "coalesce", .{ "get", "dash" }, "solid" }, "solid" }, .{ "!", .{ "has", "ls_style" } } };
+const FILT_SOLID = .{ "==", .{ "coalesce", .{ "get", "dash" }, "solid" }, "solid" };
 const FILT_DASHED = .{ "==", .{ "get", "dash" }, "dashed" };
 const FILT_DOTTED = .{ "==", .{ "get", "dash" }, "dotted" };
 
-const ICON_SIZE = .{ "/", .{ "coalesce", .{ "get", "scale" }, 0.08 }, 0.08 };
+// The sheet is baked at the drawn scale (sprite.zig mln_drawn_scale), so the
+// engine SYMBOL_SCALE is the unit: a feature at that scale samples 1:1.
+const MLN_BAKE_SCALE: f64 = 0.02834627777338028;
+const ICON_SIZE = .{ "/", .{ "coalesce", .{ "get", "scale" }, 0.08 }, MLN_BAKE_SCALE };
 
 const VROW = .{ "match", .{ "coalesce", .{ "get", "valign" }, "middle" }, "top", "top", "bottom", "bottom", "center" };
 const TEXT_ANCHOR = .{
@@ -267,6 +270,12 @@ const SCtx = struct {
     // DENOM literal under the live filter-gate, else the per-archive K/2^zoom.
     oscl_gate: DenomGate,
     show_overscale: bool, // S-52 §10.1.10 mariner toggle -> the overscale layer's visibility
+    // The mariner's soundings switch -> the soundings layers' visibility.
+    // Resolved as the hosts do (root.zig deriveLive): explicit on/off wins,
+    // auto follows display OTHER (S-52 files SOUNDG under that category).
+    // Visibility, not a filter: a toggle is then a one-op visibility diff
+    // instead of a whole-tile re-layout.
+    soundings_on: bool,
 };
 
 // Display-denominator gate value for the overscale clauses.
@@ -298,10 +307,14 @@ fn writeOsclClause(js: *Stringify, gate: DenomGate, negate: bool) !void {
             try js.write(.{ "!", .{ ">", .{ "coalesce", .{ "get", "oscl" }, 0 }, d } })
         else
             try js.write(.{ ">", .{ "coalesce", .{ "get", "oscl" }, 0 }, d }),
-        .zoom_k => |k| if (negate)
-            try js.write(.{ "!", .{ ">", .{ "coalesce", .{ "get", "oscl" }, 0 }, .{ "/", k, .{ "^", 2, .{"zoom"} } } } })
+        // The bake folded oscl > K/2^zoom into the per-feature `oz` (the
+        // display zoom past which the cell is overscaled — scene.augmentV3);
+        // a feature without oscl coalesces to an unreachable zoom and never
+        // reads overscaled.
+        .zoom_k => if (negate)
+            try js.write(.{ "!", .{ ">", .{"zoom"}, .{ "coalesce", .{ "get", "oz" }, 99 } } })
         else
-            try js.write(.{ ">", .{ "coalesce", .{ "get", "oscl" }, 0 }, .{ "/", k, .{ "^", 2, .{"zoom"} } } }),
+            try js.write(.{ ">", .{"zoom"}, .{ "coalesce", .{ "get", "oz" }, 99 } }),
     }
 }
 
@@ -400,11 +413,13 @@ fn writeScaminClause(js: *Stringify, bkt: Bucket) !void {
         try js.endArray();
         return;
     }
-    // zoom_gate (the only other clause-bearing mode; has_clause guarantees it): static,
-    // latitude-correct gate — show a SCAMIN feature only when the display is at least as
-    // fine as its 1:N, i.e. scamin >= D(zoom) with D = K/2^zoom. Shares the oscl
-    // gate's K (writeSmaxClause/.zoom_k), so the three stay in lockstep.
-    try js.write(.{ ">=", .{ "coalesce", .{ "get", "scamin" }, SCAMIN_COALESCE_MAX }, .{ "/", bkt.zoom_k, .{ "^", 2, .{"zoom"} } } });
+    // zoom_gate (the only other clause-bearing mode; has_clause guarantees it):
+    // the bake already folded scamin >= K/2^zoom into the per-feature `vz`
+    // (the fractional display zoom at which the SCAMIN admits — see
+    // scene.augmentV3), so the gate is one compare instead of a
+    // coalesce/divide/pow tree per feature per layer. A feature without
+    // SCAMIN carries no vz and coalesces to 0: always shown.
+    try js.write(.{ "<=", .{ "coalesce", .{ "get", "vz" }, 0 }, .{"zoom"} });
 }
 
 // Write a layer's `filter`. The filter ANDs together (in order): the `base` predicate
@@ -445,10 +460,16 @@ fn lineLayer(js: *Stringify, s: *const SCtx, sl: []const u8, name: []const u8, f
     try applyBucket(js, filt, true, bkt, s, null); // line: scamin line variants band-independent
     try js.objectField("layout");
     try js.beginObject();
-    // display_priority as the sole intra-layer z-order axis (mirrors fill-/symbol-sort-key),
-    // so a higher-priority line paints over a lower one within a dash class.
+    // display_priority as the primary intra-layer z-order axis (mirrors
+    // fill-/symbol-sort-key), so a higher-priority line paints over a lower
+    // one within a dash class. Width breaks the tie DOWNWARD: at equal
+    // priority a wider stroke draws first, i.e. underneath — which is what an
+    // S-52 outline+ink pair means. A light's sector arc bakes as a wide CHBLK
+    // outline plus a narrower coloured ink stroke at one priority; without
+    // this tiebreak the outline could land on top and every sector read
+    // black.
     try js.objectField("line-sort-key");
-    try js.write(.{ "coalesce", .{ "get", "display_priority" }, 0 });
+    try js.write(.{ "coalesce", .{ "get", "lsk" }, 0 });
     try js.endObject();
     try js.objectField("paint");
     try linePaint(js, s.line_color, dash, s.size_scale);
@@ -500,22 +521,18 @@ const DANGER_CLASSES = .{ "OBSTRN", "WRECKS", "UWTROC" };
 // The soundings DrawingPriority — the z-order boundary the point family partitions on.
 const SOUNDINGS_PRIO = 18;
 
-// `class in DANGER_CLASSES` — the danger-over-sounding deviation (see DANGER_CLASSES).
-const IN_DANGER = .{ "in", .{ "get", "class" }, .{ "literal", DANGER_CLASSES } };
-
-// Effective DrawingPriority = display_priority (the honest catalogue 0..30 tile property,
-// NEVER bucketed) offset by the display plane (plane*64 most-significant; +1 OverRadar
-// / -1 UnderRadar, inert today -> coalesce 0). This is the SOLE point z-order axis:
-// no base/danger/light class TIERS. Used both as the partition threshold and, via
-// SYMBOL_SORT, as the intra-layer sort key.
-const EFF_PRIO = .{ "+", .{ "*", .{ "coalesce", .{ "get", "display_plane" }, 0 }, 64 }, .{ "coalesce", .{ "get", "display_priority" }, 0 } };
+// Effective DrawingPriority, baked per feature as `ep` (scene.augmentV3):
+// display_plane*64 + display_priority, with a danger class (DANGER_CLASSES)
+// folded to 19. The SOLE point z-order axis — the partition threshold and,
+// via SYMBOL_SORT, the intra-layer sort key.
+const EP = .{ "coalesce", .{ "get", "ep" }, 0 };
 
 // symbol-sort-key: display_priority is the sole axis, EXCEPT the S-52 danger deviation is
 // expressed here as a sort VALUE — a danger (OBSTRN/WRECKS/UWTROC) sorts at an
 // effective 19 so it draws just above soundings (18) WITHOUT baking a fake display_priority
 // into the tile (the tile keeps the honest 12, so pick/spec stay correct). A base at
 // display_priority 30 still sorts above the danger's 19; a base at 5 stays under soundings.
-const SYMBOL_SORT = .{ "case", IN_DANGER, 19, EFF_PRIO };
+const SYMBOL_SORT = .{ "coalesce", .{ "get", "ep" }, 0 };
 
 // Which slice of the point family a layer carries. z-order is display_priority ALONE: `base`
 // = effective-prio under soundings (< 18), `dangers_only` = effective-prio at/over
@@ -529,19 +546,24 @@ const PointMode = enum { base, dangers_only, lights_only };
 // bucket filter. rot_north_eq / mode are comptime so each switch arm passes a concrete
 // tuple type to the generic applyBucket.
 fn applyPointBucket(js: *Stringify, s: *const SCtx, bkt: Bucket, comptime rot_north_eq: bool, comptime mode: PointMode) !void {
+    // Absent rot_north reads null: null==1 is false and null!=1 is true in
+    // expression filters, so the common untagged case needs no coalesce.
     const rot = if (rot_north_eq)
-        .{ "==", .{ "coalesce", .{ "get", "rot_north" }, 0 }, 1 }
+        .{ "==", .{ "get", "rot_north" }, 1 }
     else
-        .{ "!=", .{ "coalesce", .{ "get", "rot_north" }, 0 }, 1 };
-    const not_light = .{ "!=", .{ "get", "class" }, "LIGHTS" };
+        .{ "!=", .{ "get", "rot_north" }, 1 };
+    // The baked `ep` (scene.augmentV3) already folds the danger deviation —
+    // an OBSTRN/WRECKS/UWTROC marker carries ep 19 — so the class-membership
+    // OR the partition used to need is gone; `lt` (1 on LIGHTS) replaces the
+    // class string compare.
+    const not_light = .{ "!=", .{ "get", "lt" }, 1 };
     switch (mode) {
-        // UNDER soundings: effective-prio < 18, and neither a danger (rides the over
-        // pass via its class) nor a light (its own top pass).
-        .base => try applyBucket(js, .{ "all", rot, .{ "<", EFF_PRIO, SOUNDINGS_PRIO }, not_light, .{ "!", IN_DANGER } }, true, bkt, s, null),
-        // OVER soundings: effective-prio >= 18 OR a danger class (the deviation), not a light.
-        .dangers_only => try applyBucket(js, .{ "all", rot, .{ "any", .{ ">=", EFF_PRIO, SOUNDINGS_PRIO }, IN_DANGER }, not_light }, true, bkt, s, null),
+        // UNDER soundings: effective-prio < 18 (dangers carry 19), not a light.
+        .base => try applyBucket(js, .{ "all", rot, .{ "<", EP, SOUNDINGS_PRIO }, not_light }, true, bkt, s, null),
+        // OVER soundings: effective-prio >= 18 (dangers included via ep 19), not a light.
+        .dangers_only => try applyBucket(js, .{ "all", rot, .{ ">=", EP, SOUNDINGS_PRIO }, not_light }, true, bkt, s, null),
         // LIGHTS on top (kept a dedicated pass for legibility order).
-        .lights_only => try applyBucket(js, .{ "all", rot, .{ "==", .{ "get", "class" }, "LIGHTS" } }, true, bkt, s, null),
+        .lights_only => try applyBucket(js, .{ "all", rot, .{ "==", .{ "get", "lt" }, 1 } }, true, bkt, s, null),
     }
 }
 
@@ -584,9 +606,19 @@ const LIGHT_TEXT_OFFSET = .{ "match", .{ "coalesce", .{ "get", "loff" }, "0,0" }
 /// resolves collisions layer by layer, top down — that is how the important tier
 /// gets first claim on the space. Inside a layer there is deliberately NO
 /// symbol-sort-key: peers are settled by feature order, the SENC sequence.
-fn textLayer(js: *Stringify, s: *const SCtx, sl: []const u8, bkt: Bucket, id: []const u8, filt: anytype) !void {
+fn textLayer(js: *Stringify, s: *const SCtx, sl: []const u8, bkt: Bucket, id: []const u8, filt: anytype, minzoom: ?u32) !void {
     try js.beginObject();
     try layerHead(js, id, "symbol", sl);
+    // Live symbol placement is the one per-frame cost that scales with the
+    // CANDIDATE pool, not the drawn count — at coastal zoom every minor
+    // label on half a seaboard entered collision and the pass blocked the
+    // render thread for hundreds of ms. The GPU path declutters at build
+    // time, off-thread, and those labels lose there anyway; a minzoom on the
+    // minor tier is the same outcome for a fraction of the work.
+    if (minzoom) |mz| {
+        try js.objectField("minzoom");
+        try js.write(mz);
+    }
     try applyBucket(js, filt, true, bkt, s, s.text_group); // SCAMIN text band-independent
     try js.objectField("layout");
     try js.beginObject();
@@ -618,8 +650,10 @@ fn textLayers(js: *Stringify, s: *const SCtx, sl: []const u8, bkt: Bucket) !void
     var buf2: [96]u8 = undefined;
     // Other text FIRST, important text ABOVE it: the upper layer places first,
     // so IMPORTANT text claims its space before anything else competes for it.
-    try textLayer(js, s, sl, bkt, try std.fmt.bufPrint(&buf, "text{s}", .{bkt.suffix}), FILT_TEXT_OTHER);
-    try textLayer(js, s, sl, bkt, try std.fmt.bufPrint(&buf2, "text-important{s}", .{bkt.suffix}), FILT_TEXT_IMPORTANT);
+    // The minor tier only exists from ~1:56k display (512-zoom 10): coarser
+    // than that it never survives declutter, it only bloats placement.
+    try textLayer(js, s, sl, bkt, try std.fmt.bufPrint(&buf, "text{s}", .{bkt.suffix}), FILT_TEXT_OTHER, 10);
+    try textLayer(js, s, sl, bkt, try std.fmt.bufPrint(&buf2, "text-important{s}", .{bkt.suffix}), FILT_TEXT_IMPORTANT, null);
 }
 
 fn textPaint(js: *Stringify, text_color: std.json.Value, halo: std.json.Value, scale: f64) !void {
@@ -706,24 +740,25 @@ fn overscaleLayer(js: *Stringify, s: *const SCtx) !void {
     try js.endObject();
 }
 
-// Linestyle-embedded symbols draw at the engine's SYMBOL_SCALE (0.028346…, see
-// scene/linestyle.zig drawComplexLine), not the 0.08 point-symbol default the sprite
-// atlas is sized for. Un-tessellated ls_style runs carry no per-symbol `scale` tile
-// property, so ICON_SIZE would coalesce to 0.08/0.08 = 1.0 (full atlas size, ~2.8x
-// too large); this fixed ratio makes the style-placed symbols match the tessellated
-// ones exactly.
-const LS_ICON_SIZE: f64 = 0.02834627777338028 / 0.08;
-
-// One decorated layer set for one analysed complex linestyle: a line layer whose
-// line-dasharray is the pattern's on/off runs in line-width units, and (sprite
-// permitting) a line-placed symbol layer per embedded symbol, spaced one period
-// apart. Colour/width ride the run's own color_token/width_px tile properties, so
-// the palette resolves exactly like every other line. The tiles carry each run
-// UN-tessellated (tagged ls_style); MapLibre walks the dash rhythm + symbol
-// placement at render time — the web analogue of replay.zig's drawComplexRun, and
-// it scales uniformly with zoom/DPR so spacing and glyph size stay locked together.
+// Linestyle-embedded symbols draw at the engine's SYMBOL_SCALE — which is now
+// the sheet's own bake scale, so they sample 1:1.
+const LS_ICON_SIZE: f64 = 1.0;
+
+// Decorated layers for the analysed complex linestyles, one source-layer per
+// style (tile57/3): the bake routes each ls_style's runs into their own
+// `lines-ls-<STYLE>` source-layer, so a style's dash layer and symbol
+// layer(s) see ONLY their own features — no ls_style membership filter, no
+// icon-image match, and a tile without the style doesn't carry the
+// source-layer at all. (The predecessor kept every decorated line in one
+// `lines` source-layer and merged symbol layers by quantized spacing; every
+// layer still filtered every line feature of every tile, the largest single
+// contributor to layout cost, and the merge cost ~7% spacing error. Per-style
+// source-layers delete the cross-product instead.) symbol-spacing is exact
+// per style again. The tiles carry each run UN-tessellated (tagged ls_style);
+// MapLibre walks the dash rhythm + symbol placement at render time.
 fn linestyleLayers(js: *Stringify, s: *const SCtx, ls: std.json.Value, bkt: Bucket, sprite_on: bool) !void {
     if (ls != .object) return;
+
     var it = ls.object.iterator();
     while (it.next()) |e| {
         const id = e.key_ptr.*;
@@ -736,13 +771,15 @@ fn linestyleLayers(js: *Stringify, s: *const SCtx, ls: std.json.Value, bkt: Buck
         if (dash_v != .array or dash_v.array.items.len == 0) continue;
 
         var buf: [96]u8 = undefined;
+        var slbuf: [80]u8 = undefined;
+        const sl = try std.fmt.bufPrint(&slbuf, "lines-ls-{s}", .{id});
         try js.beginObject();
-        try layerHead(js, try std.fmt.bufPrint(&buf, "lines-ls-{s}{s}", .{ id, bkt.suffix }), "line", "lines");
-        try applyBucket(js, .{ "==", .{ "get", "ls_style" }, id }, true, bkt, s, null);
+        try layerHead(js, try std.fmt.bufPrint(&buf, "lines-ls-{s}{s}", .{ id, bkt.suffix }), "line", sl);
+        try applyBucket(js, .{}, false, bkt, s, null);
         try js.objectField("layout");
         try js.beginObject();
         try js.objectField("line-sort-key");
-        try js.write(.{ "coalesce", .{ "get", "display_priority" }, 0 });
+        try js.write(.{ "coalesce", .{ "get", "lsk" }, 0 });
         try js.endObject();
         try js.objectField("paint");
         try js.beginObject();
@@ -764,19 +801,33 @@ fn linestyleLayers(js: *Stringify, s: *const SCtx, ls: std.json.Value, bkt: Buck
         if (!sprite_on) continue;
         const syms_v = v.object.get("symbols") orelse continue;
         if (syms_v != .array) continue;
+        // Distinct icons only, first-seen order: repeats drew at the same
+        // phase as their first occurrence and added nothing but overdraw.
+        var slot: u32 = 0;
+        const spacing = @max(period * s.size_scale, 1.0);
         for (syms_v.array.items, 0..) |sv, si| {
             if (sv != .object) continue;
             const name_v = sv.object.get("n") orelse continue;
             if (name_v != .string) continue;
+            var dup = false;
+            for (syms_v.array.items[0..si]) |pv| {
+                if (pv != .object) continue;
+                const pn = pv.object.get("n") orelse continue;
+                if (pn == .string and std.mem.eql(u8, pn.string, name_v.string)) {
+                    dup = true;
+                    break;
+                }
+            }
+            if (dup) continue;
             try js.beginObject();
-            try layerHead(js, try std.fmt.bufPrint(&buf, "lines-ls-{s}-sym{d}{s}", .{ id, si, bkt.suffix }), "symbol", "lines");
-            try applyBucket(js, .{ "==", .{ "get", "ls_style" }, id }, true, bkt, s, null);
+            try layerHead(js, try std.fmt.bufPrint(&buf, "lines-ls-{s}-sym{d}{s}", .{ id, slot, bkt.suffix }), "symbol", sl);
+            try applyBucket(js, .{}, false, bkt, s, null);
             try js.objectField("layout");
             try js.beginObject();
             try js.objectField("symbol-placement");
             try js.write("line");
             try js.objectField("symbol-spacing");
-            try js.write(@max(period * s.size_scale, 1.0));
+            try js.write(spacing);
             try js.objectField("icon-image");
             try js.write(name_v.string);
             try js.objectField("icon-size");
@@ -789,6 +840,7 @@ fn linestyleLayers(js: *Stringify, s: *const SCtx, ls: std.json.Value, bkt: Buck
             try js.write(true);
             try js.endObject(); // layout
             try js.endObject(); // layer
+            slot += 1;
         }
     }
 }
@@ -810,6 +862,10 @@ fn contourLabelLayer(js: *Stringify, s: *const SCtx, sl: []const u8, bkt: Bucket
     var buf: [96]u8 = undefined;
     try js.beginObject();
     try layerHead(js, try std.fmt.bufPrint(&buf, "contour-labels-{s}{s}", .{ sl, bkt.suffix }), "symbol", sl);
+    // Same placement-pool argument as the minor text tier: a contour value
+    // is unreadable coarser than ~1:112k anyway.
+    try js.objectField("minzoom");
+    try js.write(@as(u32, 9));
     try applyBucket(js, .{ "has", "valdco" }, true, bkt, s, null); // contour value labels (scamin text) band-independent
     try js.objectField("layout");
     try js.beginObject();
@@ -865,6 +921,8 @@ fn soundingsLayer(js: *Stringify, s: *const SCtx, bkt: Bucket, id: []const u8, f
     try applyBucket(js, filt, true, bkt, s, null); // soundings (band-quilted)
     try js.objectField("layout");
     try js.beginObject();
+    try js.objectField("visibility");
+    try js.write(if (s.soundings_on) "visible" else "none");
     try js.objectField("icon-image");
     try js.write(s.sound_img);
     try js.objectField("icon-size");
@@ -965,6 +1023,8 @@ pub fn json(alloc: std.mem.Allocator, opts: Options) ![]u8 {
         else
             .{ .zoom_k = scaminGateK(opts.scamin_lat) },
         .show_overscale = m.show_overscale,
+        // A TEMPLATE (null mariner) keeps soundings visible; the client gates.
+        .soundings_on = if (filters_on) (m.show_soundings orelse m.display_other) else true,
     };
 
     var aw: std.Io.Writer.Allocating = .init(alloc);
@@ -1425,10 +1485,11 @@ test "json: ignore_scamin drops SCAMIN gating (no buckets, no zoom-gate)" {
     };
 
     // Manifest present, gating ON -> the merged zoom-gate rides every layer (per-value
-    // #sm buckets are retired — a manifest never buckets now).
+    // #sm buckets are retired — a manifest never buckets now). tile57/3: the
+    // gate compares the baked vz against ["zoom"].
     const gated = try json(a, base);
     defer a.free(gated);
-    try std.testing.expect(std.mem.indexOf(u8, gated, "[\">=\",[\"coalesce\",[\"get\",\"scamin\"],1000000000000],[\"/\",") != null);
+    try std.testing.expect(std.mem.indexOf(u8, gated, "[\"<=\",[\"coalesce\",[\"get\",\"vz\"],0],[\"zoom\"]]") != null);
     try std.testing.expect(std.mem.indexOf(u8, gated, "#sm") == null);
 
     // Manifest present, ignore_scamin -> no buckets at all.
@@ -1438,13 +1499,12 @@ test "json: ignore_scamin drops SCAMIN gating (no buckets, no zoom-gate)" {
     defer a.free(out_ign);
     try std.testing.expect(std.mem.indexOf(u8, out_ign, "#sm") == null);
 
-    // No manifest, gating ON -> the static K/2^zoom SCAMIN gate is present (the
-    // scamin>=D(zoom) fallback shape, no per-value buckets).
+    // No manifest, gating ON -> the same vz gate (no per-value buckets).
     var nomanifest = base;
     nomanifest.scamin = &.{};
     const out_fb = try json(a, nomanifest);
     defer a.free(out_fb);
-    try std.testing.expect(std.mem.indexOf(u8, out_fb, "[\">=\",[\"coalesce\",[\"get\",\"scamin\"],1000000000000],[\"/\",") != null);
+    try std.testing.expect(std.mem.indexOf(u8, out_fb, "[\"<=\",[\"coalesce\",[\"get\",\"vz\"],0],[\"zoom\"]]") != null);
     try std.testing.expect(std.mem.indexOf(u8, out_fb, "#sm") == null);
     try std.testing.expect(std.mem.indexOf(u8, out_fb, "log2") == null); // old form retired
 
@@ -1453,7 +1513,7 @@ test "json: ignore_scamin drops SCAMIN gating (no buckets, no zoom-gate)" {
     nm_ign.ignore_scamin = true;
     const out_nm_ign = try json(a, nm_ign);
     defer a.free(out_nm_ign);
-    try std.testing.expect(std.mem.indexOf(u8, out_nm_ign, "[\">=\",[\"coalesce\",[\"get\",\"scamin\"],1000000000000],[\"/\",") == null);
+    try std.testing.expect(std.mem.indexOf(u8, out_nm_ign, "[\"<=\",[\"coalesce\",[\"get\",\"vz\"],0],[\"zoom\"]]") == null);
     try std.testing.expect(std.mem.indexOf(u8, out_nm_ign, "#sm") == null);
 }
 
@@ -1476,15 +1536,16 @@ test "json: point z-order = display_priority alone (threshold partition + danger
     });
     defer a.free(out);
 
-    // symbol-sort-key = display_priority (via plane*64 + display_priority), with dangers mapped to an
-    // effective 19 as a sort VALUE — NOT a baked tile display_priority, NOT a class tier.
-    try std.testing.expect(std.mem.indexOf(u8, out, "\"symbol-sort-key\":[\"case\",[\"in\",[\"get\",\"class\"],[\"literal\",[\"OBSTRN\",\"WRECKS\",\"UWTROC\"]]],19,[\"+\",[\"*\",[\"coalesce\",[\"get\",\"display_plane\"],0],64],[\"coalesce\",[\"get\",\"display_priority\"],0]]]") != null);
-    // The under-soundings pass filters on effective-prio < 18 (the threshold), not class.
-    try std.testing.expect(std.mem.indexOf(u8, out, "[\"<\",[\"+\",[\"*\",[\"coalesce\",[\"get\",\"display_plane\"],0],64],[\"coalesce\",[\"get\",\"display_priority\"],0]],18]") != null);
-    // The over-soundings pass = effective-prio >= 18 OR a danger class.
-    try std.testing.expect(std.mem.indexOf(u8, out, "[\"any\",[\">=\",[\"+\",[\"*\",[\"coalesce\",[\"get\",\"display_plane\"],0],64],[\"coalesce\",[\"get\",\"display_priority\"],0]],18],[\"in\",[\"get\",\"class\"],[\"literal\",[\"OBSTRN\",\"WRECKS\",\"UWTROC\"]]]]") != null);
-    // Lines gained a display_priority sort key.
-    try std.testing.expect(std.mem.indexOf(u8, out, "\"line-sort-key\":[\"coalesce\",[\"get\",\"display_priority\"],0]") != null);
+    // symbol-sort-key = the baked ep (plane*64 + display_priority, dangers
+    // folded to an effective 19 at bake — scene.augmentV3).
+    try std.testing.expect(std.mem.indexOf(u8, out, "\"symbol-sort-key\":[\"coalesce\",[\"get\",\"ep\"],0]") != null);
+    // The under-soundings pass filters on effective-prio < 18 (the threshold).
+    try std.testing.expect(std.mem.indexOf(u8, out, "[\"<\",[\"coalesce\",[\"get\",\"ep\"],0],18]") != null);
+    // The over-soundings pass = effective-prio >= 18 (dangers ride via ep 19).
+    try std.testing.expect(std.mem.indexOf(u8, out, "[\">=\",[\"coalesce\",[\"get\",\"ep\"],0],18]") != null);
+    // Lines sort on the baked lsk (display_priority*1000 - width_px, so an
+    // S-52 outline+ink pair at one priority keeps the ink on top).
+    try std.testing.expect(std.mem.indexOf(u8, out, "\"line-sort-key\":[\"coalesce\",[\"get\",\"lsk\"],0]") != null);
 
     // z-order (emit order): under-symbols < soundings < over-symbols < lights. So a
     // base at display_priority 30 (over pass, sorts 30) draws above a danger (over pass, sorts
@@ -1502,6 +1563,45 @@ test "json: point z-order = display_priority alone (threshold partition + danger
     try std.testing.expect(i_over < i_lt);
 }
 
+test "json: the soundings switch drives the soundings layers' visibility" {
+    const a = std.testing.allocator;
+    const ct =
+        \\{"day":{"DEPDW":"#c9edff"},"dusk":{},"night":{}}
+    ;
+    var base = Options{
+        .scheme = "day",
+        .colortables_json = ct,
+        .sprite = "sprite",
+        .glyphs = "glyphs/{fontstack}/{range}.pbf",
+    };
+
+    // A template (no mariner) keeps soundings visible — the client gates live.
+    const tmpl = try json(a, base);
+    defer a.free(tmpl);
+    try std.testing.expect(std.mem.indexOf(u8, tmpl, "\"id\":\"soundings\",\"type\":\"symbol\",\"source\":\"chart\",\"source-layer\":\"soundings\"") != null);
+    try std.testing.expect(std.mem.indexOf(u8, tmpl, "\"visibility\":\"none\"") == null);
+
+    // soundings OFF hides the layer outright.
+    var m = mariner.Settings{ .show_soundings = false };
+    base.mariner = m;
+    const off = try json(a, base);
+    defer a.free(off);
+    try std.testing.expect(std.mem.indexOf(u8, off, "\"visibility\":\"none\"") != null);
+
+    // auto (null) follows display OTHER, the category S-52 files SOUNDG under.
+    m = mariner.Settings{ .display_other = false };
+    base.mariner = m;
+    const auto_off = try json(a, base);
+    defer a.free(auto_off);
+    try std.testing.expect(std.mem.indexOf(u8, auto_off, "\"visibility\":\"none\"") != null);
+
+    m = mariner.Settings{ .show_soundings = true, .display_other = false };
+    base.mariner = m;
+    const on = try json(a, base);
+    defer a.free(on);
+    try std.testing.expect(std.mem.indexOf(u8, on, "\"visibility\":\"none\"") == null);
+}
+
 test "json: size_scale wraps icon/line/text sizes in a multiplier" {
     const a = std.testing.allocator;
     const ct =
@@ -1547,8 +1647,10 @@ test "buildFromTemplate: defaults bake SEABED fill + category/M_QUAL filter (sin
     const out = try buildFromTemplate(a, cs_template, &m, cs_ct, null, 1700000000);
     defer a.free(out);
     try std.testing.expect(std.mem.indexOf(u8, out, "DEPMD") != null); // SEABED01 band
-    try std.testing.expect(std.mem.indexOf(u8, out, "ISODGR01") != null); // category filter
-    try std.testing.expect(std.mem.indexOf(u8, out, "M_QUAL") != null);
+    // Category filter reads the v3 precomputes: iso (ISODGR01) + mq (M_QUAL) ints.
+    try std.testing.expect(std.mem.indexOf(u8, out, "[\"get\",\"iso\"]") != null);
+    try std.testing.expect(std.mem.indexOf(u8, out, "[\"get\",\"mq\"]") != null);
+    try std.testing.expect(std.mem.indexOf(u8, out, "[\"get\",\"display_category\"]") != null);
     try std.testing.expect(std.mem.indexOf(u8, out, "10.0") != null); // float depth edges
     try std.testing.expect(std.mem.indexOf(u8, out, "30.0") != null);
 }
@@ -1665,17 +1767,17 @@ test "buildFromTemplate: viewing-group deny-list filter gates by vg" {
 test "buildFromTemplateScamin: a manifest no longer buckets — the merged zoom-gate rides every layer" {
     const a = std.testing.allocator;
     const m = mariner.Settings{};
-    // No manifest -> the static K/2^zoom SCAMIN zoom-gate, no #sm buckets.
+    // No manifest -> the baked-vz SCAMIN zoom-gate, no #sm buckets.
     const plain = try buildFromTemplate(a, cs_template, &m, cs_ct, null, 1700000000);
     defer a.free(plain);
-    try std.testing.expect(std.mem.indexOf(u8, plain, "[\">=\",[\"coalesce\",[\"get\",\"scamin\"],1000000000000],[\"/\",") != null);
+    try std.testing.expect(std.mem.indexOf(u8, plain, "[\"<=\",[\"coalesce\",[\"get\",\"vz\"],0],[\"zoom\"]]") != null);
     try std.testing.expect(std.mem.indexOf(u8, plain, "#sm") == null);
     // With a manifest -> STILL the merged zoom-gate (per-value buckets retired): the
     // manifest no longer produces #sm layers, only the TileJSON ladder (served apart).
     const scamin = [_]u32{ 89999, 259999 };
     const bucketed = try buildFromTemplateScamin(a, cs_template, &m, cs_ct, null, 1700000000, &scamin, 38.0);
     defer a.free(bucketed);
-    try std.testing.expect(std.mem.indexOf(u8, bucketed, "[\">=\",[\"coalesce\",[\"get\",\"scamin\"],1000000000000],[\"/\",") != null);
+    try std.testing.expect(std.mem.indexOf(u8, bucketed, "[\"<=\",[\"coalesce\",[\"get\",\"vz\"],0],[\"zoom\"]]") != null);
     try std.testing.expect(std.mem.indexOf(u8, bucketed, "#sm") == null);
     try std.testing.expect(std.mem.indexOf(u8, bucketed, "log2") == null);
 }
@@ -1819,20 +1921,20 @@ test "json: showOverscale=false hides the hatch layer; ignoreScamin keeps it (de
     defer a.free(hidden);
     try std.testing.expect(std.mem.indexOf(u8, hidden, "\"id\":\"overscale\",") != null);
     try std.testing.expect(std.mem.indexOf(u8, hidden, "{\"visibility\":\"none\"}") != null);
-    try std.testing.expect(std.mem.indexOf(u8, hidden, "\"oscl\"") != null);
+    try std.testing.expect(std.mem.indexOf(u8, hidden, "[\"get\",\"oz\"]") != null);
 
-    // Bucket mode derives the oscl DENOM from zoom (same K as the scamin clause).
+    // The zoom-gate compares ["zoom"] against the baked oz (scene.augmentV3).
     const bucketed = try json(a, base);
     defer a.free(bucketed);
-    try std.testing.expect(std.mem.indexOf(u8, bucketed, "[\">\",[\"coalesce\",[\"get\",\"oscl\"],0],[\"/\",") != null);
+    try std.testing.expect(std.mem.indexOf(u8, bucketed, "[\">\",[\"zoom\"],[\"coalesce\",[\"get\",\"oz\"],99]]") != null);
 
     // ignore_scamin: the overscale indication is DECOUPLED from decluttering
-    // (spec §5) — the oscl clauses + hatch layer survive the debug toggle.
+    // (spec §5) — the oz clauses + hatch layer survive the debug toggle.
     var ign = base;
     ign.ignore_scamin = true;
     const out_ign = try json(a, ign);
     defer a.free(out_ign);
-    try std.testing.expect(std.mem.indexOf(u8, out_ign, "oscl") != null);
+    try std.testing.expect(std.mem.indexOf(u8, out_ign, "[\"get\",\"oz\"]") != null);
     try std.testing.expect(std.mem.indexOf(u8, out_ign, "\"id\":\"overscale\",") != null);
 
     // No sprite -> nothing can draw the hatch: single plain fill layer, no sandwich.
@@ -1840,7 +1942,7 @@ test "json: showOverscale=false hides the hatch layer; ignoreScamin keeps it (de
     nospr.sprite = null;
     const out_ns = try json(a, nospr);
     defer a.free(out_ns);
-    try std.testing.expect(std.mem.indexOf(u8, out_ns, "oscl") == null);
+    try std.testing.expect(std.mem.indexOf(u8, out_ns, "[\"get\",\"oz\"]") == null);
     try std.testing.expect(std.mem.indexOf(u8, out_ns, "\"id\":\"overscale\",") == null);
 }
 
@@ -1906,7 +2008,7 @@ test "diff: same mariner -> [] (no ops)" {
     try std.testing.expectEqualStrings("[]", ops);
 }
 
-test "diff: display_other flip emits only setFilter ops" {
+test "diff: display_other flip emits setFilter ops + the soundings visibility rider" {
     const a = std.testing.allocator;
     const base = mariner.Settings{};
     const other = mariner.Settings{ .display_other = true };
@@ -1918,8 +2020,22 @@ test "diff: display_other flip emits only setFilter ops" {
     defer a.free(ops);
     try std.testing.expect(std.mem.indexOf(u8, ops, "setFilter") != null);
     try std.testing.expect(std.mem.indexOf(u8, ops, "setPaintProperty") == null);
-    try std.testing.expect(std.mem.indexOf(u8, ops, "setLayoutProperty") == null);
-    try std.testing.expect(!std.mem.eql(u8, ops, "[]"));
+    // Auto soundings ride display OTHER (deriveLive parity), so this flip also
+    // toggles the soundings layers' visibility — a layout op, and nothing else.
+    try std.testing.expect(std.mem.indexOf(u8, ops, "setLayoutProperty") != null);
+    try std.testing.expect(std.mem.indexOf(u8, ops, "\"visibility\"") != null);
+    // An explicit soundings switch pins them, and the flip is filter-only again.
+    const base_pinned = mariner.Settings{ .show_soundings = true };
+    const other_pinned = mariner.Settings{ .display_other = true, .show_soundings = true };
+    const p1 = try buildFromTemplate(a, cs_template, &base_pinned, cs_ct, null, 1700000000);
+    defer a.free(p1);
+    const p2 = try buildFromTemplate(a, cs_template, &other_pinned, cs_ct, null, 1700000000);
+    defer a.free(p2);
+    const pops = try diff(a, p1, p2);
+    defer a.free(pops);
+    try std.testing.expect(std.mem.indexOf(u8, pops, "setFilter") != null);
+    try std.testing.expect(std.mem.indexOf(u8, pops, "setLayoutProperty") == null);
+    try std.testing.expect(!std.mem.eql(u8, pops, "[]"));
 }
 
 test "diff: day vs night emits setPaintProperty colour ops, no filter change" {
@@ -1944,6 +2060,19 @@ fn layerCount(a: std.mem.Allocator, style: []const u8) !usize {
     return p.value.object.get("layers").?.array.items.len;
 }
 
+/// SCAMIN gating must never appear as native minzoom (that is the per-value
+/// bucket explosion both merged modes exist to avoid). The only minzooms in a
+/// merged style are the fixed placement-pool tiers: 10 on minor text, 9 on
+/// contour labels.
+fn expectOnlyPlacementMinzooms(style_json: []const u8) !void {
+    var i: usize = 0;
+    while (std.mem.indexOfPos(u8, style_json, i, "\"minzoom\":")) |at| {
+        const v = style_json[at + 10 ..];
+        try std.testing.expect(std.mem.startsWith(u8, v, "10") or std.mem.startsWith(u8, v, "9"));
+        i = at + 10;
+    }
+}
+
 test "json: both merged modes (zoom-gate default, filter-gate exact) give one layer per render-type — no per-value buckets" {
     const a = std.testing.allocator;
     const ct =
@@ -1964,8 +2093,8 @@ test "json: both merged modes (zoom-gate default, filter-gate exact) give one la
     const merged = try json(a, base);
     defer a.free(merged);
     try std.testing.expect(std.mem.indexOf(u8, merged, "#sm") == null);
-    try std.testing.expect(std.mem.indexOf(u8, merged, "minzoom") == null);
-    try std.testing.expect(std.mem.indexOf(u8, merged, "[\">=\",[\"coalesce\",[\"get\",\"scamin\"],1000000000000],[\"/\",") != null);
+    try expectOnlyPlacementMinzooms(merged);
+    try std.testing.expect(std.mem.indexOf(u8, merged, "[\"<=\",[\"coalesce\",[\"get\",\"vz\"],0],[\"zoom\"]]") != null);
 
     // Filter-gate (?scaminexact): one live-clause layer per family — the SAME layer
     // set, with the client-driven curDenom clause instead of the zoom expression.
@@ -1974,7 +2103,7 @@ test "json: both merged modes (zoom-gate default, filter-gate exact) give one la
     const gated = try json(a, fg);
     defer a.free(gated);
     try std.testing.expect(std.mem.indexOf(u8, gated, "#sm") == null); // no per-value buckets
-    try std.testing.expect(std.mem.indexOf(u8, gated, "minzoom") == null); // no native minzoom gating
+    try expectOnlyPlacementMinzooms(gated); // no scamin-derived native minzooms
     try std.testing.expect(std.mem.indexOf(u8, gated, "1000000000000") != null);
     try std.testing.expect(std.mem.indexOf(u8, gated, "\"scamin\"") != null);
 
@@ -2012,3 +2141,35 @@ test "json: scamin_filter_gate honors the cur_denom literal + ignore_scamin drop
     try std.testing.expect(std.mem.indexOf(u8, out_ign, "1000000000000") == null);
     try std.testing.expect(std.mem.indexOf(u8, out_ign, "#sm") == null);
 }
+
+test "json: tile57/3 linestyle layers read per-style source-layers, constant icons, exact spacing" {
+    const a = std.testing.allocator;
+    const ct =
+        \\{"day":{"DEPDW":"#c9edff","CHMGD":"#c045d1"},"dusk":{},"night":{}}
+    ;
+    // Two analysed styles with different periods; ACHARE51 places one symbol.
+    const lsj =
+        \\{"ACHARE51":{"period_px":122.08,"dash":[0.0,7.559,22.677,38.552],"color_token":"CHMGD","width_px":1.209,"symbols":[{"o":18.898,"n":"EMAREMG1","r":0.0}]},
+        \\ "CBLSUB06":{"period_px":64.0,"dash":[32.0,32.0],"color_token":"CHMGD","width_px":1.0,"symbols":[{"o":8.0,"n":"CABLES11","r":0.0}]}}
+    ;
+    const out = try json(a, .{
+        .scheme = "day",
+        .colortables_json = ct,
+        .sprite = "sprite",
+        .glyphs = "glyphs/{fontstack}/{range}.pbf",
+        .linestyles_json = lsj,
+    });
+    defer a.free(out);
+    // Dash layer and symbol layer both read the style's OWN source-layer…
+    try std.testing.expect(std.mem.indexOf(u8, out, "\"id\":\"lines-ls-ACHARE51\",\"type\":\"line\",\"source\":\"chart\",\"source-layer\":\"lines-ls-ACHARE51\"") != null);
+    try std.testing.expect(std.mem.indexOf(u8, out, "\"id\":\"lines-ls-ACHARE51-sym0\",\"type\":\"symbol\",\"source\":\"chart\",\"source-layer\":\"lines-ls-ACHARE51\"") != null);
+    // …so no layer needs an ls_style membership filter or an icon-image match.
+    try std.testing.expect(std.mem.indexOf(u8, out, "[\"get\",\"ls_style\"]") == null);
+    try std.testing.expect(std.mem.indexOf(u8, out, "[\"match\",[\"get\",\"ls_style\"]") == null);
+    // The icon is the plain sprite name, the spacing the style's exact period.
+    try std.testing.expect(std.mem.indexOf(u8, out, "\"icon-image\":\"EMAREMG1\"") != null);
+    try std.testing.expect(std.mem.indexOf(u8, out, "\"symbol-spacing\":122.08") != null);
+    try std.testing.expect(std.mem.indexOf(u8, out, "\"symbol-spacing\":64") != null);
+    // The base line layers keep the plain `lines` source-layer.
+    try std.testing.expect(std.mem.indexOf(u8, out, "\"id\":\"lines-solid\",\"type\":\"line\",\"source\":\"chart\",\"source-layer\":\"lines\"") != null);
+}
diff --git a/src/style/mariner.zig b/src/style/mariner.zig
index e36f2913..496638e8 100644
--- a/src/style/mariner.zig
+++ b/src/style/mariner.zig
@@ -455,6 +455,12 @@ pub fn depthTextField(b: B, m: *const Settings) !Value {
 // ---- client-side display filters -------------------------------------------
 
 // Display category (S-52 §10.3.4) + M_QUAL data-quality overlay.
+//
+// Reads the tile57/3 precomputes: `display_category` (the always-present int
+// the bake emits — the old form read a `cat` property no tile ever carried,
+// so every feature coalesced to STANDARD and the base/other toggles gated
+// nothing), `iso` (1 on ISODGR01, replacing the symbol_name string compare)
+// and `mq` (1 on M_QUAL, replacing the class string compare).
 pub fn categoryFilter(b: B, m: *const Settings) !Value {
     var en = Array.init(b.a);
     if (m.display_base) try en.append(b.int(0));
@@ -463,12 +469,12 @@ pub fn categoryFilter(b: B, m: *const Settings) !Value {
     const isoCat: i64 = if (m.show_isolated_dangers_shallow) 1 else 0;
     const cat = try b.arr(&.{
         b.s("case"),
-        try b.arr(&.{ b.s("=="), try b.get("symbol_name"), b.s("ISODGR01") }),
+        try b.arr(&.{ b.s("=="), try b.get("iso"), b.int(1) }),
         b.int(isoCat),
-        try b.coalesce(try b.get("cat"), b.int(1)),
+        try b.coalesce(try b.get("display_category"), b.int(1)),
     });
     const inCat = try b.arr(&.{ b.s("in"), cat, try b.arr(&.{ b.s("literal"), .{ .array = en } }) });
-    const isQual = try b.arr(&.{ b.s("=="), try b.get("class"), b.s("M_QUAL") });
+    const isQual = try b.arr(&.{ b.s("=="), try b.get("mq"), b.int(1) });
     if (m.data_quality)
         return b.arr(&.{ b.s("any"), isQual, try b.arr(&.{ b.s("all"), inCat, try b.arr(&.{ b.s("!"), isQual }) }) });
     return b.arr(&.{ b.s("all"), inCat, try b.arr(&.{ b.s("!"), isQual }) });
@@ -501,6 +507,18 @@ pub fn pointStyleFilter(b: B, m: *const Settings) !Value {
     });
 }
 
+// Sector-leg length (S-52 §12.2.4 full sector lines): show common (2) + the
+// active length. A pre-sect bake carries no tag and coalesces to 2, so its
+// 25 mm legs keep drawing whichever way the switch stands.
+pub fn sectorFilter(b: B, m: *const Settings) !Value {
+    const rank: i64 = if (m.show_full_sector_lines) 1 else 0;
+    return b.arr(&.{
+        b.s("in"),
+        try b.coalesce(try b.get("sect"), b.int(2)),
+        try b.arr(&.{ b.s("literal"), try b.arr(&.{ b.int(2), b.int(rank) }) }),
+    });
+}
+
 // S-52 §14.5 text-group selection. Important text (11) is always on.
 pub fn textGroupFilter(b: B, m: *const Settings) !Value {
     const g = try b.coalesce(try b.get("tgrp"), b.int(-1));
@@ -624,6 +642,7 @@ pub fn commonChartFilters(a: std.mem.Allocator, m: *const Settings, enabled_band
     if (enabled_bands) |eb| try clauses.append(try bandFilter(b, eb));
     try clauses.append(try boundaryFilter(b, m));
     try clauses.append(try pointStyleFilter(b, m));
+    try clauses.append(try sectorFilter(b, m));
     if (try viewingGroupFilter(b, m)) |vgf| try clauses.append(vgf); // §14.5 (future use; no-op when null)
     if (!m.show_inform_callouts)
         try clauses.append(try b.arr(&.{ b.s("!="), try b.coalesce(try b.get("symbol_name"), b.s("")), b.s("INFORM01") }));
diff --git a/src/style/style.zig b/src/style/style.zig
index e9787ca6..fb85b46d 100644
--- a/src/style/style.zig
+++ b/src/style/style.zig
@@ -19,13 +19,20 @@ const std = @import("std");
 /// tile57/2 = the 6-source-layer schema (the `_scamin` twins folded into their
 /// base; SCAMIN is a per-feature `scamin` property the style gates
 /// band-independently).
-pub const SCHEMA_VERSION = "tile57/2";
+/// tile57/3 = /2 plus (a) linestyle-decorated lines split into one
+/// `lines-ls-<STYLE>` source-layer per linestyle and (b) the v3 precomputed
+/// properties (vz/oz gate zooms, mq/iso flags, ep/lsk sort keys) — see
+/// scene.augmentV3. The style's filters and sort keys read the precomputes;
+/// a /2 archive under a /3 style renders, but SCAMIN-gates nothing and sorts
+/// by tile order.
+pub const SCHEMA_VERSION = "tile57/3";
 
 // MapLibre style.json generation lives in maplibre.zig.
 pub const Options = @import("maplibre.zig").Options;
 pub const json = @import("maplibre.zig").json;
 pub const displayDenom = @import("maplibre.zig").displayDenom;
 pub const displayDenomZ = @import("maplibre.zig").displayDenomZ;
+pub const scaminDisplayZoom = @import("maplibre.zig").scaminDisplayZoom;
 pub const scaminGateK = @import("maplibre.zig").scaminGateK;
 pub const buildFromTemplate = @import("maplibre.zig").buildFromTemplate;
 pub const buildFromTemplateScamin = @import("maplibre.zig").buildFromTemplateScamin;
diff --git a/src/tiles/tile.zig b/src/tiles/tile.zig
index caf67f08..2691b867 100644
--- a/src/tiles/tile.zig
+++ b/src/tiles/tile.zig
@@ -593,6 +593,16 @@ fn douglasPeucker(a: Allocator, pts: []const mvt.Point, eps2: i128) ![]mvt.Point
             const ey: i64 = @as(i64, pts[i].y) - ay;
             // den constant within this segment, so argmax(perp dist) = argmax(num^2)
             // for den>0, or argmax(ex^2+ey^2) for a degenerate segment.
+            //
+            // i128 DELIBERATELY. Tracking |num| in i64 and squaring once per
+            // segment is the same argmax and measurably cheaper per point — it
+            // takes this loop out of compiler_rt on arm64. It was measured at
+            // no wall-clock gain (1.00-1.06x over a 1,200-chart bake), and it
+            // is only safe while every coordinate is tile-local: a Point is
+            // i32, `project` states its output may fall outside [0,extent],
+            // and ex*dy on unclipped input overflows i64 where this does not.
+            // Silent geometry corruption is not worth a gain that did not show
+            // up in a measurement.
             const metric: i128 = if (den == 0)
                 @as(i128, ex) * ex + @as(i128, ey) * ey
             else blk: {
@@ -611,8 +621,17 @@ fn douglasPeucker(a: Allocator, pts: []const mvt.Point, eps2: i128) ![]mvt.Point
             try stack.append(a, .{ besti, e });
         }
     }
+    // Count first, allocate once. Appending a point at a time regrew this list
+    // log2(n) times per line, and a bake runs it for every line in every tile
+    // of every cell. On Android that was the top of the bake profile: the
+    // reallocs' memset plus malloc/free was ~8% of cycles.
+    var n_keep: usize = 0;
+    for (keep) |k| {
+        if (k) n_keep += 1;
+    }
     var out = std.ArrayList(mvt.Point).empty;
-    for (pts, 0..) |p, k| if (keep[k]) try out.append(a, p);
+    try out.ensureTotalCapacityPrecise(a, n_keep);
+    for (pts, 0..) |p, k| if (keep[k]) out.appendAssumeCapacity(p);
     return out.items;
 }
 
diff --git a/tools/bake.zig b/tools/bake.zig
index fa60513e..264fc6c6 100644
--- a/tools/bake.zig
+++ b/tools/bake.zig
@@ -225,6 +225,12 @@ pub fn run(io: std.Io, a: std.mem.Allocator, args: []const [:0]const u8) !void {
         // parallel bake. It writes and frees each archive as it finishes, so peak
         // memory tracks the worker count rather than the cell count.
         var out_paths = std.ArrayList([]const u8).empty;
+        // The directory the archive wraps its cells in, dropped from every
+        // output path below. The rule is the ENGINE's (chart.bakeZip applies
+        // the same one for a caller who wants the whole archive in one call);
+        // this command only keeps its own list so it can name each finished
+        // chart as it lands.
+        const zip_root = if (zip_arc != null) chart.archiveRootPrefix(cell_paths.items) else "";
         for (cell_paths.items) |cp| {
             const stem = std.fs.path.stem(std.fs.path.basename(cp));
             // One directory per chart, as the exchange set does it: the archive
@@ -237,10 +243,21 @@ pub fn run(io: std.Io, a: std.mem.Allocator, args: []const [:0]const u8) !void {
             // referenced text beside the right chart — and two districts that
             // share a boundary cell keep their own copies instead of one
             // overwriting the other.
-            const chart_dir = if (zip_arc != null)
-                std.fs.path.join(a, &.{ out_dir, std.fs.path.dirname(cp) orelse "" }) catch continue
-            else
-                std.fs.path.join(a, &.{ out_dir, stem }) catch continue;
+            const chart_dir = if (zip_arc != null) blk: {
+                // …BELOW the archive's own root, which is not part of what the
+                // mariner asked for. `-o <dir>` names the library; carrying
+                // the zip's wrapper directory through made
+                // `-o ~/Charts/ENC_ROOT` write ~/Charts/ENC_ROOT/ENC_ROOT/,
+                // a second library beside the real one that the app then
+                // opened together with it.
+                const dir = std.fs.path.dirname(cp) orelse "";
+                var rel = dir[@min(zip_root.len, dir.len)..];
+                while (rel.len != 0 and rel[0] == '/') rel = rel[1..];
+                // Nothing left to mirror (a flat archive, or one cell under
+                // one directory): fall back to the per-chart directory the
+                // ENC_ROOT path uses, so every cell still gets its own.
+                break :blk std.fs.path.join(a, &.{ out_dir, if (rel.len == 0) stem else rel }) catch continue;
+            } else std.fs.path.join(a, &.{ out_dir, stem }) catch continue;
             std.Io.Dir.cwd().createDirPath(io, chart_dir) catch continue;
             const name = std.fmt.allocPrint(a, "{s}.pmtiles", .{stem}) catch continue;
             out_paths.append(a, std.fs.path.join(a, &.{ chart_dir, name }) catch continue) catch {};
diff --git a/tools/main.zig b/tools/main.zig
index f83f11ec..60742245 100644
--- a/tools/main.zig
+++ b/tools/main.zig
@@ -173,3 +173,10 @@ pub fn main(init: std.process.Init) !void {
 
     common.printUsage();
 }
+
+test {
+    // A test binary rooted here links lua_shim.c through engine's portray
+    // module but analyses only what its tests reach. Referencing engine scans
+    // bake_root.zig, whose comptime block emits the shim's C-ABI accessors.
+    _ = @import("engine");
+}