@chrtco/sdk 0.9.1 → 0.10.0

package/dist/index.d.cts

@@ -123,6 +123,100 @@ interface FeatureCollection<P = Record<string, unknown>> {
     limit?: number;
     offset?: number;
 }
+interface AheadOptions {
+    /** [longitude, latitude] of the craft or fixed origin */
+    point: [number, number];
+    /**
+     * Degrees true, 0–360 — a craft's COG/heading, or any fixed input.
+     * Values outside 0–360 are normalised (370 → 10).
+     */
+    bearing: number;
+    /**
+     * Full sector width in degrees, centred on `bearing` (default 90). So `arc: 60`
+     * sweeps ±30° either side. `arc: 360` degenerates to a full circle, making this a
+     * generalisation of {@link QueryOptions | query}.
+     */
+    arc?: number;
+    /** Range in metres (default 5000, max 50000). Mutually exclusive with `rangeNm`. */
+    range?: number;
+    /** Range in nautical miles — convenience for `range` (1 nm = 1852 m). */
+    rangeNm?: number;
+    /**
+     * Your safety depth in metres — typically vessel draft plus a margin, and the same
+     * number you'd set as the style's safety contour.
+     *
+     * Filters out only what is *known* to be deeper than this. Features with no charted
+     * depth are always kept: a wreck with no sounded value is still a wreck.
+     */
+    safetyDepth?: number;
+    /** Comma-separated S-57 class codes. Defaults to CHRT's significant-feature set. */
+    layer?: string;
+    limit?: number;
+    /** AbortSignal to cancel the request */
+    signal?: AbortSignal;
+}
+/** Per-feature facts returned by {@link AheadResponse}. CHRT ranks nothing — you sort. */
+interface AheadFeatureProperties {
+    layer: string;
+    cell_id: string;
+    /** Geodesic metres to the nearest point of the feature. */
+    distance_m: number;
+    /**
+     * Degrees true to the nearest point of the feature, or `null` when the origin lies
+     * on/inside it (e.g. your boat is inside a depth area).
+     *
+     * May fall *outside* the requested arc: membership is decided by whether the feature
+     * intersects the sector, while this reports where its nearest point lies — a large
+     * polygon can clip the sector edge from outside it.
+     */
+    bearing_deg: number | null;
+    /** Least charted depth in metres (VALSOU / DEPTH / DRVAL1), or `null` if unknown. */
+    least_depth_m: number | null;
+    /**
+     * `least_depth_m − safetyDepth`. Negative means shallower than you declared safe.
+     * `null` when either value is unknown. A fact, not a severity — see the class docs.
+     */
+    depth_clearance_m: number | null;
+    [key: string]: unknown;
+}
+/** An ENC cell covering some part of the swept sector, with its currency. */
+interface AheadCoverageCell {
+    cell_id: string;
+    title: string | null;
+    chart_source: string;
+    scale: number | null;
+    scale_band: string | null;
+    edition: number | null;
+    update_number: number | null;
+    issue_date: string | null;
+}
+interface AheadResponse extends FeatureCollection<AheadFeatureProperties> {
+    query: {
+        point: [number, number];
+        bearing_deg: number;
+        arc_deg: number;
+        range_m: number;
+        safety_depth_m: number | null;
+        layers: string[];
+    };
+    /**
+     * Coverage of the swept sector — the reason an empty `features` array is safe to
+     * return. Zero features in covered water and zero features because CHRT has no cells
+     * there are different answers; **only this block tells them apart.**
+     */
+    coverage: {
+        covered: boolean;
+        /** 0–1: how much of the sector any ENC cell covers. */
+        covered_fraction: number;
+        cells: AheadCoverageCell[];
+    };
+    /** Issuing-office attribution. Always present; never strip it from a UI. */
+    attribution: string;
+    /** The non-SOLAS disclaimer. Always present. */
+    disclaimer: string;
+    /** Why an empty result is not an all-clear. */
+    notice: string;
+}
 interface FeaturesOptions {
     /** Bounding box as [west, south, east, north] */
     bbox: [number, number, number, number];
@@ -138,20 +232,61 @@ interface FeaturesOptions {
 interface QueryOptions {
     /** [longitude, latitude] */
     point: [number, number];
-    /** Search radius in metres (default 1000) */
+    /** Search radius in metres (default 500, clamped 1–50 000) */
     radius?: number;
-    /** Comma-separated layer codes */
+    /** Comma-separated layer codes. Unfiltered by default — see {@link AheadOptions.layer}. */
     layer?: string;
+    /** Max features to return (default 50, clamped to 1–500). */
     limit?: number;
     /** AbortSignal to cancel the request */
     signal?: AbortSignal;
 }
+/** Per-feature facts returned by {@link QueryResponse}. */
+interface QueryFeatureProperties {
+    layer: string;
+    cell_id: string;
+    /** Geodesic metres from the queried point to the nearest point of the feature. */
+    distance_m: number;
+    [key: string]: unknown;
+}
+/**
+ * Response from {@link Chrt.query}. `/v1/query` is not paginated — it returns
+ * `limit` but no `offset`, so page with a wider `radius` rather than an offset.
+ */
+interface QueryResponse extends FeatureCollection<QueryFeatureProperties> {
+    /** The point and radius the server actually applied, after clamping. */
+    query: {
+        point: [number, number];
+        radius_m: number;
+    };
+}
+/**
+ * S-57 usage band, derived by CHRT from the cell's compilation scale — the
+ * navigational purpose the chart was drawn for, from `Overview` (>1:1.5M) down to
+ * `Harbor` (<1:22k). A closed set: CHRT assigns these itself rather than taking them
+ * from the issuing office.
+ */
+type ScaleBand$1 = "Overview" | "General" | "Coastal" | "Approach" | "Harbor";
 interface CellsOptions {
-    /** Filter by chart source, e.g. "NOAA" */
+    /**
+     * Filter by chart-source **id**, e.g. `"NOAA_ENC"` — not the agency name
+     * (`"NOAA"`), which matches no cell and returns an empty list rather than an
+     * error. `chrt.coverage.list()` enumerates the valid ids.
+     */
     source?: string;
-    /** Filter by status */
+    /** Filter by status, e.g. "CURRENT". Case-insensitive — the server upper-cases it. */
     status?: string;
+    /** Filter by scale band. Matched exactly, and **case-sensitively** — `"harbor"` matches nothing. */
+    scaleBand?: ScaleBand$1;
+    /**
+     * Only cells whose bounds intersect this box, as [west, south, east, north]
+     * in decimal degrees. Intersection, not containment — a cell that merely
+     * overlaps an edge is included.
+     */
+    bbox?: [number, number, number, number];
+    /** Max cells to return (default 100, clamped to 1–1000). */
     limit?: number;
+    /** Pagination offset. Page with `offset` against `total_count`. */
     offset?: number;
     /** AbortSignal to cancel the request */
     signal?: AbortSignal;
@@ -162,14 +297,31 @@ interface CellDetail {
     chart_source: string;
     status: string;
     scale: number | null;
+    /**
+     * In practice a {@link ScaleBand}, but typed as `string` deliberately: this is
+     * whatever is stored for the cell, and narrowing a response to a union the
+     * database does not enforce would be a promise the wire cannot keep.
+     */
     scale_band: string | null;
     edition: number | null;
     update_number: number | null;
     issue_date: string | null;
+    /**
+     * Bounds in decimal degrees (WGS 84), or `null` when the issuing office recorded
+     * none. Written as a group by every ingest path, so in practice the four are all
+     * set or all `null` — but check the one you read rather than inferring it from
+     * another. Same flat shape as {@link CoverageRouteCell} on `/v1/coverage/route`.
+     */
     bbox_north: number | null;
     bbox_south: number | null;
     bbox_east: number | null;
     bbox_west: number | null;
+    /**
+     * ISO 8601 timestamp of when CHRT last checked the issuing office's catalogue
+     * for this cell — freshness of the *check*, not of the chart. Compare
+     * `edition` / `update_number` / `issue_date` for chart currency.
+     */
+    last_checked_at: string | null;
 }
 interface CellsResponse {
     cells: CellDetail[];
@@ -177,58 +329,124 @@ interface CellsResponse {
     limit: number;
     offset: number;
 }
-interface RouteQueryOptions {
-    /** Array of [longitude, latitude] waypoints forming the route */
+interface AlongRouteOptions {
+    /** The passage as `[longitude, latitude]` waypoints. At least 2. */
     route: [number, number][];
-    /** Buffer distance in metres (default 1000, max 50000) */
+    /** Corridor half-width in metres either side of the track (default 500, max 50000). */
     buffer?: number;
-    /** Filter by chart source, e.g. "NOAA" */
-    source?: string;
-    /** Filter by scale band, e.g. "4" */
-    scaleBand?: string;
-    /** Max cells to return (default 100) */
+    /** Corridor half-width in nautical miles — convenience for `buffer`. */
+    bufferNm?: number;
+    /**
+     * Your safety depth in metres — typically draft plus a margin.
+     *
+     * Filters out only what is *known* to be deeper. Features with no charted depth are
+     * always kept: a wreck with no sounded value is still a wreck.
+     */
+    safetyDepth?: number;
+    /** Comma-separated S-57 class codes. Defaults to CHRT's significant-feature set. */
+    layer?: string;
     limit?: number;
+    offset?: number;
     /** AbortSignal to cancel the request */
     signal?: AbortSignal;
 }
-interface RouteQueryResponse {
-    cells: CellDetail[];
+/** Per-feature facts from {@link AlongRouteResponse}. CHRT ranks nothing — you sort. */
+interface AlongRouteFeatureProperties {
+    layer: string;
+    cell_id: string;
+    /** Geodesic metres from the track to the nearest point of the feature. */
+    distance_m: number;
+    /**
+     * Metres along the route to the point of closest approach — i.e. how far into the
+     * passage you meet this. Results are ordered by it, because that is the order you
+     * actually encounter things in. `null` if the route is not a simple LineString.
+     */
+    along_m: number | null;
+    /** Least charted depth in metres (VALSOU / DEPTH / DRVAL1), or `null` if unknown. */
+    least_depth_m: number | null;
+    /**
+     * `least_depth_m − safetyDepth`. Negative means shallower than you declared safe.
+     * A fact, not a severity.
+     */
+    depth_clearance_m: number | null;
+    [key: string]: unknown;
+}
+interface AlongRouteResponse extends FeatureCollection<AlongRouteFeatureProperties> {
     query: {
+        route_points: number;
+        route_length_m: number | null;
         buffer_m: number;
-        cell_count: number;
+        safety_depth_m: number | null;
+        layers: string[];
     };
-    total_count: number;
+    /**
+     * Which ENC cells cover the corridor. As with {@link AheadResponse}, this is what
+     * makes an empty `features` array safe to return: no features in charted water and
+     * no features because there is no chart are different answers.
+     */
+    coverage: {
+        covered: boolean;
+        cells: AheadCoverageCell[];
+    };
+    attribution: string;
+    disclaimer: string;
+    notice: string;
 }
-interface RouteFeatureQueryOptions {
-    /** Array of [longitude, latitude] waypoints forming the route */
+interface CoverageRouteOptions {
+    /** The passage as `[longitude, latitude]` waypoints. At least 2. */
     route: [number, number][];
-    /** Buffer distance in metres (default 1000, max 50000) */
+    /** Corridor half-width in metres (default 1000, max 50000). */
     buffer?: number;
-    /** Comma-separated layer codes to filter */
-    layer?: string;
-    /** Max features to return (default 100) */
+    /** Corridor half-width in nautical miles — convenience for `buffer`. */
+    bufferNm?: number;
+    /**
+     * Restrict to one scale band, e.g. `"Harbor"` for harbour cells. Matched exactly and
+     * **case-sensitively** against the same column `chrt.cells.list()` filters — the
+     * bands are words, not band numbers, so `"5"` matches nothing and returns an empty
+     * `cells` list rather than an error.
+     */
+    scaleBand?: ScaleBand$1;
     limit?: number;
-    /** Pagination offset */
-    offset?: number;
     /** AbortSignal to cancel the request */
     signal?: AbortSignal;
 }
-interface RouteFeatureQueryResponse extends FeatureCollection {
+interface CoverageRouteCell extends AheadCoverageCell {
+    bbox_north: number | null;
+    bbox_south: number | null;
+    bbox_east: number | null;
+    bbox_west: number | null;
+    /** Geodesic metres from the route to the cell's footprint. 0 if the route crosses it. */
+    distance_m: number;
+}
+interface CoverageRouteResponse {
+    /** Largest scale (most detailed) first — S-57 says believe the finer chart. */
+    cells: CoverageRouteCell[];
     query: {
+        route_points: number;
         buffer_m: number;
-        route_length_m?: number;
+        scale_band: string | null;
+        cell_count: number;
     };
+    total_count: number;
+    limit: number;
+    attribution: string;
+    disclaimer: string;
+    /** An empty `cells` list means CHRT holds no chart for this passage. */
+    notice: string;
 }
 interface CoverageSource {
-    /** Chart source ID, e.g. "NOAA" */
+    /**
+     * Chart-source id, e.g. `"NOAA_ENC"`. This is the value `CellsOptions.source`
+     * filters on — pass this, not {@link CoverageSource.agency}.
+     */
     source: string;
     /** ISO 3166-1 alpha-2 country code */
     country: string;
-    /** Display name of the agency */
+    /** Display name of the issuing office, e.g. `"NOAA"`. Never a filter value. */
     agency: string;
     /** Number of available ENC cells */
     cell_count: number;
-    /** Scale bands with cell counts */
+    /** Cell counts keyed by {@link ScaleBand}, e.g. `{ Harbor: 46, Coastal: 10 }`. */
     scale_bands?: Record<string, number>;
 }
 interface CoverageResponse {
@@ -236,9 +454,9 @@ interface CoverageResponse {
     total_cells: number;
 }
 interface CoverageOptions {
-    /** Filter by country code */
+    /** Filter by country code, e.g. `"US"` */
     country?: string;
-    /** Filter by chart source */
+    /** Filter by chart-source id, e.g. `"NOAA_ENC"` — see {@link CellsOptions.source}. */
     source?: string;
     /** AbortSignal to cancel the request */
     signal?: AbortSignal;
@@ -262,9 +480,44 @@ interface ChrtErrorBody {
     code?: string;
     message?: string;
 }
+/**
+ * The vessel you're answering for — one value, read by every depth-aware call.
+ *
+ * CHRT has historically carried several disagreeing notions of "how deep is safe":
+ * the sounding panel's safety contour, the isolated-danger ring's threshold, and the
+ * query's `safetyDepth`. This is the single place a client states it once.
+ *
+ * **It is deliberately client-side and per-instance, not stored on your API key.** A
+ * consumer app has one key and many skippers with different boats; a key-scoped draft
+ * would give them all the same one. Construct a `Chrt` per user (or pass `safetyDepth`
+ * per call) and each gets their own.
+ */
+interface VesselProfile {
+    /**
+     * Safety depth in metres — your draft plus whatever margin you want, i.e. the depth
+     * below which you consider water unsafe for *this* vessel.
+     *
+     * Becomes the default for `ahead({ safetyDepth })`, `alongRoute({ safetyDepth })`
+     * and `style({ safetyContour })`. Any explicit per-call value still wins.
+     */
+    safetyDepthM: number;
+}
 interface ChrtConfig {
-    /** API key (chrt_live_… or chrt_test_…) */
+    /** API key — `chrt_{pk|sk}_{live|test}_{team}_{random}`. `pk` and `sk` carry
+     *  identical privileges: the prefix records intent and re-revealability, not
+     *  capability. Treat any key embedded in a client as public. */
     apiKey: string;
+    /**
+     * The vessel this client is answering for. Sets one safety depth that defaults
+     * every depth-aware call — the query's `safetyDepth` and the generated style's
+     * `safetyContour` — so they cannot silently disagree.
+     *
+     * @example
+     * const chrt = new Chrt({ apiKey, vessel: { safetyDepthM: 3 } });
+     * await chrt.ahead({ point, bearing });  // filters at 3 m
+     * chrt.style();                          // shades and rings at 3 m
+     */
+    vessel?: VesselProfile;
     /** Override base URL (default https://api.chrt.co/v1) */
     baseUrl?: string;
     /** Max retries on 5xx/network errors (default 2) */
@@ -542,6 +795,8 @@ declare class TileAuth {
     private registerLifecycleHandlers;
 }
 
+/** Symbol-artwork families served by the Style API. */
+type ChrtSymbolSet = "s52" | "s101" | "chrt" | "raster";
 /** Palette themes served by the Style API (S-52 colour tables). */
 type ChrtStyleTheme = "day" | "dusk" | "night";
 interface StyleUrlOptions {
@@ -549,11 +804,12 @@ interface StyleUrlOptions {
      *  default — for keys with a bound CHRTstyle custom style, that's the
      *  style's default palette. */
     theme?: ChrtStyleTheme;
-    /** Symbol artwork family: "s52" (default) or "s101" (official S-101
-     *  Portrayal Catalogue symbols). Load the matching images client-side
-     *  via `loadS101SymbolImages` / `loadChrtSymbolImages` from
-     *  `@chrtco/sdk/atlas/browser`. */
-    symbols?: "s52" | "s101" | "chrt";
+    /** Symbol-artwork family: `s52` (default PresLib set), `s101` (official
+     *  S-101 Portrayal Catalogue symbols), `chrt` (the CHRT house set), or
+     *  `raster` (CHRTraster — the traditional paper-chart portrayal that
+     *  raster charts are scans of). Load the matching images client-side
+     *  from `@chrtco/sdk/atlas/browser`. */
+    symbols?: ChrtSymbolSet;
 }
 interface FetchStyleOptions extends StyleUrlOptions {
     signal?: AbortSignal;
@@ -629,6 +885,30 @@ declare class CoverageEndpoint {
     constructor(http: HttpClient);
     /** List available chart sources with cell counts */
     list(options?: CoverageOptions): Promise<CoverageResponse>;
+    /**
+     * Which ENC cells cover a passage, and how current they are.
+     *
+     * Lives on `coverage`, not `query`, deliberately: it returns *cells*, so it answers
+     * "which charts must I hold for this passage?" — a download-planning question, and
+     * the natural companion of CHRToffline. For "what might I hit along this route?",
+     * use `chrt.alongRoute()`.
+     *
+     * @example
+     * ```ts
+     * const { cells } = await chrt.coverage.forRoute({
+     *   route: [[-70.95, 42.33], [-71.0, 42.35]],
+     *   bufferNm: 1,
+     * });
+     * // cells arrive largest-scale first — S-57 says believe the finer chart
+     * for (const c of cells) {
+     *   console.log(c.cell_id, `ed ${c.edition}/${c.update_number}`, c.issue_date);
+     * }
+     * ```
+     *
+     * @remarks An empty `cells` array means CHRT holds no chart for this passage — a
+     * reason to stop and check official charts, never a sign the passage is clear.
+     */
+    forRoute(options: CoverageRouteOptions): Promise<CoverageRouteResponse>;
 }
 
 /**
@@ -1594,6 +1874,29 @@ declare function getLookupEntry(layerName: string): LookupEntry;
  * Each function takes feature properties and returns paint overrides (hex colours).
  * All expression builders accept an optional colorTable parameter.
  */
+/**
+ * Default safety contour in metres — the depth below which a feature is
+ * "dangerous to my hull" for portrayal purposes.
+ *
+ * This is the single source of truth for the *default* used by every
+ * safety-contour-driven conditional symbology rule, so the rules can't
+ * silently disagree with each other:
+ *
+ *   - §SOUNDG02 — soundings shoaler than the contour get the
+ *     high-contrast shade (see `getLabelConfig` in labels.ts).
+ *   - §CSYM02   — isolated dangers shoaler than the contour get the
+ *     DNGCIR01 ring (see `buildLayersForClass` in layer-builder.ts).
+ *
+ * Both are overridden by the user's setting (sounding panel slider,
+ * `safetyContour` in the style options); this is only the fallback when
+ * none is supplied. It matches `custom-style.ts`'s config default.
+ *
+ * NOTE: `depareFillExpression` below deliberately does NOT use this — its
+ * 2/5/10 m bands are the S-52 four-shade DEPARE ramp, a separate concept
+ * from the safety contour. Wiring those to the user's contour would change
+ * rendering for every existing user and needs its own decision.
+ */
+declare const DEFAULT_SAFETY_CONTOUR_M = 10;
 declare function depareColor(props: Record<string, unknown>, ct?: ColorTableName): string;
 declare function depareFillExpression(ct?: ColorTableName): unknown[];
 declare function lightColor(props: Record<string, unknown>, ct?: ColorTableName): string;
@@ -2090,8 +2393,15 @@ interface StyleLayer {
  *
  * Post-consolidation: all S-57 classes live as MVT layers inside one
  * consolidated PMTiles per region; `source` is always the region name.
+ *
+ * `opts.safetyContour` is the mariner's safety depth in metres — it drives
+ * the §CSYM02 isolated-danger ring on hazard classes. Defaults to
+ * `DEFAULT_SAFETY_CONTOUR_M`, the same default the SOUNDG two-shade rule
+ * uses, so the ring and the sounding colour always agree.
  */
-declare function buildLayersForClass(objectClass: string, ct: ColorTableName, sourceId?: string): StyleLayer[];
+declare function buildLayersForClass(objectClass: string, ct: ColorTableName, sourceId?: string, opts?: {
+    safetyContour?: number;
+}): StyleLayer[];
 /**
  * Get the full ordered list of object classes for style generation.
  * Uses S52_DRAW_ORDER as base, then adds any missing classes from the
@@ -2257,6 +2567,64 @@ declare function withinBboxFilter(bbox: BBox): unknown[];
  */
 declare function worldMinusBboxPolygon(bbox: BBox): GeoJSON.Polygon;
 
+/**
+ * Dominance fan-out collapse (P8 Phase 3.3 / D4 "axis 1").
+ *
+ * `makeBandVariants()` historically emitted, per (class, band): one
+ * "not-dominated" layer plus up to five `-domBy{D}` copies that differ ONLY
+ * in their dominance filter and a `maxzoom` of `dominatedVariantMaxzoom(D)`.
+ * That fan existed because MapLibre filters could not read `["zoom"]`. They
+ * can now (style-spec 24.8.5; buckets evaluate at the tile's `overscaledZ`),
+ * so the whole fan folds into ONE layer per (class, band) whose filter
+ * carries the zoom gate.
+ *
+ * **Construction principle — read before changing anything here.** The
+ * collapsed filter is the literal `["any"]` UNION of the clauses the fan
+ * already encoded: every variant the legacy emitter would have produced
+ * contributes exactly one `["all", <its dominance filter>, ["<", ["zoom"],
+ * <its maxzoom>]]` clause, and the dead-variant skip is mirrored too.
+ * Equivalence is therefore *structural*, not re-derived — which matters,
+ * because the two "obvious" hand-written forms are both wrong:
+ *
+ *   1. A `["match", ["get","_dominated_by_min"], 2,5, 3,7, 4,9, 5,11, 6,11, 24]`
+ *      threshold (the form the design doc proposed) uses band 6's *eligibility*
+ *      zoom 11. The real ceiling is `dominatedVariantMaxzoom("6") = 13` — band
+ *      6's DATA floor. Using 11 reopens the z11–z12 void window that
+ *      `band-priority.ts` documents closing.
+ *   2. That same form silently drops the legacy `_dominated: true` boolean,
+ *      which `dominatedByMinFilter("6")` still honours. A legacy-tagged feature
+ *      has no `_dominated_by_min`, so `match` falls to its default and the
+ *      feature renders FOREVER instead of dropping at z13.
+ *
+ * Deriving the gate from the emitter's own clauses avoids both by construction.
+ * `band-collapse.test.ts` re-proves it on every CI run by differentially
+ * evaluating legacy-vs-collapsed through MapLibre's real three gates.
+ *
+ * **Scope.** This is axis 1 ONLY: the per-band layers survive, with identical
+ * ids and identical positions, so the band-major draw order is untouched.
+ * "Axis 2" (collapsing the per-band copies into one layer per class) was
+ * evaluated and **KILLED** — it is unsound for the opaque-fill classes
+ * (`DOMINANCE_EXEMPT_FILL_CLASSES` ≡ `OPAQUE_FILL_LAYERS`), where band-major
+ * order is the ONLY thing separating the bands, and 15/15 class pairs are
+ * provably unsatisfiable with one layer each. Do not reintroduce it.
+ * Evidence: `.chrt/perf/2026-07-14-p8-d4-spike.md`.
+ *
+ * **Load-bearing invariant.** The collapsed layer MUST keep the `-band{B}`
+ * id segment: `custom-style.ts` `bandFloor()` parses `/-band(\d)/` to clamp
+ * customer minzoom/scamin overrides to the band's data floor, on the live
+ * public Style API path. Renaming the id silently unclamps those overrides.
+ * Asserted in `band-collapse.test.ts`.
+ */
+
+/**
+ * Which emitter the style generator uses for the dominance fan.
+ * `"legacy"` exists so CI can differentially prove the two equivalent (it is
+ * the oracle in `band-collapse.test.ts`) and as a one-line rollback. It is an
+ * internal knob — deliberately NOT on the exported `StyleGeneratorOptions`,
+ * so it cannot reach `@chrtco/sdk` consumers via `ChrtStyleOptions`.
+ */
+type BandFanMode = "collapsed" | "legacy";
+
 /**
  * Generates a complete Mapbox GL Style Specification v8 JSON
  * from the S-52 atlas definitions.
@@ -2312,11 +2680,21 @@ interface StyleGeneratorOptions extends BuildSourcesOptions {
      * CHRT house ATON/LIGHTS glyphs with colour-true tinting — see
      * chrt-style.ts. Selection logic differences are documented per module.
      */
-    symbolSet?: "s52" | "s101" | "chrt";
+    symbolSet?: "s52" | "s101" | "chrt" | "raster";
     /**
-     * S-52 §SOUNDG02 — soundings shoaler than this depth (metres) render in
-     * the high-contrast color; deeper soundings render in the muted color.
-     * Default 10 m.
+     * The mariner's safety contour in metres — the depth below which a
+     * feature is "dangerous to my hull". Drives both safety-contour
+     * conditional symbology rules:
+     *
+     *   - §SOUNDG02 — soundings shoaler than this render in the
+     *     high-contrast color; deeper soundings render in the muted color.
+     *   - §CSYM02   — isolated dangers (rocks / wrecks / obstructions)
+     *     shoaler than this get the DNGCIR01 danger ring.
+     *
+     * Default `DEFAULT_SAFETY_CONTOUR_M` (10 m).
+     *
+     * Does not affect the DEPARE depth-area shading, whose 2/5/10 m bands
+     * are a separate S-52 concept.
      */
     safetyContour?: number;
     /**
@@ -2329,7 +2707,9 @@ interface StyleGeneratorOptions extends BuildSourcesOptions {
      */
     soundingFontWeight?: "regular" | "semibold";
 }
-declare function generateStyle(palette?: ColorTableName, opts?: StyleGeneratorOptions): MapboxStyle;
+declare function generateStyle(palette?: ColorTableName, opts?: StyleGeneratorOptions & {
+    bandFan?: BandFanMode;
+}): MapboxStyle;
 declare function generateStyleJSON(palette?: ColorTableName, opts?: StyleGeneratorOptions): string;
 /** Get summary stats about the generated style */
 declare function getStyleStats(style: MapboxStyle): {
@@ -2426,12 +2806,236 @@ declare function chrtAtonTintExpression(): unknown[];
  *  the encoded colour, unlike the S-52 three-bucket flares); colourless
  *  lights read as white with the dark halo carrying contrast. */
 declare function chrtLightTintExpression(): unknown[];
+/** Per-class house icon expressions. Classes not listed keep their S-52
+ *  icons (e.g. TOPMAR's minimal black shapes already fit the house look). */
+declare const CHRT_ICON_EXPRESSIONS: Record<string, () => string | unknown[]>;
 /**
  * Switch a generated style document to the CHRT house symbol set: rewrite
- * the ATON/LIGHTS icon expressions and inject the colour-true tint on
- * tintable layers. Returns the same style object (mutated).
+ * the ATON/LIGHTS icon expressions, inject the colour-true tint on tintable
+ * layers, and restore the house dash on the cable/pipeline family. Returns
+ * the same style object (mutated).
+ *
+ * @param palette  Active colour table, used to resolve the house dash tokens.
+ *   Defaults to DAY so existing single-arg callers keep working.
+ */
+declare function applyChrtSymbolSet(style: MapboxStyle, palette?: ColorTableName): MapboxStyle;
+
+declare const CHRT_GLYPH_SVGS: Record<string, string>;
+
+declare const CHRTRASTER_SVGS: Record<string, string>;
+declare const CHRTRASTER_REF_CROPS: Record<string, {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}>;
+
+/**
+ * CHRTraster symbol-set support — the traditional PAPER-CHART ATON
+ * portrayal, so a digital chart reads like the raster charts (RNCs) that
+ * are scans of the paper charts.
+ *
+ * Two artwork sources cover the paper lookup table
+ * (`S52_ATON_LOOKUPS_PAPER` in s52-aton-lookups-generated.ts):
+ *
+ *  - Paper-table symbols that exist as vendored PresLib VECTORS
+ *    (BOYCAN01, BCNTOW01, …) render from the standard S-52 image set,
+ *    unprefixed — no duplicate registration.
+ *  - The ~131 colour-banded paper variants that are raster-only in the
+ *    reference are synthesized as vectors (hull geometry lifted from the
+ *    vendored paper glyphs; colours from each symbol's own reference
+ *    metadata — see scripts/gen-chrtraster-svgs.ts) and registered under
+ *    the `raster:` image namespace.
+ *
+ * Selection logic is the PresLib PAPER lookup table compiled through the
+ * same expression machinery as the s52 family (`compileAtonExpression`).
+ * Classes whose paper table matches the s52 family's table (TOPMAR,
+ * DAYMAR, FOGSIG, RTPBCN already use Paper there) keep their s52
+ * expressions untouched. LIGHTS keeps the LIGHTS05/06 flare — paper
+ * charts use the same magenta flare family.
+ */
+
+/** MapLibre image-id namespace for the synthesized paper variants. */
+declare const RASTER_ICON_PREFIX = "raster:";
+/** Synthesized paper-variant symbol names (unprefixed). */
+declare const RASTER_GLYPH_NAMES: ReadonlySet<string>;
+/**
+ * Map a paper-lookup symbol name to the image id CHRTraster renders it
+ * from: synthesized variants under `raster:`, vendored PresLib vectors
+ * bare, unavailable names null (their rows stay dropped, exactly like the
+ * generator's `dropped` accounting).
+ */
+declare function resolveRasterImage(name: string): string | null;
+/**
+ * Classes the CHRTraster set actually re-portrays: those whose PAPER
+ * lookup differs from the s52 family's table. Computed from the generated
+ * data so it can never drift from it. TOPMAR and DAYMAR are excluded for
+ * the same reason they're excluded from ATON_EXPRESSION_CLASSES — their
+ * paper rows reference the TOPSHP glyph family we don't synthesize, and
+ * the s52 family's hand-written TOPSHP mapping already uses the paper
+ * topmark vectors.
+ */
+declare const RASTER_ATON_CLASSES: ReadonlyArray<string>;
+/** Paper-table icon expression for a CHRTraster class. */
+declare function rasterAtonIconExpression(objectClass: string): string | unknown[];
+/** Themed SVG for a synthesized paper variant (tokens → palette hex). */
+declare function getRasterSvg(name: string, table?: ColorTableName): string | null;
+/**
+ * Switch a generated style document to the CHRTraster symbol set: every
+ * symbol layer belonging to a paper-differing ATON class gets its
+ * icon-image recompiled from the PAPER lookup table. All other layers —
+ * and the LIGHTS flares — are untouched. Returns the same style object
+ * (mutated), for chaining.
+ */
+declare function applyRasterSymbolSet(style: MapboxStyle): MapboxStyle;
+
+/** One attribute-keyed lookup row: every attr must match for the row to fire. */
+interface AtonLookupRow {
+    /** [S-57 attribute acronym, required value — comma list for L-types] */
+    attrs: ReadonlyArray<readonly [string, string]>;
+    symbol: string;
+}
+interface AtonClassLookup {
+    table: "Simplified" | "Paper";
+    /** Rows ordered by S-52 best-match precedence (most attrs first, stable). */
+    rows: ReadonlyArray<AtonLookupRow>;
+    /** The attribute-less reference row's symbol, if any. */
+    defaultSymbol: string | null;
+    /** Reference rows not compiled into the expression, with the reason. */
+    dropped: ReadonlyArray<{
+        attrs: ReadonlyArray<string>;
+        symbol: string | null;
+        reason: string;
+    }>;
+}
+declare const S52_ATON_LOOKUPS: Record<string, AtonClassLookup>;
+/**
+ * CHRTraster: the PresLib PAPER-chart lookup table for every ATON class —
+ * the traditional symbology NOAA raster charts (RNC scans of the paper
+ * charts) use. 565 attribute-keyed rows. Serve via symbols=raster.
+ */
+declare const S52_ATON_LOOKUPS_PAPER: Record<string, AtonClassLookup>;
+
+/**
+ * The symbol-artwork families, as one shared vocabulary.
+ *
+ * `applyS101SymbolSet` / `applyChrtSymbolSet` / `applyRasterSymbolSet`
+ * switch a whole generated style document. Consumers that build layers
+ * class-by-class (the /map viewer's renderer) need the same decision at
+ * the level of a single class — that's `iconExpressionForFamily`, so the
+ * viewer and the Style API can never disagree about what a family means.
+ */
+type SymbolFamily = "s52" | "s101" | "chrt" | "raster";
+/** Every family, in presentation order. Mirrors the Style API's
+ *  `?symbols=` values (SYMBOL_SET_PARAMS in the tile worker). */
+declare const SYMBOL_FAMILIES: readonly SymbolFamily[];
+interface SymbolFamilyMeta {
+    /** Short UI label. */
+    label: string;
+    /** One-line description of what the family is. */
+    description: string;
+}
+declare const SYMBOL_FAMILY_META: Record<SymbolFamily, SymbolFamilyMeta>;
+/** Narrow an arbitrary string to a family, or null. Case-insensitive. */
+declare function parseSymbolFamily(raw: string | null | undefined): SymbolFamily | null;
+/**
+ * The icon-image expression for one S-57 class under a given family —
+ * the per-class equivalent of the `apply*SymbolSet` style rewrites.
+ * Classes a family doesn't restyle fall back to the S-52 expression,
+ * exactly as they do on a served style.
+ */
+declare function iconExpressionForFamily(objectClass: string, family: SymbolFamily): string | unknown[];
+
+/**
+ * Spec-exact ATON + LIGHTS icon selection, compiled from the S-52 PresLib
+ * lookup tables in `s52-aton-lookups-generated.ts` (P7b wave A1).
+ *
+ * The generated rows are ordered by S-52 best-match precedence (most
+ * attributes first); compiling them into a first-match `case` expression
+ * reproduces the reference matcher. Attribute matchers respect S-57 types:
+ *
+ *  - E (enumeration) attributes arrive as numbers in MVT (or occasionally
+ *    strings); matched by numeric OR stringified equality.
+ *  - L (list) attributes arrive as `["3","4","3"]` (GeoJSON path) or the
+ *    JSON-stringified `'["3","4","3"]'` (post-tippecanoe) — see the shape
+ *    notes on `listAttrCase` in s52-conditional.ts. The PresLib lookup
+ *    requires the FULL list to match (order-sensitive), so we compare the
+ *    `to-string` of the attribute against every canonical encoding of the
+ *    required list.
+ *
+ * LIGHTS has no lookup rows (the table delegates to CS(LIGHTS05)); the
+ * flare selection here transcribes the PresLib LIGHTS05/06 procedure as
+ * implemented by OpenCPN s52cnsy.cpp `_selSYcol()` + the CATLIT pre-checks:
+ * red→LIGHTS11, green→LIGHTS12, white/yellow/amber→LIGHTS13,
+ * white+red→LIGHTS11, white+green→LIGHTS12, floodlight/fog-detector→LIGHTS82,
+ * strip light→LIGHTS81, everything else→LITDEF11. The vendored flare SVGs
+ * carry the spec colour and the 135° flare rotation baked in, so selection
+ * is purely icon-name choice. Sector geometry (SECTR1/SECTR2 arcs) stays
+ * app-side (P6); this module only picks the symbol at the light.
+ */
+
+/** Classes whose icon selection is fully lookup-table-driven. TOPMAR and
+ *  DAYMAR are deliberately absent: their reference tables delegate to the
+ *  TOPMAR01 CSP or reference raster-only combo symbols, so the hand-written
+ *  TOPSHP mapping in symbols.ts remains their (documented) approximation. */
+declare const ATON_EXPRESSION_CLASSES: ReadonlyArray<string>;
+/**
+ * Build the data-driven icon-image expression for an ATON class from its
+ * PresLib lookup rows. Returns the bare default symbol name when the class
+ * has no attribute-keyed rows (single-symbol classes like BOYSAW).
+ */
+declare function atonIconExpression(objectClass: string): string | unknown[];
+/**
+ * LIGHTS flare selection per the LIGHTS05/06 conditional symbology
+ * procedure (see module header for provenance). COLOUR codes: 1 white,
+ * 3 red, 4 green, 6 yellow, 9 amber.
+ */
+declare function lightsIconExpression(): unknown[];
+
+/**
+ * S-52 area-pattern (AP) sprite namespace.
+ *
+ * The S-52 Presentation Library fills many areas with an `AP(NAME)`
+ * instruction: a tile of artwork repeated across the polygon. This module owns
+ * the image-id namespace those tiles register under. It is deliberately tiny —
+ * the prefix is the whole contract.
+ *
+ * ── Why a prefix ───────────────────────────────────────────────────────────
+ *
+ * The PresLib keys each catalogue separately, so a name is unique only WITHIN
+ * a catalogue. FOUR names are defined as both a `<symbol>` and a `<pattern>`,
+ * with different artwork:
+ *
+ *     AIRARE02  FSHFAC03  MARCUL02  QUESMRK1
+ *
+ * `ALL_S52_SVGS` is one flat map and patterns spread AFTER points, so
+ * registering pattern tiles under their bare names silently shadows those four
+ * point symbols. `AIRARE02` the symbol is a plane inside a ring; `AIRARE02` the
+ * pattern is the bare plane — so `icon-image: "AIRARE02"` would quietly draw a
+ * ringless plane and look plausible while being wrong. Prefixing keeps the two
+ * catalogues disjoint by construction. `s52-pattern.test.ts` locks it.
+ *
+ * `AP:` is named for the PresLib instruction itself, matching the existing
+ * `raster:` (`RASTER_ICON_PREFIX`) convention for namespacing image ids.
+ *
+ * Chosen to be inert for the rest of the pipeline: `style-resolver`'s colour
+ * regex (`/^[A-Z]{4,5}[0-9]?$/`) cannot match a prefixed id, so a pattern
+ * sprite id is never mistaken for a colour token and hex-converted.
+ *
+ * ── Why this lives here and not in the loader ──────────────────────────────
+ *
+ * `s52-lookup` and `s52-conditional` emit `fill-pattern` ids but must not pull
+ * in the inlined SVG catalogue — style generation runs in Workers/Node, where
+ * `s52-svgs-generated` would be dead bundle weight. So the id-minting helper
+ * lives in a catalogue-free module and the loader imports IT, not the reverse.
  */
-declare function applyChrtSymbolSet(style: MapboxStyle): MapboxStyle;
+
+/**
+ * Prefix distinguishing area-pattern (AP) sprites in the flat image namespace.
+ */
+declare const S52_PATTERN_SPRITE_PREFIX = "AP:";
+/** Registered image id for a PresLib pattern name, e.g. "VEGATN03" -> "AP:VEGATN03". */
+declare function patternSpriteId(patternName: string): string;
 
 /**
  * S-52 SVG Loader — pure (DOM-free) string operations over the inlined S-52
@@ -2446,6 +3050,13 @@ declare function applyChrtSymbolSet(style: MapboxStyle): MapboxStyle;
 /**
  * Get raw SVG string for an S-52 symbol by name (e.g., "BOYCAN01").
  * Returns null if the symbol is not found.
+ *
+ * Accepts either a registered image id ("AP:VEGATN03") or a bare PresLib name
+ * ("VEGATN03") — bare pattern names stay resolvable so the published accessor
+ * keeps working. Bare lookups are POINT-FIRST: for the four dual-catalogue
+ * names (AIRARE02, FSHFAC03, MARCUL02, QUESMRK1) this returns the point
+ * symbol, which is what a caller asking for a symbol by name means. Ask for
+ * `AP:AIRARE02` to get the pattern tile.
  */
 declare function getS52SvgString(symbolName: string): string | null;
 /**
@@ -2462,9 +3073,15 @@ declare function getThemedS52Svg(symbolName: string, colorTable?: ColorTableName
 declare function applyColorTheme(svgString: string, colorTable?: ColorTableName): string;
 /** Get a list of all available S-52 point symbol names. */
 declare function getAvailablePointSymbols(): string[];
-/** Get a list of all available S-52 pattern names. */
+/**
+ * Get a list of all available S-52 pattern names, as bare PresLib names
+ * (e.g. "VEGATN03"). Use `patternSpriteId()` for the registered image id.
+ */
 declare function getAvailablePatterns(): string[];
-/** Get a list of all available S-52 line symbol names. */
+/**
+ * Get a list of all available S-52 linestyle names, as bare PresLib names
+ * (e.g. "ACHARE51"). Use `lineSpriteId()` for the registered image id.
+ */
 declare function getAvailableLineSymbols(): string[];
 /** Stats for debugging */
 declare function getS52SymbolStats(): {
@@ -2690,7 +3307,9 @@ interface GeneratedCustomStyle {
  * palette against the config's enabled set, thread the sounding rendering
  * settings into the generator, then apply the static layer transforms.
  */
-declare function generateCustomStyle(config: CustomStyleConfig, opts?: GenerateCustomStyleOptions): GeneratedCustomStyle;
+declare function generateCustomStyle(config: CustomStyleConfig, opts?: GenerateCustomStyleOptions & {
+    bandFan?: "collapsed" | "legacy";
+}): GeneratedCustomStyle;
 
 /**
  * Generic async auto-pagination generator.
@@ -2779,7 +3398,11 @@ declare function parseWebhook(body: unknown): WebhookEvent;
  * machine-readable context for programmatic handling (byte math for budget
  * violations, `resumable: true` for interrupts, etc.).
  */
-type OfflineErrorCode = "budget_exceeded" | "coverage_denied" | "quota_exceeded" | "download_corrupt" | "network_interrupted" | "partial_file_invalid" | "invalid_api_key" | "region_not_available" | "offline_not_enabled" | "missing_device_id" | "missing_manifest_path" | "sha_missing" | "unexpected_response";
+type OfflineErrorCode = "budget_exceeded" | "coverage_denied" | "quota_exceeded" | "download_corrupt" | "network_interrupted" | "partial_file_invalid" | "invalid_api_key" | "region_not_available"
+/** The team's plan doesn't include CHRToffline (Pro and above). */
+ | "offline_requires_pro_plan"
+/** The API key lacks the `offline:download` scope. Distinct from the plan gate. */
+ | "offline_not_enabled" | "missing_device_id" | "missing_manifest_path" | "sha_missing" | "unexpected_response";
 declare class OfflineError extends Error {
     readonly code: OfflineErrorCode;
     readonly status?: number;
@@ -2817,11 +3440,97 @@ declare class Chrt {
     private tileAuth;
     private readonly region;
     private readonly tileBaseUrl;
+    /** The vessel this client answers for; defaults every depth-aware call. */
+    private readonly vessel?;
     constructor(apiKeyOrConfig: string | ChrtConfig);
     /** Query GeoJSON features by bounding box */
     features(options: FeaturesOptions): Promise<FeatureCollection>;
     /** Spatial proximity query around a point */
-    query(options: QueryOptions): Promise<FeatureCollection>;
+    query(options: QueryOptions): Promise<QueryResponse>;
+    /**
+     * What's charted ahead — the significant features in a sector from a point along a
+     * bearing. Built for the "position + COG, no route" case: a craft that has a heading
+     * but not a plan.
+     *
+     * @example
+     * ```ts
+     * const fan = await chrt.ahead({
+     *   point: [-70.9245, 42.33604],
+     *   bearing: gps.cog,        // degrees true
+     *   arc: 60,                 // full width, so ±30°
+     *   rangeNm: 3,
+     *   safetyDepth: 3,          // your draft plus a margin
+     * });
+     *
+     * for (const f of fan.features) {
+     *   const { distance_m, bearing_deg, depth_clearance_m } = f.properties;
+     *   // sort/threshold however your alert policy wants — CHRT ranks nothing
+     * }
+     * ```
+     *
+     * @remarks
+     * **This answers "what is charted ahead", not "is it safe ahead".** There is no
+     * severity score and no `safe` flag, by design: a risk model is a navigation-grade
+     * claim, and CHRT is situational-awareness only. You get facts that sort —
+     * `distance_m`, `bearing_deg`, `least_depth_m`, `depth_clearance_m` — and you own
+     * the policy.
+     *
+     * **An empty `features` array is not an all-clear.** It can mean nothing is charted
+     * there, or that CHRT has no coverage there. Always check `coverage.covered` before
+     * telling a user anything; `coverage.cells` carries the issuing office and currency
+     * of every cell under the sector.
+     *
+     * **There is no `speed` parameter, deliberately.** Turning SOG into a range means
+     * deciding how many minutes of lookahead a vessel needs — a navigational judgment
+     * that belongs to you, not to us. The usual recipe is
+     * `rangeNm = SOG_knots × lookahead_hours`, narrowing `arc` as speed rises. Re-fan on
+     * a meaningful course change rather than on a timer; a sharp turn should force an
+     * immediate re-fan on the new heading.
+     */
+    ahead(options: AheadOptions): Promise<AheadResponse>;
+    /**
+     * What's charted along a passage — the significant features in a corridor either
+     * side of a route. The passage-planning sibling of {@link ahead}.
+     *
+     * @example
+     * ```ts
+     * const passage = await chrt.alongRoute({
+     *   route: [[-70.95, 42.33], [-71.0, 42.35], [-71.02, 42.36]],
+     *   bufferNm: 0.5,
+     *   safetyDepth: 3,
+     * });
+     *
+     * if (!passage.coverage.covered) {
+     *   // CHRT holds no chart for this passage — say so; do not report it as clear.
+     * }
+     *
+     * for (const f of passage.features) {
+     *   const { along_m, distance_m, depth_clearance_m } = f.properties;
+     *   // ordered by along_m: the order you actually meet them
+     * }
+     * ```
+     *
+     * @remarks
+     * **This does not replace {@link ahead}, and `ahead` does not replace this.** A boat
+     * with a route still drifts, and COG rarely equals the route bearing — so a passage
+     * app wants both: this once per route edit, `ahead` continuously against the real
+     * track.
+     *
+     * Same invariants as `ahead`: **what is charted, never whether it is safe.** No
+     * severity, no verdict — facts that sort. And an empty `features` array is **not** a
+     * clear passage: check `coverage.covered` first.
+     *
+     * For "which cells must I download for this passage?" — a different question — use
+     * {@link CoverageEndpoint.forRoute | chrt.coverage.forRoute}.
+     */
+    alongRoute(options: AlongRouteOptions): Promise<AlongRouteResponse>;
+    /**
+     * Iterate every feature along a route, auto-paginating.
+     *
+     * @remarks Yields features only. If you need the coverage block — and for anything
+     * user-facing you do — call {@link alongRoute} directly.
+     */
+    alongRouteIter(options: Omit<AlongRouteOptions, "offset">): AsyncIterable<GeoJsonFeature<AlongRouteFeatureProperties>>;
     /**
      * Iterate all features matching a bounding-box query, auto-paginating.
      *
@@ -2838,7 +3547,7 @@ declare class Chrt {
      *
      * @example
      * ```ts
-     * for await (const cell of chrt.cellsIter({ source: "NOAA" })) {
+     * for await (const cell of chrt.cellsIter({ source: "NOAA_ENC" })) {
      *   console.log(cell.cell_id, cell.title);
      * }
      * ```
@@ -2860,13 +3569,25 @@ declare class Chrt {
      *   transformRequest: chrt.transformRequest(),
      * });
      *
-     * @remarks Pass `symbolSet: "s101"` for the official S-101 Portrayal
-     * Catalogue symbol artwork (load images via `loadS101SymbolImages` from
-     * `@chrtco/sdk/atlas/browser`); default is the S-52 set. Generated
+     * @remarks `symbolSet` picks the artwork family: `"s101"` for the
+     * official S-101 Portrayal Catalogue symbols, `"chrt"` for the CHRT house
+     * set, `"raster"` for CHRTraster (the traditional paper-chart portrayal);
+     * default is the S-52 set. Load the matching images from
+     * `@chrtco/sdk/atlas/browser` (`loadS101SymbolImages`,
+     * `loadChrtSymbolImages`, `loadChrtRasterSymbolImages`). 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?: ChrtStyleOptions): MapboxStyle;
+    /**
+     * Fill in `safetyDepth` from the vessel profile when a call didn't state one.
+     *
+     * Only substitutes when the caller omitted it entirely — an explicit `undefined`
+     * behaves the same as omission (both mean "no depth filter"), and any explicit
+     * number wins. This is the whole mechanism behind the profile: one value, defaulted
+     * in one place, never guessed.
+     */
+    private withVesselDepth;
     /**
      * URL of the served S-52 style — the CHRTstyle Style API at
      * `tiles.chrt.co/v1/styles/{region}/style.json`. Unlike {@link style}
@@ -2916,4 +3637,4 @@ declare class Chrt {
     warmTiles(region?: string): Promise<void>;
 }
 
-export { ALL_NAV_AID_LAYERS, ALL_WATER_BODY_LAYERS, AREA_QUERY_LAYERS, type AreaInspectResult, type AtlasStyle, type AttachOptions, BAND_DRAW_ORDER, BAND_PRIORITY_RANGES, type BBox, BRIDGE_QUERY_LAYERS, BUILD_MAXZOOM, BUILD_MINZOOM, type BandCode, type BandPriorityRange, type BridgeInspectResult, type BuildOfflineStyleOptions, type BuildSourcesOptions, CHART_BAND_CODES, CHART_CASCADE_CODES, CHART_SECTIONS, CHRT_ATON_COLORS, CHRT_GLYPH_NAMES, CHRT_ICON_PREFIX, CHRT_SDF_GLYPHS, type CandidateQueryOptions, type CandidatesEventContext, type CellDeletedEvent, type CellDetail, type CellEventData, type CellNewEvent, type CellUpdatedData, type CellUpdatedEvent, type CellsOptions, type CellsResponse, type ChartSection, Chrt, type ChrtConfig, ChrtError, type ChrtStyleOptions, type ChrtStyleTheme, type ClickAnchor, ColorTableName, type CoverageOptions, type CoverageResponse, type CoverageSource, type CustomStyleConfig, DEFAULT_CLICK_TOLERANCE, DEFAULT_CUSTOM_STYLE_CONFIG, DEFAULT_INSPECT_CLASS_RANK, DEFAULT_LABEL_SETTINGS, DEFAULT_NAV_AID_SETTINGS, DEFAULT_REGION, DEFAULT_SOUNDING_SETTINGS, DEFAULT_TILE_BASE_URL, DEFAULT_TILE_REGION, DEFAULT_WATER_BODY_SETTINGS, type DecodedAreaFeature, type DecodedBridge, type DecodedNavAid, type DecodedProperty, type DisplayCategory, type DisplayMode, type FeatureCollection, type FeaturesOptions, type FetchStyleOptions, FileSystemAdapter, type FlashPattern, type FlashPhase, type GenerateCustomStyleOptions, type GeneratedCustomStyle, type GeoJsonFeature, type GeoJsonGeometry, type GeomType, INSPECT_CLASS_RANK, INSPECT_RANK_DEVIATIONS, type InspectCandidate, type InspectCandidateSet, type InspectEnrichment, type InspectEventContext, type InspectNotice, type InspectOptions, type InspectResult, type InspectTargetClass, type InspectableFeature, InteractClient, type InteractEntitlement, InteractError, type InteractErrorCode, type InteractHandle, type InteractMapLike, type InteractMapMouseEvent, LABELED_LAYERS, LABEL_BEHAVIOR, LABEL_LAYER_GROUPS, LABEL_PRIORITY, type LabelBehavior, type LabelConfigOptions, type LabelLayerConfig, type LabelSettings, type LookupEntry, type MapLibreStyle, type MapboxStyle, type MapboxVectorSource, NAUTICAL_SYMBOLS, NAV_AID_LAYER_GROUPS, NAV_AID_QUERY_LAYERS, NON_SOLAS_DISCLAIMER, NON_SOLAS_DISCLAIMER_SHORT, type NauticalCategory, type NauticalSymbol, type NavAidInspectResult, type NavAidSettings, type OfflineBundleResponse, type OfflineDownloadOptions, type OfflineDownloadProgress, type OfflineDownloadResult, OfflineError, type OfflineErrorCode, type OfflineFetchStyleOptions, type OfflineHeartbeatOptions, type OfflineRegionSummary, type OfflineRemoveOptions, OfflineStyleError, type OfflineStylePlatform, type OfflineStyleResponse, type PmtilesVectorSource, type QueryOptions, type ResolvedStyle, type ResolvedTheme, type RouteFeatureQueryOptions, type RouteFeatureQueryResponse, type RouteQueryOptions, type RouteQueryResponse, type S101Feature, S101_CHART_SECTIONS, S101_FEATURES, S101_ICON_PREFIX, S101_NEW_SYMBOLS, S101_SOURCE_COMMIT, S101_SYMBOL_GROUPS, S101_SYMBOL_NAMES, S52_DRAW_ORDER, S52_LOOKUP, SOUNDING_LAYERS, SYMBOL_GROUPS, SYMBOL_MAP, type ScaleBand, type SectorArcFeature, type SectorArcFeatureCollection, type SectorInfo, type SoundingSettings, type SourceMode, type StyleGeneratorOptions, type StyleLayer, type StyleUrlOptions, type SymbolGroup, TileAuth, type TileGroup, type TileGroupsResponse, TileTokenError, type TileTokenErrorCode, type TileTokenResponse, type TransformRequest, type TransformedRequest, type VectorSourceSpec, WATER_BODY_LAYER_GROUPS, type WaterBodySettings, type WebhookEvent, type WebhookEventType, type WebhookPayload, applyChrtSymbolSet, applyColorTheme, applyCustomStyleSettings, applyS101SymbolSet, bandFilterExpression, buildFlashPattern, buildLabelLayer, buildLayersForClass, buildOfflineStyle, buildSectorArcGeoJSON, buildSectorArcsFC, buildSectorsFromFeatures, buildSources, candidateRank, chrtAtonTintExpression, chrtLightTintExpression, collectCandidates, collectClickCandidates, combineWithBandFilter, daymarkColor, decimateFeatures, decodeAreaFeatureProps, decodeBridgeProps, decodeCandidate, decodeNavAidProps, depareColor, depareFillExpression, deriveMarinerName, extractNavAidDesignation, featureIdentity, generateCustomStyle, generateSpriteManifest, generateSpriteSheet, generateStyle, generateStyleJSON, getAvailableLineSymbols, getAvailablePatterns, getAvailablePointSymbols, getCollisionSettings, getDrawPriority, getGridSizeForZoom, getIconExpression, getLabelBehavior, getLabelConfig, getLabelPriority, getLookupEntry, getMaxCellsForZoom, getOrderedClasses, getS52SvgString, getS52SymbolStats, getStyleStats, getSymbolSvgString, getThemedS101Svg, getThemedS52Svg, getTopmarkMeaning, hazardColor, hazardFillExpression, isLabelLayerVisible, isNavAidLayer, isNavAidLayerVisible, isSoundingLayerVisible, isVisibleInMode, isWaterBodyLayerVisible, labelSortKey, lateralColor, lateralFillExpression, lightColor, lightFillExpression, normalizeTheme, paginate, parseListCodes, parseWebhook, preprocessLights, preprocessNavAids, preprocessSoundings, preprocessWaterBodies, resolveCustomTheme, resolveS101Color, resolveStyle, resolveTargetClass, sanitizeCustomStyleConfig, scaleSizeValue, scaminToMinZoom, withinBboxFilter, worldMinusBboxPolygon };
+export { ALL_NAV_AID_LAYERS, ALL_WATER_BODY_LAYERS, AREA_QUERY_LAYERS, ATON_EXPRESSION_CLASSES, type AheadCoverageCell, type AheadFeatureProperties, type AheadOptions, type AheadResponse, type AlongRouteFeatureProperties, type AlongRouteOptions, type AlongRouteResponse, type AreaInspectResult, type AtlasStyle, type AttachOptions, BAND_DRAW_ORDER, BAND_PRIORITY_RANGES, type BBox, BRIDGE_QUERY_LAYERS, BUILD_MAXZOOM, BUILD_MINZOOM, type BandCode, type BandPriorityRange, type BridgeInspectResult, type BuildOfflineStyleOptions, type BuildSourcesOptions, CHART_BAND_CODES, CHART_CASCADE_CODES, CHART_SECTIONS, CHRTRASTER_REF_CROPS, CHRTRASTER_SVGS, CHRT_ATON_COLORS, CHRT_GLYPH_NAMES, CHRT_GLYPH_SVGS, CHRT_ICON_EXPRESSIONS, CHRT_ICON_PREFIX, CHRT_SDF_GLYPHS, type CandidateQueryOptions, type CandidatesEventContext, type CellDeletedEvent, type CellDetail, type CellEventData, type CellNewEvent, type CellUpdatedData, type CellUpdatedEvent, type CellsOptions, type CellsResponse, type ChartSection, Chrt, type ChrtConfig, ChrtError, type ChrtStyleOptions, type ChrtStyleTheme, type ChrtSymbolSet, type ClickAnchor, ColorTableName, type CoverageOptions, type CoverageResponse, type CoverageRouteCell, type CoverageRouteOptions, type CoverageRouteResponse, type CoverageSource, type CustomStyleConfig, DEFAULT_CLICK_TOLERANCE, DEFAULT_CUSTOM_STYLE_CONFIG, DEFAULT_INSPECT_CLASS_RANK, DEFAULT_LABEL_SETTINGS, DEFAULT_NAV_AID_SETTINGS, DEFAULT_REGION, DEFAULT_SAFETY_CONTOUR_M, DEFAULT_SOUNDING_SETTINGS, DEFAULT_TILE_BASE_URL, DEFAULT_TILE_REGION, DEFAULT_WATER_BODY_SETTINGS, type DecodedAreaFeature, type DecodedBridge, type DecodedNavAid, type DecodedProperty, type DisplayCategory, type DisplayMode, type FeatureCollection, type FeaturesOptions, type FetchStyleOptions, FileSystemAdapter, type FlashPattern, type FlashPhase, type GenerateCustomStyleOptions, type GeneratedCustomStyle, type GeoJsonFeature, type GeoJsonGeometry, type GeomType, INSPECT_CLASS_RANK, INSPECT_RANK_DEVIATIONS, type InspectCandidate, type InspectCandidateSet, type InspectEnrichment, type InspectEventContext, type InspectNotice, type InspectOptions, type InspectResult, type InspectTargetClass, type InspectableFeature, InteractClient, type InteractEntitlement, InteractError, type InteractErrorCode, type InteractHandle, type InteractMapLike, type InteractMapMouseEvent, LABELED_LAYERS, LABEL_BEHAVIOR, LABEL_LAYER_GROUPS, LABEL_PRIORITY, type LabelBehavior, type LabelConfigOptions, type LabelLayerConfig, type LabelSettings, type LookupEntry, type MapLibreStyle, type MapboxStyle, type MapboxVectorSource, NAUTICAL_SYMBOLS, NAV_AID_LAYER_GROUPS, NAV_AID_QUERY_LAYERS, NON_SOLAS_DISCLAIMER, NON_SOLAS_DISCLAIMER_SHORT, type NauticalCategory, type NauticalSymbol, type NavAidInspectResult, type NavAidSettings, type OfflineBundleResponse, type OfflineDownloadOptions, type OfflineDownloadProgress, type OfflineDownloadResult, OfflineError, type OfflineErrorCode, type OfflineFetchStyleOptions, type OfflineHeartbeatOptions, type OfflineRegionSummary, type OfflineRemoveOptions, OfflineStyleError, type OfflineStylePlatform, type OfflineStyleResponse, type PmtilesVectorSource, type QueryFeatureProperties, type QueryOptions, type QueryResponse, RASTER_ATON_CLASSES, RASTER_GLYPH_NAMES, RASTER_ICON_PREFIX, type ResolvedStyle, type ResolvedTheme, type S101Feature, S101_CHART_SECTIONS, S101_FEATURES, S101_ICON_PREFIX, S101_NEW_SYMBOLS, S101_SOURCE_COMMIT, S101_SYMBOL_GROUPS, S101_SYMBOL_NAMES, S52_ATON_LOOKUPS, S52_ATON_LOOKUPS_PAPER, S52_DRAW_ORDER, S52_LOOKUP, S52_PATTERN_SPRITE_PREFIX, SOUNDING_LAYERS, SYMBOL_FAMILIES, SYMBOL_FAMILY_META, SYMBOL_GROUPS, SYMBOL_MAP, type ScaleBand$1 as ScaleBand, type SectorArcFeature, type SectorArcFeatureCollection, type SectorInfo, type SoundingSettings, type SourceMode, type StyleGeneratorOptions, type StyleLayer, type StyleUrlOptions, type SymbolFamily, type SymbolFamilyMeta, type SymbolGroup, TileAuth, type TileGroup, type TileGroupsResponse, TileTokenError, type TileTokenErrorCode, type TileTokenResponse, type TransformRequest, type TransformedRequest, type VectorSourceSpec, type VesselProfile, WATER_BODY_LAYER_GROUPS, type WaterBodySettings, type WebhookEvent, type WebhookEventType, type WebhookPayload, applyChrtSymbolSet, applyColorTheme, applyCustomStyleSettings, applyRasterSymbolSet, applyS101SymbolSet, atonIconExpression, bandFilterExpression, buildFlashPattern, buildLabelLayer, buildLayersForClass, buildOfflineStyle, buildSectorArcGeoJSON, buildSectorArcsFC, buildSectorsFromFeatures, buildSources, candidateRank, chrtAtonTintExpression, chrtLightTintExpression, collectCandidates, collectClickCandidates, combineWithBandFilter, daymarkColor, decimateFeatures, decodeAreaFeatureProps, decodeBridgeProps, decodeCandidate, decodeNavAidProps, depareColor, depareFillExpression, deriveMarinerName, extractNavAidDesignation, featureIdentity, generateCustomStyle, generateSpriteManifest, generateSpriteSheet, generateStyle, generateStyleJSON, getAvailableLineSymbols, getAvailablePatterns, getAvailablePointSymbols, getCollisionSettings, getDrawPriority, getGridSizeForZoom, getIconExpression, getLabelBehavior, getLabelConfig, getLabelPriority, getLookupEntry, getMaxCellsForZoom, getOrderedClasses, getRasterSvg, getS52SvgString, getS52SymbolStats, getStyleStats, getSymbolSvgString, getThemedS101Svg, getThemedS52Svg, getTopmarkMeaning, hazardColor, hazardFillExpression, iconExpressionForFamily, isLabelLayerVisible, isNavAidLayer, isNavAidLayerVisible, isSoundingLayerVisible, isVisibleInMode, isWaterBodyLayerVisible, labelSortKey, lateralColor, lateralFillExpression, lightColor, lightFillExpression, lightsIconExpression, normalizeTheme, paginate, parseListCodes, parseSymbolFamily, parseWebhook, patternSpriteId, preprocessLights, preprocessNavAids, preprocessSoundings, preprocessWaterBodies, rasterAtonIconExpression, resolveCustomTheme, resolveRasterImage, resolveS101Color, resolveStyle, resolveTargetClass, sanitizeCustomStyleConfig, scaleSizeValue, scaminToMinZoom, withinBboxFilter, worldMinusBboxPolygon };