@navaramap/three 0.0.1 → 0.0.3

package/src/material/enhancer/tileComposite/tileCompositeBaseEnhancer/mutates.ts

@@ -26,7 +26,11 @@ export type CoreUniformMutates = {
   bindSlot: (compactSlot: number, layer: CompositeLayer | undefined) => void;
 };
 
-export function createCoreUniformMutates(): CoreUniformMutates {
+/** `mercatorY` is Rust's clamped WebMercator northing, injected through the
+ * event context (`TileHandler.mercatorY`) like every other engine call. */
+export function createCoreUniformMutates(
+  mercatorY: (lat: number) => number,
+): CoreUniformMutates {
   const refs = {
     uShows: new Uniform<number[]>([]),
     uOpacities: new Uniform<number[]>([]),
@@ -120,8 +124,14 @@ export function createCoreUniformMutates(): CoreUniformMutates {
         const span = (Tn - Ts) / layer.uvScale.y;
         const Rs = Ts - layer.uvOffset.y * span;
         const Rn = Rs + span;
-        const mRs = Math.log(Math.tan(Math.PI * 0.25 + Rs * 0.5));
-        const mRn = Math.log(Math.tan(Math.PI * 0.25 + Rn * 0.5));
+        // Rust's clamped Mercator northing — the same function the bake affine
+        // uses (`uv_rect_from_extents_mercator`), so the pasted band stays
+        // aligned with the baked render target. The clamp matters: a polar
+        // tile's band reaches ±90° (as f32, slightly past it), where unclamped
+        // log(tan(...)) returns NaN — and a NaN span fails the shader's
+        // `abs(mDen)` guard, silently disabling reprojection for the tile.
+        const mRs = mercatorY(Rs);
+        const mRn = mercatorY(Rn);
         // Polar cap: clamp the overshoot onto the band-edge texel when this tile's
         // north/south edge sits on the WebMercator latitude limit.
         const clampTop = Rn >= WM_MAX_LAT - 1e-4 ? 1 : 0;

package/src/material/overrideMaterialsForMRT.ts

@@ -431,8 +431,13 @@ export function setupMaterialForMRT(
   material: ShaderMaterial,
   options?: SetupMaterialForMRTOptions,
 ): void {
-  if (material instanceof LineMaterial) {
-    injectGBufferToLineMaterial(material);
+  // Detect LineMaterial by `type`, not only `instanceof`: callers may construct
+  // it from `three/examples/jsm/lines` while this module's `LineMaterial` comes
+  // from `three-stdlib`, so a bare `instanceof` misses those cross-copy
+  // instances and would wrongly route them through the ShaderMaterial path
+  // (whose normal-buffer write references an undeclared `normal`).
+  if (material instanceof LineMaterial || material.type === "LineMaterial") {
+    injectGBufferToLineMaterial(material as LineMaterial);
     return;
   }
   injectGBufferToShaderMaterial(material, options?.normal);

package/src/mesh/batchTexture.ts

@@ -183,8 +183,7 @@ export function getRowIndex(
   row: BatchTextureRowKey,
 ): number {
   const config = material.userData.batchTextureConfig as
-    | BatchTextureConfig
-    | undefined;
+    BatchTextureConfig | undefined;
   invariant(config);
 
   const rowIndex = config.rows.indexOf(row);
@@ -238,8 +237,7 @@ export function updateBatchAttribute(
   const data = texture.image.data as Float32Array;
   const texWidth = texture.image.width;
   const config = material.userData.batchTextureConfig as
-    | BatchTextureConfig
-    | undefined;
+    BatchTextureConfig | undefined;
   const rowCount = config?.rows.length ?? BATCH_TEXTURE_ROW.length;
 
   switch (attribute) {

package/src/mesh/batchedSdfText.ts

@@ -3,9 +3,13 @@ import type {
   TextMaterial as NavaraTextMaterial,
 } from "@navaramap/engine";
 import type { FontManager } from "@navaramap/font";
-import { type Color } from "three";
+import { Color } from "three";
 import invariant from "tiny-invariant";
 
+import type {
+  DeclutterCandidate,
+  DeclutterParticipant,
+} from "../declutter/types";
 import type { EventContext } from "../event/context";
 
 import { InstancedMesh, type InstancedMeshOptions } from "./instanced";
@@ -34,9 +38,25 @@ type PositionsInfo = PositionsInfoBase &
       }
   );
 
+/**
+ * Per-feature evaluator state received before the feature's `SDFTextMesh`
+ * exists (meshes are created lazily on the first non-empty text — see
+ * `initMeshes`). Replayed onto the mesh at creation. Colors are kept as hex
+ * so a shared evaluator `Color` instance mutated later can't leak in.
+ */
+type PendingFeatureState = {
+  colorHex?: number;
+  show?: boolean;
+  height?: number;
+  size?: number;
+  opacity?: number;
+  declutterPriority?: number | undefined;
+  hasDeclutterPriority?: boolean;
+};
+
 export class BatchedSdfTextMesh
   extends InstancedMesh<SDFTextMesh>
-  implements PickableMesh
+  implements PickableMesh, DeclutterParticipant
 {
   readonly ctx: EventContext;
   /** The font identifier from material — may be a family name or a URL. */
@@ -55,6 +75,15 @@ export class BatchedSdfTextMesh
    * and must be balanced with unloadFont() on dispose or font change.
    */
   private _loadedFaceUrls: Set<string>;
+  /** Geometry-extracted anchor data; per-index meshes slice it lazily. */
+  private _positions: PositionsInfo | null = null;
+  /** Sparse batchIndex → mesh; `allMeshes` holds only created meshes. */
+  private _meshByIndex: (SDFTextMesh | undefined)[] = [];
+  /** Evaluator state received before a feature's mesh exists. */
+  private _pending = new Map<number, PendingFeatureState>();
+  /** Material/transform used when creating meshes lazily. */
+  private _material: NavaraTextMaterial;
+  private _transform: NavaraTextMesh["transform"];
 
   constructor(
     ctx: EventContext,
@@ -70,7 +99,12 @@ export class BatchedSdfTextMesh
     invariant(ctx.fontManager);
     this._fontManager = ctx.fontManager;
     this._loadedFaceUrls = loadedFaceUrls ?? new Set();
-    this.initMeshes(m);
+    // One getter call each: wasm getters clone, so these snapshots are owned
+    // by this batch and safe to use after the event object is freed.
+    this._material = m.material;
+    this._transform = m.transform;
+    this._positions = this.extractPositions(m);
+    this.initMeshes();
     // When the shared atlas evicts glyphs, a still-in-flight glyph this batch
     // already baked into a visible mesh may have had its rect reused. Rebuild
     // any such stale mesh so its UVs and retains refresh.
@@ -79,6 +113,41 @@ export class BatchedSdfTextMesh
       this._highQuality,
       () => this._revalidateStaleMeshes(),
     );
+    ctx.declutter?.register(this);
+  }
+
+  // --- DeclutterParticipant ---
+
+  collectDeclutterCandidates(out: DeclutterCandidate[]): void {
+    if (!this.visible) return;
+    const meshes = this.meshes();
+    for (let i = 0; i < meshes.length; i++) {
+      const candidate = meshes[i].getDeclutterCandidate(this, i);
+      if (candidate) out.push(candidate);
+    }
+  }
+
+  applyDeclutter(handle: number, hidden: boolean): void {
+    this.meshes()[handle]?.setDeclutterHidden(hidden);
+  }
+
+  stepDeclutterFade(deltaMs: number): boolean {
+    let animating = false;
+    for (const mesh of this.meshes()) {
+      animating = mesh.stepDeclutterFade(deltaMs) || animating;
+    }
+    return animating;
+  }
+
+  /** Candidates changed (text, style, position, visibility): ask the shared
+   *  declutter pass to re-place on its next update. */
+  private _markDeclutterDirty(): void {
+    this.ctx.declutter?.markDirty();
+  }
+
+  override setActive(active: boolean) {
+    super.setActive(active);
+    this._markDeclutterDirty();
   }
 
   /**
@@ -111,6 +180,7 @@ export class BatchedSdfTextMesh
           // Force a rebuild even though the text string is unchanged: the baked
           // atlas rects and glyph retains must refresh against the new metrics.
           mesh.setText(text, true);
+          this._markDeclutterDirty();
           this._needRender?.();
         })
         .catch((err: unknown) => {
@@ -127,73 +197,149 @@ export class BatchedSdfTextMesh
     return this._highQuality;
   }
 
-  private initMeshes(m: NavaraTextMesh) {
-    const positionInfo = this.extractPositions(m);
+  /**
+   * A mesh per anchor is expensive (geometry + ShaderMaterial + enhancer
+   * mount), and with per-feature texts (MVT) most features never receive a
+   * non-empty text — they'd sit invisible while still costing construction and
+   * every per-frame loop. So meshes are created lazily by `_ensureMeshAt` on
+   * the first non-empty `setTextByBatchIndex`. Only a non-empty material-level
+   * default text (single-label sources) renders without the evaluator ever
+   * setting text, so only that case creates all meshes eagerly.
+   */
+  private initMeshes() {
+    const positionInfo = this._positions;
     if (!positionInfo) {
       return;
     }
 
-    const { position, nPositions, positionSize, batchIDs, batchIDSize, RTE } =
-      positionInfo;
+    if (this._material.text) {
+      // The atlas can't be reallocated within this synchronous loop, so fetch
+      // the shared textures once and hand them to every creation.
+      const shared = this._sharedTextures();
+      for (let i = 0; i < positionInfo.nPositions; i++) {
+        this._ensureMeshAt(i, shared);
+      }
+    }
+  }
 
-    const material = m.material;
-    const transform = m.transform;
+  /** The font-level shared atlas textures for this batch's font+quality (the
+   *  color atlas is `null` for monochrome fonts). */
+  private _sharedTextures() {
+    return {
+      tex: this._fontManager.getAtlasTexture(
+        this._fontIdentifier,
+        this._highQuality,
+      ),
+      colorTex: this._fontManager.getColorAtlasTexture(
+        this._fontIdentifier,
+        this._highQuality,
+      ),
+    };
+  }
 
-    // Get the font-level shared atlas textures (one DataTexture per font,
-    // shared across all per-feature meshes). The color atlas is `null` for
-    // monochrome fonts.
-    const sharedTex = this._fontManager.getAtlasTexture(
+  /**
+   * The feature's mesh, created on first need (see `initMeshes`). `shared`
+   * lets a batch creation pass hoist the atlas lookups; when omitted (a single
+   * lazy creation) they are fetched here, since the atlas may have been
+   * (re)allocated since this batch was constructed.
+   */
+  private _ensureMeshAt(
+    batchIndex: number,
+    shared?: ReturnType<BatchedSdfTextMesh["_sharedTextures"]>,
+  ): SDFTextMesh | undefined {
+    const existing = this._meshByIndex[batchIndex];
+    if (existing) return existing;
+
+    const info = this._positions;
+    if (!info || batchIndex < 0 || batchIndex >= info.nPositions) {
+      return undefined;
+    }
+
+    const { position, positionSize, batchIDs, batchIDSize, RTE } = info;
+    const batchId = batchIDs ? batchIDs[batchIndex * batchIDSize] : undefined;
+    const posIdx = batchIndex * positionSize;
+    const pos = RTE
+      ? {
+          high: position.high.subarray(posIdx, posIdx + positionSize),
+          low: position.low.subarray(posIdx, posIdx + positionSize),
+        }
+      : position.subarray(posIdx, posIdx + positionSize);
+
+    const mesh = new SDFTextMesh(
+      pos,
+      this._material,
+      this._transform,
+      this._fontManager,
       this._fontIdentifier,
+      batchId,
+      RTE,
+      // Pin quality to the batch, not `this._material.highQuality`, which a
+      // later `_update` may have changed (quality is immutable per batch).
       this._highQuality,
     );
-    const sharedColorTex = this._fontManager.getColorAtlasTexture(
-      this._fontIdentifier,
-      this._highQuality,
+    mesh.renderOrder = this.renderOrder;
+    // Re-prepare evicted glyphs through the batch so font-family faces and
+    // refcounts stay consistent; request a render once they're rebuilt.
+    mesh.setGlyphLifecycleHandlers(
+      (text) =>
+        this._fontManager.prepareText(
+          this._fontIdentifier,
+          text,
+          this._highQuality,
+          this._loadedFaceUrls,
+        ),
+      () => this._needRender?.(),
     );
 
-    for (let i = 0; i < nPositions; i++) {
-      const batchIdIdx = i * batchIDSize;
-      const batchId = batchIDs ? batchIDs[batchIdIdx] : undefined;
-      const posIdx = i * positionSize;
-      const pos = RTE
-        ? {
-            high: position.high.subarray(posIdx, posIdx + positionSize),
-            low: position.low.subarray(posIdx, posIdx + positionSize),
-          }
-        : position.subarray(posIdx, posIdx + positionSize);
-
-      const mesh = new SDFTextMesh(
-        pos,
-        material,
-        transform,
-        this._fontManager,
-        this._fontIdentifier,
-        batchId,
-        RTE,
-      );
-      mesh.renderOrder = this.renderOrder;
-      // Re-prepare evicted glyphs through the batch so font-family faces and
-      // refcounts stay consistent; request a render once they're rebuilt.
-      mesh.setGlyphLifecycleHandlers(
-        (text) =>
-          this._fontManager.prepareText(
-            this._fontIdentifier,
-            text,
-            this._highQuality,
-            this._loadedFaceUrls,
-          ),
-        () => this._needRender?.(),
-      );
+    const { tex, colorTex } = shared ?? this._sharedTextures();
+    if (tex) {
+      mesh.setAtlasTexture(tex);
+    }
+    mesh.setColorAtlasTexture(colorTex);
+
+    mesh.update(this._material);
 
-      if (sharedTex) {
-        mesh.setAtlasTexture(sharedTex);
+    // Replay evaluator state that arrived before the mesh existed.
+    const pending = this._pending.get(batchIndex);
+    if (pending) {
+      this._pending.delete(batchIndex);
+      if (pending.colorHex !== undefined) {
+        mesh.setColor(new Color(pending.colorHex));
       }
-      mesh.setColorAtlasTexture(sharedColorTex);
+      if (pending.show !== undefined) {
+        mesh._setFeatureShow(pending.show);
+      }
+      if (pending.height !== undefined) {
+        mesh.setHeight(pending.height);
+      }
+      if (pending.size !== undefined) {
+        mesh.setSize(pending.size);
+      }
+      if (pending.opacity !== undefined) {
+        mesh.setOpacity(pending.opacity);
+      }
+      if (pending.hasDeclutterPriority) {
+        mesh.setDeclutterPriority(pending.declutterPriority);
+      }
+    }
 
-      mesh.update(material);
+    this._meshByIndex[batchIndex] = mesh;
+    this.addWithBatchIndex(mesh, batchIndex);
+    return mesh;
+  }
 
-      this.addWithBatchIndex(mesh, i);
+  /** Pending-state slot for a feature whose mesh doesn't exist yet. */
+  private _pendingAt(batchIndex: number): PendingFeatureState | undefined {
+    const info = this._positions;
+    if (!info || batchIndex < 0 || batchIndex >= info.nPositions) {
+      return undefined;
+    }
+    let state = this._pending.get(batchIndex);
+    if (!state) {
+      state = {};
+      this._pending.set(batchIndex, state);
     }
+    return state;
   }
 
   async _update(m: NavaraTextMesh, needRender?: () => void) {
@@ -201,29 +347,40 @@ export class BatchedSdfTextMesh
 
     const material = m.material;
     const text = material.text ?? "";
+    // Later lazy creations must see the updated material/transform too.
+    this._material = material;
+    this._transform = m.transform;
 
     const positionInfo = this.extractPositions(m);
     if (positionInfo) {
-      const { position, nPositions, positionSize, RTE } = positionInfo;
-
       invariant(
-        nPositions === this.meshes().length,
-        "Number of positions in the updated geometry must match the number of existing meshes",
+        this._positions === null ||
+          positionInfo.nPositions === this._positions.nPositions,
+        "Number of positions in the updated geometry must match the initial geometry",
       );
+      this._positions = positionInfo;
 
+      const { position, positionSize, RTE } = positionInfo;
       const transform = m.transform;
-      for (let i = 0; i < nPositions; i++) {
-        const posIdx = i * positionSize;
+      for (const mesh of this.meshes()) {
+        const posIdx = (mesh.userData.batchIndex as number) * positionSize;
         const pos = RTE
           ? {
               high: position.high.subarray(posIdx, posIdx + positionSize),
               low: position.low.subarray(posIdx, posIdx + positionSize),
             }
           : position.subarray(posIdx, posIdx + positionSize);
-        this.meshes()[i].setPosition(pos, RTE, transform);
+        mesh.setPosition(pos, RTE, transform);
       }
+      // Anchors moved (e.g. terrain height resolution) — re-place labels.
+      this._markDeclutterDirty();
     }
 
+    // A non-empty default text renders without per-feature setText calls, so
+    // any lazily-skipped meshes must exist before `_applyUpdate` (no-op for
+    // already-created ones).
+    if (text) this.initMeshes();
+
     const fontIdentifier = m.material.font ?? this._fontIdentifier;
     const needFontUpdate = fontIdentifier !== this._fontIdentifier;
 
@@ -292,6 +449,7 @@ export class BatchedSdfTextMesh
       mesh.update(material, forceUpdate);
       this.markVisibility(mesh);
     }
+    this._markDeclutterDirty();
 
     if (needRender) needRender();
   }
@@ -368,7 +526,12 @@ export class BatchedSdfTextMesh
   }
 
   setTextByBatchIndex(batchIndex: number, text: string) {
-    const mesh = this.meshes()[batchIndex];
+    // An empty text on a not-yet-created mesh changes nothing (a lazily
+    // skipped mesh is exactly an invisible empty-text label); only a
+    // non-empty text forces the mesh into existence.
+    const mesh = text
+      ? this._ensureMeshAt(batchIndex)
+      : this.getMeshByBatchIndex(batchIndex);
 
     if (mesh) {
       // If the text hasn't been prepared in the worker yet, schedule async preparation
@@ -412,6 +575,7 @@ export class BatchedSdfTextMesh
             // Restore intended visibility now that text content is available
             mesh.visible = intendedVisible;
             this.markVisibility(mesh);
+            this._markDeclutterDirty();
             this._needRender?.();
           })
           .catch((err: unknown) => {
@@ -422,50 +586,110 @@ export class BatchedSdfTextMesh
       }
       mesh.setText(text);
       this.markVisibility(mesh);
+      this._markDeclutterDirty();
       this._needRender?.();
     }
   }
 
+  /**
+   * The mesh for a feature's `batchIndex`, or `undefined` if not created yet.
+   * Meshes are created lazily and pushed onto `allMeshes` in creation order, so
+   * `allMeshes[batchIndex]` (the base-class mapping) does NOT hold here; the
+   * batchIndex→mesh mapping lives in `_meshByIndex`. Overriding this one
+   * accessor keeps the base-class setters and any external caller (picking,
+   * plugins) correct without patching each call site.
+   */
+  override getMeshByBatchIndex(batchIndex: number): SDFTextMesh | undefined {
+    return this._meshByIndex[batchIndex];
+  }
+
   setFeatureColorByBatchIndex(batchIndex: number, color: Color) {
-    const mesh = this.meshes()[batchIndex];
+    const mesh = this.getMeshByBatchIndex(batchIndex);
     if (mesh) {
       mesh.setColor(color);
+      return;
     }
+    const pending = this._pendingAt(batchIndex);
+    if (pending) pending.colorHex = color.getHex();
   }
 
   setFeatureShowByBatchIndex(batchIndex: number, rawVisible: boolean) {
-    const mesh = this.meshes()[batchIndex];
+    const mesh = this.getMeshByBatchIndex(batchIndex);
     if (mesh) {
       mesh._setFeatureShow(rawVisible);
       this.markVisibility(mesh);
+      this._markDeclutterDirty();
+      return;
+    }
+    // A lazily-created mesh starts hidden (empty text ⇒ `visible=false`), so a
+    // mesh-less feature is already effectively `show:false`. Only `show:true`
+    // needs buffering; buffering `show:false` would allocate a pending entry
+    // per hidden feature — the common MVT case (most features stay hidden and
+    // never get a mesh) and exactly the allocation lazy creation avoids. For
+    // `show:false` just clear any stale buffered `show`, never allocate.
+    if (rawVisible) {
+      const pending = this._pendingAt(batchIndex);
+      if (pending) pending.show = true;
+    } else {
+      const pending = this._pending.get(batchIndex);
+      if (pending) pending.show = undefined;
     }
   }
 
   setFeatureHeightByBatchIndex(batchIndex: number, height: number) {
-    const mesh = this.meshes()[batchIndex];
+    const mesh = this.getMeshByBatchIndex(batchIndex);
     if (mesh) {
       mesh.setHeight(height);
+      this._markDeclutterDirty();
+      return;
     }
+    const pending = this._pendingAt(batchIndex);
+    if (pending) pending.height = height;
   }
 
   setFeatureSizeByBatchIndex(batchIndex: number, size: number) {
-    const mesh = this.meshes()[batchIndex];
+    const mesh = this.getMeshByBatchIndex(batchIndex);
     if (mesh) {
       mesh.setSize(size);
+      this._markDeclutterDirty();
+      return;
+    }
+    const pending = this._pendingAt(batchIndex);
+    if (pending) pending.size = size;
+  }
+
+  setFeatureDeclutterPriorityByBatchIndex(
+    batchIndex: number,
+    priority: number,
+  ) {
+    const mesh = this.getMeshByBatchIndex(batchIndex);
+    if (mesh) {
+      mesh.setDeclutterPriority(priority);
+      this._markDeclutterDirty();
+      return;
+    }
+    const pending = this._pendingAt(batchIndex);
+    if (pending) {
+      pending.declutterPriority = priority;
+      pending.hasDeclutterPriority = true;
     }
   }
 
   setFeatureOpacityByBatchIndex(batchIndex: number, opacity: number) {
-    const mesh = this.meshes()[batchIndex];
+    const clampedOpacity = Number.isFinite(opacity)
+      ? Math.max(0, Math.min(1, opacity))
+      : 1.0;
+    const mesh = this.getMeshByBatchIndex(batchIndex);
     if (mesh) {
-      const clampedOpacity = Number.isFinite(opacity)
-        ? Math.max(0, Math.min(1, opacity))
-        : 1.0;
       mesh.setOpacity(clampedOpacity);
+      return;
     }
+    const pending = this._pendingAt(batchIndex);
+    if (pending) pending.opacity = clampedOpacity;
   }
 
   dispose() {
+    this.ctx.declutter?.unregister(this);
     this._unsubscribeEvict?.();
     this._unsubscribeEvict = undefined;
     const q = this._highQuality;

package/src/mesh/instanced.ts

@@ -53,7 +53,7 @@ export class InstancedMesh<M extends Object3D>
     return this.allMeshes;
   }
 
-  getMeshByBatchIndex(batchIndex: number) {
+  getMeshByBatchIndex(batchIndex: number): M | undefined {
     return this.meshes()[batchIndex];
   }
 

package/src/mesh/polygon.ts

@@ -282,7 +282,8 @@ export class PolygonMesh extends BatchedFeatureMesh<
     this.receiveShadow = !!meshMaterial.receiveShadow;
 
     // This mesh is texturized if it has a tile handle (terrain attachment).
-    const isTexturized = !!tileHandle;
+    // `!= null`, not truthiness: the root vector tile's handle is 0.
+    const isTexturized = tileHandle != null;
     const material = this.material;
 
     material.vertexColors = false;
@@ -390,9 +391,15 @@ export class PolygonMesh extends BatchedFeatureMesh<
   _update(material: PolygonMaterial, active: boolean, isTexturized: boolean) {
     const enhancer = this.getEnhancer();
 
-    // Update mesh properties (not handled by enhancer)
-    this.visible =
-      (material.show ?? true) && (material.surfaceShow ?? true) && active;
+    // Update mesh properties (not handled by enhancer).
+    // Draped (clamp-to-ground) polygons bake offscreen only — never the main
+    // scene — and the Rust drape resolve, not this LOD `active` flag, picks which
+    // baked tile composites per terrain region. Tying bake visibility to `active`
+    // makes the drape flicker on LOD swaps; keep a draped mesh bakeable whenever
+    // shown so every built tile stays a stable drape source (see
+    // PolylineMesh._update).
+    const shown = (material.show ?? true) && (material.surfaceShow ?? true);
+    this.visible = isTexturized ? shown : shown && active;
     if (this._debugBoundingSphereMesh) {
       this._debugBoundingSphereMesh.visible = this.visible;
     }

package/src/mesh/polyline.ts

@@ -404,8 +404,16 @@ export class PolylineMesh extends BatchedFeatureMesh<
 
     const enhancer = this.getEnhancer();
 
-    // Update mesh properties (not handled by enhancer)
-    this.visible = (material.show ?? true) && active;
+    // Update mesh properties (not handled by enhancer).
+    // Draped polylines render only through the offscreen bake, never the main
+    // scene, and the Rust drape resolve — not this LOD `active` flag — decides
+    // which baked tile is composited per terrain region. Tying bake visibility
+    // to `active` makes the drape flicker on every LOD swap (the tile goes
+    // invisible → bakes empty before its replacement is ready). Keep a draped
+    // mesh bakeable whenever its material is shown, so every built tile stays a
+    // stable drape source — the vector twin of a loaded raster texture.
+    const shown = material.show ?? true;
+    this.visible = enhancer.states().isTexturized ? shown : shown && active;
     this.castShadow = !!material.castShadow;
     this.receiveShadow = !!material.receiveShadow;