@chrtco/sdk 0.8.0 → 0.9.0

package/dist/index.js

@@ -135,6 +135,7 @@ var TileTokenError = class extends Error {
   }
 };
 var TILE_URL_PATH = /\/v1\/tiles\/[A-Za-z0-9_]+(?:\/[a-z][a-z0-9-]*)?\/\d+\/\d+\/\d+\.mvt(?:\?.*)?$/i;
+var STYLE_URL_PATH = /\/v1\/styles\/[A-Za-z0-9_]+\/style\.json(?:\?.*)?$/i;
 var REFRESH_MARGIN_SECONDS = 30;
 var STALE_GRACE_SECONDS = 1;
 var MINT_RETRY_DELAYS_MS = [500, 1e3, 2e3];
@@ -278,17 +279,22 @@ var TileAuth = class {
   }
   /**
    * Produce a MapLibre / Mapbox GL `transformRequest`. Attaches
-   * `Authorization: Bearer <jwt>` only to CHRT tile URLs; style, sprite, and
-   * glyph URLs pass through untouched (never leak the token to third-party
-   * CDNs). Kicks off a background mint immediately so the cache warms within
-   * one round-trip; the first tile or two may go unauthenticated and be
-   * retried by the renderer.
+   * `Authorization: Bearer <jwt>` only to CHRT tile URLs and the CHRT
+   * served-style URL (`/v1/styles/{region}/style.json`); sprite, glyph, and
+   * third-party URLs pass through untouched (never leak the token to
+   * third-party CDNs). Kicks off a background mint immediately so the cache
+   * warms within one round-trip; the first tile or two may go
+   * unauthenticated and be retried by the renderer. When pointing a map's
+   * `style` at the served style URL, obtain it via `chrt.styleUrl()` — it
+   * awaits the mint, so the style request (which MapLibre does NOT retry)
+   * is guaranteed to carry auth.
    */
   transformRequest(region) {
     const r = region ?? this.defaultRegion;
     void this.getToken(r).catch(() => void 0);
     return (url) => {
-      if (!url.startsWith(this.tileBaseUrl) || !TILE_URL_PATH.test(url)) return void 0;
+      if (!url.startsWith(this.tileBaseUrl)) return void 0;
+      if (!TILE_URL_PATH.test(url) && !STYLE_URL_PATH.test(url)) return void 0;
       const token = this.peek(r);
       if (!token) return { url };
       return { url, headers: { Authorization: `Bearer ${token}` } };
@@ -326,23 +332,67 @@ var TileAuth = class {
 
 // src/endpoints/tiles.ts
 var TilesEndpoint = class {
-  constructor(http, opts) {
+  constructor(http, tileAuth, opts) {
     this.http = http;
+    this.tileAuth = tileAuth;
     this.region = opts?.region ?? DEFAULT_TILE_REGION;
     this.tileBaseUrl = (opts?.tileBaseUrl ?? DEFAULT_TILE_BASE_URL).replace(/\/+$/, "");
   }
   region;
   tileBaseUrl;
+  styleEndpoint(theme) {
+    const query2 = theme ? `?theme=${theme}` : "";
+    return `${this.tileBaseUrl}/v1/styles/${this.region}/style.json${query2}`;
+  }
   /**
-   * @deprecated CHRT has no remote `style.json` endpoint — the S-52 style is
-   * generated client-side. Use `chrt.style(opts)` to get a ready-to-use
-   * MapLibre style object instead. Calling this throws to prevent silently
-   * pointing a map at a dead URL.
+   * URL of the served S-52 style for the configured region — the CHRTstyle
+   * Style API (`GET /v1/styles/{region}/style.json`). The served document
+   * honors the API key's bound custom style (a Dev+ feature configured at
+   * platform → Map Styles); Free keys and unbound keys get the default
+   * themes, identical to the locally generated `chrt.style()`.
+   *
+   * The endpoint is JWT-gated, so pair the URL with
+   * `chrt.transformRequest()`, which attaches the Bearer token to both the
+   * style request and its tile requests. This method is async because it
+   * pre-mints the tile token, guaranteeing the auth cache is warm before
+   * MapLibre fetches the URL.
+   *
+   * @example
+   * const map = new maplibregl.Map({
+   *   container: 'map',
+   *   style: await chrt.styleUrl({ theme: 'dusk' }),
+   *   transformRequest: chrt.transformRequest(),
+   * });
    */
-  styleUrl() {
-    throw new Error(
-      "chrt.tiles.styleUrl() is no longer supported: CHRT serves no remote style.json. Use chrt.style(opts) to generate an S-52 MapLibre style object, and chrt.transformRequest() for tile auth. See https://chrt.co/docs/vector-tiles"
-    );
+  async styleUrl(opts = {}) {
+    await this.tileAuth.getToken(this.region);
+    return this.styleEndpoint(opts.theme);
+  }
+  /**
+   * Fetch the served S-52 style as a MapLibre style object (see
+   * {@link styleUrl} for what "served" means). Prefer this over `styleUrl()`
+   * when you want to inspect or mutate the document, or when you can't use
+   * `transformRequest` for the style request itself.
+   *
+   * Falls back nowhere: a network or auth failure throws (`ChrtError` /
+   * `TileTokenError`). For an offline-capable local fallback, use
+   * `chrt.style()` — the client-side generator.
+   */
+  async fetchStyle(opts = {}) {
+    const token = await this.tileAuth.getToken(this.region);
+    const res = await fetch(this.styleEndpoint(opts.theme), {
+      headers: { authorization: `Bearer ${token.token}` },
+      signal: opts.signal
+    });
+    if (!res.ok) {
+      let body;
+      try {
+        body = await res.json();
+      } catch {
+      }
+      throw new ChrtError(res.status, body);
+    }
+    return await res.json();
   }
   /**
    * Vector tile URL template for the configured region, served by the
@@ -1146,51 +1196,2409 @@ var OfflineEndpoint = class {
         { resumable: true, bytes_written: bytesDownloaded }
       );
     }
-    emit(true);
-    const computedSha = await fs.sha256(partialPath);
-    if (computedSha.toLowerCase() !== bundle.sha256) {
-      await fs.unlink(partialPath);
-      throw new OfflineError(
-        "download_corrupt",
-        `SHA-256 mismatch for ${region}: expected ${bundle.sha256}, got ${computedSha}`,
-        void 0,
-        { expected: bundle.sha256, actual: computedSha }
+    emit(true);
+    const computedSha = await fs.sha256(partialPath);
+    if (computedSha.toLowerCase() !== bundle.sha256) {
+      await fs.unlink(partialPath);
+      throw new OfflineError(
+        "download_corrupt",
+        `SHA-256 mismatch for ${region}: expected ${bundle.sha256}, got ${computedSha}`,
+        void 0,
+        { expected: bundle.sha256, actual: computedSha }
+      );
+    }
+    await fs.rename(partialPath, path);
+    await this.persistManifestEntry(region, bundle, path, fs);
+    return {
+      path,
+      bytes: bundle.bytes,
+      sha256: bundle.sha256,
+      build_id: bundle.build_id,
+      build_tag: bundle.build_tag,
+      resumed
+    };
+  }
+  async persistManifestEntry(region, bundle, path, fs) {
+    if (!this.manifestPath) return;
+    const manifest = await readManifest(this.manifestPath, fs);
+    const nowSec = Math.floor(Date.now() / 1e3);
+    manifest.regions[region] = {
+      path,
+      bytes: bundle.bytes,
+      sha256: bundle.sha256,
+      build_id: bundle.build_id,
+      build_tag: bundle.build_tag,
+      downloaded_at: nowSec,
+      last_accessed_at: nowSec
+    };
+    await writeManifest(this.manifestPath, fs, manifest);
+  }
+};
+function dirname(p) {
+  const i = p.lastIndexOf("/");
+  const j = p.lastIndexOf("\\");
+  const k = Math.max(i, j);
+  if (k <= 0) return ".";
+  return p.slice(0, k);
+}
+
+// src/interact/decode.ts
+var LITCHR_TABLE = {
+  1: { name: "Fixed", abbr: "F" },
+  2: { name: "Flashing", abbr: "Fl" },
+  3: { name: "Long Flashing", abbr: "LFl" },
+  4: { name: "Occulting", abbr: "Oc" },
+  5: { name: "Isophase", abbr: "Iso" },
+  6: { name: "Short Flashing", abbr: "S.Fl" },
+  7: { name: "Short Long Flashing", abbr: "S.LFl" },
+  8: { name: "Alternating Occulting", abbr: "Al.Oc" },
+  9: { name: "Alternating Long Flashing", abbr: "Al.LFl" },
+  10: { name: "Alternating Flashing", abbr: "Al.Fl" },
+  11: { name: "Alternating Group", abbr: "Al.Gp" },
+  12: { name: "Morse", abbr: "Mo" },
+  13: { name: "Quick", abbr: "Q" },
+  14: { name: "Very Quick", abbr: "VQ" },
+  15: { name: "Ultra Quick", abbr: "UQ" },
+  16: { name: "Alternating", abbr: "Al" },
+  17: { name: "Alternating Fixed/Flash", abbr: "Al.F.Fl" },
+  25: { name: "Quick + Long Flash", abbr: "Q+LFl" },
+  26: { name: "Very Quick + Long Flash", abbr: "VQ+LFl" },
+  27: { name: "Ultra Quick + Long Flash", abbr: "UQ+LFl" },
+  28: { name: "Alternating", abbr: "Al" },
+  29: { name: "Fixed + Long Flash", abbr: "F.LFl" }
+};
+var COLOUR_TABLE = {
+  1: { name: "White", abbr: "W", hex: "#ffffff" },
+  2: { name: "Black", abbr: "B", hex: "#333333" },
+  3: { name: "Red", abbr: "R", hex: "#ef4444" },
+  4: { name: "Green", abbr: "G", hex: "#22c55e" },
+  5: { name: "Blue", abbr: "Bu", hex: "#3b82f6" },
+  6: { name: "Yellow", abbr: "Y", hex: "#eab308" },
+  7: { name: "Grey", abbr: "Gr", hex: "#9ca3af" },
+  8: { name: "Brown", abbr: "Bn", hex: "#92400e" },
+  9: { name: "Amber", abbr: "Am", hex: "#f59e0b" },
+  10: { name: "Violet", abbr: "Vi", hex: "#8b5cf6" },
+  11: { name: "Orange", abbr: "Or", hex: "#f97316" },
+  12: { name: "Magenta", abbr: "Mg", hex: "#d946ef" },
+  13: { name: "Pink", abbr: "Pk", hex: "#f472b6" }
+};
+var BOYSHP_TABLE = {
+  1: "Conical (nun)",
+  2: "Can (cylindrical)",
+  3: "Spherical",
+  4: "Pillar",
+  5: "Spar",
+  6: "Barrel",
+  7: "Super buoy",
+  8: "Ice buoy"
+};
+var CATLAM_TABLE = {
+  1: "Port",
+  2: "Starboard",
+  3: "Preferred channel to starboard",
+  4: "Preferred channel to port"
+};
+var CATCAM_TABLE = {
+  1: "North cardinal",
+  2: "East cardinal",
+  3: "South cardinal",
+  4: "West cardinal"
+};
+var CATLMK_TABLE = {
+  1: "Cairn",
+  2: "Cemetery",
+  3: "Chimney",
+  4: "Dish aerial",
+  5: "Flagstaff",
+  6: "Flare stack",
+  7: "Mast",
+  8: "Windsock",
+  9: "Monument",
+  10: "Column / pillar",
+  11: "Memorial plaque",
+  12: "Obelisk",
+  13: "Statue",
+  14: "Cross",
+  15: "Dome",
+  16: "Radar scanner",
+  17: "Tower",
+  18: "Windmill",
+  19: "Wind turbine",
+  20: "Spire"
+};
+var CATFOG_TABLE = {
+  1: "Explosive",
+  2: "Diaphone",
+  3: "Siren",
+  4: "Nautophone",
+  5: "Bell",
+  6: "Whistle",
+  7: "Reed",
+  8: "Gong",
+  9: "Horn"
+};
+var CATFOG_ABBR_TABLE = {
+  1: "EXPLOS",
+  2: "DIA",
+  3: "SIREN",
+  4: "NAUTO",
+  5: "BELL",
+  6: "WHIS",
+  7: "REED",
+  8: "GONG",
+  9: "HORN"
+};
+var TOPSHP_TABLE = {
+  1: "Cone, point up",
+  2: "Cone, point down",
+  3: "Sphere",
+  4: "2 spheres",
+  5: "Cylinder",
+  6: "Board",
+  7: "X-shape",
+  8: "Upright cross",
+  9: "Cube, point up",
+  10: "2 cones, point to point",
+  11: "2 cones, base to base",
+  12: "Rhombus",
+  13: "2 cones, up",
+  14: "2 cones, down",
+  15: "Besom, point up",
+  16: "Besom, point down",
+  17: "Flag",
+  18: "Sphere over rhombus",
+  19: "Square",
+  33: "T-shape"
+};
+var STATUS_TABLE = {
+  1: "Permanent",
+  2: "Occasional",
+  3: "Recommended",
+  4: "Not in use",
+  5: "Periodic/intermittent",
+  6: "Reserved",
+  7: "Temporary",
+  8: "Private",
+  9: "Mandatory",
+  11: "Extinguished",
+  12: "Illuminated",
+  13: "Historic",
+  14: "Public",
+  15: "Synchronized",
+  16: "Watched",
+  17: "Un-watched",
+  18: "Existence doubtful"
+};
+var MARSYS_TABLE = {
+  1: "IALA-A",
+  2: "IALA-B"
+};
+var LAYER_TYPE_MAP = {
+  BOYLAT: "Lateral Buoy",
+  BOYCAR: "Cardinal Buoy",
+  BOYSPP: "Special Purpose Buoy",
+  BOYISD: "Isolated Danger Buoy",
+  BOYSAW: "Safe Water Buoy",
+  BCNLAT: "Lateral Beacon",
+  BCNCAR: "Cardinal Beacon",
+  BCNSPP: "Special Purpose Beacon",
+  BCNISD: "Isolated Danger Beacon",
+  BCNSAW: "Safe Water Beacon",
+  LIGHTS: "Light",
+  DAYMAR: "Daymark",
+  FOGSIG: "Fog Signal",
+  RTPBCN: "Radar Transponder Beacon",
+  RDOSTA: "Radio/Radar Station",
+  TOPMAR: "Topmark",
+  MORFAC: "Mooring Facility",
+  LNDMRK: "Landmark",
+  SISTAT: "Signal Station",
+  PILBOP: "Pilot Boarding Place",
+  HRBFAC: "Harbour Facility",
+  SMCFAC: "Small Craft Facility",
+  CRANES: "Crane",
+  OFSPLF: "Offshore Platform",
+  ACHBRT: "Anchor Berth",
+  DISMAR: "Distance Mark",
+  LITVES: "Light Vessel",
+  LITFLT: "Light Float"
+};
+var NAV_AID_QUERY_LAYERS = [
+  "enc-BOYLAT",
+  "enc-BOYCAR",
+  "enc-BOYSPP",
+  "enc-BOYISD",
+  "enc-BOYSAW",
+  "enc-BCNLAT",
+  "enc-BCNCAR",
+  "enc-BCNSPP",
+  "enc-BCNISD",
+  "enc-BCNSAW",
+  "enc-LIGHTS",
+  "enc-LIGHTS-point",
+  "enc-DAYMAR",
+  "enc-FOGSIG",
+  "enc-RTPBCN",
+  "enc-RDOSTA",
+  "enc-TOPMAR",
+  "enc-MORFAC",
+  "enc-MORFAC-point",
+  "enc-LNDMRK",
+  "enc-LNDMRK-point",
+  "enc-SISTAT",
+  "enc-SISTAT-point",
+  "enc-PILBOP",
+  "enc-PILBOP-point",
+  "enc-HRBFAC",
+  "enc-SMCFAC",
+  "enc-CRANES",
+  "enc-CRANES-point",
+  "enc-OFSPLF",
+  "enc-OFSPLF-point",
+  "enc-ACHBRT",
+  "enc-DISMAR",
+  "enc-LITVES",
+  "enc-LITFLT"
+];
+var AREA_QUERY_LAYERS = [
+  "enc-DEPARE",
+  "enc-DEPARE-polygon",
+  "enc-OBSTRN",
+  "enc-OBSTRN-polygon",
+  "enc-OBSTRN-point",
+  "enc-WRECKS",
+  "enc-WRECKS-polygon",
+  "enc-WRECKS-point",
+  "enc-RESARE",
+  "enc-RESARE-polygon",
+  "enc-ACHARE",
+  "enc-ACHARE-polygon",
+  "enc-CTNARE",
+  "enc-CTNARE-polygon",
+  "enc-DRGARE",
+  "enc-DRGARE-polygon",
+  "enc-FAIRWY",
+  "enc-FAIRWY-polygon",
+  "enc-DMPGRD",
+  "enc-DMPGRD-polygon",
+  "enc-MIPARE",
+  "enc-MIPARE-polygon",
+  "enc-PRCARE",
+  "enc-PRCARE-polygon",
+  "enc-TSSLPT",
+  "enc-TSSLPT-polygon",
+  "enc-TSELNE",
+  "enc-TSELNE-line",
+  "enc-ISTZNE",
+  "enc-ISTZNE-polygon",
+  "enc-OSPARE",
+  "enc-OSPARE-polygon",
+  "enc-MARCUL",
+  "enc-MARCUL-polygon",
+  "enc-CBLARE",
+  "enc-CBLARE-polygon",
+  "enc-PIPARE",
+  "enc-PIPARE-polygon",
+  // Tier 3: infrastructure lines (BRIDGE handled by BRIDGE_QUERY_LAYERS)
+  "enc-CBLSUB",
+  "enc-CBLSUB-line",
+  "enc-CBLOHD",
+  "enc-CBLOHD-line",
+  "enc-PIPSOL",
+  "enc-PIPSOL-line",
+  "enc-PIPOHD",
+  "enc-PIPOHD-line",
+  "enc-BERTHS",
+  "enc-BERTHS-line",
+  "enc-DAMCON",
+  "enc-DAMCON-line",
+  "enc-FERYRT",
+  "enc-FERYRT-line",
+  "enc-RECTRC",
+  "enc-RECTRC-line",
+  // Tier 4: land/context features
+  "enc-BUISGL",
+  "enc-BUISGL-polygon",
+  "enc-BUISGL-point",
+  "enc-SILTNK",
+  "enc-SILTNK-polygon",
+  "enc-SILTNK-point",
+  "enc-HULKES",
+  "enc-HULKES-polygon",
+  "enc-HULKES-point",
+  "enc-DRYDOC",
+  "enc-DRYDOC-polygon",
+  "enc-FLODOC",
+  "enc-FLODOC-polygon",
+  "enc-PONTON",
+  "enc-PONTON-polygon",
+  "enc-GATCON",
+  "enc-GATCON-polygon",
+  "enc-GATCON-point",
+  "enc-LOGPON",
+  "enc-LOGPON-polygon",
+  "enc-AIRARE",
+  "enc-AIRARE-polygon",
+  "enc-SLCONS",
+  "enc-SLCONS-polygon",
+  "enc-SLCONS-line",
+  "enc-SLCONS-point",
+  // Tier 5: hydrographic context
+  "enc-COALNE",
+  "enc-COALNE-line",
+  "enc-DEPCNT",
+  "enc-DEPCNT-line",
+  "enc-RIVERS",
+  "enc-RIVERS-polygon",
+  "enc-RIVERS-line",
+  "enc-CANALS",
+  "enc-CANALS-polygon",
+  "enc-CANALS-line",
+  "enc-LAKARE",
+  "enc-LAKARE-polygon",
+  "enc-RAPIDS",
+  "enc-RAPIDS-polygon",
+  "enc-RAPIDS-point",
+  "enc-WATFAL",
+  "enc-WATFAL-polygon",
+  "enc-WATFAL-point",
+  "enc-LNDARE",
+  "enc-LNDARE-polygon"
+];
+var BRIDGE_QUERY_LAYERS = [
+  "enc-BRIDGE-midpoint",
+  "enc-BRIDGE",
+  "enc-BRIDGE-line",
+  "s52-BRIDGE-polygon",
+  "s52-BRIDGE-polygon-outline"
+];
+var CATBRG_LABELS = {
+  1: "Fixed bridge",
+  2: "Opening bridge",
+  3: "Swing bridge",
+  4: "Lifting bridge",
+  5: "Bascule bridge",
+  6: "Pontoon bridge",
+  7: "Drawbridge",
+  8: "Transporter bridge",
+  9: "Footbridge",
+  10: "Viaduct",
+  11: "Aqueduct",
+  12: "Suspension bridge"
+};
+var CONDTN_TABLE = {
+  1: "Under construction",
+  2: "Ruined",
+  3: "Under reclamation",
+  5: "Planned"
+};
+function parseFirstNum(val) {
+  if (val == null) return null;
+  const s = String(val);
+  if (s.startsWith("[")) {
+    try {
+      const arr = JSON.parse(s);
+      if (Array.isArray(arr)) {
+        const n2 = Number(arr[0]);
+        return Number.isFinite(n2) ? n2 : null;
+      }
+    } catch {
+    }
+  }
+  const n = Number(s.split(",")[0]);
+  return Number.isFinite(n) ? n : null;
+}
+function asNumber(val) {
+  if (val == null || val === "") return null;
+  const n = Number(val);
+  return Number.isFinite(n) ? n : null;
+}
+function decodeBridgeProps(props) {
+  const catCode = parseFirstNum(props.CATBRG);
+  const statusCode = parseFirstNum(props.STATUS);
+  const condCode = parseFirstNum(props.CONDTN);
+  return {
+    name: props.OBJNAM ? String(props.OBJNAM) : null,
+    categoryCode: catCode,
+    categoryLabel: catCode ? CATBRG_LABELS[catCode] ?? null : null,
+    verticalClearance: asNumber(props.VERCLR),
+    verticalClearanceClosed: asNumber(props.VERCCL),
+    verticalClearanceOpen: asNumber(props.VERCOP),
+    horizontalClearance: asNumber(props.HORCLR),
+    status: statusCode ? STATUS_TABLE[statusCode] ?? null : null,
+    condition: condCode ? CONDTN_TABLE[condCode] ?? null : null,
+    information: props.INFORM ? String(props.INFORM) : null,
+    nationalName: props.NOBJNM ? String(props.NOBJNM) : null,
+    sourceIndication: props.SORIND ? String(props.SORIND) : null,
+    sourceDate: props.SORDAT ? String(props.SORDAT) : null
+  };
+}
+var CATOBS_TABLE = {
+  1: "Snag / stump",
+  2: "Wellhead",
+  3: "Diffuser",
+  4: "Crib",
+  5: "Fish haven",
+  6: "Foul area",
+  7: "Foul ground",
+  8: "Ice boom",
+  9: "Ground tackle",
+  10: "Boom",
+  11: "Platform"
+};
+var CATWRK_TABLE = {
+  1: "Non-dangerous",
+  2: "Dangerous",
+  3: "Distributed remains",
+  4: "Mast showing",
+  5: "Hull showing"
+};
+var WATLEV_TABLE = {
+  1: "Partly submerged at high water",
+  2: "Always dry",
+  3: "Always submerged",
+  4: "Covers and uncovers",
+  5: "Awash",
+  6: "Subject to inundation / flooding",
+  7: "Floating"
+};
+var CATREA_TABLE = {
+  1: "Offshore safety zone",
+  2: "Anchoring prohibition",
+  3: "Fishing prohibition",
+  4: "Nature reserve",
+  5: "Bird sanctuary",
+  6: "Game preserve",
+  7: "Seal sanctuary",
+  8: "Degaussing range",
+  9: "Military area",
+  10: "Historic wreck",
+  12: "Navigational aid safety zone",
+  14: "No wake zone",
+  18: "Swimming area",
+  19: "Waiting area",
+  20: "Research area",
+  21: "Dredging area",
+  22: "Fish sanctuary",
+  23: "Ecological reserve",
+  24: "No discharge zone",
+  25: "No anchoring area",
+  26: "No fishing area",
+  27: "Speed restriction zone",
+  28: "To be avoided area"
+};
+var RESTRN_TABLE = {
+  1: "Anchoring prohibited",
+  2: "Anchoring restricted",
+  3: "Fishing prohibited",
+  4: "Fishing restricted",
+  5: "Trawling prohibited",
+  6: "Trawling restricted",
+  7: "Entry prohibited",
+  8: "Entry restricted",
+  9: "Dredging prohibited",
+  10: "Dredging restricted",
+  11: "Diving prohibited",
+  12: "Diving restricted",
+  13: "No wake",
+  14: "To be avoided",
+  15: "Construction prohibited",
+  16: "Discharging prohibited",
+  17: "Discharging restricted",
+  18: "Industrial prohibited",
+  19: "Metallic hull vessels prohibited",
+  20: "Navigating prohibited",
+  21: "Speed restricted",
+  24: "Stopping prohibited",
+  25: "Landing prohibited"
+};
+var CATHAF_TABLE = {
+  1: "RoRo terminal",
+  3: "Ferry terminal",
+  4: "Fishing harbour",
+  5: "Yacht harbour / marina",
+  6: "Naval base",
+  7: "Tanker terminal",
+  8: "Passenger terminal",
+  9: "Shipyard",
+  10: "Container terminal",
+  11: "Bulk terminal",
+  12: "Synchrolift",
+  13: "Straddle carrier",
+  14: "Port terminal"
+};
+var CATSCF_TABLE = {
+  1: "Visitors' berth",
+  2: "Nautical club",
+  3: "Boat hoist",
+  4: "Sailmaker",
+  5: "Boatyard",
+  6: "Public inn",
+  7: "Restaurant",
+  8: "Chandler",
+  9: "Provisions",
+  10: "Doctor",
+  11: "Pharmacy",
+  12: "Water tap",
+  13: "Fuel station",
+  14: "Electricity",
+  15: "Bottle gas",
+  16: "Showers",
+  17: "Launderette",
+  18: "Public toilets",
+  19: "Post box"
+};
+var CATCRN_TABLE = {
+  2: "Container crane / gantry",
+  3: "Sheerlegs",
+  4: "Travelling crane"
+};
+var CATACH_TABLE = {
+  1: "Unrestricted anchorage",
+  2: "Deep water anchorage",
+  3: "Tanker anchorage",
+  4: "Explosives anchorage",
+  5: "Quarantine anchorage",
+  6: "Sea-plane anchorage",
+  7: "Small craft anchorage",
+  8: "Small craft mooring area",
+  9: "Anchorage for 24 hours or less"
+};
+var CATDPG_TABLE = {
+  1: "General dumping ground",
+  2: "Chemical waste",
+  3: "Nuclear waste",
+  4: "Explosives",
+  5: "Spoil ground",
+  6: "Vessel dumping ground"
+};
+var CATMFA_TABLE = {
+  1: "Crustaceans",
+  2: "Oysters / mussels",
+  3: "Fish",
+  4: "Seaweed",
+  5: "Pearl culture"
+};
+var CATCBL_TABLE = {
+  1: "Submarine power cable",
+  2: "Submarine transmission cable",
+  3: "Submarine telegraph cable",
+  4: "Submarine telephone cable",
+  5: "Mooring cable",
+  6: "Ferry cable"
+};
+var CATPIP_TABLE = {
+  1: "Pipeline",
+  2: "Outfall pipe",
+  3: "Intake pipe",
+  4: "Sewer",
+  5: "Bubbler system",
+  6: "Supply pipe"
+};
+var TRAFIC_TABLE = {
+  1: "Inbound",
+  2: "Outbound",
+  3: "One-way",
+  4: "Two-way"
+};
+var QUASOU_TABLE = {
+  1: "Depth known",
+  2: "Depth unknown",
+  3: "Doubtful sounding",
+  4: "Unreliable sounding",
+  6: "Least depth known",
+  7: "Least depth unknown",
+  9: "Not regularly maintained",
+  10: "Maintained depth",
+  11: "Not surveyed"
+};
+function decodeAreaFeatureProps(layerName, props) {
+  const rawLayer = layerName.replace(/^enc-/, "").replace(/-(point|line|polygon|midpoint)$/, "");
+  const parseCodeLocal = (val) => {
+    if (val == null) return null;
+    const s = String(val);
+    try {
+      const arr = JSON.parse(s);
+      if (Array.isArray(arr)) return Number(arr[0]) || null;
+    } catch {
+    }
+    return Number(s.split(",")[0]) || null;
+  };
+  const entries = [];
+  let type = rawLayer;
+  let title = props.OBJNAM ? String(props.OBJNAM) : "";
+  if (rawLayer === "DEPARE") {
+    type = "Depth Area";
+    const drval1 = props.DRVAL1 != null ? Number(props.DRVAL1) : null;
+    const drval2 = props.DRVAL2 != null ? Number(props.DRVAL2) : null;
+    if (drval1 != null && drval2 != null) {
+      title = title || `${drval1}m \u2013 ${drval2}m`;
+      entries.push({ label: "Depth Range", value: `${drval1}m \u2013 ${drval2}m` });
+    } else if (drval1 != null) {
+      entries.push({ label: "Min Depth", value: `${drval1}m` });
+    }
+    const qc = parseCodeLocal(props.QUASOU);
+    if (qc && QUASOU_TABLE[qc]) entries.push({ label: "Quality", value: QUASOU_TABLE[qc] });
+  } else if (rawLayer === "OBSTRN") {
+    type = "Obstruction";
+    const cat = parseCodeLocal(props.CATOBS);
+    if (cat && CATOBS_TABLE[cat]) {
+      entries.push({ label: "Category", value: CATOBS_TABLE[cat] });
+      if (!title) title = CATOBS_TABLE[cat];
+    }
+    if (props.VALSOU != null) entries.push({ label: "Depth", value: `${props.VALSOU}m` });
+    const wl = parseCodeLocal(props.WATLEV);
+    if (wl && WATLEV_TABLE[wl]) entries.push({ label: "Water Level", value: WATLEV_TABLE[wl] });
+    const qc = parseCodeLocal(props.QUASOU);
+    if (qc && QUASOU_TABLE[qc]) entries.push({ label: "Sounding Quality", value: QUASOU_TABLE[qc] });
+  } else if (rawLayer === "WRECKS") {
+    type = "Wreck";
+    const cat = parseCodeLocal(props.CATWRK);
+    if (cat && CATWRK_TABLE[cat]) {
+      entries.push({ label: "Category", value: CATWRK_TABLE[cat] });
+      if (!title) title = CATWRK_TABLE[cat];
+    }
+    if (props.VALSOU != null) entries.push({ label: "Depth", value: `${props.VALSOU}m` });
+    const wl = parseCodeLocal(props.WATLEV);
+    if (wl && WATLEV_TABLE[wl]) entries.push({ label: "Water Level", value: WATLEV_TABLE[wl] });
+    const qc = parseCodeLocal(props.QUASOU);
+    if (qc && QUASOU_TABLE[qc]) entries.push({ label: "Sounding Quality", value: QUASOU_TABLE[qc] });
+  } else if (rawLayer === "RESARE") {
+    type = "Restricted Area";
+    const cat = parseCodeLocal(props.CATREA);
+    if (cat && CATREA_TABLE[cat]) {
+      entries.push({ label: "Category", value: CATREA_TABLE[cat] });
+      if (!title) title = CATREA_TABLE[cat];
+    }
+    if (props.RESTRN) {
+      const codes = parseListCodes(props.RESTRN).filter((n) => RESTRN_TABLE[n]);
+      if (codes.length > 0) {
+        entries.push({ label: "Restrictions", value: codes.map((c) => RESTRN_TABLE[c]).join("; ") });
+      }
+    }
+  } else if (rawLayer === "ACHARE") {
+    type = "Anchorage Area";
+    const cat = parseCodeLocal(props.CATACH);
+    if (cat && CATACH_TABLE[cat]) {
+      entries.push({ label: "Category", value: CATACH_TABLE[cat] });
+      if (!title) title = CATACH_TABLE[cat];
+    }
+    if (props.RESTRN) {
+      const codes = parseListCodes(props.RESTRN).filter((n) => RESTRN_TABLE[n]);
+      if (codes.length > 0) entries.push({ label: "Restrictions", value: codes.map((c) => RESTRN_TABLE[c]).join("; ") });
+    }
+    const st2 = parseCodeLocal(props.STATUS);
+    if (st2 && STATUS_TABLE[st2]) entries.push({ label: "Status", value: STATUS_TABLE[st2] });
+  } else if (rawLayer === "CTNARE") {
+    type = "Caution Area";
+  } else if (rawLayer === "DRGARE") {
+    type = "Dredged Area";
+    const drval1 = props.DRVAL1 != null ? Number(props.DRVAL1) : null;
+    const drval2 = props.DRVAL2 != null ? Number(props.DRVAL2) : null;
+    if (drval1 != null && drval2 != null) {
+      entries.push({ label: "Maintained Depth", value: `${drval1}m \u2013 ${drval2}m` });
+    } else if (drval1 != null) {
+      entries.push({ label: "Maintained Depth", value: `${drval1}m` });
+    }
+    const qc = parseCodeLocal(props.QUASOU);
+    if (qc && QUASOU_TABLE[qc]) entries.push({ label: "Quality", value: QUASOU_TABLE[qc] });
+  } else if (rawLayer === "FAIRWY") {
+    type = "Fairway";
+    const trafic = parseCodeLocal(props.TRAFIC);
+    if (trafic && TRAFIC_TABLE[trafic]) entries.push({ label: "Traffic", value: TRAFIC_TABLE[trafic] });
+    if (props.ORIENT != null) entries.push({ label: "Orientation", value: `${props.ORIENT}\xB0` });
+  } else if (rawLayer === "DMPGRD") {
+    type = "Dumping Ground";
+    const cat = parseCodeLocal(props.CATDPG);
+    if (cat && CATDPG_TABLE[cat]) {
+      entries.push({ label: "Category", value: CATDPG_TABLE[cat] });
+      if (!title) title = CATDPG_TABLE[cat];
+    }
+  } else if (rawLayer === "MIPARE") {
+    type = "Military Practice Area";
+    if (props.RESTRN) {
+      const codes = parseListCodes(props.RESTRN).filter((n) => RESTRN_TABLE[n]);
+      if (codes.length > 0) entries.push({ label: "Restrictions", value: codes.map((c) => RESTRN_TABLE[c]).join("; ") });
+    }
+  } else if (rawLayer === "PRCARE") {
+    type = "Precautionary Area";
+    const trafic = parseCodeLocal(props.TRAFIC);
+    if (trafic && TRAFIC_TABLE[trafic]) entries.push({ label: "Traffic", value: TRAFIC_TABLE[trafic] });
+    if (props.ORIENT != null) entries.push({ label: "Orientation", value: `${props.ORIENT}\xB0` });
+  } else if (rawLayer === "TSSLPT") {
+    type = "TSS Lane";
+    const trafic = parseCodeLocal(props.TRAFIC);
+    if (trafic && TRAFIC_TABLE[trafic]) entries.push({ label: "Traffic", value: TRAFIC_TABLE[trafic] });
+    if (props.ORIENT != null) entries.push({ label: "Orientation", value: `${props.ORIENT}\xB0` });
+  } else if (rawLayer === "TSELNE") {
+    type = "TSS Boundary";
+  } else if (rawLayer === "ISTZNE") {
+    type = "Inshore Traffic Zone";
+  } else if (rawLayer === "OSPARE") {
+    type = "Offshore Production Area";
+    if (props.RESTRN) {
+      const codes = parseListCodes(props.RESTRN).filter((n) => RESTRN_TABLE[n]);
+      if (codes.length > 0) entries.push({ label: "Restrictions", value: codes.map((c) => RESTRN_TABLE[c]).join("; ") });
+    }
+  } else if (rawLayer === "MARCUL") {
+    type = "Marine Farm / Culture";
+    const cat = parseCodeLocal(props.CATMFA);
+    if (cat && CATMFA_TABLE[cat]) {
+      entries.push({ label: "Category", value: CATMFA_TABLE[cat] });
+      if (!title) title = CATMFA_TABLE[cat];
+    }
+    if (props.RESTRN) {
+      const codes = parseListCodes(props.RESTRN).filter((n) => RESTRN_TABLE[n]);
+      if (codes.length > 0) entries.push({ label: "Restrictions", value: codes.map((c) => RESTRN_TABLE[c]).join("; ") });
+    }
+  } else if (rawLayer === "CBLARE") {
+    type = "Cable Area";
+    const cat = parseCodeLocal(props.CATCBL);
+    if (cat && CATCBL_TABLE[cat]) {
+      entries.push({ label: "Category", value: CATCBL_TABLE[cat] });
+      if (!title) title = `${CATCBL_TABLE[cat]} area`;
+    }
+    const st2 = parseCodeLocal(props.STATUS);
+    if (st2 && STATUS_TABLE[st2]) entries.push({ label: "Status", value: STATUS_TABLE[st2] });
+    if (props.RESTRN) {
+      const codes = parseListCodes(props.RESTRN).filter((n) => RESTRN_TABLE[n]);
+      if (codes.length > 0) entries.push({ label: "Restrictions", value: codes.map((c) => RESTRN_TABLE[c]).join("; ") });
+    }
+  } else if (rawLayer === "PIPARE") {
+    type = "Pipeline Area";
+    const cat = parseCodeLocal(props.CATPIP);
+    if (cat && CATPIP_TABLE[cat]) {
+      entries.push({ label: "Category", value: CATPIP_TABLE[cat] });
+      if (!title) title = `${CATPIP_TABLE[cat]} area`;
+    }
+    const st2 = parseCodeLocal(props.STATUS);
+    if (st2 && STATUS_TABLE[st2]) entries.push({ label: "Status", value: STATUS_TABLE[st2] });
+    if (props.RESTRN) {
+      const codes = parseListCodes(props.RESTRN).filter((n) => RESTRN_TABLE[n]);
+      if (codes.length > 0) entries.push({ label: "Restrictions", value: codes.map((c) => RESTRN_TABLE[c]).join("; ") });
+    }
+  } else if (rawLayer === "BRIDGE") {
+    const CATBRG_SHORT = {
+      1: "Fixed",
+      2: "Opening",
+      3: "Swing",
+      4: "Lifting",
+      5: "Bascule",
+      6: "Pontoon",
+      7: "Draw",
+      8: "Transporter",
+      9: "Footbridge",
+      10: "Viaduct",
+      11: "Aqueduct",
+      12: "Suspension"
+    };
+    const NATCON_TABLE = {
+      1: "Masonry",
+      2: "Concrete",
+      3: "Loose boulders",
+      4: "Hard-surfaced",
+      5: "Unsurfaced",
+      6: "Wooden",
+      7: "Metal",
+      8: "GRP"
+    };
+    const CONDTN_SHORT = {
+      1: "Under construction",
+      2: "Ruined",
+      3: "Under reclamation",
+      5: "Planned"
+    };
+    const catCode = parseCodeLocal(props.CATBRG);
+    const catName = catCode ? CATBRG_SHORT[catCode] : null;
+    type = catName ? `${catName} Bridge` : "Bridge";
+    if (catName) entries.push({ label: "Category", value: catName });
+    if (props.VERCLR != null) entries.push({ label: "Vertical Clearance", value: `${props.VERCLR} m` });
+    if (props.VERCCL != null) entries.push({ label: "Clearance (closed)", value: `${props.VERCCL} m` });
+    if (props.VERCOP != null) entries.push({ label: "Clearance (open)", value: `${props.VERCOP} m` });
+    if (props.HORCLR != null) entries.push({ label: "Horizontal Clearance", value: `${props.HORCLR} m` });
+    const natCode = parseCodeLocal(props.NATCON);
+    if (natCode && NATCON_TABLE[natCode]) entries.push({ label: "Construction", value: NATCON_TABLE[natCode] });
+    const condCode = parseCodeLocal(props.CONDTN);
+    if (condCode && CONDTN_SHORT[condCode]) entries.push({ label: "Condition", value: CONDTN_SHORT[condCode] });
+    const st2 = parseCodeLocal(props.STATUS);
+    if (st2 && STATUS_TABLE[st2]) entries.push({ label: "Status", value: STATUS_TABLE[st2] });
+    if (props.NOBJNM) entries.push({ label: "National Name", value: String(props.NOBJNM) });
+  } else if (rawLayer === "CBLSUB" || rawLayer === "CBLOHD") {
+    const CATCBL_LINE = {
+      1: "Power line",
+      2: "Transmission line",
+      3: "Telephone",
+      4: "Telegraph",
+      5: "Mooring cable/chain",
+      6: "Ferry cable"
+    };
+    type = rawLayer === "CBLSUB" ? "Submarine Cable" : "Overhead Cable";
+    const cat = parseCodeLocal(props.CATCBL);
+    if (cat && CATCBL_LINE[cat]) {
+      entries.push({ label: "Category", value: CATCBL_LINE[cat] });
+      if (!title) title = `${CATCBL_LINE[cat]} (${rawLayer === "CBLSUB" ? "submarine" : "overhead"})`;
+    }
+    if (props.VERCLR != null) entries.push({ label: "Vertical Clearance", value: `${props.VERCLR}m` });
+    if (props.VERCSA != null) entries.push({ label: "Clearance (safe)", value: `${props.VERCSA}m` });
+    if (props.RESTRN) {
+      const codes = parseListCodes(props.RESTRN).filter((n) => RESTRN_TABLE[n]);
+      if (codes.length > 0) entries.push({ label: "Restrictions", value: codes.map((c) => RESTRN_TABLE[c]).join("; ") });
+    }
+  } else if (rawLayer === "PIPSOL" || rawLayer === "PIPOHD") {
+    const CATPIP_LINE = {
+      2: "Outfall pipe",
+      3: "Intake pipe",
+      4: "Sewer",
+      5: "Bubbler system",
+      6: "Supply pipe"
+    };
+    type = rawLayer === "PIPSOL" ? "Submarine Pipeline" : "Overhead Pipeline";
+    const cat = parseCodeLocal(props.CATPIP);
+    if (cat && CATPIP_LINE[cat]) {
+      entries.push({ label: "Category", value: CATPIP_LINE[cat] });
+      if (!title) title = `${CATPIP_LINE[cat]} (${rawLayer === "PIPSOL" ? "submarine" : "overhead"})`;
+    }
+    if (props.VERCLR != null) entries.push({ label: "Vertical Clearance", value: `${props.VERCLR}m` });
+    if (props.RESTRN) {
+      const codes = parseListCodes(props.RESTRN).filter((n) => RESTRN_TABLE[n]);
+      if (codes.length > 0) entries.push({ label: "Restrictions", value: codes.map((c) => RESTRN_TABLE[c]).join("; ") });
+    }
+  } else if (rawLayer === "BERTHS") {
+    type = "Berth";
+  } else if (rawLayer === "DAMCON") {
+    type = "Dam";
+    if (props.VERCLR != null) entries.push({ label: "Vertical Clearance", value: `${props.VERCLR}m` });
+  } else if (rawLayer === "FERYRT") {
+    type = "Ferry Route";
+  } else if (rawLayer === "RECTRC") {
+    type = "Recommended Track";
+    const trafic = parseCodeLocal(props.TRAFIC);
+    if (trafic && TRAFIC_TABLE[trafic]) entries.push({ label: "Traffic", value: TRAFIC_TABLE[trafic] });
+    if (props.ORIENT != null) entries.push({ label: "Orientation", value: `${props.ORIENT}\xB0` });
+  } else if (rawLayer === "BUISGL") {
+    type = "Building";
+    const cat = parseCodeLocal(props.CATBUA);
+    if (cat) {
+      const CATBUA = {
+        1: "Urban area",
+        5: "Settlement",
+        6: "Town",
+        7: "Village",
+        8: "City"
+      };
+      if (CATBUA[cat]) {
+        entries.push({ label: "Category", value: CATBUA[cat] });
+        if (!title) title = CATBUA[cat];
+      }
+    }
+    const func = parseCodeLocal(props.FUNCTN);
+    if (func) {
+      const FUNCTN = {
+        2: "Harbour master's office",
+        3: "Customs office",
+        4: "Health office",
+        5: "Hospital",
+        6: "Post office",
+        7: "Hotel",
+        8: "Railway station",
+        9: "Police station",
+        10: "Water-police station",
+        11: "Pilot office",
+        13: "Bank",
+        14: "Headquarters",
+        15: "Transit shed/warehouse",
+        18: "Church",
+        19: "Chapel",
+        20: "Temple",
+        21: "Synagogue",
+        22: "Mosque",
+        24: "Lookout",
+        25: "Communication",
+        28: "Power station",
+        33: "Factory",
+        35: "Refinery",
+        36: "Religious order",
+        37: "School",
+        38: "University"
+      };
+      if (FUNCTN[func]) entries.push({ label: "Function", value: FUNCTN[func] });
+    }
+    if (props.VERLEN != null) entries.push({ label: "Height", value: `${props.VERLEN}m` });
+  } else if (rawLayer === "SILTNK") {
+    type = "Silo / Tank";
+    const cat = parseCodeLocal(props.CATSIL);
+    if (cat) {
+      const CATSIL = { 1: "Silo", 2: "Tank", 3: "Grain elevator", 4: "Water tower" };
+      if (CATSIL[cat]) {
+        type = CATSIL[cat];
+        if (!title) title = CATSIL[cat];
+      }
+    }
+    if (parseCodeLocal(props.CONVIS) === 1) entries.push({ label: "Visibility", value: "Conspicuous from seaward" });
+    if (props.VERLEN != null) entries.push({ label: "Height", value: `${props.VERLEN}m` });
+  } else if (rawLayer === "HULKES") {
+    type = "Hulk";
+    if (props.CATHLK != null) {
+      const cat = parseCodeLocal(props.CATHLK);
+      const CATHLK = { 1: "Floating restaurant", 2: "Historic ship", 3: "Museum", 4: "Accommodation", 5: "Floating breakwater" };
+      if (cat && CATHLK[cat]) {
+        entries.push({ label: "Use", value: CATHLK[cat] });
+        if (!title) title = CATHLK[cat];
+      }
+    }
+  } else if (rawLayer === "DRYDOC") {
+    type = "Dry Dock";
+  } else if (rawLayer === "FLODOC") {
+    type = "Floating Dock";
+    if (props.VERLEN != null) entries.push({ label: "Length", value: `${props.VERLEN}m` });
+    if (props.HORLEN != null) entries.push({ label: "Horiz. Length", value: `${props.HORLEN}m` });
+  } else if (rawLayer === "PONTON") {
+    type = "Pontoon";
+  } else if (rawLayer === "PYLONS") {
+    type = "Pylon / Bridge Support";
+    const cat = parseCodeLocal(props.CATPYL);
+    if (cat) {
+      const CATPYL = {
+        1: "Power transmission pylon",
+        2: "Telecom pylon",
+        3: "Aerial cableway pylon",
+        4: "Bridge pylon",
+        5: "Bridge pier",
+        6: "Chimney",
+        7: "Flare stack"
+      };
+      if (CATPYL[cat]) {
+        entries.push({ label: "Type", value: CATPYL[cat] });
+        if (!title) title = CATPYL[cat];
+      }
+    }
+    if (props.VERLEN != null) entries.push({ label: "Height", value: `${props.VERLEN}m` });
+  } else if (rawLayer === "GATCON") {
+    type = "Gate";
+    const cat = parseCodeLocal(props.CATGAT);
+    if (cat) {
+      const CATGAT = { 1: "General gate", 2: "Flood barrage gate", 3: "Caisson", 4: "Lock gate", 5: "Dyke gate" };
+      if (CATGAT[cat]) {
+        entries.push({ label: "Type", value: CATGAT[cat] });
+        if (!title) title = CATGAT[cat];
+      }
+    }
+  } else if (rawLayer === "LOGPON") {
+    type = "Log Pond";
+  } else if (rawLayer === "AIRARE") {
+    type = "Airport / Airfield";
+    const cat = parseCodeLocal(props.CATAIR);
+    if (cat) {
+      const CATAIR = { 1: "Airport", 2: "Heliport", 3: "Helipad", 4: "Emergency helipad" };
+      if (CATAIR[cat]) {
+        entries.push({ label: "Type", value: CATAIR[cat] });
+        if (!title) title = CATAIR[cat];
+      }
+    }
+  } else if (rawLayer === "SLCONS") {
+    type = "Shoreline Construction";
+    const cat = parseCodeLocal(props.CATSLC);
+    if (cat) {
+      const CATSLC = {
+        1: "Breakwater",
+        2: "Groyne",
+        3: "Mole",
+        4: "Pier",
+        5: "Promenade pier",
+        6: "Wharf",
+        7: "Training wall",
+        8: "Rip rap",
+        9: "Revetment",
+        10: "Sea wall",
+        11: "Landing stairs",
+        12: "Landing place",
+        13: "Fender",
+        14: "Lock",
+        15: "Flood gate",
+        16: "Slipway",
+        17: "Log ramp"
+      };
+      if (CATSLC[cat]) {
+        entries.push({ label: "Type", value: CATSLC[cat] });
+        if (!title) title = CATSLC[cat];
+      }
+    }
+    const wl = parseCodeLocal(props.WATLEV);
+    if (wl && WATLEV_TABLE[wl]) entries.push({ label: "Water Level", value: WATLEV_TABLE[wl] });
+  } else if (rawLayer === "COALNE") {
+    type = "Coastline";
+    const cat = parseCodeLocal(props.CATCOA);
+    if (cat) {
+      const CATCOA = {
+        1: "Steep coast",
+        2: "Flat coast",
+        3: "Sandy shore",
+        4: "Stony shore",
+        5: "Shingly shore",
+        6: "Glacier",
+        7: "Mangrove",
+        8: "Marshy shore",
+        9: "Coral reef",
+        10: "Ice coast",
+        11: "Rocky shore"
+      };
+      if (CATCOA[cat]) {
+        entries.push({ label: "Type", value: CATCOA[cat] });
+        if (!title) title = CATCOA[cat];
+      }
+    }
+  } else if (rawLayer === "DEPCNT") {
+    type = "Depth Contour";
+    if (props.VALDCO != null) {
+      title = title || `${props.VALDCO}m contour`;
+      entries.push({ label: "Depth", value: `${props.VALDCO}m` });
+    }
+  } else if (rawLayer === "RIVERS") {
+    type = "River";
+  } else if (rawLayer === "CANALS") {
+    type = "Canal";
+    if (props.HORWID != null) entries.push({ label: "Width", value: `${props.HORWID}m` });
+  } else if (rawLayer === "LAKARE") {
+    type = "Lake";
+  } else if (rawLayer === "RAPIDS") {
+    type = "Rapids";
+  } else if (rawLayer === "WATFAL") {
+    type = "Waterfall";
+    if (props.HEIGHT != null) entries.push({ label: "Height", value: `${props.HEIGHT}m` });
+  } else if (rawLayer === "LNDARE") {
+    type = "Land Area";
+  }
+  if (props.INFORM) entries.push({ label: "Information", value: String(props.INFORM) });
+  if (props.TXTDSC) entries.push({ label: "Text Description", value: String(props.TXTDSC) });
+  const st = parseCodeLocal(props.STATUS);
+  if (st && STATUS_TABLE[st]) entries.push({ label: "Status", value: STATUS_TABLE[st] });
+  return { type, title: title || type, properties: entries };
+}
+function parseCode(val) {
+  if (val == null) return null;
+  let s = String(val).trim();
+  if (s.startsWith("[")) {
+    try {
+      const arr = JSON.parse(s);
+      if (Array.isArray(arr) && arr.length > 0) s = String(arr[0]);
+      else return null;
+    } catch {
+    }
+  }
+  s = s.split(/[,;]/)[0].trim();
+  const n = Number(s);
+  return isNaN(n) ? null : n;
+}
+function parseListCodes(val) {
+  if (val == null) return [];
+  if (Array.isArray(val)) {
+    return val.map(Number).filter((n) => !isNaN(n) && n > 0);
+  }
+  const s = String(val).trim();
+  if (s.startsWith("[")) {
+    try {
+      const arr = JSON.parse(s);
+      if (Array.isArray(arr)) return arr.map(Number).filter((n) => !isNaN(n) && n > 0);
+    } catch {
+    }
+  }
+  return s.split(/[,;]/).map((v) => Number(v.trim())).filter((n) => !isNaN(n) && n > 0);
+}
+function parseGroup(val) {
+  if (val == null) return null;
+  const s = String(val).trim();
+  const parenMatch = s.match(/^\(?([\d+]+)\)?$/);
+  if (parenMatch) {
+    const parts = parenMatch[1].split("+").map(Number);
+    if (parts.every((n2) => !isNaN(n2) && n2 > 0)) return parts;
+  }
+  const n = Number(s);
+  return isNaN(n) || n <= 0 ? null : [n];
+}
+var CHILD_LAYERS = /* @__PURE__ */ new Set(["LIGHTS", "FOGSIG", "RTPBCN", "DAYMAR", "TOPMAR"]);
+var PARENT_LAYERS = [
+  "enc-BOYLAT",
+  "enc-BOYCAR",
+  "enc-BOYSPP",
+  "enc-BOYISD",
+  "enc-BOYSAW",
+  "enc-BCNLAT",
+  "enc-BCNCAR",
+  "enc-BCNSPP",
+  "enc-BCNISD",
+  "enc-BCNSAW"
+];
+function deriveMarinerName(objnam, colourCode) {
+  if (!objnam) return "";
+  const m = objnam.match(/(\d+[A-Z]?)\s*$/);
+  if (!m) return objnam;
+  const num = m[1];
+  const colourAbbr = colourCode ? COLOUR_TABLE[colourCode]?.abbr : null;
+  if (colourAbbr && colourAbbr !== "W") {
+    return `${colourAbbr} "${num}"`;
+  }
+  return `"${num}"`;
+}
+function getTopmarkMeaning(topshpCode, rawLayer) {
+  if (topshpCode == null) return null;
+  switch (topshpCode) {
+    case 10:
+      return "West cardinal \u2014 pass to the west";
+    // 2 cones, point to point
+    case 11:
+      return "East cardinal \u2014 pass to the east";
+    // 2 cones, base to base
+    case 13:
+      return "North cardinal \u2014 pass to the north";
+    // 2 cones, points up
+    case 14:
+      return "South cardinal \u2014 pass to the south";
+  }
+  const parent = rawLayer.replace(/^(BOY|BCN)/, "");
+  if (parent === "LAT") {
+    if (topshpCode === 1) return "Starboard-hand mark";
+    if (topshpCode === 5) return "Port-hand mark";
+  }
+  if (parent === "SAW" && topshpCode === 3) return "Safe water \u2014 navigable water all around";
+  if (parent === "ISD" && topshpCode === 4) return "Isolated danger \u2014 danger of limited extent";
+  if (parent === "SPP" && topshpCode === 7) return "Special-purpose mark";
+  return null;
+}
+function decodeNavAidProps(layerName, props, coords) {
+  const rawLayer = layerName.replace(/^enc-/, "").replace(/-(point|line|polygon|midpoint)$/, "");
+  const fullName = props.OBJNAM || props.NOBJNM || "";
+  const colourCode = parseCode(props.COLOUR);
+  const marinerName = deriveMarinerName(fullName, colourCode);
+  const name = marinerName || fullName;
+  const type = LAYER_TYPE_MAP[rawLayer] ?? rawLayer;
+  const lightColourSource = props.LIGHT_COLOUR ?? props.COLOUR;
+  const lightColourCodes = parseListCodes(lightColourSource);
+  const colourEntry = colourCode ? COLOUR_TABLE[colourCode] : null;
+  const lightColourHexList = lightColourCodes.map((c) => COLOUR_TABLE[c]?.hex ?? "#ffffff");
+  const boyshpCode = parseCode(props.BOYSHP);
+  const shape = boyshpCode ? BOYSHP_TABLE[boyshpCode] ?? null : null;
+  const topshpCode = parseCode(props.TOPSHP);
+  const topmark = topshpCode ? TOPSHP_TABLE[topshpCode] ?? null : null;
+  const topmarkMeaning = getTopmarkMeaning(topshpCode, rawLayer);
+  const litchrCode = parseCode(props.LITCHR);
+  const litchrEntry = litchrCode ? LITCHR_TABLE[litchrCode] : null;
+  const sigper = props.SIGPER != null ? Number(props.SIGPER) : null;
+  const group = parseGroup(props.SIGGRP);
+  const nameForFog = String(props.OBJNAM ?? "").toLowerCase();
+  let catfogCode = null;
+  if (/\bwhistle\b/.test(nameForFog)) catfogCode = 6;
+  else if (/\bgong\b/.test(nameForFog)) catfogCode = 8;
+  else if (/\bbell\b/.test(nameForFog)) catfogCode = 5;
+  else if (/\bhorn\b/.test(nameForFog)) catfogCode = 9;
+  else if (/\bsiren\b/.test(nameForFog)) catfogCode = 3;
+  else if (/diaphone/.test(nameForFog)) catfogCode = 2;
+  else if (/nautophone|nauto/.test(nameForFog)) catfogCode = 4;
+  if (!catfogCode) catfogCode = parseCode(props.CATFOG);
+  const fogSignal2 = catfogCode ? CATFOG_TABLE[catfogCode] ?? null : null;
+  const fogSignalAbbr = catfogCode ? CATFOG_ABBR_TABLE[catfogCode] ?? null : null;
+  const radarReflector = props.RETRFL != null && String(props.RETRFL) !== "0" && String(props.RETRFL) !== "";
+  const valsou = props.VALSOU != null ? Number(props.VALSOU) : null;
+  const depth = valsou != null && !isNaN(valsou) ? valsou : null;
+  const statusCode = parseCode(props.STATUS);
+  const status = statusCode ? STATUS_TABLE[statusCode] ?? null : null;
+  const marsysCode = parseCode(props.MARSYS);
+  const markingSystem = marsysCode ? MARSYS_TABLE[marsysCode] ?? null : null;
+  const catlamCode = parseCode(props.CATLAM);
+  const catcamCode = parseCode(props.CATCAM);
+  const cathafCode = parseCode(props.CATHAF);
+  const catscfCode = parseCode(props.CATSCF);
+  const catcrnCode = parseCode(props.CATCRN);
+  const catlmkNames = parseListCodes(props.CATLMK).map((c) => CATLMK_TABLE[c]).filter((n) => Boolean(n));
+  const category = catlamCode ? CATLAM_TABLE[catlamCode] ?? null : catcamCode ? CATCAM_TABLE[catcamCode] ?? null : cathafCode ? CATHAF_TABLE[cathafCode] ?? null : catscfCode ? CATSCF_TABLE[catscfCode] ?? null : catcrnCode ? CATCRN_TABLE[catcrnCode] ?? null : catlmkNames.length > 0 ? catlmkNames.join(" / ") : null;
+  const information = props.INFORM || null;
+  const lightColourAbbrs = lightColourCodes.map((c) => COLOUR_TABLE[c]?.abbr).filter(Boolean);
+  const notation = buildNotation(litchrEntry?.abbr ?? null, lightColourAbbrs, sigper, group);
+  const sectr1 = props.SECTR1 != null ? Number(props.SECTR1) : null;
+  const sectr2 = props.SECTR2 != null ? Number(props.SECTR2) : null;
+  const orient = props.ORIENT != null ? Number(props.ORIENT) : null;
+  const catlit = parseCode(props.CATLIT);
+  const isDirectional = catlit === 1;
+  const sectors = [];
+  const isSectorLight = sectr1 != null && sectr2 != null && !isNaN(sectr1) && !isNaN(sectr2);
+  const valnmr = props.VALNMR != null ? Number(props.VALNMR) : null;
+  const nominalRange = valnmr != null && !isNaN(valnmr) && valnmr > 0 ? valnmr : null;
+  if (isSectorLight) {
+    sectors.push({
+      sectorStart: sectr1,
+      sectorEnd: sectr2,
+      colour: colourEntry?.name ?? "White",
+      colourHex: colourEntry?.hex ?? "#ffffff",
+      notation,
+      nominalRange
+    });
+  }
+  return {
+    name,
+    fullName: fullName && fullName !== name ? fullName : null,
+    type,
+    layerName: rawLayer,
+    colour: colourEntry?.name ?? null,
+    colourHex: colourEntry?.hex ?? "#ffffff",
+    lightColourHex: lightColourHexList[0] ?? colourEntry?.hex ?? "#ffffff",
+    colourHexList: lightColourHexList.length > 0 ? lightColourHexList : [colourEntry?.hex ?? "#ffffff"],
+    shape,
+    topmark,
+    topmarkMeaning,
+    lightCharacter: litchrEntry?.abbr ?? null,
+    lightCharacterFull: litchrEntry?.name ?? null,
+    period: sigper,
+    group,
+    fogSignal: fogSignal2,
+    fogSignalAbbr,
+    radarReflector,
+    depth,
+    status,
+    markingSystem,
+    category,
+    information,
+    notation,
+    coordinates: coords ?? null,
+    sectors,
+    orientation: orient != null && !isNaN(orient) ? orient : null,
+    isDirectional,
+    isSectorLight
+  };
+}
+function buildNotation(litchrAbbr, colourAbbrs, sigper, group) {
+  if (!litchrAbbr) return "";
+  const parts = [];
+  let charPart = litchrAbbr;
+  const totalFlashes = group ? group.reduce((a, b) => a + b, 0) : 0;
+  if (totalFlashes > 1) charPart += `(${group.join("+")})`;
+  parts.push(charPart);
+  if (colourAbbrs.length > 0) parts.push(colourAbbrs.join("."));
+  if (sigper && sigper > 0) parts.push(`${sigper}s`);
+  return parts.join(" ");
+}
+function buildFlashPattern(decoded) {
+  const litchr = decoded.lightCharacter;
+  if (!litchr) return null;
+  const period = decoded.period && decoded.period > 0 ? decoded.period * 1e3 : 6e3;
+  const groups = decoded.group ?? [1];
+  const totalFlashes = groups.reduce((a, b) => a + b, 0);
+  const hex = decoded.lightColourHex;
+  const colours = decoded.colourHexList;
+  const notation = decoded.notation;
+  const phases = [];
+  switch (litchr) {
+    case "F": {
+      phases.push({ on: true, duration: period, color: hex });
+      break;
+    }
+    case "Fl":
+    case "S.Fl": {
+      const flashDur = 400;
+      const interFlashGap = 300;
+      const interGroupGap = 800;
+      const activeDur = groups.reduce((sum, g) => sum + g * flashDur + (g - 1) * interFlashGap, 0) + (groups.length - 1) * interGroupGap;
+      const eclipseDur = Math.max(period - activeDur, 500);
+      for (let gi = 0; gi < groups.length; gi++) {
+        const g = groups[gi];
+        for (let i = 0; i < g; i++) {
+          phases.push({ on: true, duration: flashDur, color: hex });
+          if (i < g - 1) phases.push({ on: false, duration: interFlashGap });
+        }
+        if (gi < groups.length - 1) phases.push({ on: false, duration: interGroupGap });
+      }
+      phases.push({ on: false, duration: eclipseDur });
+      break;
+    }
+    case "LFl":
+    case "S.LFl": {
+      const onDur = 2e3;
+      phases.push({ on: true, duration: onDur, color: hex });
+      phases.push({ on: false, duration: Math.max(period - onDur, 1e3) });
+      break;
+    }
+    case "Oc": {
+      const offDur = 400;
+      const interGroupOn = 300;
+      const interGroupGap = 800;
+      const totalOcclusions = totalFlashes;
+      const activeDur = totalOcclusions * offDur + (totalOcclusions - 1) * interGroupOn + (groups.length > 1 ? (groups.length - 1) * (interGroupGap - interGroupOn) : 0);
+      const onDur = Math.max(period - activeDur, 500);
+      phases.push({ on: true, duration: onDur, color: hex });
+      for (let gi = 0; gi < groups.length; gi++) {
+        const g = groups[gi];
+        for (let i = 0; i < g; i++) {
+          phases.push({ on: false, duration: offDur });
+          if (i < g - 1) phases.push({ on: true, duration: interGroupOn, color: hex });
+        }
+        if (gi < groups.length - 1) phases.push({ on: true, duration: interGroupGap, color: hex });
+      }
+      break;
+    }
+    case "Iso": {
+      const half = period / 2;
+      phases.push({ on: true, duration: half, color: hex });
+      phases.push({ on: false, duration: half });
+      break;
+    }
+    case "Q": {
+      const cycleDur = 1e3;
+      const count = Math.max(totalFlashes, 1);
+      if (count === 1) {
+        phases.push({ on: true, duration: cycleDur / 2, color: hex });
+        phases.push({ on: false, duration: cycleDur / 2 });
+      } else {
+        const flashDur = 250;
+        const gap = 250;
+        for (let i = 0; i < count; i++) {
+          phases.push({ on: true, duration: flashDur, color: hex });
+          if (i < count - 1) phases.push({ on: false, duration: gap });
+        }
+        phases.push({ on: false, duration: Math.max(period - count * (flashDur + gap), 500) });
+      }
+      break;
+    }
+    case "VQ": {
+      const flashDur = 150;
+      const gap = 150;
+      const count = Math.max(totalFlashes, 1);
+      if (count === 1) {
+        phases.push({ on: true, duration: flashDur, color: hex });
+        phases.push({ on: false, duration: gap });
+      } else {
+        for (let i = 0; i < count; i++) {
+          phases.push({ on: true, duration: flashDur, color: hex });
+          if (i < count - 1) phases.push({ on: false, duration: gap });
+        }
+        phases.push({ on: false, duration: Math.max(period - count * (flashDur + gap), 500) });
+      }
+      break;
+    }
+    case "UQ": {
+      const flashDur = 80;
+      const gap = 80;
+      phases.push({ on: true, duration: flashDur, color: hex });
+      phases.push({ on: false, duration: gap });
+      break;
+    }
+    case "Mo": {
+      const dot = 300;
+      const dash = 900;
+      const gap = 300;
+      phases.push({ on: true, duration: dot, color: hex });
+      phases.push({ on: false, duration: gap });
+      phases.push({ on: true, duration: dash, color: hex });
+      phases.push({ on: false, duration: gap });
+      phases.push({ on: true, duration: dot, color: hex });
+      phases.push({ on: false, duration: Math.max(period - 3 * gap - dot * 2 - dash, 1e3) });
+      break;
+    }
+    case "Al":
+    case "Al.Gp":
+    case "Al.Fl":
+    case "Al.LFl":
+    case "Al.Oc":
+    case "Al.F.Fl": {
+      const isFlashing = litchr.includes("Fl") || litchr === "Al.Gp";
+      const isOcculting = litchr.includes("Oc");
+      const isFixed = litchr === "Al" || litchr === "Al.F.Fl";
+      if (isFlashing && totalFlashes > 1) {
+        const flashDur = 400;
+        const interFlashGap = 300;
+        const interGroupGap = 800;
+        const activeDur = groups.reduce((sum, g) => sum + g * flashDur + (g - 1) * interFlashGap, 0) + (groups.length - 1) * interGroupGap;
+        const eclipseDur = Math.max(period - activeDur, 500);
+        for (let gi = 0; gi < groups.length; gi++) {
+          const g = groups[gi];
+          const groupColour = colours[gi % colours.length];
+          for (let i = 0; i < g; i++) {
+            phases.push({ on: true, duration: flashDur, color: groupColour });
+            if (i < g - 1) phases.push({ on: false, duration: interFlashGap });
+          }
+          if (gi < groups.length - 1) phases.push({ on: false, duration: interGroupGap });
+        }
+        phases.push({ on: false, duration: eclipseDur });
+      } else if (isOcculting) {
+        const numColours = Math.max(colours.length, 2);
+        const offDur = 400;
+        const onDur = (period - numColours * offDur) / numColours;
+        for (let i = 0; i < numColours; i++) {
+          phases.push({ on: true, duration: Math.max(onDur, 300), color: colours[i % colours.length] });
+          phases.push({ on: false, duration: offDur });
+        }
+      } else if (isFixed) {
+        const numColours = Math.max(colours.length, 2);
+        const phaseDur = period / numColours;
+        for (let i = 0; i < numColours; i++) {
+          phases.push({ on: true, duration: phaseDur, color: colours[i % colours.length] });
+        }
+      } else {
+        const numColours = Math.max(colours.length, 2);
+        const phaseDur = period / numColours;
+        for (let i = 0; i < numColours; i++) {
+          phases.push({ on: true, duration: phaseDur, color: colours[i % colours.length] });
+        }
+      }
+      break;
+    }
+    default: {
+      phases.push({ on: true, duration: 500, color: hex });
+      phases.push({ on: false, duration: Math.max(period - 500, 500) });
+      break;
+    }
+  }
+  const totalCycle = phases.reduce((sum, p) => sum + p.duration, 0);
+  return { phases, totalCycle, notation };
+}
+function buildSectorsFromFeatures(features) {
+  const sectors = [];
+  for (const f of features) {
+    const props = f.properties ?? {};
+    const s1 = props.SECTR1 != null ? Number(props.SECTR1) : null;
+    const s2 = props.SECTR2 != null ? Number(props.SECTR2) : null;
+    if (s1 == null || s2 == null || isNaN(s1) || isNaN(s2)) continue;
+    const colourCode = parseCode(props.COLOUR);
+    const ce = colourCode ? COLOUR_TABLE[colourCode] : null;
+    const litchrCode = parseCode(props.LITCHR);
+    const le = litchrCode ? LITCHR_TABLE[litchrCode] : null;
+    const sigper = props.SIGPER != null ? Number(props.SIGPER) : null;
+    const group = parseGroup(props.SIGGRP);
+    const notation = buildNotation(le?.abbr ?? null, ce ? [ce.abbr] : [], sigper, group);
+    const valnmr = props.VALNMR != null ? Number(props.VALNMR) : null;
+    const nominalRange = valnmr != null && !isNaN(valnmr) && valnmr > 0 ? valnmr : null;
+    sectors.push({
+      sectorStart: s1,
+      sectorEnd: s2,
+      colour: ce?.name ?? "White",
+      colourHex: ce?.hex ?? "#ffffff",
+      notation,
+      nominalRange
+    });
+  }
+  return sectors;
+}
+function buildSectorArcGeoJSON(center, startBearing, endBearing, radiusNm = 0.5, innerRadiusNm = 0, steps = 64) {
+  const radiusDeg = radiusNm / 60;
+  const innerDeg = innerRadiusNm > 0 ? innerRadiusNm / 60 : 0;
+  const [lng, lat] = center;
+  const cosLat = Math.cos(lat * Math.PI / 180);
+  const s = (startBearing % 360 + 360) % 360;
+  const e = (endBearing % 360 + 360) % 360;
+  let sweep = e - s;
+  if (sweep <= 0) sweep += 360;
+  const project = (bearingDeg, rDeg) => {
+    const rad = bearingDeg * Math.PI / 180;
+    return [
+      lng + rDeg * Math.sin(rad) / cosLat,
+      lat + rDeg * Math.cos(rad)
+    ];
+  };
+  const outerCoords = [];
+  for (let i = 0; i <= steps; i++) {
+    outerCoords.push(project(s + sweep * i / steps, radiusDeg));
+  }
+  let ring;
+  if (innerDeg > 0) {
+    const innerCoords = [];
+    for (let i = steps; i >= 0; i--) {
+      innerCoords.push(project(s + sweep * i / steps, innerDeg));
+    }
+    ring = [...outerCoords, ...innerCoords, outerCoords[0]];
+  } else {
+    ring = [[lng, lat], ...outerCoords, [lng, lat]];
+  }
+  return {
+    type: "Feature",
+    properties: {},
+    geometry: {
+      type: "Polygon",
+      coordinates: [ring]
+    }
+  };
+}
+function buildSectorArcsFC(center, sectors, radiusNm = 0.4, innerRadiusFrac = 0.92) {
+  const innerNm = innerRadiusFrac > 0 ? radiusNm * innerRadiusFrac : 0;
+  const features = sectors.map((sec, i) => {
+    const arc = buildSectorArcGeoJSON(center, sec.sectorStart, sec.sectorEnd, radiusNm, innerNm);
+    arc.properties = {
+      sectorIndex: i,
+      colour: sec.colour,
+      colourHex: sec.colourHex,
+      notation: sec.notation,
+      sectorStart: sec.sectorStart,
+      sectorEnd: sec.sectorEnd,
+      nominalRange: sec.nominalRange ?? null
+    };
+    return arc;
+  });
+  const lineFeatures = [];
+  const labelFeatures = [];
+  const seenBearings = /* @__PURE__ */ new Set();
+  const TICK_OUTER_OVERHANG = 1.05;
+  const TICK_INNER_OVERHANG = 0.93;
+  for (const sec of sectors) {
+    for (const bearing of [sec.sectorStart, sec.sectorEnd]) {
+      const rad = bearing * Math.PI / 180;
+      const radiusDeg = radiusNm / 60;
+      const innerRadiusDeg = innerNm > 0 ? innerNm / 60 : 0;
+      const cosLat = Math.cos(center[1] * Math.PI / 180);
+      const sinB = Math.sin(rad);
+      const cosB = Math.cos(rad);
+      const tickOuterDeg = radiusDeg * TICK_OUTER_OVERHANG;
+      const outerPt = [
+        center[0] + tickOuterDeg * sinB / cosLat,
+        center[1] + tickOuterDeg * cosB
+      ];
+      const tickInnerDeg = innerRadiusDeg > 0 ? Math.min(innerRadiusDeg * TICK_INNER_OVERHANG, innerRadiusDeg) : 0;
+      const innerPt = tickInnerDeg > 0 ? [center[0] + tickInnerDeg * sinB / cosLat, center[1] + tickInnerDeg * cosB] : center;
+      lineFeatures.push({
+        type: "Feature",
+        properties: { type: "sector-boundary" },
+        geometry: {
+          type: "LineString",
+          coordinates: [innerPt, outerPt]
+        }
+      });
+      const roundedBearing = Math.round(bearing * 10) / 10;
+      if (!seenBearings.has(roundedBearing)) {
+        seenBearings.add(roundedBearing);
+        const labelRadius = radiusDeg * 1.12;
+        const ldlat = labelRadius * Math.cos(rad);
+        const ldlng = labelRadius * Math.sin(rad) / cosLat;
+        labelFeatures.push({
+          type: "Feature",
+          properties: {
+            type: "bearing-label",
+            bearing: `${roundedBearing}\xB0`,
+            bearingDeg: roundedBearing
+          },
+          geometry: {
+            type: "Point",
+            coordinates: [center[0] + ldlng, center[1] + ldlat]
+          }
+        });
+      }
+    }
+  }
+  const rangeRingFeatures = [];
+  const seenRanges = /* @__PURE__ */ new Set();
+  for (const sec of sectors) {
+    if (sec.nominalRange != null && sec.nominalRange > 0 && !seenRanges.has(sec.nominalRange)) {
+      seenRanges.add(sec.nominalRange);
+      const rangeDeg = sec.nominalRange / 60;
+      const cosLat = Math.cos(center[1] * Math.PI / 180);
+      const ringCoords = [];
+      const ringSteps = 72;
+      for (let i = 0; i <= ringSteps; i++) {
+        const angle = 360 * i / ringSteps;
+        const rad = angle * Math.PI / 180;
+        const dlat = rangeDeg * Math.cos(rad);
+        const dlng = rangeDeg * Math.sin(rad) / cosLat;
+        ringCoords.push([center[0] + dlng, center[1] + dlat]);
+      }
+      rangeRingFeatures.push({
+        type: "Feature",
+        properties: { type: "range-ring", nominalRange: sec.nominalRange },
+        geometry: { type: "LineString", coordinates: ringCoords }
+      });
+      rangeRingFeatures.push({
+        type: "Feature",
+        properties: { type: "range-label", rangeLabel: `${sec.nominalRange} NM` },
+        geometry: { type: "Point", coordinates: [center[0], center[1] + rangeDeg] }
+      });
+    }
+  }
+  return {
+    type: "FeatureCollection",
+    features: [...features, ...lineFeatures, ...labelFeatures, ...rangeRingFeatures]
+  };
+}
+
+// src/interact/notices.ts
+var NON_SOLAS_DISCLAIMER = "\u26A0\uFE0F CHRT data is derived from official electronic navigational charts but is NOT FOR PRIMARY NAVIGATION and is NOT SOLAS-compliant. Always use official, type-approved ECDIS or paper charts for navigation safety. CHRT provides situational awareness data only.";
+var NON_SOLAS_DISCLAIMER_SHORT = "Not for primary navigation";
+function baseNotice() {
+  return {
+    disclaimer: NON_SOLAS_DISCLAIMER,
+    attribution: "Derived from official Electronic Navigational Charts issued by national hydrographic offices (e.g. NOAA).",
+    dataCurrency: "Tile attributes carry no per-feature edition/update metadata; call inspect({ enrich: true }) to resolve the source cell's edition, update_number and issue_date."
+  };
+}
+function enrichedNotice(cell) {
+  const title = cell.title ? ` \u2014 ${cell.title}` : "";
+  return {
+    disclaimer: NON_SOLAS_DISCLAIMER,
+    attribution: `Official ENC data \xA9 ${cell.chart_source} (cell ${cell.cell_id}${title}).`,
+    dataCurrency: `Edition ${cell.edition ?? "unknown"}, update ${cell.update_number ?? "unknown"}, issued ${cell.issue_date ?? "unknown"}.`
+  };
+}
+
+// src/interact/errors.ts
+var InteractError = class extends Error {
+  code;
+  status;
+  /** The team's current plan id, when the server included it (denials). */
+  plan;
+  constructor(code, message, opts) {
+    super(message);
+    this.name = "InteractError";
+    this.code = code;
+    this.status = opts?.status;
+    this.plan = opts?.plan;
+  }
+};
+
+// src/interact/inspect.ts
+var NAV_AID_RAW_LAYERS = new Set(
+  NAV_AID_QUERY_LAYERS.map((id) => stripLayerId(id))
+);
+var BRIDGE_RAW_LAYERS = new Set(BRIDGE_QUERY_LAYERS.map((id) => stripLayerId(id)));
+function stripLayerId(layerId) {
+  return layerId.replace(/^(enc|s52)-/, "").replace(/-(point|line|polygon|midpoint|outline)$/, "").replace(/-(point|line|polygon|midpoint)$/, "");
+}
+function resolveLayerId(feature, opts) {
+  if (opts?.layer) {
+    return opts.layer.includes("-") || opts.layer.startsWith("enc") ? opts.layer : `enc-${opts.layer}`;
+  }
+  const layer = feature.layer;
+  if (typeof layer === "string" && layer) {
+    return layer.includes("-") ? layer : `enc-${layer}`;
+  }
+  if (layer && typeof layer === "object" && typeof layer.id === "string" && layer.id) {
+    return layer.id;
+  }
+  if (feature.sourceLayer) return `enc-${feature.sourceLayer}`;
+  throw new InteractError(
+    "unknown_layer",
+    "inspect(): cannot determine the feature's chart layer \u2014 pass { layer } or a feature from queryRenderedFeatures()"
+  );
+}
+function resolveCoordinates(feature, opts) {
+  if (opts?.coordinates) return opts.coordinates;
+  const geom = feature.geometry;
+  if (geom && geom.type === "Point" && Array.isArray(geom.coordinates)) {
+    const [lng, lat] = geom.coordinates;
+    if (typeof lng === "number" && typeof lat === "number") return [lng, lat];
+  }
+  return null;
+}
+function navAidPropertyRows(decoded) {
+  const rows = [];
+  const push = (label, value) => {
+    if (value == null || value === "") return;
+    rows.push({ label, value: String(value) });
+  };
+  push("Colour", decoded.colour);
+  push("Shape", decoded.shape);
+  push("Topmark", decoded.topmark);
+  push("Topmark meaning", decoded.topmarkMeaning);
+  push("Light", decoded.lightCharacterFull);
+  push("Characteristic", decoded.notation || null);
+  if (decoded.orientation != null) push("Orientation", `${decoded.orientation}\xB0`);
+  push("Fog Signal", decoded.fogSignal);
+  if (decoded.radarReflector) push("Radar", "Reflector");
+  if (decoded.depth != null) push("Depth", `${decoded.depth}m`);
+  push("Status", decoded.status);
+  push("System", decoded.markingSystem);
+  push("Category", decoded.category);
+  return rows;
+}
+function bridgePropertyRows(decoded) {
+  const rows = [];
+  const push = (label, value) => {
+    if (value == null || value === "") return;
+    rows.push({ label, value });
+  };
+  push("Category", decoded.categoryLabel);
+  if (decoded.verticalClearanceClosed != null && decoded.verticalClearanceOpen != null) {
+    push(
+      "Vertical clearance",
+      `Closed: ${decoded.verticalClearanceClosed}m / Open: ${decoded.verticalClearanceOpen}m`
+    );
+  } else if (decoded.verticalClearance != null) {
+    push("Vertical clearance", `${decoded.verticalClearance}m`);
+  } else if (decoded.verticalClearanceClosed != null) {
+    push("Vertical clearance", `${decoded.verticalClearanceClosed}m (closed)`);
+  } else if (decoded.verticalClearanceOpen != null) {
+    push("Vertical clearance", `${decoded.verticalClearanceOpen}m (open)`);
+  }
+  if (decoded.horizontalClearance != null) {
+    push("Horizontal clearance", `${decoded.horizontalClearance}m`);
+  }
+  push("Status", decoded.status);
+  push("Condition", decoded.condition);
+  push("National name", decoded.nationalName);
+  push("Source", decoded.sourceIndication);
+  push("Source date", decoded.sourceDate);
+  return rows;
+}
+function buildInspectResult(feature, opts) {
+  const layerId = resolveLayerId(feature, opts);
+  const rawLayer = stripLayerId(layerId);
+  const props = { ...feature.properties ?? {} };
+  const coords = resolveCoordinates(feature, opts);
+  const notice = baseNotice();
+  if (BRIDGE_RAW_LAYERS.has(rawLayer)) {
+    const bridge = decodeBridgeProps(props);
+    const result2 = {
+      kind: "bridge",
+      layer: "BRIDGE",
+      layerId,
+      objectClass: bridge.categoryLabel ?? "Bridge",
+      title: bridge.name || bridge.categoryLabel || "Bridge",
+      coordinates: coords,
+      properties: bridgePropertyRows(bridge),
+      raw: props,
+      notice,
+      enrichment: null,
+      bridge
+    };
+    return result2;
+  }
+  if (NAV_AID_RAW_LAYERS.has(rawLayer)) {
+    const navAid = decodeNavAidProps(layerId, props, coords ?? void 0);
+    const flashPattern = buildFlashPattern(navAid);
+    const result2 = {
+      kind: "navaid",
+      layer: navAid.layerName,
+      layerId,
+      objectClass: navAid.type,
+      title: navAid.fullName || navAid.name || navAid.type,
+      coordinates: navAid.coordinates,
+      properties: navAidPropertyRows(navAid),
+      raw: props,
+      notice,
+      enrichment: null,
+      navAid,
+      characteristic: navAid.notation || null,
+      flashPattern
+    };
+    return result2;
+  }
+  const area = decodeAreaFeatureProps(layerId, props);
+  const result = {
+    kind: "area",
+    layer: rawLayer,
+    layerId,
+    objectClass: area.type,
+    title: area.title,
+    coordinates: coords,
+    properties: area.properties,
+    raw: props,
+    notice,
+    enrichment: null,
+    area
+  };
+  return result;
+}
+
+// src/interact/attach.ts
+function bboxAround(point, pad) {
+  return [
+    [point.x - pad, point.y - pad],
+    [point.x + pad, point.y + pad]
+  ];
+}
+function existingLayers(map, ids) {
+  return ids.filter((id) => {
+    try {
+      return Boolean(map.getLayer(id));
+    } catch {
+      return false;
+    }
+  });
+}
+function query(map, geometry, layers) {
+  if (layers.length === 0) return [];
+  try {
+    return map.queryRenderedFeatures(geometry, { layers }) ?? [];
+  } catch {
+    return [];
+  }
+}
+function featureLayerId(f) {
+  const layer = f.layer;
+  if (layer && typeof layer === "object" && typeof layer.id === "string") return layer.id;
+  if (typeof layer === "string") return layer;
+  return f.sourceLayer ? `enc-${f.sourceLayer}` : "";
+}
+function decodeClickedNavAid(map, feature, e, navAidLayers) {
+  const layerId = featureLayerId(feature);
+  const props = { ...feature.properties ?? {} };
+  const geom = feature.geometry;
+  const coords = geom?.type === "Point" && Array.isArray(geom.coordinates) ? [geom.coordinates[0], geom.coordinates[1]] : [e.lngLat.lng, e.lngLat.lat];
+  const rawLayer = stripLayerId(layerId);
+  if (!props.OBJNAM && CHILD_LAYERS.has(rawLayer)) {
+    const parentLayers = existingLayers(map, PARENT_LAYERS);
+    const parents = query(map, bboxAround(e.point, 8), parentLayers);
+    for (const p of parents) {
+      const pName = p.properties?.OBJNAM;
+      if (pName) {
+        props.OBJNAM = pName;
+        if (!props.COLOUR && p.properties?.COLOUR) {
+          props.COLOUR = p.properties.COLOUR;
+        }
+        break;
+      }
+    }
+  }
+  if (!props.CATFOG) {
+    const fogFeats = query(map, bboxAround(e.point, 10), existingLayers(map, ["enc-FOGSIG"]));
+    for (const f of fogFeats) {
+      if (f.properties?.CATFOG) {
+        props.CATFOG = f.properties.CATFOG;
+        break;
+      }
+    }
+  }
+  if (!props.RETRFL) {
+    const radarFeats = query(map, bboxAround(e.point, 10), existingLayers(map, ["enc-RTPBCN"]));
+    if (radarFeats.length > 0) props.RETRFL = "1";
+  }
+  if (!props.TOPSHP) {
+    const topmarFeats = query(map, bboxAround(e.point, 10), existingLayers(map, ["enc-TOPMAR"]));
+    for (const f of topmarFeats) {
+      if (f.properties?.TOPSHP) {
+        props.TOPSHP = f.properties.TOPSHP;
+        break;
+      }
+    }
+  }
+  const lightLayerIds = existingLayers(
+    map,
+    navAidLayers.filter((id) => id === "enc-LIGHTS" || id === "enc-LIGHTS-point")
+  );
+  let coLocatedLightFeats = null;
+  const isLightsLayer = layerId.includes("LIGHTS");
+  if (!props.LITCHR) {
+    const lightFeats = query(map, bboxAround(e.point, 10), lightLayerIds);
+    if (lightFeats.length > 0) {
+      coLocatedLightFeats = lightFeats;
+      let primaryLight = null;
+      for (const lf of lightFeats) {
+        if (lf.properties?.LITCHR) {
+          if (!lf.properties?.SECTR1 && !lf.properties?.SECTR2) {
+            primaryLight = lf;
+            break;
+          }
+          if (!primaryLight) primaryLight = lf;
+        }
+      }
+      if (primaryLight?.properties) {
+        props.LITCHR = primaryLight.properties.LITCHR;
+        if (!props.SIGPER && primaryLight.properties.SIGPER) props.SIGPER = primaryLight.properties.SIGPER;
+        if (!props.SIGGRP && primaryLight.properties.SIGGRP) props.SIGGRP = primaryLight.properties.SIGGRP;
+        if (primaryLight.properties.COLOUR) props.LIGHT_COLOUR = primaryLight.properties.COLOUR;
+        if (primaryLight.properties.CATLIT) props.CATLIT = primaryLight.properties.CATLIT;
+      }
+    }
+  }
+  const result = buildInspectResult(
+    { ...feature, properties: props },
+    { layer: layerId, coordinates: coords }
+  );
+  if (result.kind === "navaid") {
+    let sectorSources = null;
+    if (isLightsLayer) {
+      const nearby = query(map, bboxAround(e.point, 12), lightLayerIds);
+      if (nearby.length > 1) sectorSources = nearby;
+    } else if (coLocatedLightFeats && coLocatedLightFeats.length > 0) {
+      sectorSources = coLocatedLightFeats;
+    }
+    if (sectorSources) {
+      const sectors = buildSectorsFromFeatures(
+        sectorSources.map((f) => ({ properties: f.properties ?? {} }))
+      );
+      if (sectors.length > 0) {
+        result.navAid.sectors = sectors;
+        result.navAid.isSectorLight = true;
+      }
+    }
+  }
+  return result;
+}
+function decodeClick(map, e, opts) {
+  const navAidLayers = opts.navAidLayers ?? NAV_AID_QUERY_LAYERS;
+  const bridgeLayers = opts.bridgeLayers ?? BRIDGE_QUERY_LAYERS;
+  const areaLayers = opts.areaLayers ?? AREA_QUERY_LAYERS;
+  const navFeatures = query(map, e.point, existingLayers(map, navAidLayers));
+  if (navFeatures.length > 0) {
+    const feature = navFeatures[0];
+    return { result: decodeClickedNavAid(map, feature, e, navAidLayers), feature };
+  }
+  const bridgeFeatures = query(map, e.point, existingLayers(map, bridgeLayers));
+  if (bridgeFeatures.length > 0) {
+    const feature = bridgeFeatures[0];
+    const result = buildInspectResult(feature, {
+      layer: featureLayerId(feature) || "enc-BRIDGE",
+      coordinates: [e.lngLat.lng, e.lngLat.lat]
+    });
+    return { result, feature };
+  }
+  const areaFeatures = query(map, e.point, existingLayers(map, areaLayers));
+  if (areaFeatures.length > 0) {
+    const feature = areaFeatures[0];
+    const result = buildInspectResult(feature, {
+      layer: featureLayerId(feature),
+      coordinates: [e.lngLat.lng, e.lngLat.lat]
+    });
+    return { result, feature };
+  }
+  return null;
+}
+
+// src/interact/entitlement.ts
+function mapDenialCode(raw, status) {
+  if (raw === "interact_not_enabled") return "interact_not_enabled";
+  if (status === 401) return "invalid_api_key";
+  if (status === 403) return "missing_scope";
+  return "unexpected_response";
+}
+var EntitlementClient = class {
+  constructor(http) {
+    this.http = http;
+  }
+  cached = null;
+  pending = null;
+  /**
+   * Check (and cache) the interact entitlement for this client's API key.
+   * Concurrent callers share one in-flight request; a denial is NOT cached so
+   * a plan upgrade takes effect on the next call.
+   */
+  async check() {
+    if (this.cached) return this.cached;
+    if (this.pending) return this.pending;
+    this.pending = (async () => {
+      try {
+        const result = await this.checkOnce();
+        this.cached = result;
+        return result;
+      } finally {
+        this.pending = null;
+      }
+    })();
+    return this.pending;
+  }
+  async checkOnce() {
+    let res;
+    try {
+      res = await this.http.postJson("/interact/entitlement", {});
+    } catch (err) {
+      throw new InteractError(
+        "network_error",
+        err instanceof Error ? err.message : "entitlement request failed"
+      );
+    }
+    if (!res.ok) {
+      const code = mapDenialCode(res.body?.error, res.status);
+      const message = typeof res.body?.message === "string" ? res.body.message : code === "interact_not_enabled" ? "CHRTinteract requires the Dev plan or above. Upgrade at https://chrt.co/pricing." : `entitlement check failed (HTTP ${res.status})`;
+      const plan = typeof res.body?.plan === "string" ? res.body.plan : void 0;
+      throw new InteractError(code, message, { status: res.status, plan });
+    }
+    if (res.body?.enabled !== true) {
+      throw new InteractError(
+        "unexpected_response",
+        "entitlement endpoint returned a malformed body",
+        { status: res.status }
+      );
+    }
+    return {
+      enabled: true,
+      ...typeof res.body.plan === "string" ? { plan: res.body.plan } : {}
+    };
+  }
+  /** Drop the cached grant (e.g. after an API-key swap in tests). */
+  reset() {
+    this.cached = null;
+    this.pending = null;
+  }
+};
+
+// src/interact/enrich.ts
+var ENRICH_BBOX_PAD_DEG = 1e-3;
+var ENRICH_LIMIT = 5;
+function featurePoint(f) {
+  if (f.geometry?.type === "Point" && Array.isArray(f.geometry.coordinates)) {
+    const [lng, lat] = f.geometry.coordinates;
+    if (typeof lng === "number" && typeof lat === "number") return [lng, lat];
+  }
+  return null;
+}
+function distSq(a, b) {
+  return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2;
+}
+function matchEnrichedFeature(candidates, raw, coords) {
+  if (candidates.length === 0) return null;
+  const objnam = typeof raw.OBJNAM === "string" && raw.OBJNAM ? raw.OBJNAM : null;
+  if (objnam) {
+    const byName = candidates.find(
+      (f) => f.properties?.OBJNAM === objnam
+    );
+    if (byName) return byName;
+  }
+  if (coords) {
+    let best = null;
+    let bestD = Infinity;
+    for (const f of candidates) {
+      const pt = featurePoint(f);
+      if (!pt) continue;
+      const d = distSq(pt, coords);
+      if (d < bestD) {
+        bestD = d;
+        best = f;
+      }
+    }
+    if (best) return best;
+  }
+  return candidates[0];
+}
+async function enrichResult(http, result, signal) {
+  const coords = result.coordinates;
+  if (!coords) {
+    throw new InteractError(
+      "enrich_failed",
+      "enrich: the feature has no coordinates to look up \u2014 pass { coordinates } to inspect()"
+    );
+  }
+  const [lng, lat] = coords;
+  const bbox = [
+    lng - ENRICH_BBOX_PAD_DEG,
+    lat - ENRICH_BBOX_PAD_DEG,
+    lng + ENRICH_BBOX_PAD_DEG,
+    lat + ENRICH_BBOX_PAD_DEG
+  ].join(",");
+  let fc;
+  try {
+    fc = await http.request(
+      "/features",
+      { bbox, layer: result.layer, limit: ENRICH_LIMIT },
+      signal
+    );
+  } catch (err) {
+    if (err instanceof ChrtError) {
+      throw new InteractError("enrich_failed", `features lookup failed: ${err.message}`, {
+        status: err.status
+      });
+    }
+    throw new InteractError(
+      "network_error",
+      err instanceof Error ? err.message : "features lookup failed"
+    );
+  }
+  const matched = matchEnrichedFeature(fc.features ?? [], result.raw, coords);
+  const enrichment = {
+    matched: matched != null,
+    properties: matched ? matched.properties : null,
+    cellId: null,
+    cell: null
+  };
+  if (matched) {
+    const cellId = matched.properties?.cell_id;
+    if (typeof cellId === "string" && cellId) {
+      enrichment.cellId = cellId;
+      try {
+        const cell = await http.request(
+          `/cells/${encodeURIComponent(cellId)}`,
+          void 0,
+          signal
+        );
+        enrichment.cell = cell;
+        result.notice = enrichedNotice(cell);
+      } catch {
+      }
+    }
+  }
+  result.enrichment = enrichment;
+  return result;
+}
+
+// src/interact/popup.ts
+var POPUP_CLASS = "chrt-interact-popup";
+var POPUP_CSS = `
+.${POPUP_CLASS} {
+  position: absolute;
+  z-index: 40;
+  min-width: 220px;
+  max-width: 320px;
+  transform: translate(-50%, calc(-100% - 12px));
+  background: var(--chrt-interact-bg, #0b1524);
+  color: var(--chrt-interact-fg, #e2e8f0);
+  border: 1px solid var(--chrt-interact-border, rgba(148, 163, 184, 0.25));
+  border-radius: 8px;
+  box-shadow: 0 8px 24px rgba(0, 0, 0, 0.45);
+  font: 12px/1.45 var(--chrt-interact-font, ui-sans-serif, system-ui, sans-serif);
+  pointer-events: auto;
+}
+.${POPUP_CLASS} * { box-sizing: border-box; }
+.${POPUP_CLASS}__inner { padding: 10px 12px 8px; }
+.${POPUP_CLASS}__close {
+  position: absolute; top: 4px; right: 6px;
+  border: 0; background: none; color: inherit; opacity: 0.55;
+  font-size: 14px; line-height: 1; cursor: pointer; padding: 4px;
+}
+.${POPUP_CLASS}__close:hover { opacity: 1; }
+.${POPUP_CLASS}__title { font-weight: 600; font-size: 13px; padding-right: 16px; }
+.${POPUP_CLASS}__subtitle { color: var(--chrt-interact-muted, #94a3b8); margin-top: 1px; }
+.${POPUP_CLASS}__badge {
+  display: inline-flex; align-items: center; gap: 6px;
+  margin-top: 6px; padding: 2px 8px;
+  border: 1px solid var(--chrt-interact-border, rgba(148, 163, 184, 0.25));
+  border-radius: 4px;
+  font-family: var(--chrt-interact-mono, ui-monospace, monospace);
+  font-weight: 600; font-size: 11px;
+}
+.${POPUP_CLASS}__dot {
+  width: 10px; height: 10px; border-radius: 50%;
+  background: #555; opacity: 0.15;
+}
+.${POPUP_CLASS}__rows { margin-top: 8px; border-top: 1px solid var(--chrt-interact-border, rgba(148,163,184,0.18)); padding-top: 6px; }
+.${POPUP_CLASS}__row { display: flex; justify-content: space-between; gap: 12px; padding: 1px 0; }
+.${POPUP_CLASS}__label { color: var(--chrt-interact-muted, #94a3b8); flex-shrink: 0; }
+.${POPUP_CLASS}__value { text-align: right; font-weight: 500; }
+.${POPUP_CLASS}__info { margin-top: 4px; font-style: italic; color: var(--chrt-interact-muted, #94a3b8); font-size: 11px; }
+.${POPUP_CLASS}__footer {
+  margin-top: 8px; padding: 6px 12px 8px;
+  border-top: 1px solid var(--chrt-interact-border, rgba(148,163,184,0.18));
+  color: var(--chrt-interact-muted, #94a3b8);
+  font-size: 10px;
+}
+.${POPUP_CLASS}__footer strong { color: var(--chrt-interact-warn, #fbbf24); font-weight: 600; }
+`;
+var styleInjected = false;
+function ensureStyles(doc) {
+  if (styleInjected && doc.getElementById(`${POPUP_CLASS}-style`)) return;
+  const style = doc.createElement("style");
+  style.id = `${POPUP_CLASS}-style`;
+  style.textContent = POPUP_CSS;
+  doc.head.appendChild(style);
+  styleInjected = true;
+}
+function el(doc, tag, className, text) {
+  const node = doc.createElement(tag);
+  node.className = className;
+  if (text != null) node.textContent = text;
+  return node;
+}
+function animateDot(dot, pattern) {
+  if (pattern.totalCycle <= 0 || typeof requestAnimationFrame === "undefined") {
+    return () => void 0;
+  }
+  let raf = 0;
+  const start = performance.now();
+  const tick = (now2) => {
+    const elapsed = (now2 - start) % pattern.totalCycle;
+    let acc = 0;
+    let phase = pattern.phases[0];
+    for (const p of pattern.phases) {
+      acc += p.duration;
+      if (elapsed < acc) {
+        phase = p;
+        break;
+      }
+    }
+    if (phase.on) {
+      const color = phase.color || "#ffffff";
+      dot.style.opacity = "1";
+      dot.style.backgroundColor = color;
+      dot.style.boxShadow = `0 0 8px 2px ${color}88`;
+    } else {
+      dot.style.opacity = "0.15";
+      dot.style.backgroundColor = "#555";
+      dot.style.boxShadow = "none";
+    }
+    raf = requestAnimationFrame(tick);
+  };
+  raf = requestAnimationFrame(tick);
+  return () => cancelAnimationFrame(raf);
+}
+var InteractPopup = class {
+  constructor(map) {
+    this.map = map;
+  }
+  root = null;
+  stopAnimation = null;
+  lngLat = null;
+  reposition = () => this.place();
+  show(result, lngLat) {
+    const container = this.map.getContainer();
+    const doc = container.ownerDocument;
+    ensureStyles(doc);
+    this.close();
+    const root = el(doc, "div", POPUP_CLASS);
+    const inner = el(doc, "div", `${POPUP_CLASS}__inner`);
+    const close = el(doc, "button", `${POPUP_CLASS}__close`, "\u2715");
+    close.setAttribute("aria-label", "Close");
+    close.addEventListener("click", () => this.close());
+    root.appendChild(close);
+    inner.appendChild(el(doc, "div", `${POPUP_CLASS}__title`, result.title));
+    const subtitleParts = [result.objectClass];
+    if (result.kind === "navaid") {
+      if (result.navAid.shape) subtitleParts.push(result.navAid.shape);
+      if (result.navAid.isSectorLight) subtitleParts.push("Sector");
+      if (result.navAid.isDirectional) subtitleParts.push("Directional");
+    }
+    inner.appendChild(
+      el(doc, "div", `${POPUP_CLASS}__subtitle`, subtitleParts.filter(Boolean).join(" \xB7 "))
+    );
+    if (result.kind === "navaid" && result.characteristic) {
+      const badge = el(doc, "div", `${POPUP_CLASS}__badge`);
+      const dot = el(doc, "span", `${POPUP_CLASS}__dot`);
+      badge.appendChild(dot);
+      badge.appendChild(doc.createTextNode(result.characteristic));
+      if (result.navAid.lightColourHex && result.navAid.lightColourHex !== "#ffffff") {
+        badge.style.color = result.navAid.lightColourHex;
+      }
+      inner.appendChild(badge);
+      if (result.flashPattern) {
+        this.stopAnimation = animateDot(dot, result.flashPattern);
+      }
+    }
+    if (result.properties.length > 0) {
+      const rows = el(doc, "div", `${POPUP_CLASS}__rows`);
+      for (const p of result.properties) {
+        const row = el(doc, "div", `${POPUP_CLASS}__row`);
+        row.appendChild(el(doc, "span", `${POPUP_CLASS}__label`, p.label));
+        row.appendChild(el(doc, "span", `${POPUP_CLASS}__value`, p.value));
+        rows.appendChild(row);
+      }
+      inner.appendChild(rows);
+    }
+    if (result.kind === "navaid" && result.navAid.information) {
+      inner.appendChild(el(doc, "div", `${POPUP_CLASS}__info`, result.navAid.information));
+    }
+    root.appendChild(inner);
+    const footer = el(doc, "div", `${POPUP_CLASS}__footer`);
+    footer.title = `${NON_SOLAS_DISCLAIMER}
+
+${result.notice.attribution}
+${result.notice.dataCurrency}`;
+    const warn = el(doc, "strong", "", `\u26A0 ${NON_SOLAS_DISCLAIMER_SHORT}`);
+    footer.appendChild(warn);
+    footer.appendChild(doc.createElement("br"));
+    footer.appendChild(doc.createTextNode(result.notice.attribution));
+    const currency = result.notice.dataCurrency;
+    if (currency.startsWith("Edition")) {
+      footer.appendChild(doc.createElement("br"));
+      footer.appendChild(doc.createTextNode(currency));
+    }
+    root.appendChild(footer);
+    const position = typeof getComputedStyle !== "undefined" ? getComputedStyle(container).position : container.style.position;
+    if (position === "static" || position === "") {
+      container.style.position = "relative";
+    }
+    container.appendChild(root);
+    this.root = root;
+    this.lngLat = lngLat;
+    this.place();
+    this.map.on("move", this.reposition);
+  }
+  place() {
+    if (!this.root || !this.lngLat) return;
+    const { x, y } = this.map.project(this.lngLat);
+    this.root.style.left = `${x}px`;
+    this.root.style.top = `${y}px`;
+  }
+  close() {
+    if (this.stopAnimation) {
+      this.stopAnimation();
+      this.stopAnimation = null;
+    }
+    if (this.root) {
+      this.map.off("move", this.reposition);
+      this.root.remove();
+      this.root = null;
+    }
+    this.lngLat = null;
+  }
+};
+
+// src/interact/index.ts
+var InteractClient = class {
+  constructor(http) {
+    this.http = http;
+    this.entitlementClient = new EntitlementClient(http);
+  }
+  entitlementClient;
+  /**
+   * Check the CHRTinteract entitlement for this API key (server-side, plan
+   * derived, cached per client). Throws `InteractError` with code
+   * `interact_not_enabled` for Free-plan teams.
+   */
+  async entitlement() {
+    return this.entitlementClient.check();
+  }
+  /**
+   * Decode a chart feature (from `queryRenderedFeatures`, the features API,
+   * or plain `{ layer, properties }`) into a typed {@link InspectResult}.
+   *
+   * The first call performs the server-side entitlement check. With
+   * `{ enrich: true }` the result is upgraded with full S-57 properties and
+   * source-cell provenance (edition / update / issue date) via the features
+   * API — metered against the key's `featureCalls` quota.
+   *
+   * @example
+   * const result = await chrt.interact.inspect(feature);
+   * if (result.kind === "navaid") console.log(result.characteristic); // "Fl R 4s"
+   */
+  async inspect(feature, opts) {
+    await this.entitlementClient.check();
+    const result = buildInspectResult(feature, opts);
+    if (opts?.enrich) {
+      return enrichResult(this.http, result, opts.signal);
+    }
+    return result;
+  }
+  /**
+   * Attach click-to-inspect to a MapLibre / Mapbox GL map rendering CHRT
+   * tiles. Resolves once the server-side entitlement check passes; rejects
+   * with `InteractError` (`interact_not_enabled` on Free plans) otherwise —
+   * no listeners are wired on denial.
+   *
+   * Headless-first: pass `onInspect` to receive every decoded
+   * {@link InspectResult} and render your own UI. Without `onInspect`, the
+   * built-in minimal popup is shown (opt back in explicitly with
+   * `popup: true` to have both).
+   *
+   * @example
+   * const handle = await chrt.interact.attach(map, {
+   *   onInspect: (result) => console.log(result.title, result.characteristic),
+   * });
+   * // later: handle.detach();
+   */
+  async attach(map, opts = {}) {
+    if (!map || typeof map.queryRenderedFeatures !== "function" || typeof map.on !== "function") {
+      throw new InteractError(
+        "unexpected_response",
+        "attach(): expected a MapLibre / Mapbox GL map instance"
       );
     }
-    await fs.rename(partialPath, path);
-    await this.persistManifestEntry(region, bundle, path, fs);
-    return {
-      path,
-      bytes: bundle.bytes,
-      sha256: bundle.sha256,
-      build_id: bundle.build_id,
-      build_tag: bundle.build_tag,
-      resumed
+    await this.entitlementClient.check();
+    const showPopup = opts.popup ?? !opts.onInspect;
+    const popup = showPopup ? new InteractPopup(map) : null;
+    const clickHandler = (e) => {
+      const hit = decodeClick(map, e, opts);
+      if (!hit) {
+        popup?.close();
+        opts.onMiss?.({ lngLat: e.lngLat });
+        return;
+      }
+      const finish = (result) => {
+        popup?.show(result, result.coordinates ?? [e.lngLat.lng, e.lngLat.lat]);
+        opts.onInspect?.(result, { lngLat: e.lngLat, point: e.point, feature: hit.feature });
+      };
+      if (opts.enrich) {
+        enrichResult(this.http, hit.result).then(finish).catch(() => finish(hit.result));
+      } else {
+        finish(hit.result);
+      }
     };
-  }
-  async persistManifestEntry(region, bundle, path, fs) {
-    if (!this.manifestPath) return;
-    const manifest = await readManifest(this.manifestPath, fs);
-    const nowSec = Math.floor(Date.now() / 1e3);
-    manifest.regions[region] = {
-      path,
-      bytes: bundle.bytes,
-      sha256: bundle.sha256,
-      build_id: bundle.build_id,
-      build_tag: bundle.build_tag,
-      downloaded_at: nowSec,
-      last_accessed_at: nowSec
+    map.on("click", clickHandler);
+    return {
+      detach: () => {
+        map.off("click", clickHandler);
+        popup?.close();
+      }
     };
-    await writeManifest(this.manifestPath, fs, manifest);
   }
 };
-function dirname(p) {
-  const i = p.lastIndexOf("/");
-  const j = p.lastIndexOf("\\");
-  const k = Math.max(i, j);
-  if (k <= 0) return ".";
-  return p.slice(0, k);
-}
 
 // src/atlas/s52-colors.ts
 var S52_DAY = {
@@ -6914,6 +9322,118 @@ var LABEL_ANCHOR_FILTER = [
   ["get", "_label_anchor"],
   false
 ];
+var LABEL_PRIORITY = {
+  LIGHTS: 100,
+  UWTROC: 100,
+  OBSTRN: 100,
+  WRECKS: 100,
+  CBLOHD: 100,
+  PIPOHD: 100,
+  BOYLAT: 200,
+  BOYCAR: 200,
+  BOYSPP: 200,
+  BOYISD: 200,
+  BOYSAW: 200,
+  BCNLAT: 200,
+  BCNCAR: 200,
+  BCNSPP: 200,
+  FOGSIG: 250,
+  SOUNDG: 300,
+  DEPCNT: 300,
+  BRIDGE: 400,
+  LNDMRK: 400,
+  PILPNT: 400,
+  MORFAC: 400,
+  SLCONS: 400,
+  BUISGL: 400,
+  SBDARE: 500,
+  MAGVAR: 500,
+  WEDKLP: 500
+};
+var DEFAULT_LABEL_PRIORITY = 450;
+var ORIENTATION_LABEL_PRIORITY = 900;
+function getLabelPriority(layerName) {
+  if (getLabelBehavior(layerName) === "orientation-cross-band") {
+    return ORIENTATION_LABEL_PRIORITY;
+  }
+  return LABEL_PRIORITY[layerName] ?? DEFAULT_LABEL_PRIORITY;
+}
+function labelSortKey(rank, within) {
+  if (within === void 0) return rank * 1e3;
+  return [
+    "+",
+    rank * 1e3,
+    ["min", 999, ["max", 0, within]]
+  ];
+}
+var NAV_DESIGNATION_STOPWORDS = [
+  "Buoy",
+  "Can",
+  "Nun",
+  "Bell",
+  "Gong",
+  "Mark"
+];
+function extractNavAidDesignation(objnam) {
+  const trimmed = objnam.trim();
+  if (/^[A-Za-z0-9]{1,4}$/.test(trimmed)) {
+    return NAV_DESIGNATION_STOPWORDS.some((w) => w === trimmed) ? null : trimmed;
+  }
+  const m = trimmed.match(/ ([A-Za-z0-9]{1,4})$/);
+  if (!m) return null;
+  const token = m[1];
+  if (NAV_DESIGNATION_STOPWORDS.some((w) => w === token)) return null;
+  return token;
+}
+function navAidDesignationTextExpression(objnam, colourPrefix) {
+  const len = ["length", objnam];
+  const tokenBranches = [];
+  for (let k = 1; k <= 4; k++) {
+    tokenBranches.push(
+      [
+        "all",
+        [">", len, k],
+        ["==", ["slice", objnam, ["-", len, k + 1], ["-", len, k]], " "]
+      ],
+      ["slice", objnam, ["-", len, k]]
+    );
+  }
+  return [
+    "let",
+    "desig",
+    ["case", ...tokenBranches, ""],
+    [
+      "case",
+      [
+        "any",
+        ["==", ["var", "desig"], ""],
+        ["match", ["var", "desig"], [...NAV_DESIGNATION_STOPWORDS], true, false]
+      ],
+      ["concat", colourPrefix, objnam],
+      ["concat", colourPrefix, '"', ["var", "desig"], '"']
+    ]
+  ];
+}
+function navAidLabelLayout(sortKey) {
+  return {
+    "text-allow-overlap": false,
+    "text-ignore-placement": false,
+    "text-optional": true,
+    "text-padding": 4,
+    "symbol-sort-key": sortKey
+  };
+}
+var NAV_AID_SORT_KEY = labelSortKey(200, [
+  "case",
+  ["has", "VALNMR"],
+  ["-", 300, ["min", 299, ["to-number", ["get", "VALNMR"], 0]]],
+  ["+", 400, ["min", 500, ["length", ["coalesce", ["get", "OBJNAM"], ""]]]]
+]);
+var LIGHT_SORT_KEY = labelSortKey(100, [
+  "-",
+  300,
+  ["min", 299, ["to-number", ["coalesce", ["get", "VALNMR"], 0], 0]]
+]);
 function getLabelConfig(layerName, opts = {}) {
   const ct = opts.colorTable ?? "DAY";
   switch (layerName) {
@@ -6981,14 +9501,15 @@ function getLabelConfig(layerName, opts = {}) {
           // sizes — established cartographic typography practice.
           "text-letter-spacing": 0.02,
           // Shallowest-wins: Mapbox GL renders lower sort keys first and
-          // gives them collision priority. Using depth directly ensures
-          // the shallowest sounding in a cluster is always the one shown,
-          // even when labels are hidden due to overlap.
-          "symbol-sort-key": [
+          // gives them collision priority. Depth as the within-class key
+          // ensures the shallowest sounding in a cluster is always the
+          // one shown, even when labels are hidden due to overlap. Folded
+          // into the rank-300 band of the LABEL_PRIORITY ladder.
+          "symbol-sort-key": labelSortKey(300, [
             "to-number",
             ["coalesce", ["get", "depth"], ["get", "DEPTH"], ["get", "VALSOU"]],
             999
-          ]
+          ])
         }
       };
     }
@@ -7028,8 +9549,14 @@ function getLabelConfig(layerName, opts = {}) {
         textColor: DARK_BG,
         textHaloColor: "#d4c9b0",
         textHaloWidth: 1.5,
-        textOffset: [0, 1.2],
-        minzoom: 9
+        textOffset: [0, 0],
+        minzoom: 9,
+        layout: {
+          "text-variable-anchor": ["top", "bottom", "right", "left"],
+          "text-radial-offset": 1.2,
+          "text-justify": "auto",
+          "symbol-sort-key": labelSortKey(400, ["length", ["coalesce", ["get", "OBJNAM"], ""]])
+        }
       };
     case "BOYLAT":
       return {
@@ -7041,7 +9568,8 @@ function getLabelConfig(layerName, opts = {}) {
         textHaloColor: navHalo("WHITE", ct),
         textHaloWidth: 1.5,
         textOffset: [0, 1.5],
-        minzoom: 10
+        minzoom: 10,
+        layout: navAidLabelLayout(NAV_AID_SORT_KEY)
       };
     case "BCNLAT":
       return {
@@ -7053,7 +9581,8 @@ function getLabelConfig(layerName, opts = {}) {
         textHaloColor: navHalo("WHITE", ct),
         textHaloWidth: 1.5,
         textOffset: [0, 1.5],
-        minzoom: 10
+        minzoom: 10,
+        layout: navAidLabelLayout(NAV_AID_SORT_KEY)
       };
     case "BOYCAR":
     case "BCNCAR":
@@ -7066,7 +9595,8 @@ function getLabelConfig(layerName, opts = {}) {
         textHaloColor: navHalo("CREAM", ct),
         textHaloWidth: 1.5,
         textOffset: [0, 1.5],
-        minzoom: 10
+        minzoom: 10,
+        layout: navAidLabelLayout(NAV_AID_SORT_KEY)
       };
     case "BOYSPP":
     case "BCNSPP":
@@ -7079,7 +9609,8 @@ function getLabelConfig(layerName, opts = {}) {
         textHaloColor: navHalo("YELLOW", ct),
         textHaloWidth: 1.5,
         textOffset: [0, 1.5],
-        minzoom: 10
+        minzoom: 10,
+        layout: navAidLabelLayout(NAV_AID_SORT_KEY)
       };
     case "BOYISD":
     case "BOYSAW":
@@ -7092,7 +9623,8 @@ function getLabelConfig(layerName, opts = {}) {
         textHaloColor: navHalo("WHITE", ct),
         textHaloWidth: 1.5,
         textOffset: [0, 1.5],
-        minzoom: 10
+        minzoom: 10,
+        layout: navAidLabelLayout(NAV_AID_SORT_KEY)
       };
     case "LIGHTS":
       return {
@@ -7106,7 +9638,12 @@ function getLabelConfig(layerName, opts = {}) {
         textOffset: [2, 0],
         minzoom: 9,
         layout: {
-          "text-anchor": "left"
+          "text-anchor": "left",
+          "text-allow-overlap": false,
+          "text-ignore-placement": false,
+          "text-optional": true,
+          "text-padding": 2,
+          "symbol-sort-key": LIGHT_SORT_KEY
         }
       };
     case "FOGSIG": {
@@ -7144,7 +9681,8 @@ function getLabelConfig(layerName, opts = {}) {
         layout: {
           "text-anchor": "left",
           "text-allow-overlap": false,
-          "text-optional": true
+          "text-optional": true,
+          "symbol-sort-key": labelSortKey(250)
         }
       };
     }
@@ -7317,11 +9855,15 @@ function getLabelConfig(layerName, opts = {}) {
         textColor: "#bfa88a",
         textHaloColor: DARK_BG,
         textHaloWidth: 1.5,
-        textOffset: [0, 1],
+        textOffset: [0, 0],
         minzoom: 12,
         layout: {
+          "text-variable-anchor": ["top", "bottom", "right", "left"],
+          "text-radial-offset": 1,
+          "text-justify": "auto",
           "text-allow-overlap": false,
-          "text-optional": true
+          "text-optional": true,
+          "symbol-sort-key": labelSortKey(400, ["length", ["coalesce", ["get", "OBJNAM"], ""]])
         }
       };
     case "PILPNT":
@@ -7545,17 +10087,26 @@ function getLabelConfig(layerName, opts = {}) {
         textColor: resolveColor("CHBLK", ct2),
         textHaloColor: resolveColor("CHWHT", ct2),
         textHaloWidth: 1.2,
-        // Place to the upper-right of the symbol so it doesn't sit on top
-        // of the asterisk / cross. Anchor top-left so the offset grows
-        // away from the symbol as text-size grows.
-        textOffset: [0.8, -0.4],
+        textOffset: [0, 0],
         textFont: ["Open Sans Regular"],
         minzoom: 12,
+        // Variable anchors: the depth callout tries each corner of the
+        // hazard symbol and takes the first free spot, so in a rocky
+        // field the callouts fan out around their symbols instead of
+        // overprinting or vanishing. Safe here (unlike nav-aids) because
+        // UWTROC/OBSTRN/WRECKS are dominance-PARTICIPATING classes —
+        // exactly one band's copy renders at any zoom, so anchor-shifting
+        // can't split a cross-band duplicate pair into two visible labels.
+        // Shallowest (most dangerous) hazard wins within-class contests;
+        // VALSOU-less hazards (awash / unsounded) rank first of all.
         layout: {
-          "text-anchor": "top-left",
+          "text-variable-anchor": ["top-left", "bottom-left", "top-right", "bottom-right"],
+          "text-radial-offset": 0.9,
+          "text-justify": "auto",
           "text-allow-overlap": false,
           "text-optional": true,
-          "text-padding": 2
+          "text-padding": 2,
+          "symbol-sort-key": labelSortKey(100, ["*", 10, valsou])
         }
       };
     }
@@ -7594,7 +10145,13 @@ function getLabelConfig(layerName, opts = {}) {
           "text-rotation-alignment": "map",
           "text-allow-overlap": false,
           "text-optional": true,
-          "text-letter-spacing": 0.02
+          "text-letter-spacing": 0.02,
+          // Lower clearance = more dangerous = places first.
+          "symbol-sort-key": labelSortKey(100, [
+            "*",
+            5,
+            ["to-number", ["coalesce", ["get", "VERCLR"], 199], 199]
+          ])
         }
       };
     }
@@ -7623,7 +10180,10 @@ function getLabelConfig(layerName, opts = {}) {
           "symbol-spacing": 250,
           "text-rotation-alignment": "map",
           "text-allow-overlap": false,
-          "text-optional": true
+          "text-optional": true,
+          // Shallower contours win within-class contests, mirroring the
+          // SOUNDG shallowest-wins rule.
+          "symbol-sort-key": labelSortKey(300, ["to-number", ["get", "VALDCO"], 999])
         }
       };
     default:
@@ -7796,9 +10356,8 @@ function preprocessNavAids(fc) {
       const props = f.properties ?? {};
       const objnam = props.OBJNAM;
       if (!objnam) return f;
-      const match = objnam.match(/(\d+[A-Z]?)\s*$/);
-      if (!match) return f;
-      const designation = match[1];
+      const designation = extractNavAidDesignation(objnam);
+      if (!designation) return f;
       const colourCode = firstListCode(props.COLOUR);
       const prefix = NAV_COLOUR_PREFIX[colourCode];
       const label = prefix ? `${prefix} "${designation}"` : `"${designation}"`;
@@ -9552,7 +12111,7 @@ function getS52SymbolStats() {
 }
 
 // src/atlas/tile-zoom.ts
-var BUILD_MINZOOM = 3;
+var BUILD_MINZOOM = 0;
 var BUILD_MAXZOOM = 14;
 
 // src/atlas/source-registry.ts
@@ -9652,33 +12211,6 @@ var CHILD_ICON_OFFSETS = {
   LIGHTS: [14, 14]
   // lower-right, off the buoy hull so the flare is visible
 };
-var SAFETY_CRITICAL_LABELS = /* @__PURE__ */ new Set([
-  "LIGHTS",
-  "SOUNDG",
-  "BOYLAT",
-  "BCNLAT",
-  "BOYCAR",
-  "BCNCAR",
-  "BOYSPP",
-  "BCNSPP",
-  "BOYISD",
-  "BOYSAW",
-  "FOGSIG",
-  "RTPBCN"
-]);
-var HIGH_DENSITY_NAV_AIDS = /* @__PURE__ */ new Set([
-  "BOYLAT",
-  "BOYCAR",
-  "BOYSPP",
-  "BOYISD",
-  "BOYSAW",
-  "BOYINB",
-  "BCNLAT",
-  "BCNCAR",
-  "BCNSPP",
-  "BCNISD",
-  "BCNSAW"
-]);
 function buildNavAidLabelExpression() {
   const colourPrefix = colourCodeCase(
     [
@@ -9693,7 +12225,12 @@ function buildNavAidLabelExpression() {
     ["has", "_navAidLabel"],
     ["get", "_navAidLabel"],
     ["has", "OBJNAM"],
-    ["concat", colourPrefix, ["get", "OBJNAM"]],
+    // Chart-convention abbreviation: `R "4"` instead of the full NOAA
+    // name ("R Boston North Channel Lighted Buoy 4") — the tile pipeline
+    // doesn't precompute `_navAidLabel`, so before this expression every
+    // production buoy label carried its full 30-40 glyph OBJNAM, the
+    // biggest single driver of Harbor/Approach label overprint (E3).
+    navAidDesignationTextExpression(["get", "OBJNAM"], colourPrefix),
     ""
   ];
 }
@@ -9884,6 +12421,11 @@ function buildLayersForClass(objectClass, ct, sourceId = DEFAULT_REGION) {
         layer.paint["icon-color"] = lightFillExpression(ct);
         layer.paint["icon-halo-color"] = resolveColor("CHBLK", ct);
         layer.paint["icon-halo-width"] = 1;
+        layer.layout = {
+          ...layer.layout,
+          "icon-allow-overlap": true,
+          "icon-ignore-placement": true
+        };
       }
     } else if (resolved.layout) {
       layer.layout = resolved.layout;
@@ -10754,7 +13296,7 @@ function buildLabelLayer2(objectClass, ct, sourceId = DEFAULT_REGION, depthUnits
       ];
     }
   }
-  const isSafetyCritical = SAFETY_CRITICAL_LABELS.has(objectClass);
+  const labelPriority = getLabelPriority(objectClass);
   const layer = {
     id: `s52-${objectClass}-label`,
     type: "symbol",
@@ -10767,15 +13309,20 @@ function buildLabelLayer2(objectClass, ct, sourceId = DEFAULT_REGION, depthUnits
       "text-font": config.textFont ?? ["Open Sans Regular"],
       "text-offset": config.textOffset,
       "text-anchor": "top",
-      "text-allow-overlap": isSafetyCritical,
-      "text-optional": !isSafetyCritical,
-      "text-padding": isSafetyCritical ? 0 : 4,
+      "text-allow-overlap": false,
+      "text-optional": true,
+      "text-padding": 4,
+      "symbol-sort-key": labelPriority * 1e3,
       ...config.layout ?? {}
     },
     paint: {
       "text-color": config.textColor,
       "text-halo-color": config.textHaloColor,
       "text-halo-width": config.textHaloWidth
+    },
+    metadata: {
+      "s52:objectClass": objectClass,
+      "chrt:labelPriority": labelPriority
     }
   };
   if (config.minzoom) {
@@ -10827,13 +13374,24 @@ function getOrderedClasses() {
 
 // src/atlas/band-priority.ts
 var BAND_PRIORITY_RANGES = {
-  "1": { minzoom: 3 },
+  "1": { minzoom: 0 },
   "2": { minzoom: 5 },
   "3": { minzoom: 7 },
   "4": { minzoom: 9 },
   "5": { minzoom: 11 },
   "6": { minzoom: 11 }
 };
+var BAND_DATA_MINZOOM = {
+  "1": 0,
+  "2": 5,
+  "3": 7,
+  "4": 9,
+  "5": 11,
+  "6": 13
+};
+function dominatedVariantMaxzoom(D) {
+  return Math.max(BAND_PRIORITY_RANGES[D].minzoom, BAND_DATA_MINZOOM[D]);
+}
 var BAND_DRAW_ORDER = ["1", "2", "3", "4", "5", "6"];
 var CHART_BAND_CODES = {
   Overview: ["1"],
@@ -10994,12 +13552,26 @@ var DOMINANCE_EXEMPT_CLASSES = /* @__PURE__ */ new Set([
   "RTPBCN",
   "RDOSTA"
 ]);
+var DOMINANCE_EXEMPT_FILL_CLASSES = /* @__PURE__ */ new Set([
+  "LNDARE",
+  "DEPARE",
+  "UNSARE",
+  "LAKARE",
+  "DRGARE",
+  "SEAARE"
+]);
 function isDominanceExempt(layer) {
   for (const cls of DOMINANCE_EXEMPT_CLASSES) {
     if (layer.id.startsWith(`s52-${cls}-`)) return true;
   }
+  if (layer.type === "fill") {
+    for (const cls of DOMINANCE_EXEMPT_FILL_CLASSES) {
+      if (layer.id.startsWith(`s52-${cls}-`)) return true;
+    }
+  }
   return false;
 }
+var TOP_STACK_LIGHT_CLASSES = /* @__PURE__ */ new Set(["LIGHTS"]);
 function makeBandVariants(layer, B) {
   const range = BAND_PRIORITY_RANGES[B];
   const classMinzoom = layer.minzoom ?? 0;
@@ -11030,8 +13602,8 @@ function makeBandVariants(layer, B) {
   for (const D of BAND_DRAW_ORDER) {
     const dInt = parseInt(D, 10);
     if (dInt <= bInt) continue;
-    const dRange = BAND_PRIORITY_RANGES[D];
-    if (dRange.minzoom <= minzoom) continue;
+    const dMaxzoom = dominatedVariantMaxzoom(D);
+    if (dMaxzoom <= minzoom) continue;
     const domVariant = {
       ...layer,
       id: `${layer.id}-band${B}-domBy${D}`,
@@ -11040,7 +13612,7 @@ function makeBandVariants(layer, B) {
         ["all", bandFilterExpression(B), dominatedByMinFilter(D)]
       ),
       minzoom,
-      maxzoom: dRange.minzoom
+      maxzoom: dMaxzoom
     };
     variants.push(domVariant);
   }
@@ -11087,46 +13659,26 @@ function fanOrientationLabelByCellBand(label) {
       paint
     });
     for (const D of BAND_DRAW_ORDER) {
-      const dom = BAND_PRIORITY_RANGES[D];
-      if (dom.minzoom <= minzoom) continue;
+      const dMaxzoom = dominatedVariantMaxzoom(D);
+      if (dMaxzoom <= minzoom) continue;
       variants.push({
         ...label,
         id: `${label.id}-cell${code}-domBy${D}`,
         filter: combineWithBandFilter(cellFiltered, dominatedByMinFilter(D)),
         minzoom,
-        maxzoom: dom.minzoom,
+        // Data-aware ceiling: band 6 has no tile data until z13 despite
+        // being style-eligible at z11 (see dominatedVariantMaxzoom).
+        maxzoom: dMaxzoom,
         paint
       });
     }
   }
   return variants;
 }
-function applyHarborLabelCollisionDiscipline(variant, objectClass, code) {
-  if (!HIGH_DENSITY_NAV_AIDS.has(objectClass)) return variant;
-  if (code !== "5" && code !== "6") return variant;
-  const oldLayout = variant.layout ?? {};
-  return {
-    ...variant,
-    layout: {
-      ...oldLayout,
-      "text-allow-overlap": false,
-      "text-optional": true,
-      // Wider padding so even allowed labels space visually instead of
-      // touching. 6 is enough to read individual buoy designations clearly
-      // at z12-14 over Boston Harbor.
-      "text-padding": 6,
-      // Deterministic collision arbitration: prefer features with
-      // longer-range nav-aid significance (VALNMR — visible nautical
-      // miles), then shorter OBJNAM (tighter labels win), then FIDN as
-      // tiebreaker. Lower sort-key wins in MapLibre.
-      "symbol-sort-key": [
-        "case",
-        ["has", "VALNMR"],
-        ["-", 0, ["coalesce", ["to-number", ["get", "VALNMR"]], 0]],
-        ["length", ["coalesce", ["get", "OBJNAM"], ""]]
-      ]
-    }
-  };
+function byLabelPriorityBottomUp(bundles) {
+  return [...bundles].sort(
+    (a, b) => getLabelPriority(b.objectClass) - getLabelPriority(a.objectClass)
+  );
 }
 function chartModeFilterForBand(layer, B, higherCascadeBands, lockedBounds, isRequestedBand) {
   let filter = combineWithBandFilter(layer.filter, bandFilterExpression(B));
@@ -11162,37 +13714,47 @@ function generateStyle(palette = "DAY", opts = {}) {
       })
     });
   }
+  const regularBundles = bundles.filter((b) => !TOP_STACK_LIGHT_CLASSES.has(b.objectClass));
+  const topLightBundles = bundles.filter((b) => TOP_STACK_LIGHT_CLASSES.has(b.objectClass));
   if (chartCascade && chartRequestedCodes) {
     const requestedSet = new Set(chartRequestedCodes);
-    for (let i = 0; i < chartCascade.length; i++) {
-      const B = chartCascade[i];
-      const higher = chartCascade.slice(i + 1);
-      const isRequested = requestedSet.has(B);
-      for (const { featureLayers } of bundles) {
-        for (const base of featureLayers) {
-          const filter = chartModeFilterForBand(
-            base,
-            B,
-            higher,
-            lockedBounds,
-            isRequested
-          );
-          const variant = {
-            ...base,
-            id: `${base.id}-band${B}`,
-            filter
-          };
-          delete variant.maxzoom;
-          layers.push(variant);
+    const emitChartFeatureVariants = (bundleSet) => {
+      for (let i = 0; i < chartCascade.length; i++) {
+        const B = chartCascade[i];
+        const higher = chartCascade.slice(i + 1);
+        const isRequested = requestedSet.has(B);
+        for (const { featureLayers } of bundleSet) {
+          for (const base of featureLayers) {
+            const filter = chartModeFilterForBand(
+              base,
+              B,
+              higher,
+              lockedBounds,
+              isRequested
+            );
+            const variant = {
+              ...base,
+              id: `${base.id}-band${B}`,
+              filter
+            };
+            delete variant.maxzoom;
+            layers.push(variant);
+          }
         }
       }
-    }
-    for (let i = 0; i < chartCascade.length; i++) {
-      const B = chartCascade[i];
-      const higher = chartCascade.slice(i + 1);
-      const isRequested = requestedSet.has(B);
-      for (const { label } of bundles) {
-        if (!label) continue;
+    };
+    emitChartFeatureVariants(regularBundles);
+    emitChartFeatureVariants(topLightBundles);
+    const chartLabelBundles = byLabelPriorityBottomUp(
+      bundles.filter(
+        (b) => b.label !== null
+      )
+    );
+    for (const { label } of chartLabelBundles) {
+      for (let i = 0; i < chartCascade.length; i++) {
+        const B = chartCascade[i];
+        const higher = chartCascade.slice(i + 1);
+        const isRequested = requestedSet.has(B);
         const filter = chartModeFilterForBand(
           label,
           B,
@@ -11212,7 +13774,14 @@ function generateStyle(palette = "DAY", opts = {}) {
     layers.push(...labelLayers);
   } else {
     for (const code of BAND_DRAW_ORDER) {
-      for (const { featureLayers } of bundles) {
+      for (const { featureLayers } of regularBundles) {
+        for (const base of featureLayers) {
+          layers.push(...makeBandVariants(base, code));
+        }
+      }
+    }
+    for (const code of BAND_DRAW_ORDER) {
+      for (const { featureLayers } of topLightBundles) {
         for (const base of featureLayers) {
           layers.push(...makeBandVariants(base, code));
         }
@@ -11224,13 +13793,14 @@ function generateStyle(palette = "DAY", opts = {}) {
         labelLayers.push(...fanOrientationLabelByCellBand(label));
       }
     }
-    for (const code of BAND_DRAW_ORDER) {
-      for (const { objectClass, label } of bundles) {
-        if (!label) continue;
-        if (getLabelBehavior(objectClass) === "orientation-cross-band") continue;
-        for (const variant of makeBandVariants(label, code)) {
-          labelLayers.push(applyHarborLabelCollisionDiscipline(variant, objectClass, code));
-        }
+    const featureLabelBundles = byLabelPriorityBottomUp(
+      bundles.filter(
+        (b) => b.label !== null && getLabelBehavior(b.objectClass) !== "orientation-cross-band"
+      )
+    );
+    for (const { label } of featureLabelBundles) {
+      for (const code of BAND_DRAW_ORDER) {
+        labelLayers.push(...makeBandVariants(label, code));
       }
     }
     layers.push(...labelLayers);
@@ -11296,6 +13866,363 @@ function getStyleStats(style) {
   };
 }
 
+// src/atlas/custom-style.ts
+var DEFAULT_NAV_AID_SETTINGS = {
+  buoysVisible: true,
+  beaconsVisible: true,
+  lightsVisible: true,
+  scaminOverride: 0,
+  iconScale: 0.8,
+  iconSizeLocked: false,
+  allowOverlap: false,
+  showSectorArcs: true,
+  fogSignalsVisible: true,
+  radarVisible: true
+};
+var DEFAULT_LABEL_SETTINGS = {
+  navAidLabelsVisible: true,
+  landLabelsVisible: true,
+  structureLabelsVisible: true,
+  depthContoursVisible: true,
+  navAidFullNames: false,
+  minzoomOverride: null,
+  textScale: 1,
+  allowOverlap: false
+};
+var DEFAULT_SOUNDING_SETTINGS = {
+  visible: true,
+  minzoomOverride: null,
+  textScale: 1,
+  allowOverlap: false,
+  showUnits: false,
+  safetyContour: 10,
+  fontWeight: "semibold",
+  twoShade: true
+};
+var DEFAULT_WATER_BODY_SETTINGS = {
+  seaAreasVisible: true,
+  lakesVisible: true,
+  riversVisible: true,
+  canalsVisible: true,
+  minzoomOverride: null,
+  textScale: 1,
+  allowOverlap: false,
+  uppercaseSeaAreas: true
+};
+var NAV_AID_LAYER_GROUPS = {
+  buoys: ["BOYLAT", "BOYCAR", "BOYSPP", "BOYISD", "BOYSAW"],
+  beacons: ["BCNLAT", "BCNCAR", "BCNSPP"],
+  lights: ["LIGHTS"],
+  fogSignals: ["FOGSIG"],
+  radar: ["RTPBCN", "RDOSTA"]
+};
+var ALL_NAV_AID_LAYERS = new Set(
+  Object.values(NAV_AID_LAYER_GROUPS).flat()
+);
+var LABEL_LAYER_GROUPS = {
+  navAids: ["BOYLAT", "BCNLAT", "BOYCAR", "BOYSPP", "BOYISD", "BOYSAW", "BCNCAR", "BCNSPP", "LIGHTS", "FOGSIG", "RTPBCN", "RDOSTA"],
+  land: ["LNDRGN", "LNDMRK", "LNDARE"],
+  structures: ["BRIDGE", "PILPNT", "MORFAC", "SLCONS", "BUISGL", "AIRARE"],
+  depthContours: ["DEPCNT"]
+};
+var SOUNDING_LAYERS = ["SOUNDG"];
+var WATER_BODY_LAYER_GROUPS = {
+  seaAreas: ["SEAARE"],
+  lakes: ["LAKARE"],
+  rivers: ["RIVERS"],
+  canals: ["CANALS"]
+};
+var ALL_WATER_BODY_LAYERS = new Set(
+  Object.values(WATER_BODY_LAYER_GROUPS).flat()
+);
+function isNavAidLayerVisible(layerName, settings) {
+  if (NAV_AID_LAYER_GROUPS.buoys.includes(layerName)) return settings.buoysVisible;
+  if (NAV_AID_LAYER_GROUPS.beacons.includes(layerName)) return settings.beaconsVisible;
+  if (NAV_AID_LAYER_GROUPS.lights.includes(layerName)) return settings.lightsVisible;
+  if (NAV_AID_LAYER_GROUPS.fogSignals.includes(layerName)) return settings.fogSignalsVisible;
+  if (NAV_AID_LAYER_GROUPS.radar.includes(layerName)) return settings.radarVisible;
+  return true;
+}
+function isLabelLayerVisible(layerName, settings) {
+  if (LABEL_LAYER_GROUPS.navAids.includes(layerName)) return settings.navAidLabelsVisible;
+  if (LABEL_LAYER_GROUPS.land.includes(layerName)) return settings.landLabelsVisible;
+  if (LABEL_LAYER_GROUPS.structures.includes(layerName)) return settings.structureLabelsVisible;
+  if (LABEL_LAYER_GROUPS.depthContours.includes(layerName)) return settings.depthContoursVisible;
+  return true;
+}
+function isSoundingLayerVisible(settings) {
+  return settings.visible;
+}
+function isWaterBodyLayerVisible(layerName, settings) {
+  if (WATER_BODY_LAYER_GROUPS.seaAreas.includes(layerName)) return settings.seaAreasVisible;
+  if (WATER_BODY_LAYER_GROUPS.lakes.includes(layerName)) return settings.lakesVisible;
+  if (WATER_BODY_LAYER_GROUPS.rivers.includes(layerName)) return settings.riversVisible;
+  if (WATER_BODY_LAYER_GROUPS.canals.includes(layerName)) return settings.canalsVisible;
+  return true;
+}
+var DEFAULT_CUSTOM_STYLE_CONFIG = {
+  enabled_color_tables: ["DAY", "DUSK", "NIGHT"],
+  default_color_table: "DAY",
+  display_mode: "STANDARD",
+  nav_aid_settings: DEFAULT_NAV_AID_SETTINGS,
+  label_settings: DEFAULT_LABEL_SETTINGS,
+  sounding_settings: DEFAULT_SOUNDING_SETTINGS,
+  water_body_settings: DEFAULT_WATER_BODY_SETTINGS,
+  visible_layers: null
+};
+var COLOR_TABLE_NAMES = /* @__PURE__ */ new Set(["DAY", "DUSK", "NIGHT"]);
+var DISPLAY_MODES = /* @__PURE__ */ new Set(["BASE", "STANDARD", "ALL"]);
+var LAYER_NAME_RE = /^[A-Za-z0-9_$]{2,16}$/;
+var MAX_VISIBLE_LAYERS = 512;
+function clampNumber(raw, min, max, fallback) {
+  const n = typeof raw === "number" ? raw : NaN;
+  if (!Number.isFinite(n)) return fallback;
+  return Math.min(max, Math.max(min, n));
+}
+function intOrNull(raw, min, max, fallback) {
+  if (raw === null) return null;
+  const n = typeof raw === "number" ? raw : NaN;
+  if (!Number.isFinite(n)) return fallback;
+  return Math.round(Math.min(max, Math.max(min, n)));
+}
+function bool(raw, fallback) {
+  return typeof raw === "boolean" ? raw : fallback;
+}
+function asRecord(raw) {
+  return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+}
+function sanitizeNavAid(raw) {
+  const r = asRecord(raw);
+  const d = DEFAULT_NAV_AID_SETTINGS;
+  return {
+    buoysVisible: bool(r.buoysVisible, d.buoysVisible),
+    beaconsVisible: bool(r.beaconsVisible, d.beaconsVisible),
+    lightsVisible: bool(r.lightsVisible, d.lightsVisible),
+    scaminOverride: intOrNull(r.scaminOverride, 0, 14, d.scaminOverride),
+    iconScale: clampNumber(r.iconScale, 0.2, 2, d.iconScale),
+    iconSizeLocked: bool(r.iconSizeLocked, d.iconSizeLocked),
+    allowOverlap: bool(r.allowOverlap, d.allowOverlap),
+    showSectorArcs: bool(r.showSectorArcs, d.showSectorArcs),
+    fogSignalsVisible: bool(r.fogSignalsVisible, d.fogSignalsVisible),
+    radarVisible: bool(r.radarVisible, d.radarVisible)
+  };
+}
+function sanitizeLabels(raw) {
+  const r = asRecord(raw);
+  const d = DEFAULT_LABEL_SETTINGS;
+  return {
+    navAidLabelsVisible: bool(r.navAidLabelsVisible, d.navAidLabelsVisible),
+    landLabelsVisible: bool(r.landLabelsVisible, d.landLabelsVisible),
+    structureLabelsVisible: bool(r.structureLabelsVisible, d.structureLabelsVisible),
+    depthContoursVisible: bool(r.depthContoursVisible, d.depthContoursVisible),
+    navAidFullNames: bool(r.navAidFullNames, d.navAidFullNames),
+    minzoomOverride: intOrNull(r.minzoomOverride, 0, 14, d.minzoomOverride),
+    textScale: clampNumber(r.textScale, 0.5, 2, d.textScale),
+    allowOverlap: bool(r.allowOverlap, d.allowOverlap)
+  };
+}
+function sanitizeSoundings(raw) {
+  const r = asRecord(raw);
+  const d = DEFAULT_SOUNDING_SETTINGS;
+  return {
+    visible: bool(r.visible, d.visible),
+    minzoomOverride: intOrNull(r.minzoomOverride, 0, 14, d.minzoomOverride),
+    textScale: clampNumber(r.textScale, 0.5, 2, d.textScale),
+    allowOverlap: bool(r.allowOverlap, d.allowOverlap),
+    showUnits: bool(r.showUnits, d.showUnits),
+    safetyContour: clampNumber(r.safetyContour, 0, 100, d.safetyContour),
+    fontWeight: r.fontWeight === "regular" || r.fontWeight === "semibold" ? r.fontWeight : d.fontWeight,
+    twoShade: bool(r.twoShade, d.twoShade)
+  };
+}
+function sanitizeWaterBody(raw) {
+  const r = asRecord(raw);
+  const d = DEFAULT_WATER_BODY_SETTINGS;
+  return {
+    seaAreasVisible: bool(r.seaAreasVisible, d.seaAreasVisible),
+    lakesVisible: bool(r.lakesVisible, d.lakesVisible),
+    riversVisible: bool(r.riversVisible, d.riversVisible),
+    canalsVisible: bool(r.canalsVisible, d.canalsVisible),
+    minzoomOverride: intOrNull(r.minzoomOverride, 0, 14, d.minzoomOverride),
+    textScale: clampNumber(r.textScale, 0.5, 2, d.textScale),
+    allowOverlap: bool(r.allowOverlap, d.allowOverlap),
+    uppercaseSeaAreas: bool(r.uppercaseSeaAreas, d.uppercaseSeaAreas)
+  };
+}
+function sanitizeCustomStyleConfig(raw) {
+  const r = asRecord(raw);
+  const enabledRaw = Array.isArray(r.enabled_color_tables) ? r.enabled_color_tables : [];
+  const enabled = [...new Set(
+    enabledRaw.filter((c) => typeof c === "string" && COLOR_TABLE_NAMES.has(c))
+  )];
+  const enabledFinal = enabled.length > 0 ? enabled : ["DAY", "DUSK", "NIGHT"];
+  const defaultRaw = typeof r.default_color_table === "string" ? r.default_color_table : "";
+  const defaultFinal = enabledFinal.includes(defaultRaw) ? defaultRaw : enabledFinal[0];
+  const modeRaw = typeof r.display_mode === "string" ? r.display_mode : "";
+  const mode = DISPLAY_MODES.has(modeRaw) ? modeRaw : "STANDARD";
+  let visibleLayers = null;
+  if (Array.isArray(r.visible_layers)) {
+    visibleLayers = r.visible_layers.filter((l) => typeof l === "string" && LAYER_NAME_RE.test(l)).slice(0, MAX_VISIBLE_LAYERS).map((l) => l.toUpperCase());
+  }
+  return {
+    enabled_color_tables: enabledFinal,
+    default_color_table: defaultFinal,
+    display_mode: mode,
+    nav_aid_settings: sanitizeNavAid(r.nav_aid_settings),
+    label_settings: sanitizeLabels(r.label_settings),
+    sounding_settings: sanitizeSoundings(r.sounding_settings),
+    water_body_settings: sanitizeWaterBody(r.water_body_settings),
+    visible_layers: visibleLayers
+  };
+}
+function normalizeTheme(raw) {
+  if (!raw) return null;
+  const upper = raw.trim().toUpperCase();
+  return COLOR_TABLE_NAMES.has(upper) ? upper : null;
+}
+function resolveCustomTheme(config, requested) {
+  if (!requested) return { palette: config.default_color_table, themeFellBack: false };
+  if (config.enabled_color_tables.includes(requested)) {
+    return { palette: requested, themeFellBack: false };
+  }
+  return { palette: config.default_color_table, themeFellBack: true };
+}
+function layerObjectClass(layer) {
+  const meta = layer.metadata;
+  const fromMeta = meta?.["s52:objectClass"];
+  if (typeof fromMeta === "string" && fromMeta.length > 0) return fromMeta;
+  const m = /^s52-([A-Za-z0-9_$]+)-/.exec(layer.id);
+  return m ? m[1] : null;
+}
+function isLabelLayer(layer) {
+  if (layer.type !== "symbol") return false;
+  const layout = layer.layout;
+  return layout?.["text-field"] !== void 0;
+}
+function isIconLayer(layer) {
+  if (layer.type !== "symbol") return false;
+  const layout = layer.layout;
+  return layout?.["icon-image"] !== void 0 && layout?.["text-field"] === void 0;
+}
+function bandFloor(layerId) {
+  const m = /-band(\d)/.exec(layerId);
+  if (!m) return 0;
+  const range = BAND_PRIORITY_RANGES[m[1]];
+  return range ? range.minzoom : 0;
+}
+function scaleSizeValue(value, factor) {
+  if (typeof value === "number") {
+    return Math.round(value * factor * 100) / 100;
+  }
+  if (!Array.isArray(value) || value.length === 0) return value;
+  const op = value[0];
+  if (op === "interpolate") {
+    const out = [...value];
+    for (let i = 4; i < out.length; i += 2) out[i] = scaleSizeValue(out[i], factor);
+    return out;
+  }
+  if (op === "step") {
+    const out = [...value];
+    for (let i = 2; i < out.length; i += 2) out[i] = scaleSizeValue(out[i], factor);
+    return out;
+  }
+  if (op === "case") {
+    const out = [...value];
+    for (let i = 2; i < out.length - 1; i += 2) out[i] = scaleSizeValue(out[i], factor);
+    out[out.length - 1] = scaleSizeValue(out[out.length - 1], factor);
+    return out;
+  }
+  if (op === "match") {
+    const out = [...value];
+    for (let i = 3; i < out.length - 1; i += 2) out[i] = scaleSizeValue(out[i], factor);
+    out[out.length - 1] = scaleSizeValue(out[out.length - 1], factor);
+    return out;
+  }
+  return value;
+}
+function setLayout(layer, key, val) {
+  const layout = { ...layer.layout ?? {} };
+  layout[key] = val;
+  layer.layout = layout;
+}
+function hideLayer(layer) {
+  setLayout(layer, "visibility", "none");
+}
+function applyCustomStyleSettings(style, config) {
+  const nav = config.nav_aid_settings;
+  const labels = config.label_settings;
+  const soundings = config.sounding_settings;
+  const water = config.water_body_settings;
+  const visibleSet = config.visible_layers ? new Set(config.visible_layers) : null;
+  for (const layer of style.layers) {
+    const cls = layerObjectClass(layer);
+    if (!cls) continue;
+    const label = isLabelLayer(layer);
+    if (visibleSet && !visibleSet.has(cls)) {
+      hideLayer(layer);
+      continue;
+    }
+    if (label) {
+      const hidden = SOUNDING_LAYERS.includes(cls) && !isSoundingLayerVisible(soundings) || ALL_WATER_BODY_LAYERS.has(cls) && !isWaterBodyLayerVisible(cls, water) || !SOUNDING_LAYERS.includes(cls) && !ALL_WATER_BODY_LAYERS.has(cls) && !isLabelLayerVisible(cls, labels);
+      if (hidden) {
+        hideLayer(layer);
+        continue;
+      }
+    } else {
+      const hidden = ALL_NAV_AID_LAYERS.has(cls) && !isNavAidLayerVisible(cls, nav) || ALL_WATER_BODY_LAYERS.has(cls) && !isWaterBodyLayerVisible(cls, water) || SOUNDING_LAYERS.includes(cls) && !isSoundingLayerVisible(soundings);
+      if (hidden) {
+        hideLayer(layer);
+        continue;
+      }
+    }
+    if (label) {
+      const bundle = SOUNDING_LAYERS.includes(cls) ? { textScale: soundings.textScale, minzoom: soundings.minzoomOverride, allowOverlap: soundings.allowOverlap } : ALL_WATER_BODY_LAYERS.has(cls) ? { textScale: water.textScale, minzoom: water.minzoomOverride, allowOverlap: water.allowOverlap } : { textScale: labels.textScale, minzoom: labels.minzoomOverride, allowOverlap: labels.allowOverlap };
+      if (bundle.textScale !== 1) {
+        const layout = layer.layout;
+        if (layout?.["text-size"] !== void 0) {
+          setLayout(layer, "text-size", scaleSizeValue(layout["text-size"], bundle.textScale));
+        }
+      }
+      if (bundle.allowOverlap === true) {
+        setLayout(layer, "text-allow-overlap", true);
+        setLayout(layer, "text-optional", false);
+      }
+      if (bundle.minzoom !== null) {
+        layer.minzoom = Math.max(bundle.minzoom, bandFloor(layer.id));
+      }
+      if (cls === "SEAARE") {
+        setLayout(layer, "text-transform", water.uppercaseSeaAreas ? "uppercase" : "none");
+      }
+    }
+    if (!label && ALL_NAV_AID_LAYERS.has(cls) && isIconLayer(layer)) {
+      if (nav.iconScale !== 1) {
+        const layout = layer.layout;
+        const current = layout?.["icon-size"];
+        setLayout(layer, "icon-size", current === void 0 ? Math.round(nav.iconScale * 100) / 100 : scaleSizeValue(current, nav.iconScale));
+      }
+      if (nav.allowOverlap === true) {
+        setLayout(layer, "icon-allow-overlap", true);
+      }
+      if (nav.scaminOverride !== null) {
+        layer.minzoom = Math.max(nav.scaminOverride, bandFloor(layer.id));
+      }
+    }
+  }
+  return style;
+}
+function generateCustomStyle(config, opts = {}) {
+  const { theme, ...generatorOpts } = opts;
+  const { palette, themeFellBack } = resolveCustomTheme(config, theme ?? null);
+  const style = generateStyle(palette, {
+    ...generatorOpts,
+    safetyContour: config.sounding_settings.safetyContour,
+    twoShadeSoundings: config.sounding_settings.twoShade,
+    soundingFontWeight: config.sounding_settings.fontWeight
+  });
+  applyCustomStyleSettings(style, config);
+  return { style, palette, themeFellBack };
+}
+
 // src/pagination.ts
 async function* paginate(fetchPage, getItems, getTotalCount, options) {
   const pageSize = options?.pageSize ?? 100;
@@ -11351,6 +14278,12 @@ var Chrt = class {
    * requires `manifestPath`.
    */
   offline;
+  /**
+   * CHRTinteract — click-to-inspect: `attach(map)` for wired popups/events,
+   * `inspect(feature)` for headless decode. Included with the Dev plan and
+   * above; enforced server-side at attach/inspect time.
+   */
+  interact;
   featuresEp;
   queryEp;
   http;
@@ -11363,13 +14296,14 @@ var Chrt = class {
     this.tileBaseUrl = config.tileBaseUrl ?? DEFAULT_TILE_BASE_URL;
     this.http = new HttpClient(config.apiKey, config.baseUrl, config.retries);
     const tileOpts = { region: this.region, tileBaseUrl: this.tileBaseUrl };
-    this.tiles = new TilesEndpoint(this.http, tileOpts);
+    this.tileAuth = new TileAuth(this.http, tileOpts);
+    this.tiles = new TilesEndpoint(this.http, this.tileAuth, tileOpts);
     this.cells = new CellsEndpoint(this.http);
     this.coverage = new CoverageEndpoint(this.http);
     this.featuresEp = new FeaturesEndpoint(this.http);
     this.queryEp = new QueryEndpoint(this.http);
     this.offline = new OfflineEndpoint(this.http, config.deviceId, config.manifestPath);
-    this.tileAuth = new TileAuth(this.http, tileOpts);
+    this.interact = new InteractClient(this.http);
   }
   /* ── Convenience shortcuts ───────────────────────── */
   /** Query GeoJSON features by bounding box */
@@ -11463,6 +14397,9 @@ var Chrt = class {
    * });
    *
    * @remarks S-101 portrayal is on the roadmap; today `style()` emits S-52.
+   * Generated locally, so it never applies a key-bound CHRTstyle custom
+   * style — use {@link styleUrl} / {@link fetchStyle} (the served Style API)
+   * for that.
    */
   style(opts = {}) {
     const { palette = "DAY", ...styleOpts } = opts;
@@ -11473,12 +14410,33 @@ var Chrt = class {
     });
   }
   /**
-   * @deprecated CHRT serves no remote `style.json`. Use {@link style} to get a
-   * MapLibre style object instead. Throws to avoid silently pointing a map at a
-   * dead URL.
+   * URL of the served S-52 style — the CHRTstyle Style API at
+   * `tiles.chrt.co/v1/styles/{region}/style.json`. Unlike {@link style}
+   * (generated locally), the served document honors the API key's bound
+   * CHRTstyle custom style: palettes, layer visibility, label/icon scale,
+   * and the rest of the platform's Map Styles settings, applied server-side
+   * and tier-gated (custom styles are Dev+; Free keys get the default
+   * themes). Async because it pre-mints the tile token, so the style
+   * request is guaranteed to carry auth via `transformRequest()`.
+   *
+   * @example
+   * const map = new maplibregl.Map({
+   *   container: 'map',
+   *   style: await chrt.styleUrl({ theme: 'day' }),
+   *   transformRequest: chrt.transformRequest(),
+   * });
+   */
+  async styleUrl(opts) {
+    return this.tiles.styleUrl(opts);
+  }
+  /**
+   * Fetch the served S-52 style (see {@link styleUrl}) as a MapLibre style
+   * object — inspect or mutate it before handing it to the map.
+   * `chrt.style()` remains the local generator that needs no network
+   * round-trip (and therefore applies no custom style).
    */
-  styleUrl() {
-    return this.tiles.styleUrl();
+  async fetchStyle(opts) {
+    return this.tiles.fetchStyle(opts);
   }
   /**
    * Returns a `transformRequest` for Mapbox GL JS / MapLibre GL JS that mints a
@@ -11506,8 +14464,12 @@ var Chrt = class {
   }
 };
 export {
+  ALL_NAV_AID_LAYERS,
+  ALL_WATER_BODY_LAYERS,
+  AREA_QUERY_LAYERS,
   BAND_DRAW_ORDER,
   BAND_PRIORITY_RANGES,
+  BRIDGE_QUERY_LAYERS,
   BUILD_MAXZOOM,
   BUILD_MINZOOM,
   CHART_BAND_CODES,
@@ -11515,12 +14477,25 @@ export {
   CHART_SECTIONS,
   Chrt,
   ChrtError,
+  DEFAULT_CUSTOM_STYLE_CONFIG,
+  DEFAULT_LABEL_SETTINGS,
+  DEFAULT_NAV_AID_SETTINGS,
   DEFAULT_REGION,
+  DEFAULT_SOUNDING_SETTINGS,
   DEFAULT_TILE_BASE_URL,
   DEFAULT_TILE_REGION,
+  DEFAULT_WATER_BODY_SETTINGS,
+  InteractClient,
+  InteractError,
   LABELED_LAYERS,
   LABEL_BEHAVIOR,
+  LABEL_LAYER_GROUPS,
+  LABEL_PRIORITY,
   NAUTICAL_SYMBOLS,
+  NAV_AID_LAYER_GROUPS,
+  NAV_AID_QUERY_LAYERS,
+  NON_SOLAS_DISCLAIMER,
+  NON_SOLAS_DISCLAIMER_SHORT,
   OfflineError,
   OfflineStyleError,
   S101_CHART_SECTIONS,
@@ -11533,21 +14508,34 @@ export {
   S52_DUSK,
   S52_LOOKUP,
   S52_NIGHT,
+  SOUNDING_LAYERS,
   SYMBOL_GROUPS,
   SYMBOL_MAP,
   TileAuth,
   TileTokenError,
+  WATER_BODY_LAYER_GROUPS,
   applyColorTheme,
+  applyCustomStyleSettings,
   bandFilterExpression,
+  buildFlashPattern,
   buildLabelLayer,
   buildLayersForClass,
   buildOfflineStyle,
+  buildSectorArcGeoJSON,
+  buildSectorArcsFC,
+  buildSectorsFromFeatures,
   buildSources,
   combineWithBandFilter,
   daymarkColor,
   decimateFeatures,
+  decodeAreaFeatureProps,
+  decodeBridgeProps,
+  decodeNavAidProps,
   depareColor,
   depareFillExpression,
+  deriveMarinerName,
+  extractNavAidDesignation,
+  generateCustomStyle,
   generateSpriteManifest,
   generateSpriteSheet,
   generateStyle,
@@ -11562,6 +14550,7 @@ export {
   getIconExpression,
   getLabelBehavior,
   getLabelConfig,
+  getLabelPriority,
   getLookupEntry,
   getMaxCellsForZoom,
   getOrderedClasses,
@@ -11570,22 +14559,33 @@ export {
   getStyleStats,
   getSymbolSvgString,
   getThemedS52Svg,
+  getTopmarkMeaning,
   hazardColor,
   hazardFillExpression,
+  isLabelLayerVisible,
   isNavAidLayer,
+  isNavAidLayerVisible,
+  isSoundingLayerVisible,
   isVisibleInMode,
+  isWaterBodyLayerVisible,
+  labelSortKey,
   lateralColor,
   lateralFillExpression,
   lightColor,
   lightFillExpression,
+  normalizeTheme,
   paginate,
+  parseListCodes,
   parseWebhook,
   preprocessLights,
   preprocessNavAids,
   preprocessSoundings,
   preprocessWaterBodies,
   resolveColor,
+  resolveCustomTheme,
   resolveStyle,
+  sanitizeCustomStyleConfig,
+  scaleSizeValue,
   scaminToMinZoom,
   withinBboxFilter,
   worldMinusBboxPolygon