@ifc-lite/viewer 1.28.1 → 1.30.0

package/src/components/viewer/useAnimationLoop.ts

@@ -17,7 +17,7 @@
  */
 
 import { useEffect, type MutableRefObject, type RefObject } from 'react';
-import type { Renderer, VisualEnhancementOptions } from '@ifc-lite/renderer';
+import type { Renderer, VisualEnhancementOptions, LightingEnvironment } from '@ifc-lite/renderer';
 import type { CoordinateInfo } from '@ifc-lite/geometry';
 import type { SectionPlane } from '@/store';
 
@@ -37,6 +37,8 @@ export interface UseAnimationLoopParams {
   selectedModelIndexRef: MutableRefObject<number | undefined>;
   clearColorRef: MutableRefObject<[number, number, number, number]>;
   visualEnhancementRef: MutableRefObject<VisualEnhancementOptions>;
+  /** Lighting environment (sun, hemisphere ambient, exposure, sky pass). */
+  environmentRef: MutableRefObject<LightingEnvironment>;
   sectionPlaneRef: MutableRefObject<SectionPlane>;
   sectionRangeRef: MutableRefObject<{ min: number; max: number } | null>;
   /**
@@ -77,6 +79,7 @@ export function useAnimationLoop(params: UseAnimationLoopParams): void {
     selectedModelIndexRef,
     clearColorRef,
     visualEnhancementRef,
+    environmentRef,
     sectionPlaneRef,
     sectionRangeRef,
     modelBoundsRef,
@@ -102,6 +105,7 @@ export function useAnimationLoop(params: UseAnimationLoopParams): void {
     let lastRotationUpdate = 0;
     let lastScaleUpdate = 0;
     let lastRenderTime = 0;
+    let wasAnimating = false;
 
     // Adaptive render throttle: large models get fewer FPS during continuous
     // rendering (interaction + inertia) to prevent the main thread from being
@@ -150,6 +154,16 @@ export function useAnimationLoop(params: UseAnimationLoopParams): void {
       // 2. Camera update (animation / inertia)
       const isAnimating = camera.update(deltaTime);
 
+      // Camera tweens (Home / view cube / zoom-extent) render their frames
+      // with isInteracting=true; without a settle render the last tween frame
+      // could stay on screen at degraded quality until the next incidental
+      // render. Mouse/wheel/touch paths already request their own settle
+      // frame on release — this covers the animation path.
+      if (wasAnimating && !isAnimating && !isInteractingRef.current) {
+        renderer.requestRender();
+      }
+      wasAnimating = isAnimating;
+
       // 3. Render if anything changed
       // Peek first — only consume the flag when we actually commit to rendering.
       // This prevents a throttled frame from eating the dirty flag.
@@ -174,7 +188,11 @@ export function useAnimationLoop(params: UseAnimationLoopParams): void {
           selectedModelIndex: selectedModelIndexRef.current,
           clearColor: clearColorRef.current,
           visualEnhancement: visualEnhancementRef.current,
+          environment: environmentRef.current,
           isInteracting: isInteractingRef.current || isAnimating,
+          // Let the effects governor judge missed frames against the
+          // intentional large-model throttle instead of display refresh.
+          interactionFrameIntervalMs: continuousThrottleMs || undefined,
           buildingRotation: coordinateInfoRef.current?.buildingRotation,
           sectionPlane: activeToolRef.current === 'section' ? {
             axis: sectionPlaneRef.current.axis,

package/src/disable-react-dev-perf-track.ts

@@ -0,0 +1,38 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Disable React 19.2's DEV-mode component-render Performance tracking.
+ *
+ * react-dom (dev build) calls `logComponentRender` on every commit whose props
+ * changed; it recursively walks the prop diff (`addObjectDiffToProperties` →
+ * `addObjectToProperties`, a `for..in` recursion with no depth/size bound) to feed
+ * the browser's Performance timeline. The viewer passes large IFC `geometryResult`
+ * (typed arrays — `for..in` enumerates every index across thousands of meshes) and
+ * the `ifcDataStore` (circular relationship-graph refs → unbounded recursion) as
+ * props, so on big models (schependomlaan, Holter Tower) the diff array grows until
+ * `RangeError: Invalid array length` and a multi-GB main-thread OOM — the load
+ * "stops halfway" and the tab stalls/crashes. (Playwright-confirmed: with this
+ * tracker off, Holter loads in ~350MB instead of OOMing at ~4GB.)
+ *
+ * React gates the entire tracker on `supportsUserTiming`, cached at react-dom init
+ * from `typeof performance.measure === 'function'`. Making `performance.measure`
+ * unavailable BEFORE react-dom initializes (this is the first import in main.tsx)
+ * disables ONLY this tracking; the viewer times with `performance.now()`, not
+ * `measure`. DEV-only — the production build strips the tracker, so this is a no-op.
+ */
+if (import.meta.env.DEV && typeof performance !== 'undefined') {
+  try {
+    (performance as unknown as { measure?: unknown }).measure = undefined;
+  } catch (err) {
+    // `performance.measure` is read-only in some engines — surface it so a
+    // failed patch (which leaves large models OOM-prone) isn't silently hidden.
+    if (typeof console !== 'undefined') {
+      console.warn(
+        '[perf-track] could not disable React DEV perf tracking; large models may OOM',
+        err,
+      );
+    }
+  }
+}

package/src/hooks/has-entity-type.ts

@@ -0,0 +1,33 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import type { IfcDataStore } from '@ifc-lite/parser';
+
+/**
+ * Cheap presence check against the data store's type index — true if the store
+ * contains at least one entity of any of the given IFC types.
+ *
+ * `entityIndex.byType` indexes EVERY parsed entity (it backs on-demand
+ * extraction), so absence here is authoritative: a model with no `IfcAlignment`
+ * truly has none. Keys are the raw IFC type strings, which are UPPERCASE in
+ * STEP files but can be mixed-case on some cache-load paths, so we check both.
+ *
+ * Used to skip the always-on full-source WASM scans (`parseAlignmentLines`,
+ * `parseGridLines`, `parseSymbolicRepresentations`) on models that have none of
+ * the relevant entities — those scans copy the entire IFC source into the WASM
+ * heap (hundreds of ms on a 170MB file) on the main thread during load, purely
+ * to find nothing.
+ *
+ * Returns `true` (i.e. do NOT skip) when the index is missing/empty, so gating
+ * can never drop real data — worst case is the pre-existing behaviour.
+ */
+export function hasEntityType(store: IfcDataStore, ...types: string[]): boolean {
+  const byType = store.entityIndex?.byType;
+  if (!byType || byType.size === 0) return true;
+  for (const t of types) {
+    if ((byType.get(t.toUpperCase())?.length ?? 0) > 0) return true;
+    if ((byType.get(t)?.length ?? 0) > 0) return true;
+  }
+  return false;
+}

package/src/hooks/ids/idsWorkerClient.ts

@@ -0,0 +1,136 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Main-thread client for the IDS validation worker.
+ *
+ * Spawns the worker per run (validation is infrequent and the worker
+ * re-parses the model, so a long-lived instance would only pin memory),
+ * streams progress back to the caller, and resolves with the report.
+ * The caller falls back to in-process validation when `isSupported()`
+ * is false or the worker rejects.
+ */
+
+import type {
+  IDSDocument,
+  IDSValidationReport,
+  ValidationProgress,
+} from '@ifc-lite/ids';
+import type {
+  IdsWorkerRequest,
+  IdsWorkerResponse,
+} from '@/workers/idsValidation.worker';
+
+export function idsWorkerSupported(): boolean {
+  return typeof Worker !== 'undefined';
+}
+
+export interface RunInWorkerArgs {
+  /** Raw IFC/STEP bytes from the loaded model's data store. */
+  source: Uint8Array;
+  document: IDSDocument;
+  schemaVersion: string;
+  modelId: string;
+  locale: 'en' | 'de' | 'fr';
+  includePassingEntities: boolean;
+  onProgress?: (progress: ValidationProgress) => void;
+}
+
+/**
+ * Hand the model bytes + parsed IDS document to the worker and resolve
+ * with the validation report. A SharedArrayBuffer-backed source is
+ * shared zero-copy; a plain ArrayBuffer is copied and transferred so
+ * the main-thread store is never detached.
+ */
+export function runValidationInWorker(
+  args: RunInWorkerArgs
+): Promise<IDSValidationReport> {
+  return new Promise((resolve, reject) => {
+    let worker: Worker;
+    try {
+      worker = new Worker(
+        new URL('../../workers/idsValidation.worker.ts', import.meta.url),
+        { type: 'module' }
+      );
+    } catch (err) {
+      reject(
+        new Error(
+          `Failed to spawn IDS worker: ${err instanceof Error ? err.message : String(err)}`
+        )
+      );
+      return;
+    }
+
+    const id = Date.now();
+    const { buffer, transfer } = prepareSource(args.source);
+
+    const settle = (fn: () => void) => {
+      worker.onmessage = null;
+      worker.onerror = null;
+      worker.onmessageerror = null;
+      worker.terminate();
+      fn();
+    };
+
+    worker.onmessage = (event: MessageEvent<IdsWorkerResponse>) => {
+      const msg = event.data;
+      if (!msg || msg.id !== id) return;
+      switch (msg.type) {
+        case 'progress':
+          args.onProgress?.(msg.progress);
+          return;
+        case 'complete':
+          settle(() => resolve(msg.report));
+          return;
+        case 'error':
+          settle(() => reject(new Error(msg.message)));
+          return;
+      }
+    };
+
+    worker.onerror = (event) => {
+      settle(() => reject(new Error(event.message || 'IDS worker crashed')));
+    };
+    worker.onmessageerror = () => {
+      settle(() => reject(new Error('IDS worker message deserialization failed')));
+    };
+
+    const request: IdsWorkerRequest = {
+      type: 'validate',
+      id,
+      source: buffer,
+      document: args.document,
+      schemaVersion: args.schemaVersion,
+      modelId: args.modelId,
+      locale: args.locale,
+      includePassingEntities: args.includePassingEntities,
+    };
+    worker.postMessage(request, transfer);
+  });
+}
+
+/**
+ * Resolve the exact source bytes into a worker-postable buffer.
+ * SharedArrayBuffer is shared by reference (zero copy); a plain
+ * ArrayBuffer (or a partial view) is copied into a fresh, transferable
+ * ArrayBuffer so the caller's store keeps its bytes.
+ */
+function prepareSource(source: Uint8Array): {
+  buffer: ArrayBuffer | SharedArrayBuffer;
+  transfer: Transferable[];
+} {
+  const sharedAvailable = typeof SharedArrayBuffer !== 'undefined';
+  if (
+    sharedAvailable &&
+    source.buffer instanceof SharedArrayBuffer &&
+    source.byteOffset === 0 &&
+    source.byteLength === source.buffer.byteLength
+  ) {
+    // Shared by reference — no copy, the worker only reads it.
+    return { buffer: source.buffer, transfer: [] };
+  }
+  // Copy the exact bytes; transfer the copy (never the original).
+  const copy = source.slice();
+  return { buffer: copy.buffer, transfer: [copy.buffer] };
+}

package/src/hooks/ingest/federationAlign.ts

@@ -17,7 +17,7 @@ import {
   type ProjectedCRS,
 } from '@ifc-lite/parser';
 import type { CoordinateInfo } from '@ifc-lite/geometry';
-import { useViewerStore, type FederatedModel } from '../../store.js';
+import { useViewerStore, type FederatedModel } from '../../store/index.js';
 import { getEffectiveGeoreference, getEffectiveHorizontalScale, hasStandardGeoreferencing, type GeorefMutationDataLike } from '../../lib/geo/effective-georef.js';
 import { resolveMapUnitToMetreScale } from '../../lib/geo/geo-scale.js';
 import { resolveProjection } from '../../lib/geo/reproject.js';

package/src/hooks/ingest/pointCloudIngest.ts

@@ -19,118 +19,42 @@ import {
   type StreamHandle,
 } from '@ifc-lite/pointcloud';
 import type { CoordinateInfo, GeometryResult, PointCloudAsset } from '@ifc-lite/geometry';
-import type { IfcDataStore } from '@ifc-lite/parser';
+import { createSyntheticDataStore, type IfcDataStore } from '@ifc-lite/parser';
 import type { SchemaVersion } from '../../store/types.js';
 import { createCoordinateInfo } from '../../utils/localParsingUtils.js';
 
 export type PointCloudFormat = 'las' | 'laz' | 'ply' | 'pcd' | 'e57' | 'pts' | 'xyz';
 
 /**
- * IfcTypeEnum.IfcGeographicElement — the closest IFC4 entity for a scan
- * is `IfcGeographicElement`. We hard-code the enum value (58) here so
- * we don't pull `@ifc-lite/data` into the viewer ingest path.
- */
-const IFC_GEOGRAPHIC_ELEMENT_ENUM = 58;
-
-/**
- * Synthetic IfcDataStore for a point-cloud-only model. Picking a point
- * sets the synthetic expressId as the selected entity, which then runs
- * through the regular property/hover/properties-panel pipeline. That
- * pipeline calls `entities.getTypeName / getName / getGlobalId` and
- * `properties.getForEntity` — without those methods, picking crashes
- * with "getTypeName is not a function". We give it just enough shape
- * to round-trip the single synthetic entity.
+ * Synthetic IfcDataStore for a point-cloud-only model. Picking a point sets
+ * the synthetic expressId as the selected entity, which then runs through the
+ * regular property/hover/properties-panel pipeline. That pipeline calls
+ * `entities.getTypeName / getName / getGlobalId` and `properties.getForEntity`
+ * — `createSyntheticDataStore` builds a real single-row entity table (plus the
+ * lazy `getEntity` / `getProperties` accessors) so every member of the
+ * `IfcDataStore` contract is present and compiler-enforced — no `as unknown as`
+ * shims that silently drop an accessor and crash picking at runtime (#1004).
+ *
+ * `IfcGeographicElement` is the closest IFC4 entity for a real-world scan; the
+ * entity table derives its enum (58) from the type name itself.
  */
 function emptyDataStore(
   buffer: ArrayBuffer,
   expressId: number,
   fileName: string,
 ): IfcDataStore {
-  const expressIds = new Uint32Array([expressId]);
-  const empty32 = new Uint32Array(0);
-  const empty8 = new Uint8Array(0);
-  const emptyI32 = new Int32Array(0);
-  const indexOf = (id: number) => (id === expressId ? 0 : -1);
-  const entities = {
-    count: 1,
-    expressId: expressIds,
-    typeEnum: new Uint16Array([IFC_GEOGRAPHIC_ELEMENT_ENUM]),
-    globalId: empty32,
-    name: empty32,
-    description: empty32,
-    objectType: empty32,
-    flags: new Uint8Array([0]),
-    containedInStorey: new Int32Array([-1]),
-    definedByType: new Int32Array([-1]),
-    geometryIndex: new Int32Array([-1]),
-    typeRanges: new Map(),
-    getGlobalId: (id: number) => (indexOf(id) >= 0 ? `pointcloud-${expressId}` : ''),
-    getName: (id: number) => (indexOf(id) >= 0 ? fileName : ''),
-    getDescription: () => '',
-    getObjectType: () => '',
-    getTypeName: (id: number) => (indexOf(id) >= 0 ? 'IfcGeographicElement' : 'Unknown'),
-    hasGeometry: (id: number) => indexOf(id) >= 0,
-    getByType: () => [expressId],
-    getTypeEnum: (id: number) =>
-      indexOf(id) >= 0 ? IFC_GEOGRAPHIC_ELEMENT_ENUM : 9999, // 9999 = Unknown
-    getExpressIdByGlobalId: (gid: string) =>
-      gid === `pointcloud-${expressId}` ? expressId : -1,
-    getGlobalIdMap: () => new Map([[`pointcloud-${expressId}`, expressId]]),
-  };
-  const properties = {
-    count: 0,
-    entityId: empty32, psetName: empty32, psetGlobalId: empty32,
-    propName: empty32, propType: empty8,
-    valueString: empty32, valueReal: new Float64Array(0),
-    valueInt: emptyI32, valueBool: empty8, unitId: emptyI32,
-    entityIndex: new Map<number, number[]>(),
-    psetIndex: new Map<number, number[]>(),
-    propIndex: new Map<number, number[]>(),
-    getForEntity: () => [],
-    getPropertyValue: () => null,
-    findByProperty: () => [],
-  };
-  const quantities = {
-    count: 0,
-    entityId: empty32, qsetName: empty32, qsetGlobalId: empty32,
-    quantityName: empty32, quantityType: empty8,
-    valueReal: new Float64Array(0), unitId: emptyI32,
-    entityIndex: new Map<number, number[]>(),
-    qsetIndex: new Map<number, number[]>(),
-    getForEntity: () => [],
-  };
-  const relationships = {
-    count: 0,
-    relType: empty8, relatingId: empty32, relatedId: empty32,
-    byRelating: new Map<number, number[]>(),
-    byRelated: new Map<number, number[]>(),
-    getOutgoing: () => [],
-    getIncoming: () => [],
-    getRelated: () => [],
-    getRelating: () => [],
-  };
-  const byId = new Map<number, unknown>([[expressId, { expressId }]]);
-  return {
+  return createSyntheticDataStore({
+    schemaVersion: 'IFC4',
     fileSize: buffer.byteLength,
-    schemaVersion: 'IFC4' as const,
     entityCount: 1,
-    parseTime: 0,
-    source: new Uint8Array(0),
-    entityIndex: {
-      byId: byId as unknown as IfcDataStore['entityIndex']['byId'],
-      byType: new Map([['IFCGEOGRAPHICELEMENT', [expressId]]]),
-    },
-    strings: {
-      get: () => '',
-      getId: () => 0,
-      count: 0,
-    } as unknown as IfcDataStore['strings'],
-    entities: entities as unknown as IfcDataStore['entities'],
-    properties: properties as unknown as IfcDataStore['properties'],
-    quantities: quantities as unknown as IfcDataStore['quantities'],
-    relationships: relationships as unknown as IfcDataStore['relationships'],
-    spatialHierarchy: undefined,
-  } as unknown as IfcDataStore;
+    entities: [{
+      expressId,
+      type: 'IfcGeographicElement',
+      globalId: `pointcloud-${expressId}`,
+      name: fileName,
+      hasGeometry: true,
+    }],
+  });
 }
 
 export interface PointCloudIngestResult {

package/src/hooks/ingest/viewerModelIngest.ts

@@ -2,7 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-import { parseIfcx, type IfcDataStore, type PointCloudExtraction } from '@ifc-lite/parser';
+import { parseIfcx, createSyntheticDataStore, type IfcDataStore, type PointCloudExtraction } from '@ifc-lite/parser';
 import { type GeometryResult, type MeshData, type PointCloudAsset } from '@ifc-lite/geometry';
 import { loadGLBToMeshData } from '@ifc-lite/cache';
 import type { SchemaVersion } from '../../store/types.js';
@@ -44,20 +44,15 @@ export function convertIfcxMeshes(rawMeshes: RawIfcxMesh[]): MeshData[] {
 }
 
 export function createMinimalGlbDataStore(buffer: ArrayBuffer, meshCount: number): IfcDataStore {
-  return {
+  // A GLB carries renderable meshes but no IFC entities. Build a typed,
+  // entity-less store via the shared factory so the full `IfcDataStore`
+  // contract (including the lazy `getEntity` / `getProperties` accessors the
+  // query path calls) is compiler-enforced instead of cast away (#1004).
+  return createSyntheticDataStore({
+    schemaVersion: 'IFC4',
     fileSize: buffer.byteLength,
-    schemaVersion: 'IFC4' as const,
     entityCount: meshCount,
-    parseTime: 0,
-    source: new Uint8Array(0),
-    entityIndex: { byId: new Map(), byType: new Map() },
-    strings: { getString: () => undefined, getStringId: () => undefined, count: 0 } as unknown as IfcDataStore['strings'],
-    entities: { count: 0, getId: () => 0, getType: () => 0, getName: () => undefined, getGlobalId: () => undefined } as unknown as IfcDataStore['entities'],
-    properties: { count: 0, getPropertiesForEntity: () => [], getPropertySetForEntity: () => [] } as unknown as IfcDataStore['properties'],
-    quantities: { count: 0, getQuantitiesForEntity: () => [] } as unknown as IfcDataStore['quantities'],
-    relationships: { count: 0, getRelationships: () => [], getRelated: () => [] } as unknown as IfcDataStore['relationships'],
-    spatialHierarchy: null as unknown as IfcDataStore['spatialHierarchy'],
-  } as unknown as IfcDataStore;
+  });
 }
 
 export function getMaxExpressId(dataStore: IfcDataStore, meshes: MeshData[]): number {

package/src/hooks/useAlignmentLines3D.ts

@@ -24,6 +24,7 @@ import { useViewerStore } from '@/store';
 import { useShallow } from 'zustand/react/shallow';
 import type { IfcDataStore } from '@ifc-lite/parser';
 import { sourceKey } from './source-key.js';
+import { hasEntityType } from './has-entity-type.js';
 
 const EMPTY_F32 = new Float32Array(0);
 
@@ -42,6 +43,10 @@ function notifyCacheChange(): void {
 async function parseAlignmentLinesFor(store: IfcDataStore): Promise<Float32Array> {
   const source = store.source;
   if (!source || source.byteLength === 0) return EMPTY_F32;
+  // Most models (all buildings) have no alignments. Skip the full-source WASM
+  // scan — it copies the entire IFC source into the WASM heap on the main thread
+  // just to find none (~0.5s on a 170MB file).
+  if (!hasEntityType(store, 'IfcAlignment', 'IfcAlignmentCurve')) return EMPTY_F32;
   const processor = new GeometryProcessor();
   try {
     await processor.init();

package/src/hooks/useConstructionUnderlay.ts

@@ -0,0 +1,94 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Faint plan-cut underlay of building elements (walls/doors/columns ~1.2 m
+ * above the storey floor) for the 2D Space Sketch, registered into the same
+ * model-metre frame as the room outlines so the user keeps building orientation
+ * while editing rooms.
+ *
+ * The construction projection (the same one the sections canvas uses) runs on
+ * render-frame meshes (Y-up, RTC-shifted). For a plan (down = `'y'`) cut,
+ * `projectTo2D` yields `(renderX, renderZ)`, and `renderX = ifcX − rtc.x +
+ * shift.x`, `renderZ = −ifcY + rtc.y + shift.z`. We invert that back to the
+ * room frame `(ifcX, ifcY)` so the underlay overlays the rooms directly.
+ */
+
+import { useEffect, useRef, useState } from 'react';
+import { Drawing2DGenerator, createSectionConfig } from '@ifc-lite/drawing-2d';
+import type { CoordinateInfo } from '@ifc-lite/geometry';
+import { useViewerStore } from '@/store';
+
+export interface UnderlayLine {
+  a: [number, number];
+  b: [number, number];
+  /** Dashed (above-cut / occluded) vs solid (at/below cut). */
+  hidden: boolean;
+}
+
+export function useConstructionUnderlay(
+  enabled: boolean,
+  floorElevation: number | null,
+): { lines: UnderlayLine[]; loading: boolean } {
+  const geometryResult = useViewerStore((s) => s.geometryResult);
+  const [lines, setLines] = useState<UnderlayLine[]>([]);
+  const [loading, setLoading] = useState(false);
+  const genRef = useRef<Drawing2DGenerator | null>(null);
+
+  useEffect(() => {
+    const meshes = geometryResult?.meshes;
+    if (!enabled || floorElevation === null || !meshes || meshes.length === 0) {
+      setLines([]);
+      return;
+    }
+    let cancelled = false;
+    setLoading(true);
+
+    const coord = geometryResult?.coordinateInfo as CoordinateInfo | undefined;
+    const rtc = coord?.wasmRtcOffset ?? { x: 0, y: 0, z: 0 };
+    const shift = coord?.originShift ?? { x: 0, y: 0, z: 0 };
+    // Plan cut at floor + 1.2 m, in render-frame Y.
+    const cutY = floorElevation + 1.2 - rtc.z + shift.y;
+    // Inverse of the plan projection → room (ifcX, ifcY) frame.
+    const cx = rtc.x - shift.x;
+    const cy = rtc.y + shift.z;
+
+    const config = createSectionConfig('y', cutY, {
+      projectionDepth: 1.5,
+      projectionBelowDepth: 1.4,
+      projectionAboveDepth: 0.8,
+    });
+
+    void (async () => {
+      try {
+        const gen = genRef.current ?? new Drawing2DGenerator();
+        genRef.current = gen;
+        await gen.initialize();
+        const drawing = await gen.generate(meshes, config, {
+          includeProjection: true,
+          includeEdges: false,
+          includeHiddenLines: false,
+          mergeLines: true,
+        });
+        if (cancelled) return;
+        const out: UnderlayLine[] = drawing.lines.map((l) => ({
+          a: [l.line.start.x + cx, cy - l.line.start.y] as [number, number],
+          b: [l.line.end.x + cx, cy - l.line.end.y] as [number, number],
+          hidden: l.visibility === 'hidden',
+        }));
+        setLines(out);
+      } catch {
+        if (!cancelled) setLines([]);
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    })();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled, floorElevation, geometryResult]);
+
+  return { lines, loading };
+}