@ifc-lite/viewer 1.19.0 → 1.21.0

package/CHANGELOG.md

@@ -1,5 +1,501 @@
 # @ifc-lite/viewer
 
+## 1.21.0
+
+### Minor Changes
+
+- [#650](https://github.com/louistrue/ifc-lite/pull/650) [`2ff772d`](https://github.com/louistrue/ifc-lite/commit/2ff772d0174f8cd6657f7e4090e15bc7744e8158) Thanks [@louistrue](https://github.com/louistrue)! - Arbitrary-normal section planes with face-pick (Bonsai-style) and a
+  properly-rendered cap on tilted planes (#243). Click any face in the
+  section tool's "Pick" mode to cut through it; the kept half-space
+  defaults to the side facing the camera. The cardinal "Down / Front /
+  Side" presets are unchanged.
+
+  Renderer:
+
+  - New `planeBasis(normal)` + `nearestCardinalAxis(normal)` exports
+    derive a deterministic in-plane basis used by both the cap renderer
+    and the 2D cutter — without a single shared derivation the cap hatch
+    rotated when state was reconstructed.
+  - `SectionPlaneRenderOptions` and `SectionPlane` gain optional
+    `normal` + `distance` fields. When set, the shader clips on that
+    plane verbatim (no axis mapping, no building-rotation, no
+    position-percentage math) and the gizmo renders as a violet quad
+    oriented from `planeBasis(normal)`.
+  - `Section2DOverlayRenderer.uploadDrawing` accepts an optional
+    `customPlane = { origin, tangent, bitangent }`. When supplied it
+    replaces the cardinal-axis 2D→3D coordinate swap with
+    `origin + tangent·x + bitangent·y`, so the cap silhouette lands
+    exactly on the tilted plane (the bug PR #581 hid by suppressing the
+    cap entirely for non-cardinal planes).
+
+  Drawing-2d:
+
+  - `SectionPlaneConfig` gains an optional `customPlane`. `SectionCutter`
+    uses it verbatim for the plane equation and projects intersections
+    to 2D via `(dot(p − origin, tangent), dot(p − origin, bitangent))`,
+    matching the cap renderer's lift exactly.
+  - `DrawingGenerator` now rebuilds the CPU cutter on each `generate()`
+    call so a switch from cardinal to custom (or between custom planes)
+    takes effect immediately.
+
+  Tests: 11 new viewer tests covering normalisation, sign-preserving
+  cardinal mapping, basis orthonormality, half-space flip, slice
+  clearing on cardinal preset, and degenerate-normal handling. 6 new
+  renderer tests covering basis derivation across cardinal axes,
+  near-axis tilts, and the +Y / −Y reference-axis boundary.
+
+### Patch Changes
+
+- Updated dependencies [[`2ff772d`](https://github.com/louistrue/ifc-lite/commit/2ff772d0174f8cd6657f7e4090e15bc7744e8158)]:
+  - @ifc-lite/renderer@1.20.0
+  - @ifc-lite/drawing-2d@1.16.0
+
+## 1.20.0
+
+### Minor Changes
+
+- [#614](https://github.com/louistrue/ifc-lite/pull/614) [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e) Thanks [@louistrue](https://github.com/louistrue)! - Per-class visibility toggles for ASPRS-classified point clouds.
+
+  A new "Classes" section in the point cloud panel exposes a checkbox
+  list of every LAS 1.4 standard class (Ground, Vegetation, Building,
+  Water, Wires, Bridge deck, ...). Toggling a class hides every point
+  with that classification. Works in any colour mode; the swatch
+  colours mirror the splat shader's classification palette so the UI
+  matches what's on screen.
+
+  Implementation:
+
+  - New `pointCloudClassMask: number` (u32 bitmask, default
+    `0xFFFFFFFF`) on the point cloud slice. `togglePointCloudClass(id)`
+    flips a single bit; `setPointCloudClassMask(mask)` replaces all 32.
+  - `PointCloudRenderOptions.classMask` plumbed through the renderer.
+    Stored in uniform slot `flags.w` (was unused).
+  - Splat shader checks `(flags.w >> classId) & 1` per vertex; hidden
+    classes get a degenerate `clipPos = vec4(0, 0, -2, 1)` so they're
+    culled before rasterisation rather than wasted on a fragment-stage
+    discard.
+  - New `PointCloudClasses` component in the panel renders a
+    `<details>` collapsible with "Show all" + per-class toggles. A
+    badge surfaces "N of 32 visible" when not all are on.
+  - `usePointCloudSync` forwards the mask to
+    `setPointCloudOptions({ classMask })`.
+
+  Class ids ≥32 always show — the mask only covers the standard
+  range. Custom-labelled scans need a richer UI (deferred).
+
+- [#614](https://github.com/louistrue/ifc-lite/pull/614) [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e) Thanks [@louistrue](https://github.com/louistrue)! - BIM ↔ scan deviation heatmap — GPU compute pipeline that colours each
+  scan point by signed distance to the nearest mesh surface. Works with
+  every IFC ingest path (STEP / IFCx / GLB / federated) and with every
+  point cloud format (inline IFCx + streamed LAS / LAZ / PLY / PCD / E57
+  / PTS / XYZ — anywhere `Scene.forEachMeshData` reaches and any node
+  the splat pipeline already renders).
+
+  Pipeline:
+
+  1. **Per-triangle BVH** built from `Scene.forEachMeshData()` —
+     reaches every CPU-side `MeshData` regardless of source. Median
+     split along longest axis, max 16 tris per leaf, flattened to a
+     `Float32Array` of 32-byte nodes during the build (no second
+     pass).
+  2. **Two GPU storage buffers** — nodes + triangles — uploaded once
+     per mesh-set change. Cached by a `(meshCount, totalPositions)`
+     fingerprint so re-running deviation against the same model is a
+     pure dispatch.
+  3. **Compute shader** with stack-based BVH descent (workgroup-size
+     64). Per point: descend BVH pruning by squared point-to-AABB
+     distance, run Ericson §5.1.5 closest-point-on-triangle on every
+     leaf candidate, output signed distance via the closest face's
+     precomputed normal.
+  4. **Per-chunk deviation buffer** allocated alongside the splat
+     vertex buffer (`STORAGE | VERTEX | COPY_DST`, 4 bytes per point,
+     zero-initialised). Compute reads the vertex buffer's positions
+     directly — no CPU copy of streamed clouds needed.
+  5. **Splat shader** gains a 2nd vertex buffer (location 4 = `f32`
+     deviation), a new `deviation` color mode, and a diverging
+     blue → white → red `deviation_ramp`. Uniform block grows by 16
+     bytes (new `deviationRange: vec4<f32>` slot for centre + half-
+     range), `POINT_UNIFORM_SIZE` 208 → 224.
+  6. **Public API** — `Renderer.computeDeviations({ maxRange?,
+forceRebuild? })` returns `{ bvhTriangles, bvhNodes,
+chunksProcessed, pointsProcessed, bounds, suggestedHalfRange }`.
+     Awaits `queue.onSubmittedWorkDone` so callers see populated
+     buffers when the promise resolves.
+  7. **UI** — new `DeviationPanel` inside `PointCloudPanel`. Compute
+     button (gated on `triangleCount > 0`), live progress + duration
+     readout, range slider in millimetres (1 mm to 1 m), inline
+     blue-white-red legend. Auto-suggests a half-range from the BVH
+     bbox (±max-extent / 1000) and auto-switches the colour mode to
+     `deviation` on success.
+  8. **Slice** — `pointCloudColorMode` gains `'deviation'`, plus
+     `pointCloudDeviationCenterOffset`, `pointCloudDeviationHalfRange`
+     (default ±5 cm), and `pointCloudDeviationComputed`. Sync hook
+     forwards the range to the renderer uniform.
+
+  Sign convention: positive = scan point is on the outward-normal
+  side of the closest triangle (typical "scan overshoots wall by
+  5 mm"). Negative = inside / behind. Non-watertight BIM (typical
+  IFC) means "inside the building" isn't globally defined, but
+  per-surface front/back is always meaningful.
+
+  Limitations / future work:
+
+  - The dispatch processes every uploaded point against every
+    triangle in the scene; isolated / hidden meshes still contribute
+    to the BVH. A `meshFilter` predicate is a natural follow-up.
+  - Histogram + auto-range from p5/p95 not yet implemented — the
+    default half-range suggestion is a coarse bbox/1000 heuristic.
+    Phase B will add a 2nd compute pass with atomic histogram.
+  - The BVH walk uses a 64-deep per-thread stack. Pathologically
+    unbalanced trees (>64 deep) silently drop the deepest branch.
+    Real BIMs don't get there; SAH or surface-area cost would help
+    if we ever hit it.
+
+  Verified: full repo typecheck (24/24), 655 viewer tests, viewer
+  Vite build green.
+
+- [#614](https://github.com/louistrue/ifc-lite/pull/614) [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e) Thanks [@louistrue](https://github.com/louistrue)! - Near-term UX features from #611.
+
+  **Hover XYZ readback.** GPU pick now also samples the depth texel at
+  the click position and unprojects it through the inverse view-
+  projection. `PickResult` carries an optional `worldXYZ`. Reverse-Z is
+  honoured (depth=1 = near, 0 = far / miss). The hover tooltip shows
+  `x, y, z` (2 decimals) under the entity id. Useful for measurement
+  hooks and point-cloud picks where the synthetic entity has no
+  surface property to display.
+
+  **Solid-color picker.** When the point-cloud panel's colour mode is
+  set to `fixed`, a native `<input type="color">` swatch appears.
+  Hex round-trips through the existing `[r,g,b,a]` store tuple.
+
+  **Colour-mode legend.** A new `PointCloudLegend` component renders
+  inline beneath the colour-mode buttons:
+
+  - Classification → list of ASPRS LAS 1.4 class id / colour swatch /
+    label (Ground, Vegetation, Building, ...). Palette mirrors
+    `point-shader.wgsl.ts` exactly.
+  - Intensity → black-to-white gradient bar with low/high labels.
+  - Height → cool-warm gradient bar (blue → cyan → green → yellow →
+    red), matching the shader's `height_ramp`.
+    RGB and Solid don't render a legend.
+
+  **Cancel button for in-flight streams.** New
+  `activeStreamCanceller` field on the loading slice. Both ingest
+  sites (`useIfcLoader`, `useIfcFederation`) register
+  `() => streamHandle.cancel()` after starting and clear on success /
+  error. `StatusBar` shows a Cancel button while the canceller is
+  non-null. AbortError on cancel is reported as "Cancelled" rather
+  than a scary error string.
+
+- [#614](https://github.com/louistrue/ifc-lite/pull/614) [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e) Thanks [@louistrue](https://github.com/louistrue)! - PTS / XYZ ASCII point cloud reader.
+
+  Both formats are line-oriented plain-text scans common in legacy
+  survey workflows. They share the same syntax — they differ only in
+  the optional first-line point count (PTS may have one; XYZ never
+  does). One shared decoder + streaming source handles both.
+
+  Auto-detected per-line layouts (by column count of the first data
+  line):
+
+  - 3 cols → `X Y Z`
+  - 4 cols → `X Y Z I` (intensity)
+  - 6 cols → `X Y Z R G B`
+  - 7 cols → `X Y Z I R G B` (canonical PTS)
+  - 9 cols → `X Y Z R G B Nx Ny Nz` (XYZ-with-normals; normals dropped)
+  - 10 cols → `X Y Z I R G B Nx Ny Nz` (PTS-with-normals; normals dropped)
+  - For XYZ with unknown column counts ≥3 we still emit positions and
+    skip the rest, so weird custom exports load instead of erroring.
+
+  Other behaviour:
+
+  - Comment lines (`#`, `//`) and blank lines are skipped.
+  - Intensity normalisation: 0..1 vs 0..255 vs raw sensor detected from
+    the observed maximum, then mapped to u16.
+  - RGB normalisation: same heuristic (>1.0 → 0..255 source).
+  - Whole-file decode wrapped in `AsciiPointsStreamingSource`; the
+    streaming host's 25M-point cap stride-downsamples on the way out.
+
+  Wired into the decode worker, format detection
+  (`detectPointCloudFormat` returns `'pts'` / `'xyz'`), the file
+  picker accept lists, drop handlers, and both `useIfcLoader` /
+  `useIfcFederation` ingest branches. The "PTS / XYZ ASCII points —
+  not yet supported" toast is removed from `describeUnsupportedFormat`.
+
+  10 new unit tests cover layout probing, decoder round-trips for the
+  common shapes, and the comment / header-count edge cases.
+
+- [#614](https://github.com/louistrue/ifc-lite/pull/614) [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e) Thanks [@louistrue](https://github.com/louistrue)! - GPU rectangle pick (marquee select) — meshes + point clouds.
+
+  Hold `Ctrl` (or `⌘` on macOS) and drag with the left mouse button
+  in the select tool to draw a rectangle. On release, every entity
+  (mesh or point cloud) whose pixel falls inside the rect becomes
+  the new selection. A teal-dashed SVG outline tracks the drag.
+
+  Implementation:
+
+  - `Picker.pickRect(x0, y0, x1, y1, …) → Set<expressId>` renders the
+    same pick pass as `pick()` and reads back the texel rect, deduping
+    hits to a Set. Mesh + point splats both participate (point splats
+    share the depth buffer in the pick pass).
+  - A new private `Picker.renderPickPass` extracts the shared render-
+    pass setup so single-pixel `pick` and rect `pickRect` don't drift.
+  - `PickingManager.pickRect` applies the same visibility filtering
+    (`hiddenIds`, `isolatedIds`) as `pick`. The CPU-raycast and
+    dynamic-mesh-creation fallbacks `pick` uses for very large batched
+    models are skipped — rect pick only sees already-hydrated meshes.
+  - `Renderer.pickRect` exposes the manager's API.
+  - New `RectSelectionOverlay` component renders the dashed SVG box
+    while dragging; lives inside `Viewport.tsx` as a sibling of the
+    canvas.
+  - `useMouseControls` tracks a new `mouseState.isRectSelecting` flag,
+    suppresses orbit/pan during the drag, and on mouseup runs
+    `renderer.pickRect(...)` and feeds the result into
+    `setSelectedEntityIds`. A 4-pixel minimum rect size avoids
+    clobbering selection on a stray Ctrl-click.
+  - `MouseState.isRectSelecting?: boolean` and a new
+    `setRectSelection?` callback added to `UseMouseControlsParams`.
+
+  Lasso (polygonal) pick still pending — covered by issue #611's
+  mid-term list. Per-class isolation for points is a separate
+  follow-up.
+
+- [#614](https://github.com/louistrue/ifc-lite/pull/614) [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e) Thanks [@louistrue](https://github.com/louistrue)! - Section-plane drag preview — render at 1/4 density during slider
+  drag for responsive section-cutting on huge point clouds.
+
+  The splat shader gains a `previewStride` uniform that culls
+  `(instance_index % stride) != 0` at the start of `vs_main`. The
+  section-plane position slider wires `onPointerDown` to set
+  `previewStride: 4` and `onPointerUp` to restore `1`, so scans of
+  millions of points stay responsive while the user drags.
+
+  Implementation:
+
+  - `POINT_UNIFORM_SIZE` bumped from 208 → 224 to add a new
+    `extras: vec4<u32>` slot. `extras.x` carries `previewStride`;
+    `yzw` reserved for future per-frame state.
+  - `PointCloudRenderOptions.previewStride?: number` clamped to
+    [1, 256] in the renderer.
+  - Vertex shader culls hidden instances by writing
+    `clipPos = vec4(0, 0, -2, 1)` (outside reverse-Z `[0, 1]`) so they
+    drop pre-rasterisation.
+  - New `pointCloudPreviewStride` field on the point cloud slice
+    (default 1) with `setPointCloudPreviewStride` action.
+  - `usePointCloudSync` forwards the stride to
+    `setPointCloudOptions`.
+  - `SectionOverlay`'s position slider triggers stride 4 on
+    drag start (pointer + keyboard), 1 on release. Only flips when
+    `pointCloudAssetCount > 0` so IFC-only sessions are unaffected.
+
+  Triangle meshes ignore the stride — they're cheap enough that
+  section drag was already smooth.
+
+  Verified: full repo typecheck (24/24), 655 viewer tests, viewer
+  Vite build green.
+
+### Patch Changes
+
+- [#614](https://github.com/louistrue/ifc-lite/pull/614) [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e) Thanks [@louistrue](https://github.com/louistrue)! - Fix LAZ load failing with `WebAssembly: Response has unsupported MIME
+type 'text/plain'` on real-world files (e.g. autzen-classified.laz).
+
+  `laz-perf`'s emscripten shim resolves the wasm via `locateFile()` and
+  calls `fetch("laz-perf.wasm")` relative to its own script directory.
+  In a Vite-bundled module worker that path becomes `/assets/<chunk>/…`
+  or just `/laz-perf.wasm` — both 404, and the SPA fallback returns
+  `index.html` as `text/plain`, which `instantiateStreaming` rightly
+  rejects. The async fallback then 404s the same way and aborts.
+
+  `loadLazPerf` now resolves the wasm asset URL through Vite's
+  `?url` import (`laz-perf/lib/web/laz-perf.wasm?url`), pre-fetches the
+  bytes itself, and hands them to emscripten as `Module.wasmBinary` so
+  the shim's own fetch is bypassed entirely. Failure modes (asset
+  resolution, fetch HTTP error) now produce a precise error message
+  naming the URL and status instead of the opaque emscripten "Aborted".
+
+- [#614](https://github.com/louistrue/ifc-lite/pull/614) [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e) Thanks [@louistrue](https://github.com/louistrue)! - Near-term batch — correctness + robustness items from #611.
+
+  **`computeBBox` empty / non-finite guards.** Both `e57.ts` and
+  `ifcx-points.ts` now return `{0,0,0}/{0,0,0}` for empty arrays and
+  skip non-finite triplets. Previously a zero-point or NaN-poisoned
+  chunk produced ±Infinity bounds that broke camera fit-to-view and
+  section-plane sliders.
+
+  **Magic-byte-first format detection.** `detectPointCloudFormat` now
+  probes the buffer (E57 magic, LASF magic, "ply" / "#" / ".PCD"
+  ASCII tokens) before falling back to extension. A LAS file
+  mistakenly named `*.ply` no longer goes down the wrong decoder. LAS
+  vs LAZ still uses the extension to disambiguate (they share the
+  LASF magic).
+
+  **E57 packet-bounds + per-stream guards.** Validate that the
+  DataPacket header, bytestream-length table, and each individual
+  bytestream stay inside `payloadEnd = packetEnd - 4` before reading.
+  Corrupt files now fail with a precise "bytestream X runs past
+  packet payload" error instead of silently reading into the next
+  packet.
+
+  **`e57.ts` split (631 → 4 files).** `e57-page.ts` (header / page CRC
+  / section-header resolver), `e57-xml.ts` (prototype + Data3D
+  parser), `e57-decode.ts` (per-scan binary decoder), `e57.ts`
+  (orchestrator + re-exports). All four under the AGENTS ~400-line
+  guideline.
+
+  **`point-cloud-renderer.ts` extract.** Pulled the uniform-block
+  writer into `point-cloud-uniforms.ts` (`writePointCloudUniforms` +
+  mode index maps). Renderer drops below 400 lines.
+
+  Verified: 62 pointcloud unit tests pass, full repo typecheck
+  (24/24).
+
+- [#614](https://github.com/louistrue/ifc-lite/pull/614) [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e) Thanks [@louistrue](https://github.com/louistrue)! - Round 2 of CodeRabbit feedback on PR #614:
+
+  - **E57 stride downsampling drops classifications.** `applyStride` rebuilt
+    positions / colors / intensities into new arrays but never copied the
+    per-point class IDs, so any non-default stride (`{ stride: 2 }` and up)
+    silently lost them and `hasClassification` flipped to false.
+  - **Federation abort can stomp a newer load.** The AbortError handler in
+    `useIfcFederation.addModel()` wrote `progress`, `error`, and `loading`
+    unconditionally — if a second `addModel()` started after the first was
+    cancelled, it lost its spinner and progress to the cancelled load's
+    cleanup. Added a `loadSessionRef` token (mirrors `useIfcLoader`) and
+    gate state writes on `loadSessionRef.current === currentSession`.
+  - **E57 Integer classification subtracts `minimum`.** Class IDs are
+    absolute labels (ASPRS LAS 1.4 0..31), not range-normalised offsets.
+    `raw - minimum` was corrupting class IDs whenever a producer declared
+    a non-zero `minimum` on the Integer-encoded classification field. The
+    Integer branch now matches the ScaledInteger branch's intent: keep
+    the raw byte, clamp to 0..255.
+  - **PCD probe missed `VERSION` / `FIELDS` headers.** The magic-byte
+    detector only recognised `# .PCD …` comment-style headers. Real PCDs
+    emitted by PCL's `pcl_io` and a few third-party tools start directly
+    with `VERSION 0.7\n…` or `FIELDS x y z\n…` — these now route through
+    the PCD decoder instead of falling through to extension-based
+    detection (which would mis-route a renamed PCD).
+  - **Catch-block logging.** Per repo convention, log point-cloud ingest
+    failures in `useIfcLoader.ts` before the early return so abort vs.
+    real-failure vs. stale-session paths are distinguishable in console
+    triage.
+
+  Test cleanup: drop the shadowed (and unused) ScaledInteger packet
+  buffer in `e57.test.ts` so only the live `fullBuf` setup remains.
+
+- Updated dependencies [[`8408c88`](https://github.com/louistrue/ifc-lite/commit/8408c88c4c0a1e848fade6c60474952eca1a4149), [`2334993`](https://github.com/louistrue/ifc-lite/commit/2334993827839b9f5b96ca8008c49543fb597660), [`ba7553a`](https://github.com/louistrue/ifc-lite/commit/ba7553af693939896a840074999b5f6806a94815), [`2ab0e4c`](https://github.com/louistrue/ifc-lite/commit/2ab0e4c0eafc21feb22bfc7cd96c467b8b9ff599), [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e), [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e), [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e), [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e), [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e), [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e), [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e), [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e), [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e), [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e), [`7efc878`](https://github.com/louistrue/ifc-lite/commit/7efc8783314559b674509131f1e203ae7c1fda8e)]:
+  - @ifc-lite/wasm@1.16.9
+  - @ifc-lite/geometry@1.18.0
+  - @ifc-lite/parser@2.4.0
+  - @ifc-lite/data@1.17.0
+  - @ifc-lite/renderer@1.19.0
+  - @ifc-lite/pointcloud@0.3.0
+  - @ifc-lite/ids@1.15.1
+  - @ifc-lite/lists@1.14.12
+
+## 1.19.2
+
+### Patch Changes
+
+- [#622](https://github.com/louistrue/ifc-lite/pull/622) [`28db7df`](https://github.com/louistrue/ifc-lite/commit/28db7df0fa64dc8cab0d08f4948fb1d9b67e0f70) Thanks [@louistrue](https://github.com/louistrue)! - Cesium overlay: precomputed terrain placement, ground-floor clamping,
+  and a refactored camera path.
+
+  **Placement is now resolved before the bridge is built** (no more
+  "model loads at IFC OrthogonalHeight, then jumps to terrain"):
+
+  - `terrain-elevation.ts` (new module) tries sources in fast-first
+    order — sync `globe.getHeight`, sync `scene.sampleHeight`, async
+    `scene.sampleHeightMostDetailed` with a 3.5 s timeout, then
+    Open-Meteo as a bare-earth fallback. Implausible elevations
+    (e.g. depth-buffer noise from Google Photorealistic 3D Tiles
+    returning `-69184 m`) are range-checked against terrestrial bounds.
+    Results are cached per-session via `clearTerrainElevationCache()`.
+  - `sampleHeightMostDetailed` runs _before_ Open-Meteo so the model
+    lands on the same surface the user actually sees in 3D Tiles
+    (street decks, podiums) rather than the bare-earth DEM.
+  - `createCesiumBridge` accepts a `placementHeightOverride` so the
+    computed placement is baked into the `enuToEcef` origin altitude
+    for both camera frame and model matrix from creation.
+
+  **`findClampAnchorY` (new helper, 9 unit tests)** picks the anchor
+  viewer-Y that auto-clamp pins to terrain. Primary: the
+  `IfcBuildingStorey` whose elevation is closest to 0 (ground floor),
+  within the model AABB. Fallback: `bounds.min.y`. Without this,
+  basements and foundations dragged the model deep below the terrain
+  surface.
+
+  **`oHeightForBaseAltitude`** in the Georeferencing panel now mirrors
+  the auto-clamp formula (anchor-aware, shift- and RTC-aware), so the
+  "Set OrthogonalHeight to Cesium terrain elevation" button produces
+  the same world position as toggling the clamp.
+
+  **UX behaviours**
+
+  - `cesiumTerrainClamp` defaults to `true` (slice + reset path).
+  - Clamp toggle is now actually uncheckable — dropped the auto-toggle
+    branch that fought the user's setting.
+  - Editing OrthogonalHeight directly auto-releases the clamp so the
+    edit takes effect (with clamp on, placement is intentionally
+    terrain-anchored regardless of OrthogonalHeight).
+  - Stale `terrainHeight` / `terrainClipY` are cleared when a re-query
+    fails so the clip plane doesn't drift relative to the new bridge.
+  - Effect 2d depends on `bridgeVersion` so the model matrix refreshes
+    after an async bridge rebuild.
+
+  **Camera navigation refactor.** Reported symptom: orbit/zoom
+  restricted to the terrain plane. Two coupled root causes:
+
+  1. `screenSpaceCameraController.enableInputs` was still default-true.
+     Any input slipping past the overlay's `pointer-events: none`
+     reached Cesium and got processed in the locked frame, fighting
+     our externally-driven pose. Now flipped to `false` (master kill-
+     switch) on top of the per-mode flags.
+  2. `syncCamera` used `lookAtTransform(viewerToEcef)` to write
+     position/direction/up in viewer-space. `lookAtTransform` _locks_
+     Cesium's reference frame; rotate/tilt/zoom operations are then
+     constrained to that local frame — the "stuck to terrain plane"
+     behaviour. Refactored to clear `lookAtTransform` with
+     `Matrix4.IDENTITY` and write position/direction/up directly in
+     ECEF (Cesium's RTC handles shader precision for primitives).
+
+  **Network hygiene.** `queryTerrainElevation` (Open-Meteo) gets a 5 s
+  `AbortController` timeout and a `console.warn` so failures are
+  visible instead of silently swallowed.
+
+- [#622](https://github.com/louistrue/ifc-lite/pull/622) [`28db7df`](https://github.com/louistrue/ifc-lite/commit/28db7df0fa64dc8cab0d08f4948fb1d9b67e0f70) Thanks [@louistrue](https://github.com/louistrue)! - Apply IfcMapConversion.Scale per IFC schema (issue #595).
+
+  Scale converts local engineering coordinates (in the project length unit)
+  to map CRS units (e.g. `0.001` for a millimetre project with a metre map).
+  ifc-lite's geometry pipeline already converts vertices to metres during
+  extraction, so applying the raw Scale to viewer-space coordinates double-
+  scaled the model — making the Cesium 3D world context unusable for files
+  authored per spec.
+
+  Introduces `getEffectiveHorizontalScale(scale, mapUnitScale, lengthUnitScale)`
+  which returns `(scale × mapUnitScale) / lengthUnitScale` — the correct
+  multiplier for metre-converted geometry. For files where Scale is set
+  consistently with the unit difference this evaluates to 1.0 and the
+  geometry passes through unchanged. Wired through:
+
+  - `cesium-bridge.ts` — 3D model origin and the viewer→ENU rotation.
+  - `CesiumOverlay.tsx::buildModelMatrix` — GLB placement.
+  - `reproject.ts` — 2D map centre, footprint, and reverse-pick.
+  - `useIfcFederation.ts` — multi-model alignment transform.
+
+  Adds a visible amber warning in the Georeferencing panel when
+  `Scale × mapUnitScale ≠ lengthUnitScale` (the IFC schema invariant) so
+  authoring errors are discoverable. The warning surfaces both inline (in
+  the expanded Coordinate Operation section) and as a small indicator on
+  the collapsed section header.
+
+- Updated dependencies [[`7c85376`](https://github.com/louistrue/ifc-lite/commit/7c853760ef96e6f0f88ebdc29c17aefae724ff43), [`7c85376`](https://github.com/louistrue/ifc-lite/commit/7c853760ef96e6f0f88ebdc29c17aefae724ff43), [`5439cce`](https://github.com/louistrue/ifc-lite/commit/5439cce34edaff1c050ce8975a330163167df6fd)]:
+  - @ifc-lite/data@1.16.0
+  - @ifc-lite/ids@1.15.0
+  - @ifc-lite/geometry@1.17.1
+  - @ifc-lite/lists@1.14.11
+
+## 1.19.1
+
+### Patch Changes
+
+- Updated dependencies [[`7a7cf79`](https://github.com/louistrue/ifc-lite/commit/7a7cf79c181004f9974bd303181aeeaa97d6869d), [`7a7cf79`](https://github.com/louistrue/ifc-lite/commit/7a7cf79c181004f9974bd303181aeeaa97d6869d)]:
+  - @ifc-lite/ids@1.14.11
+  - @ifc-lite/mcp@0.2.0
+
 ## 1.19.0
 
 ### Minor Changes

package/dist/assets/basketViewActivator-Bzw51jhm.js

@@ -0,0 +1,71 @@
+import { u as o, __tla as __tla_0 } from "./index-DVNSvEMh.js";
+import "./cesium-DUOzBlqv.js";
+import "./arrow-CZ5kQ26f.js";
+import { __tla as __tla_1 } from "./exporters-u0sz2Upj.js";
+import "./bcf-4K724hw0.js";
+import "./zip-DBEtpeu6.js";
+import { __tla as __tla_2 } from "./sandbox-DPD1ROr0.js";
+import "./lens-CSASnhAL.js";
+import "./drawing-2d-Bjy8YPrg.js";
+import { __tla as __tla_3 } from "./server-client-DP8fMPY9.js";
+import { __tla as __tla_4 } from "./ids-B7AXEv7h.js";
+import "./three-CDRZThFA.js";
+let T;
+let __tla = Promise.all([
+    (()=>{
+        try {
+            return __tla_0;
+        } catch  {}
+    })(),
+    (()=>{
+        try {
+            return __tla_1;
+        } catch  {}
+    })(),
+    (()=>{
+        try {
+            return __tla_2;
+        } catch  {}
+    })(),
+    (()=>{
+        try {
+            return __tla_3;
+        } catch  {}
+    })(),
+    (()=>{
+        try {
+            return __tla_4;
+        } catch  {}
+    })()
+]).then(async ()=>{
+    const n = 700;
+    T = function(s) {
+        const e = o.getState(), i = e.basketViews.find((t)=>t.id === s);
+        if (i) {
+            if (e.setDrawing2D(null), e.setDrawing2DPanelVisible(!1), e.updateDrawing2DDisplayOptions({
+                show3DOverlay: !1
+            }), e.clearEntitySelection(), e.restoreBasketEntities(i.entityRefs, s), i.viewpoint) {
+                const t = i.transitionMs ?? n;
+                e.cameraCallbacks.applyViewpoint?.(i.viewpoint, !0, t);
+            }
+            if (i.section) {
+                const t = i.section;
+                o.setState({
+                    sectionPlane: {
+                        ...t.plane
+                    },
+                    drawing2DPanelVisible: !1
+                }), t.plane.enabled ? (e.activeTool !== "section" && e.setSuppressNextSection2DPanelAutoOpen(!0), e.setActiveTool("section")) : e.activeTool === "section" && e.setActiveTool("select");
+            } else {
+                const t = o.getState().sectionPlane;
+                o.setState({
+                    sectionPlane: {
+                        ...t,
+                        enabled: !1
+                    }
+                }), e.activeTool === "section" && e.setActiveTool("select");
+            }
+        }
+    };
+});
+export { T as activateBasketViewFromStore, __tla };