@ifc-lite/viewer 1.22.0 → 1.22.1

package/src/store/slices/splitToolSlice.ts

@@ -0,0 +1,165 @@
+/* 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/. */
+
+/**
+ * State for the Split tool.
+ *
+ * Single-element flow today: user hovers a wall, the overlay
+ * projects the cursor onto the wall's axis to compute a candidate
+ * cut distance, click commits via `MutationSlice.splitWallAtDistance`.
+ *
+ * Bigger surface (slab cut-line, multi-element plane split, beam /
+ * column / member) is in `docs/design/element-splitting.md` and
+ * arrives in subsequent phases. The slice is shaped to grow without
+ * a breaking rename — `splitMode` covers the future modes;
+ * `splitHoverPoint` and `splitTargetExpressId` will be reused.
+ */
+
+import type { StateCreator } from 'zustand';
+
+/**
+ * Split-tool state machine:
+ *   - `'idle'` — cursor isn't over a splittable element
+ *   - `'aiming'` — preview cut is live for a single-click element
+ *     (wall / beam / column / member)
+ *   - `'first-anchor'` — slab two-click flow: user clicked once,
+ *     the anchor is latched, the cursor's second click commits
+ *     the cut line. Esc clears back to `'idle'`.
+ */
+export type SplitMode = 'idle' | 'aiming' | 'first-anchor';
+
+export interface SplitToolSlice {
+  /** Tool state machine. `'idle'` while the cursor isn't over a
+   * splittable element; `'aiming'` while a preview cut is live. */
+  splitMode: SplitMode;
+  /** Federated model id that owns the hovered target. */
+  splitTargetModelId: string | null;
+  /** Express id of the hovered wall. */
+  splitTargetExpressId: number | null;
+  /**
+   * Cursor in storey-local IFC space (Z-up). The overlay reads
+   * this to drive a per-frame preview without trampolining through
+   * camera projection.
+   */
+  splitHoverPoint: [number, number, number] | null;
+  /**
+   * Cached projection from the last hover update — distance along
+   * the wall axis from start. Single source of truth for both the
+   * SVG preview label and the commit handler.
+   */
+  splitHoverDistance: number | null;
+  /** Total length of the hovered wall (for the "1.42 / 3.50 m" label). */
+  splitHoverLength: number | null;
+  /** Cut point in storey-local space, derived from distance + wall axis. */
+  splitHoverCutPoint: [number, number, number] | null;
+  /**
+   * Unit-length axis direction in storey-local IFC space (Z-up).
+   * Used by the overlay to compute the perpendicular guide line
+   * without re-walking the IFC chain. Element-type-agnostic — wall
+   * axis lies on the storey plane, beam/member axis can have a Z
+   * component, column axis is `[0, 0, 1]`.
+   */
+  splitHoverAxisDirection: [number, number, number] | null;
+  /**
+   * Slab two-click flow: storey-local XY of the first click. When
+   * set, the tool is in `'first-anchor'` state and the next click
+   * commits a cut line from the anchor to the cursor.
+   */
+  slabCutAnchor: [number, number] | null;
+  /**
+   * Slab cached footprint polygon (storey-local 2D) — read once on
+   * first-anchor latch so the overlay can render the polygon
+   * outline and clip the ghost cut line against it without
+   * re-walking the IFC chain per frame.
+   */
+  slabCutFootprint: [number, number][] | null;
+  slabCutStoreyElevation: number | null;
+
+  setSplitTarget: (modelId: string | null, expressId: number | null) => void;
+  setSplitHover: (
+    hoverPoint: [number, number, number] | null,
+    distance: number | null,
+    length: number | null,
+    cutPoint: [number, number, number] | null,
+    axisDirection: [number, number, number] | null,
+  ) => void;
+  /**
+   * Slab flow: latch the first click + cache the footprint so the
+   * overlay's per-frame work stays cheap. Promotes the tool to
+   * `'first-anchor'`.
+   */
+  setSlabCutAnchor: (
+    anchor: [number, number] | null,
+    footprint: [number, number][] | null,
+    storeyElevation: number | null,
+  ) => void;
+  clearSplitHover: () => void;
+}
+
+export const createSplitToolSlice: StateCreator<SplitToolSlice, [], [], SplitToolSlice> = (set) => ({
+  splitMode: 'idle',
+  splitTargetModelId: null,
+  splitTargetExpressId: null,
+  splitHoverPoint: null,
+  splitHoverDistance: null,
+  splitHoverLength: null,
+  splitHoverCutPoint: null,
+  splitHoverAxisDirection: null,
+  slabCutAnchor: null,
+  slabCutFootprint: null,
+  slabCutStoreyElevation: null,
+
+  setSplitTarget: (modelId, expressId) =>
+    set((s) => ({
+      splitTargetModelId: modelId,
+      splitTargetExpressId: expressId,
+      // Entering / leaving a target without a hover yet means we're
+      // back to 'idle' (unless we're mid-slab-cut, in which case
+      // we preserve the latched anchor — the user might re-enter
+      // the slab from outside).
+      splitMode: s.splitMode === 'first-anchor' ? 'first-anchor' : 'idle',
+      splitHoverPoint: null,
+      splitHoverDistance: null,
+      splitHoverLength: null,
+      splitHoverCutPoint: null,
+      splitHoverAxisDirection: null,
+    })),
+  setSplitHover: (hoverPoint, distance, length, cutPoint, axisDirection) =>
+    set((s) => ({
+      splitHoverPoint: hoverPoint,
+      splitHoverDistance: distance,
+      splitHoverLength: length,
+      splitHoverCutPoint: cutPoint,
+      splitHoverAxisDirection: axisDirection,
+      // Promote to 'aiming' on first hover; don't downgrade the
+      // slab two-click state when hover ends mid-flow.
+      splitMode:
+        s.splitMode === 'first-anchor'
+          ? 'first-anchor'
+          : hoverPoint !== null
+          ? 'aiming'
+          : 'idle',
+    })),
+  setSlabCutAnchor: (anchor, footprint, storeyElevation) =>
+    set({
+      slabCutAnchor: anchor,
+      slabCutFootprint: footprint,
+      slabCutStoreyElevation: storeyElevation,
+      splitMode: anchor === null ? 'idle' : 'first-anchor',
+    }),
+  clearSplitHover: () =>
+    set({
+      splitMode: 'idle',
+      splitTargetModelId: null,
+      splitTargetExpressId: null,
+      splitHoverPoint: null,
+      splitHoverDistance: null,
+      splitHoverLength: null,
+      splitHoverCutPoint: null,
+      splitHoverAxisDirection: null,
+      slabCutAnchor: null,
+      slabCutFootprint: null,
+      slabCutStoreyElevation: null,
+    }),
+});

