@ifc-lite/viewer 1.25.2 → 1.27.0

package/src/lib/slab-edit.ts

@@ -35,6 +35,7 @@ import type { MutablePropertyView, StoreEditor } from '@ifc-lite/mutations';
 import {
   asExpressIdRef,
   asCoordinateTriple,
+  asDirectionRatios,
   readAttributes,
   resolvePlacementChain,
 } from './placement-core.js';
@@ -61,6 +62,93 @@ function stepTypeToSlabLike(stepType: string): SlabLikeType | null {
   return SLAB_LIKE_STEP_TYPES[stepType.toUpperCase()] ?? null;
 }
 
+/**
+ * A 2D rigid transform mapping a profile-coordinate point into the
+ * solid's local plan (XY). Built from the `IfcExtrudedAreaSolid`'s
+ * `Position` (an `IfcAxis2Placement3D`), it folds in the in-place
+ * translation + rotation that real-world authoring tools bake there.
+ * In-store-built slabs carry an identity Position, so the resolver
+ * defaults to the identity transform for them.
+ */
+type Xform2D = (p: [number, number]) => [number, number];
+
+const IDENTITY_XFORM2D: Xform2D = (p) => [p[0], p[1]];
+
+function readDirection(
+  dataStore: IfcDataStore,
+  view: MutablePropertyView,
+  editor: StoreEditor,
+  id: number | null,
+): [number, number, number] | null {
+  if (id === null) return null;
+  const attrs = readAttributes(dataStore, view, editor, id);
+  return attrs ? asDirectionRatios(attrs[0]) : null;
+}
+
+/**
+ * Build the plan-space transform for an `IfcExtrudedAreaSolid.Position`.
+ * The profile lives in the placement's local XY plane; we map a profile
+ * point `(px, py)` to `origin + px·X + py·Y` and keep the XY components
+ * (the footprint is the plan). X comes from RefDirection (orthonormalised
+ * against the Axis/Z), Y = Z × X — matching the IFC placement convention,
+ * including axis flips (e.g. Axis `(0,0,-1)`, RefDirection `(-1,0,0)`).
+ * Returns identity when the placement is absent or degenerate.
+ */
+function resolveSolidPositionXform(
+  dataStore: IfcDataStore,
+  view: MutablePropertyView,
+  editor: StoreEditor,
+  placementId: number | null,
+): Xform2D {
+  if (placementId === null) return IDENTITY_XFORM2D;
+  const attrs = readAttributes(dataStore, view, editor, placementId);
+  if (!attrs) return IDENTITY_XFORM2D;
+
+  // IfcAxis2Placement3D: [0] Location · [1] Axis (Z) · [2] RefDirection (X).
+  const locId = asExpressIdRef(attrs[0]);
+  let ox = 0;
+  let oy = 0;
+  if (locId !== null) {
+    const locAttrs = readAttributes(dataStore, view, editor, locId);
+    const c = locAttrs ? asCoordinateTriple(locAttrs[0]) : null;
+    if (c) {
+      ox = c[0];
+      oy = c[1];
+    }
+  }
+
+  // IfcDirection ratios are NOT guaranteed unit length, so normalise Z
+  // before using it as a basis vector — otherwise the Gram-Schmidt
+  // projection (which assumes |Z|=1) and Y = Z × X both pick up |Z| as a
+  // stray scale factor, skewing the footprint away from the rendered mesh
+  // for files with e.g. Axis=(0,0,2). The Rust profile extractor
+  // normalises the same placement.
+  const rawZ = readDirection(dataStore, view, editor, asExpressIdRef(attrs[1])) ?? [0, 0, 1];
+  const zlen = Math.hypot(rawZ[0], rawZ[1], rawZ[2]);
+  if (zlen < 1e-9) return IDENTITY_XFORM2D;
+  const z: [number, number, number] = [rawZ[0] / zlen, rawZ[1] / zlen, rawZ[2] / zlen];
+  const refX = readDirection(dataStore, view, editor, asExpressIdRef(attrs[2])) ?? [1, 0, 0];
+
+  // Orthonormalise X against the unit Z (Gram-Schmidt), then Y = Z × X.
+  const dot = refX[0] * z[0] + refX[1] * z[1] + refX[2] * z[2];
+  let xv: [number, number, number] = [
+    refX[0] - dot * z[0],
+    refX[1] - dot * z[1],
+    refX[2] - dot * z[2],
+  ];
+  const xlen = Math.hypot(xv[0], xv[1], xv[2]);
+  if (xlen < 1e-9) return IDENTITY_XFORM2D;
+  xv = [xv[0] / xlen, xv[1] / xlen, xv[2] / xlen];
+  // Z and X are now orthonormal, so Y = Z × X is already unit length.
+  const yv: [number, number, number] = [
+    z[1] * xv[2] - z[2] * xv[1],
+    z[2] * xv[0] - z[0] * xv[2],
+    z[0] * xv[1] - z[1] * xv[0],
+  ];
+
+  return (p) => [ox + p[0] * xv[0] + p[1] * yv[0], oy + p[0] * xv[1] + p[1] * yv[1]];
+}
+
 export interface SlabEditChain {
   /** STEP type name, for the slice's dispatch. */
   elementType: SlabLikeType;
@@ -106,22 +194,23 @@ function rectangleFootprint(
   profileOrigin2D: [number, number],
   xdim: number,
   ydim: number,
+  solidXform: Xform2D,
 ): Point2D[] {
-  // The profile's local frame maps directly to storey-local XY for
-  // a slab (no in-plane rotation; the builder writes Position +
-  // null Axis + null RefDirection so the placement is axis-aligned).
+  // Rectangle corners in the profile coordinate system (centred on the
+  // profile origin), mapped through the solid Position into plan space,
+  // then offset by the slab's placement origin.
   const [px, py] = placementOrigin;
   const [cx, cy] = profileOrigin2D;
-  const xMin = px + cx - xdim / 2;
-  const xMax = px + cx + xdim / 2;
-  const yMin = py + cy - ydim / 2;
-  const yMax = py + cy + ydim / 2;
-  return [
-    [xMin, yMin],
-    [xMax, yMin],
-    [xMax, yMax],
-    [xMin, yMax],
+  const corners: Point2D[] = [
+    [cx - xdim / 2, cy - ydim / 2],
+    [cx + xdim / 2, cy - ydim / 2],
+    [cx + xdim / 2, cy + ydim / 2],
+    [cx - xdim / 2, cy + ydim / 2],
   ];
+  return corners.map((c) => {
+    const [wx, wy] = solidXform(c);
+    return [px + wx, py + wy] as Point2D;
+  });
 }
 
 /**
@@ -136,6 +225,7 @@ function polylineFootprint(
   polylineId: number,
   placementOrigin: [number, number, number],
   profileOrigin2D: [number, number],
+  solidXform: Xform2D,
 ): Point2D[] | null {
   const attrs = readAttributes(dataStore, view, editor, polylineId);
   if (!attrs) return null;
@@ -155,7 +245,10 @@ function polylineFootprint(
     // tolerantly — IFC files in the wild sometimes pad with Z=0.
     const coords = asCoordinateTriple(ptAttrs[0]);
     if (!coords) return null;
-    out.push([px + cx + coords[0], py + cy + coords[1]]);
+    // Point in profile CS → solid plan (Position translation + rotation)
+    // → slab placement origin.
+    const [wx, wy] = solidXform([cx + coords[0], cy + coords[1]]);
+    out.push([px + wx, py + wy]);
   }
   // IfcPolyline for a closed profile may or may not repeat the
   // first vertex at the end — strip if present, our clip API
@@ -170,22 +263,57 @@ function polylineFootprint(
   return out.length >= 3 ? out : null;
 }
 
+/**
+ * Scale a chain's coordinate-bearing fields (footprint, placement
+ * origin, thickness) by `scale`. Identity when `scale === 1`. Used to
+ * lift a native-unit (e.g. millimetre) STEP read into the viewer's
+ * metre working space — see `resolveSlabEditChain`'s `lengthUnitScale`.
+ */
+function scaleSlabChain(chain: SlabEditChain, scale: number): SlabEditChain {
+  if (scale === 1) return chain;
+  return {
+    ...chain,
+    placementOrigin: [
+      chain.placementOrigin[0] * scale,
+      chain.placementOrigin[1] * scale,
+      chain.placementOrigin[2] * scale,
+    ],
+    footprint: chain.footprint.map(([x, y]) => [x * scale, y * scale] as Point2D),
+    thickness: chain.thickness * scale,
+  };
+}
+
 /**
  * Resolve the slab chain (placement + footprint + extrusion). Works
  * for IfcSlab / IfcRoof / IfcPlate / IfcSpace whose representation
  * matches the in-store builder shape; null otherwise.
+ *
+ * `lengthUnitScale` is the model's native-unit → metre factor (e.g.
+ * `0.001` for a millimetre file). Raw STEP coordinate reads are in
+ * native units, but the rest of the split flow — raycast cut points,
+ * preview meshes, selection hit-tests — lives in metres, so the
+ * resolved footprint/thickness are scaled to match. Authored overlay
+ * entities are skipped: the in-store builders already emit metres, so
+ * scaling them would double-apply (re-splitting a freshly-cut half).
  */
 export function resolveSlabEditChain(
   dataStore: IfcDataStore,
   view: MutablePropertyView,
   editor: StoreEditor,
   expressId: number,
+  lengthUnitScale = 1,
 ): SlabEditChain | null {
   const rawType = readEntityType(dataStore, view, editor, expressId);
   if (!rawType) return null;
   const elementType = stepTypeToSlabLike(rawType);
   if (!elementType) return null;
 
+  // Overlay (authored) entities are stored in metres by the in-store
+  // builders; only native STEP reads need the unit scale applied.
+  // `getNewEntity` returns null (not undefined) for source entities.
+  const isAuthored = editor.getNewEntity(expressId) != null;
+  const scale = isAuthored ? 1 : lengthUnitScale;
+
   const chain = resolvePlacementChain(dataStore, view, editor, expressId);
   if (!chain) return null;
   const placementOrigin = chain.coordinates;
@@ -212,6 +340,18 @@ export function resolveSlabEditChain(
   const thicknessRaw = solidAttrs[3];
   if (profileId === null || typeof thicknessRaw !== 'number') return null;
 
+  // IfcExtrudedAreaSolid.Position (attr 1) is an IfcAxis2Placement3D that
+  // places the profile in the solid's frame — real authoring tools bake
+  // the slab's plan offset + rotation here (in-store-built slabs leave it
+  // identity). Fold it into the footprint so the preview, cut line, and
+  // resulting halves land where the rendered mesh actually is.
+  const solidXform = resolveSolidPositionXform(
+    dataStore,
+    view,
+    editor,
+    asExpressIdRef(solidAttrs[1]),
+  );
+
   // Profile dispatch — rectangle vs polygon, both produced by
   // addSlabToStore. Source-buffer slabs with mapped representations,
   // I-shape profiles, etc. land in `null` here and the slice
@@ -244,29 +384,29 @@ export function resolveSlabEditChain(
     const xdim = profileAttrs[3];
     const ydim = profileAttrs[4];
     if (typeof xdim !== 'number' || typeof ydim !== 'number') return null;
-    return {
+    return scaleSlabChain({
       elementType,
       placementOrigin,
-      footprint: rectangleFootprint(placementOrigin, profileOrigin2D, xdim, ydim),
+      footprint: rectangleFootprint(placementOrigin, profileOrigin2D, xdim, ydim, solidXform),
       extrudedSolidId: solidId,
       thickness: thicknessRaw,
       profileKind: 'rectangle',
-    };
+    }, scale);
   }
   if (profileType && profileType.toUpperCase() === 'IFCARBITRARYCLOSEDPROFILEDEF') {
     // OuterCurve at attr 2.
     const polylineId = asExpressIdRef(profileAttrs[2]);
     if (polylineId === null) return null;
-    const fp = polylineFootprint(dataStore, view, editor, polylineId, placementOrigin, profileOrigin2D);
+    const fp = polylineFootprint(dataStore, view, editor, polylineId, placementOrigin, profileOrigin2D, solidXform);
     if (!fp) return null;
-    return {
+    return scaleSlabChain({
       elementType,
       placementOrigin,
       footprint: fp,
       extrudedSolidId: solidId,
       thickness: thicknessRaw,
       profileKind: 'polygon',
-    };
+    }, scale);
   }
   return null;
 }

package/src/sdk/adapters/export-adapter.ts

@@ -153,13 +153,13 @@ export function createExportAdapter(store: StoreApi): ExportBackendMethods {
     if (!model?.ifcDataStore) return [];
 
     const node = new EntityNode(model.ifcDataStore, ref.expressId);
-    return node.properties().map((pset: { name: string; globalId?: string; properties: Array<{ name: string; type: number; value: string | number | boolean | null }> }) => ({
+    return node.properties().map((pset) => ({
       name: pset.name,
       globalId: pset.globalId,
-      properties: pset.properties.map((p: { name: string; type: number; value: string | number | boolean | null }) => ({
+      properties: pset.properties.map((p) => ({
         name: p.name,
         type: p.type,
-        value: p.value,
+        value: p.value as string | number | boolean | null,
       })),
     }));
   }

package/src/sdk/adapters/query-adapter.ts

@@ -136,13 +136,13 @@ export function createQueryAdapter(store: StoreApi): QueryBackendMethods {
     if (!model?.ifcDataStore) return [];
 
     const node = new EntityNode(model.ifcDataStore, ref.expressId);
-    return node.properties().map((pset: { name: string; globalId?: string; properties: Array<{ name: string; type: number; value: string | number | boolean | null }> }) => ({
+    return node.properties().map((pset) => ({
       name: pset.name,
       globalId: pset.globalId,
-      properties: pset.properties.map((p: { name: string; type: number; value: string | number | boolean | null }) => ({
+      properties: pset.properties.map((p) => ({
         name: p.name,
         type: p.type,
-        value: p.value,
+        value: p.value as string | number | boolean | null,
       })),
     }));
   }

package/src/services/extensions/host.ts

@@ -436,6 +436,19 @@ export class ExtensionHostService {
     } catch (err) {
       console.warn('[ext-host] lens restore on switch failed:', err);
     }
+    // Restore the flavor's clash config (rule-set + detection settings) from the
+    // opaque settings.clash blob, mirroring the lens roundtrip above. Missing /
+    // malformed blobs deserialize to null and are skipped (no-op).
+    try {
+      const { deserializeClashConfig } = await import('@/lib/clash/persistence');
+      const config = deserializeClashConfig((target.settings as Record<string, unknown> | undefined)?.clash);
+      if (config) {
+        const { useViewerStore } = await import('@/store');
+        useViewerStore.getState().applyClashFlavorConfig(config);
+      }
+    } catch (err) {
+      console.warn('[ext-host] clash restore on switch failed:', err);
+    }
     this.emit();
   }
 

package/src/store/constants.ts

@@ -6,6 +6,8 @@
  * Store constants - extracted magic numbers for maintainability
  */
 
+import type { TypeVisibility } from './types.js';
+
 // ============================================================================
 // Camera Defaults
 // ============================================================================
@@ -182,37 +184,43 @@ function readPersistedBool(key: string, fallback: boolean): boolean {
 // on first load. IfcSite + IfcAnnotation + IfcGrid on — all three convey
 // design intent users expect to see by default. (Issue #862 split grid
 // into its own toggle so dense-grid models can hide grids without losing
-// dimensions/labels.)
-const SEMANTIC_DEFAULTS = {
+// dimensions/labels.) Exported so the "Reset" action in the visibility
+// menu can restore these without re-deriving them.
+export const TYPE_VISIBILITY_SEMANTIC_DEFAULTS: TypeVisibility = {
   spaces: false,
   openings: false,
   site: true,
   ifcAnnotations: true,
   ifcGrid: true,
-} as const;
+};
 
-export const TYPE_VISIBILITY_DEFAULTS = {
-  /** IfcSpace visibility — persisted across reloads. */
-  SPACES:          readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.spaces, SEMANTIC_DEFAULTS.spaces),
-  /** IfcOpeningElement visibility — persisted across reloads. */
-  OPENINGS:        readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.openings, SEMANTIC_DEFAULTS.openings),
-  /** IfcSite visibility — persisted across reloads. */
-  SITE:            readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.site, SEMANTIC_DEFAULTS.site),
-  /** IfcAnnotation visibility (text, dimensions, leaders) — persisted. */
-  IFC_ANNOTATIONS: readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.ifcAnnotations, SEMANTIC_DEFAULTS.ifcAnnotations),
-  /**
-   * IfcGrid visibility (axis lines + bubble tags) — persisted. Issue
-   * #862. Migration: if the new key isn't set yet, fall back to the
-   * legacy combined `ifcAnnotations` preference. That way a user who
-   * previously turned the combined "Annotations & Grids" toggle off
-   * keeps grids hidden after upgrade, instead of grids silently
-   * reappearing (PR #868 review, chatgpt-codex P2).
-   */
-  IFC_GRID:        readPersistedBool(
-    TYPE_VISIBILITY_STORAGE_KEYS.ifcGrid,
-    readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.ifcAnnotations, SEMANTIC_DEFAULTS.ifcGrid),
-  ),
-} as const;
+/**
+ * Resolve the full type-visibility preference set from localStorage.
+ *
+ * Read fresh on EVERY call — not captured once at module load. The store
+ * applies this both at boot (slice init) and on every new-file load
+ * (`resetViewerState`). A module-level constant would snapshot localStorage
+ * at first import and then go stale after the first in-session toggle, so
+ * loading a second model would silently revert the user's choices (e.g.
+ * "Show Annotations" flipping back on). Reading live keeps every toggle
+ * sticky across reloads AND across model swaps within a session.
+ */
+export function getPersistedTypeVisibility(): TypeVisibility {
+  return {
+    spaces:         readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.spaces, TYPE_VISIBILITY_SEMANTIC_DEFAULTS.spaces),
+    openings:       readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.openings, TYPE_VISIBILITY_SEMANTIC_DEFAULTS.openings),
+    site:           readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.site, TYPE_VISIBILITY_SEMANTIC_DEFAULTS.site),
+    ifcAnnotations: readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.ifcAnnotations, TYPE_VISIBILITY_SEMANTIC_DEFAULTS.ifcAnnotations),
+    // Issue #862. Migration: if the new grid key isn't set yet, fall back to
+    // the legacy combined `ifcAnnotations` preference so a user who turned
+    // the old "Annotations & Grids" toggle off keeps grids hidden after
+    // upgrade instead of grids silently reappearing (PR #868 review).
+    ifcGrid:        readPersistedBool(
+      TYPE_VISIBILITY_STORAGE_KEYS.ifcGrid,
+      readPersistedBool(TYPE_VISIBILITY_STORAGE_KEYS.ifcAnnotations, TYPE_VISIBILITY_SEMANTIC_DEFAULTS.ifcGrid),
+    ),
+  };
+}
 
 // ============================================================================
 // Data Defaults

package/src/store/index.ts

@@ -33,6 +33,7 @@ import { createExtensionsSlice, type ExtensionsSlice } from './slices/extensions
 import { createListSlice, type ListSlice } from './slices/listSlice.js';
 import { createPinboardSlice, type PinboardSlice } from './slices/pinboardSlice.js';
 import { createLensSlice, type LensSlice } from './slices/lensSlice.js';
+import { createClashSlice, type ClashSlice } from './slices/clashSlice.js';
 import { createScriptSlice, type ScriptSlice } from './slices/scriptSlice.js';
 import { createChatSlice, type ChatSlice } from './slices/chatSlice.js';
 import { createCesiumSlice, type CesiumSlice } from './slices/cesiumSlice.js';
@@ -49,7 +50,7 @@ import { createPointCloudSlice, type PointCloudSlice, POINT_CLOUD_DEFAULTS } fro
 import { invalidateVisibleBasketCache } from './basketVisibleSet.js';
 
 // Import constants for reset function
-import { CAMERA_DEFAULTS, SECTION_PLANE_DEFAULTS, UI_DEFAULTS, TYPE_VISIBILITY_DEFAULTS } from './constants.js';
+import { CAMERA_DEFAULTS, SECTION_PLANE_DEFAULTS, UI_DEFAULTS, getPersistedTypeVisibility } from './constants.js';
 
 // Re-export types for consumers
 export type * from './types.js';
@@ -129,6 +130,7 @@ export type ViewerState = LoadingSlice &
   ListSlice &
   PinboardSlice &
   LensSlice &
+  ClashSlice &
   ScriptSlice &
   ChatSlice &
   CesiumSlice &
@@ -144,6 +146,16 @@ export type ViewerState = LoadingSlice &
   PointCloudSlice &
   ExtensionsSlice & {
     resetViewerState: () => void;
+    /**
+     * Open one right-side analysis panel and close the others, so the chosen
+     * panel is always the topmost/active one. The right panel renders a single
+     * mutually-exclusive chain (lens → clash → ids → bcf → extensions), so
+     * leaving a sibling flag set would keep the higher-precedence panel on top
+     * (the cause of "I have to close clash before I see BCF"). Also un-collapses
+     * the right panel. Routed through by the toolbar, command palette, and the
+     * BCF overlay so every entry point behaves identically.
+     */
+    openWorkspacePanel: (panel: 'bcf' | 'ids' | 'lens' | 'clash' | 'extensions') => void;
   };
 
 /**
@@ -169,6 +181,7 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
   ...createListSlice(...args),
   ...createPinboardSlice(...args),
   ...createLensSlice(...args),
+  ...createClashSlice(...args),
   ...createScriptSlice(...args),
   ...createChatSlice(...args),
   ...createCesiumSlice(...args),
@@ -203,13 +216,9 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
       hiddenEntities: new Set(),
       isolatedEntities: null,
       classFilter: null,
-      typeVisibility: {
-        spaces: TYPE_VISIBILITY_DEFAULTS.SPACES,
-        openings: TYPE_VISIBILITY_DEFAULTS.OPENINGS,
-        site: TYPE_VISIBILITY_DEFAULTS.SITE,
-        ifcAnnotations: TYPE_VISIBILITY_DEFAULTS.IFC_ANNOTATIONS,
-        ifcGrid: TYPE_VISIBILITY_DEFAULTS.IFC_GRID,
-      },
+      // Re-read persisted toggles on every file load so a new model never
+      // reverts the user's visibility choices (e.g. "Show Annotations").
+      typeVisibility: getPersistedTypeVisibility(),
 
       // Visibility (multi-model)
       hiddenEntitiesByModel: new Map(),
@@ -443,6 +452,18 @@ const createViewerStore = () => create<ViewerState>()((...args) => ({
       pointCloudFixedColor: [...POINT_CLOUD_DEFAULTS.pointCloudFixedColor] as [number, number, number, number],
     });
   },
+
+  openWorkspacePanel: (panel) => {
+    const [set] = args;
+    set({
+      bcfPanelVisible: panel === 'bcf',
+      idsPanelVisible: panel === 'ids',
+      lensPanelVisible: panel === 'lens',
+      clashPanelVisible: panel === 'clash',
+      extensionsPanelVisible: panel === 'extensions',
+      rightPanelCollapsed: false,
+    });
+  },
 }));
 
 const STORE_SINGLETON_KEY = '__ifc_lite_viewer_store__';