package/src/store/slices/uiSlice.edit-mode.test.ts

@@ -0,0 +1,210 @@
+/* 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 { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+
+/**
+ * Stand up minimal browser globals — `uiSlice.ts` reaches into
+ * `localStorage` (theme seed), `matchMedia` (theme detection), and
+ * `document.documentElement.classList` (theme apply) at construction
+ * time. Mirrors the harness in `uiSlice.merge-layers.test.ts`.
+ */
+function installGlobals(): void {
+  const store: Record<string, string> = {};
+  Object.defineProperty(globalThis, 'localStorage', {
+    value: {
+      getItem: (k: string) => (k in store ? store[k] : null),
+      setItem: (k: string, v: string) => {
+        store[k] = String(v);
+      },
+      removeItem: (k: string) => {
+        delete store[k];
+      },
+      clear: () => {
+        for (const k of Object.keys(store)) delete store[k];
+      },
+      key: (i: number) => Object.keys(store)[i] ?? null,
+      get length() {
+        return Object.keys(store).length;
+      },
+    },
+    configurable: true,
+    writable: true,
+  });
+  Object.defineProperty(globalThis, 'window', {
+    value: globalThis,
+    configurable: true,
+    writable: true,
+  });
+  Object.defineProperty(globalThis, 'matchMedia', {
+    value: () => ({ matches: false, addEventListener: () => {}, removeEventListener: () => {} }),
+    configurable: true,
+    writable: true,
+  });
+  Object.defineProperty(globalThis, 'document', {
+    value: {
+      documentElement: {
+        classList: {
+          toggle: () => {},
+          add: () => {},
+          remove: () => {},
+          contains: () => false,
+        },
+      },
+    },
+    configurable: true,
+    writable: true,
+  });
+}
+
+function uninstallGlobals(): void {
+  Reflect.deleteProperty(globalThis as Record<string, unknown>, 'localStorage');
+  Reflect.deleteProperty(globalThis as Record<string, unknown>, 'window');
+  Reflect.deleteProperty(globalThis as Record<string, unknown>, 'matchMedia');
+  Reflect.deleteProperty(globalThis as Record<string, unknown>, 'document');
+}
+
+interface SliceHandle {
+  readonly state: Record<string, unknown>;
+}
+
+/**
+ * Build a fresh UISlice on top of a mock combined state.
+ *
+ * The slice's `createUISlice` returns its own initial values (default
+ * `activeTool`, `editEnabled: false`, etc.) which sit on top of the
+ * cross-slice seeds. To exercise non-default starting conditions,
+ * tests pass `overrides` — these are merged in AFTER slice creation
+ * so they actually take effect, rather than being overwritten by the
+ * slice's own initial values.
+ */
+async function buildSlice(overrides: Record<string, unknown> = {}): Promise<SliceHandle> {
+  const mod = await import('./uiSlice.js');
+  const createUISlice = (mod as { createUISlice: (...args: unknown[]) => unknown }).createUISlice;
+  let state: Record<string, unknown> = {
+    models: new Map(),
+    geometryResult: null,
+    // Cesium cross-slice seeds — the slice writes through these when
+    // exiting edit mode.
+    cesiumPlacementEditMode: false,
+    cesiumPlacementDraftModelId: null,
+    cesiumPlacementDraft: null,
+  };
+  const setState = (partial: unknown) => {
+    if (typeof partial === 'function') {
+      const updates = (partial as (s: Record<string, unknown>) => Record<string, unknown>)(state);
+      state = { ...state, ...updates };
+    } else {
+      state = { ...state, ...(partial as Record<string, unknown>) };
+    }
+  };
+  const getState = () => state;
+  state = {
+    ...state,
+    ...(createUISlice as (set: unknown, get: unknown, api: unknown) => Record<string, unknown>)(setState, getState, {}),
+    ...overrides,
+  };
+  return {
+    get state() {
+      return state;
+    },
+  };
+}
+
+describe('UISlice — edit mode', () => {
+  beforeEach(() => installGlobals());
+  afterEach(() => uninstallGlobals());
+
+  it('starts disabled', async () => {
+    const slice = await buildSlice();
+    assert.strictEqual(slice.state.editEnabled, false);
+  });
+
+  it('toggle flips the flag', async () => {
+    const slice = await buildSlice();
+    (slice.state.toggleEditEnabled as () => void)();
+    assert.strictEqual(slice.state.editEnabled, true);
+    (slice.state.toggleEditEnabled as () => void)();
+    assert.strictEqual(slice.state.editEnabled, false);
+  });
+
+  it('setEditEnabled(true) leaves authoring tools untouched', async () => {
+    const slice = await buildSlice({ activeTool: 'measure' });
+    (slice.state.setEditEnabled as (v: boolean) => void)(true);
+    assert.strictEqual(slice.state.editEnabled, true);
+    assert.strictEqual(slice.state.activeTool, 'measure');
+  });
+
+  it('setEditEnabled(true) auto-opens the Add Element panel when nothing is selected', async () => {
+    // Default state has activeTool === 'select' and no selectedEntity,
+    // so flipping edit on should swap to 'addElement' as a friction-
+    // free entry into the authoring flow.
+    const slice = await buildSlice({ activeTool: 'select', selectedEntity: null });
+    (slice.state.setEditEnabled as (v: boolean) => void)(true);
+    assert.strictEqual(slice.state.editEnabled, true);
+    assert.strictEqual(slice.state.activeTool, 'addElement');
+  });
+
+  it('setEditEnabled(true) leaves activeTool=select when an entity IS selected', async () => {
+    // With a selection in hand the user is most likely going to use
+    // the Properties / Geometry edit card next — don't yank focus
+    // into the Add panel.
+    const slice = await buildSlice({
+      activeTool: 'select',
+      selectedEntity: { modelId: 'm', expressId: 1 },
+    });
+    (slice.state.setEditEnabled as (v: boolean) => void)(true);
+    assert.strictEqual(slice.state.editEnabled, true);
+    assert.strictEqual(slice.state.activeTool, 'select');
+  });
+
+  it('setEditEnabled(false) exits the add-element tool', async () => {
+    const slice = await buildSlice({ activeTool: 'addElement', editEnabled: true });
+    (slice.state.setEditEnabled as (v: boolean) => void)(false);
+    assert.strictEqual(slice.state.editEnabled, false);
+    assert.strictEqual(slice.state.activeTool, 'select');
+  });
+
+  it('setEditEnabled(false) clears cesium placement state', async () => {
+    const slice = await buildSlice({
+      activeTool: 'cesium-placement',
+      editEnabled: true,
+      cesiumPlacementEditMode: true,
+      cesiumPlacementDraftModelId: 'model-1',
+      cesiumPlacementDraft: { eastings: 1, northings: 2, orthogonalHeight: 3, xAxisAbscissa: 1, xAxisOrdinate: 0 },
+    });
+    (slice.state.setEditEnabled as (v: boolean) => void)(false);
+    assert.strictEqual(slice.state.editEnabled, false);
+    assert.strictEqual(slice.state.activeTool, 'select');
+    assert.strictEqual(slice.state.cesiumPlacementEditMode, false);
+    assert.strictEqual(slice.state.cesiumPlacementDraftModelId, null);
+    assert.strictEqual(slice.state.cesiumPlacementDraft, null);
+  });
+
+  it('setEditEnabled(false) preserves non-edit tools', async () => {
+    const slice = await buildSlice({ activeTool: 'section', editEnabled: true });
+    (slice.state.setEditEnabled as (v: boolean) => void)(false);
+    assert.strictEqual(slice.state.activeTool, 'section');
+  });
+
+  it('setActiveTool to addElement auto-enables edit mode', async () => {
+    const slice = await buildSlice();
+    (slice.state.setActiveTool as (t: string) => void)('addElement');
+    assert.strictEqual(slice.state.activeTool, 'addElement');
+    assert.strictEqual(slice.state.editEnabled, true);
+  });
+
+  it('setActiveTool to cesium-placement auto-enables edit mode', async () => {
+    const slice = await buildSlice();
+    (slice.state.setActiveTool as (t: string) => void)('cesium-placement');
+    assert.strictEqual(slice.state.editEnabled, true);
+  });
+
+  it('setActiveTool to a read-only tool does not touch edit mode', async () => {
+    const slice = await buildSlice({ editEnabled: false });
+    (slice.state.setActiveTool as (t: string) => void)('measure');
+    assert.strictEqual(slice.state.editEnabled, false);
+  });
+});

package/src/store/slices/uiSlice.ts

@@ -11,9 +11,24 @@ import { MERGE_LAYERS_STORAGE_KEY, UI_DEFAULTS } from '../constants.js';
 import type { ContactShadingQuality, SeparationLinesQuality } from '@ifc-lite/renderer';
 import type { FederatedModel } from '../types.js';
 import type { GeometryResult } from '@ifc-lite/geometry';
+import type { CesiumPlacementDraft } from './cesiumSlice.js';
 
 export type ThemeMode = 'light' | 'dark' | 'colorful';
 
+/**
+ * Tools that require edit mode to function. Entering one of them
+ * flips `editEnabled` on; leaving edit mode forces these tools
+ * back to `'select'`. Keep the list in sync — duplicating the
+ * authoring-tool check between `setActiveTool` and
+ * `setEditEnabled` is how the two states drift apart in the
+ * "enter edit, switch tool, exit edit" flow.
+ */
+const AUTHORING_TOOLS: ReadonlySet<string> = new Set([
+  'addElement',
+  'cesium-placement',
+  'split',
+]);
+
 /**
  * Cross-slice surface UISlice reaches into via the combined Zustand
  * `get()` to decide whether toggling a load-time setting needs a
@@ -22,6 +37,15 @@ export type ThemeMode = 'light' | 'dark' | 'colorful';
 export interface UICrossSliceState {
   models: Map<string, FederatedModel>;
   geometryResult: GeometryResult | null;
+  /**
+   * Cesium placement draft state owned by `CesiumSlice`. UISlice
+   * reaches in to clear it when global edit mode flips off, so that
+   * "exit edit" really exits everything (the placement editor, the
+   * draft values, the active tool) in a single atomic update.
+   */
+  cesiumPlacementEditMode: boolean;
+  cesiumPlacementDraftModelId: string | null;
+  cesiumPlacementDraft: CesiumPlacementDraft | null;
 }
 
 export interface UISlice {
@@ -29,6 +53,16 @@ export interface UISlice {
   leftPanelCollapsed: boolean;
   rightPanelCollapsed: boolean;
   activeTool: string;
+  /**
+   * Global edit mode. When `true`, all in-place editing affordances
+   * (inline property/attribute editors, future geometry manipulators,
+   * georeference placement, the add-element draw tools) are unlocked.
+   * When `false` the viewer is strictly read-only — this is the
+   * default. The toggle is surfaced as a single pill in the main
+   * toolbar so the user has one switch for "am I editing anything?"
+   * rather than per-panel toggles.
+   */
+  editEnabled: boolean;
   theme: ThemeMode;
   isMobile: boolean;
   hoverTooltipsEnabled: boolean;
@@ -56,6 +90,8 @@ export interface UISlice {
   setLeftPanelCollapsed: (collapsed: boolean) => void;
   setRightPanelCollapsed: (collapsed: boolean) => void;
   setActiveTool: (tool: string) => void;
+  setEditEnabled: (enabled: boolean) => void;
+  toggleEditEnabled: () => void;
   setTheme: (theme: ThemeMode) => void;
   toggleTheme: () => void;
   /** Shift+click secret: toggle colorful mode on/off */
@@ -101,6 +137,7 @@ export const createUISlice: StateCreator<UISlice & UICrossSliceState, [], [], UI
   leftPanelCollapsed: false,
   rightPanelCollapsed: false,
   activeTool: UI_DEFAULTS.ACTIVE_TOOL,
+  editEnabled: false,
   theme: UI_DEFAULTS.THEME,
   isMobile: false,
   hoverTooltipsEnabled: UI_DEFAULTS.HOVER_TOOLTIPS_ENABLED,
@@ -120,7 +157,47 @@ export const createUISlice: StateCreator<UISlice & UICrossSliceState, [], [], UI
   // Actions
   setLeftPanelCollapsed: (leftPanelCollapsed) => set({ leftPanelCollapsed }),
   setRightPanelCollapsed: (rightPanelCollapsed) => set({ rightPanelCollapsed }),
-  setActiveTool: (activeTool) => set({ activeTool }),
+  setActiveTool: (activeTool) => {
+    // Authoring tools require edit mode. Entering one of them flips
+    // the global toggle on so the rest of the UI (Properties panel,
+    // future manipulators) stays in sync. Read-only tools leave the
+    // flag alone.
+    set(AUTHORING_TOOLS.has(activeTool) ? { activeTool, editEnabled: true } : { activeTool });
+  },
+  setEditEnabled: (editEnabled) => {
+    if (!editEnabled) {
+      // Flipping edit mode off must clear every authoring sub-state
+      // that depends on it — otherwise the viewer ends up "not in
+      // edit mode" but still carrying a georef draft or a half-drawn
+      // slab polygon. Cross-slice reset lives here so callers don't
+      // have to remember to mop up.
+      set((s) => ({
+        editEnabled: false,
+        activeTool: AUTHORING_TOOLS.has(s.activeTool) ? 'select' : s.activeTool,
+        cesiumPlacementEditMode: false,
+        cesiumPlacementDraftModelId: null,
+        cesiumPlacementDraft: null,
+      }));
+      return;
+    }
+    // Turning edit mode ON with nothing selected auto-opens the
+    // AddElement panel — most "I want to edit" sessions start
+    // with adding something, and forcing the user to click an
+    // extra button to reach the panel adds friction. When a
+    // selection already exists, leave activeTool alone so the
+    // Properties panel + Geometry edit card stay primary.
+    set((s) => {
+      const next: Partial<UISlice & UICrossSliceState> = { editEnabled: true };
+      const slice = s as unknown as { selectedEntity?: unknown };
+      if (s.activeTool === 'select' && !slice.selectedEntity) {
+        next.activeTool = 'addElement';
+      }
+      return next;
+    });
+  },
+  toggleEditEnabled: () => {
+    get().setEditEnabled(!get().editEnabled);
+  },
 
   setTheme: (theme) => {
     applyThemeClasses(theme);

package/src/store/types.ts

@@ -228,6 +228,14 @@ export interface CameraCallbacks {
   frameSelection?: () => void;
   orbit?: (deltaX: number, deltaY: number) => void;
   projectToScreen?: (worldPos: { x: number; y: number; z: number }) => { x: number; y: number } | null;
+  /**
+   * Unproject a screen pixel onto the horizontal plane at the
+   * specified world Y. Used by drag handles (wall endpoints,
+   * georeference move) to convert a cursor position back into
+   * world coordinates on the storey floor. Returns null when the
+   * camera ray is parallel to the plane or points the wrong way.
+   */
+  unprojectToFloor?: (clientX: number, clientY: number, worldY: number) => { x: number; y: number; z: number } | null;
   setProjectionMode?: (mode: ProjectionMode) => void;
   toggleProjectionMode?: () => void;
   getProjectionMode?: () => ProjectionMode;
@@ -240,9 +248,20 @@ export interface CameraCallbacks {
 // ============================================================================
 
 import type { IfcDataStore } from '@ifc-lite/parser';
-import type { GeometryResult } from '@ifc-lite/geometry';
+import type { CoordinateInfo, GeometryResult } from '@ifc-lite/geometry';
 
-/** Compound identifier for entities across multiple models */
+/**
+ * Compound identifier for entities across multiple models.
+ *
+ * Structurally identical to `@ifc-lite/sdk`'s EntityRef, but
+ * defined locally because the desktop app bundles viewer source
+ * via tsconfig path aliases and does not declare `@ifc-lite/sdk`
+ * as a workspace dep — re-exporting from the SDK breaks the
+ * desktop Vite build with an unresolvable module. Keep the
+ * shapes in sync manually; both packages exhaustively test
+ * EntityRef-shaped values, so drift will surface at the
+ * federation boundary.
+ */
 export interface EntityRef {
   modelId: string;
   expressId: number;
@@ -389,6 +408,42 @@ export interface FederatedModel {
    * when the model is dropped from the store.
    */
   pointCloudHandleId?: number;
+  /**
+   * Snapshot of mesh positions before federation alignment ran (one Float32Array
+   * per mesh, indexed in `geometryResult.meshes` order). Populated when this
+   * model joined an existing federation and its geometry was re-baked into the
+   * anchor's viewer frame. Used by `realignFederation()` to re-apply alignment
+   * against a different anchor without re-parsing the source file.
+   *
+   * Stays `undefined` for single-model loads and the federation anchor itself
+   * (which has no alignment applied).
+   */
+  preAlignmentPositions?: Float32Array[];
+  /**
+   * Snapshot of mesh normals before federation alignment ran (one Float32Array
+   * per mesh, sparse — empty slot when a mesh had no normals). Restored
+   * alongside `preAlignmentPositions` on re-alignment so repeated re-bakes
+   * don't accumulate rotation drift on the normals (lighting/shading bug).
+   */
+  preAlignmentNormals?: (Float32Array | undefined)[];
+  /**
+   * CoordinateInfo at the time `preAlignmentPositions` was taken. Restored
+   * together with the positions on re-alignment so the source's RTC/shift
+   * frame is recovered before applying the new alignment.
+   */
+  preAlignmentCoordinateInfo?: CoordinateInfo;
+  /**
+   * How this model was placed in the current federation:
+   *   - `'anchor'`       — this model drives the world frame, no alignment
+   *   - `'same-crs'`     — vertex transform applied (shared projected CRS)
+   *   - `'reprojected'`  — per-vertex proj4 hop into the anchor's CRS
+   *   - `'identity'`     — same CRS and same MapConversion → no change needed
+   *   - `'failed'`       — alignment could not be computed; model rendered in
+   *                        its own local frame and likely at the wrong real
+   *                        world position
+   *   - `'none'`         — single-model load or first georeferenced model
+   */
+  federationAlignmentStatus?: 'anchor' | 'same-crs' | 'reprojected' | 'identity' | 'failed' | 'none';
 }
 
 /** Convert EntityRef to string for use as Map/Set key */

package/src/utils/createBlankIfc.ts

@@ -0,0 +1,37 @@
+/* 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/. */
+
+/**
+ * Generate a minimal blank IFC4 model as a synthetic `File`, so the
+ * welcome card's "Start blank" action can feed it through the regular
+ * `loadFile()` pipeline (format detection → WASM → store federation)
+ * without diverging code paths.
+ *
+ * The result has the smallest spatial hierarchy that satisfies the
+ * Add Element panel's gating (`AddElementPanel.tsx`): one IfcProject,
+ * IfcSite, IfcBuilding and a single IfcBuildingStorey at elevation 0.
+ */
+
+import { IfcCreator } from '@ifc-lite/create';
+
+export interface BlankIfcOptions {
+  projectName?: string;
+  storeyName?: string;
+  storeyElevation?: number;
+}
+
+export function createBlankIfcFile(options: BlankIfcOptions = {}): File {
+  const {
+    projectName = 'Untitled Project',
+    storeyName = 'Level 1',
+    storeyElevation = 0,
+  } = options;
+
+  const creator = new IfcCreator({ Name: projectName });
+  creator.addIfcBuildingStorey({ Name: storeyName, Elevation: storeyElevation });
+  const { content } = creator.toIfc();
+
+  const safeName = projectName.replace(/[^a-z0-9_-]+/gi, '_').replace(/^_+|_+$/g, '') || 'untitled';
+  return new File([content], `${safeName}.ifc`, { type: 'application/ifc' });
+}

package/tsconfig.json

@@ -3,6 +3,7 @@
   "compilerOptions": {
     "jsx": "react-jsx",
     "outDir": "./dist",
+    "rootDir": "../..",
     "baseUrl": ".",
     "paths": {
       "@/*": ["./src/*"],

package/.turbo/turbo-typecheck.log

@@ -1,4 +0,0 @@
-
-> @ifc-lite/viewer@1.22.0 typecheck /home/runner/work/ifc-lite/ifc-lite/apps/viewer
-> tsc --noEmit
-