@ifc-lite/viewer 1.21.0 → 1.22.1

package/src/lib/geo/cesium-placement.test.ts

@@ -0,0 +1,260 @@
+/* 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 } from 'node:test';
+import assert from 'node:assert';
+
+import {
+  closestYOnVerticalLineFromRay,
+  computeCesiumPlacement,
+  computeIfcOriginHeight,
+  computeOrthogonalHeightForBaseAltitude,
+  getMapUnitScale,
+  intersectRayWithHorizontalPlane,
+  mapUnitsToMeters,
+  metersToMapUnits,
+  projectedDeltaToViewerDelta,
+  shouldPreferOrthometricTerrain,
+  viewerDeltaToProjectedDelta,
+} from './cesium-placement.js';
+
+describe('cesium placement helpers', () => {
+  it('defaults to METRES when MapUnit is absent (overrides project length unit)', () => {
+    // Per IFC4 spec, missing MapUnit falls back to the project's length unit.
+    // In practice (Bonsai/IfcOpenShell/Revit), MapConversion offsets are
+    // authored in METRES regardless of project unit. Honouring the spec
+    // pushes offsets thousands of km out of the CRS's valid range and lands
+    // models at the projection's antipode (Hans's IXAS_KW 018 file: mm
+    // project + MapConversion (126500, 480000) → South Pacific instead of
+    // Netherlands). See `resolveMapUnitToMetreScale` rationale.
+    assert.strictEqual(getMapUnitScale(undefined, 0.001), 1);
+    assert.strictEqual(getMapUnitScale({ mapUnitScale: 1 }, 0.001), 1);
+    // Explicit non-metre MapUnit still wins — the heuristic only fires when
+    // MapUnit is unset.
+    assert.strictEqual(getMapUnitScale({ mapUnitScale: 0.3048006096 }, 1), 0.3048006096);
+  });
+
+  it('converts between metres and map units using ProjectedCRS.mapUnitScale', () => {
+    const usFoot = { mapUnitScale: 0.3048006096 };
+    assert.strictEqual(mapUnitsToMeters(10, usFoot, 1), 3.048006096);
+    assert.strictEqual(
+      metersToMapUnits(3.048006096, usFoot, 1),
+      10,
+    );
+  });
+
+  it('prefers orthometric terrain when a vertical datum is present', () => {
+    assert.strictEqual(shouldPreferOrthometricTerrain({ verticalDatum: 'EPSG:8357' }), true);
+    assert.strictEqual(shouldPreferOrthometricTerrain({ verticalDatum: '$' }), false);
+    assert.strictEqual(shouldPreferOrthometricTerrain({ verticalDatum: '' }), false);
+    assert.strictEqual(shouldPreferOrthometricTerrain(undefined), false);
+  });
+
+  it('places the model at its authored IFC height — no terrain/storey clamp', () => {
+    // Model placement is purely IfcMapConversion.OrthogonalHeight + the
+    // geometry origin. Terrain and storey data never move the model.
+    const placement = computeCesiumPlacement({
+      coordinateInfo: {
+        originShift: { x: 0, y: 0, z: 0 },
+        originalBounds: {
+          min: { x: 0, y: -3, z: 0 },
+          max: { x: 10, y: 9, z: 10 },
+        },
+        shiftedBounds: {
+          min: { x: 0, y: -3, z: 0 },
+          max: { x: 10, y: 9, z: 10 },
+        },
+        hasLargeCoordinates: false,
+      },
+      projectedCRS: { verticalDatum: 'EPSG:8357' },
+      ifcOriginHeight: 244,
+      terrainHeight: 245,
+      storeyElevations: new Map([[1, -3], [2, 0], [3, 3]]),
+    });
+
+    // placementHeight == authored ifcOriginHeight, NOT terrain+anchorOffset.
+    assert.strictEqual(placement.placementHeight, 244);
+    // clampAnchorY / anchorOffset are still derived (gizmo + clip math use
+    // them) but no longer feed placementHeight.
+    assert.strictEqual(placement.clampAnchorY, 0);
+    assert.strictEqual(placement.anchorOffset, 3);
+    assert.strictEqual(placement.preferOrthometricTerrain, true);
+  });
+
+  it('keeps the authored height whether it is above OR below terrain', () => {
+    // Above terrain — unchanged.
+    const above = computeCesiumPlacement({ ifcOriginHeight: 244, terrainHeight: 195.4 });
+    assert.strictEqual(above.placementHeight, 244);
+
+    // Below terrain — the model stays sub-grade, NOT lifted to terrain.
+    // (Regression: the old Math.max floor pinned it to terrain, which froze
+    //  the vertical placement gizmo and lifted basements above ground.)
+    const below = computeCesiumPlacement({ ifcOriginHeight: -20, terrainHeight: 70.61 });
+    assert.strictEqual(below.placementHeight, -20);
+  });
+
+  it('computes OrthogonalHeight from target base altitude with shift and RTC', () => {
+    const orthogonalHeight = computeOrthogonalHeightForBaseAltitude({
+      coordinateInfo: {
+        originShift: { x: 0, y: 2, z: 0 },
+        originalBounds: {
+          min: { x: 0, y: -1, z: 0 },
+          max: { x: 10, y: 11, z: 10 },
+        },
+        shiftedBounds: {
+          min: { x: 0, y: -1, z: 0 },
+          max: { x: 10, y: 11, z: 10 },
+        },
+        hasLargeCoordinates: false,
+        wasmRtcOffset: { x: 0, y: 0, z: 3 },
+      },
+      projectedCRS: { mapUnitScale: 0.3048 },
+      lengthUnitScale: 1,
+      storeyElevations: new Map([[1, 0]]),
+      targetBaseAltitude: 245,
+    });
+
+    assert.strictEqual(orthogonalHeight, 787.4);
+  });
+
+  it('computes the IFC origin height from OrthogonalHeight and model center', () => {
+    const height = computeIfcOriginHeight(
+      { orthogonalHeight: 12 },
+      { mapUnitScale: 0.5 },
+      {
+        originShift: { x: 0, y: 3, z: 0 },
+        originalBounds: {
+          min: { x: 0, y: 2, z: 0 },
+          max: { x: 10, y: 8, z: 10 },
+        },
+        shiftedBounds: {
+          min: { x: 0, y: 2, z: 0 },
+          max: { x: 10, y: 8, z: 10 },
+        },
+        hasLargeCoordinates: false,
+      },
+      1,
+    );
+
+    assert.strictEqual(height, 14);
+  });
+
+  it('converts viewer XY drag deltas into projected map deltas', () => {
+    const projected = viewerDeltaToProjectedDelta(
+      2,
+      -1,
+      { xAxisAbscissa: 1, xAxisOrdinate: 0, scale: 1 },
+      { mapUnitScale: 1 },
+      1,
+    );
+
+    assert.deepStrictEqual(projected, { eastings: 2, northings: 1 });
+  });
+
+  it('converts projected map deltas back to viewer drag deltas', () => {
+    const viewer = projectedDeltaToViewerDelta(
+      2,
+      1,
+      { xAxisAbscissa: 1, xAxisOrdinate: 0, scale: 1 },
+      { mapUnitScale: 1 },
+      1,
+    );
+
+    assert.deepStrictEqual(viewer, { x: 2, z: -1 });
+  });
+
+  it('intersects a downward ray with a horizontal plane at the expected point', () => {
+    const hit = intersectRayWithHorizontalPlane(
+      { origin: { x: 5, y: 10, z: -3 }, direction: { x: 0, y: -1, z: 0 } },
+      0,
+    );
+    assert.deepStrictEqual(hit, { x: 5, y: 0, z: -3 });
+  });
+
+  it('intersects an oblique ray with a horizontal plane consistently for two cursor samples', () => {
+    // Two parallel rays separated by a known horizontal offset should map to
+    // hit points separated by the same offset on the plane. This is the
+    // invariant the placement gizmo relies on for stable XY drag at any
+    // camera angle.
+    const direction = { x: 0.4, y: -0.6, z: 0.5 };
+    const hitA = intersectRayWithHorizontalPlane(
+      { origin: { x: 0, y: 12, z: 0 }, direction },
+      0,
+    );
+    const hitB = intersectRayWithHorizontalPlane(
+      { origin: { x: 1, y: 12, z: 2 }, direction },
+      0,
+    );
+    assert.ok(hitA && hitB);
+    assert.strictEqual(Math.round((hitB.x - hitA.x) * 1e6) / 1e6, 1);
+    assert.strictEqual(Math.round((hitB.z - hitA.z) * 1e6) / 1e6, 2);
+  });
+
+  it('rejects rays that are parallel to the horizontal plane', () => {
+    const hit = intersectRayWithHorizontalPlane(
+      { origin: { x: 0, y: 5, z: 0 }, direction: { x: 1, y: 0, z: 0 } },
+      0,
+    );
+    assert.strictEqual(hit, null);
+  });
+
+  it('rejects rays whose intersection lies behind the origin', () => {
+    // Ray going up, plane below origin: t < 0.
+    const hit = intersectRayWithHorizontalPlane(
+      { origin: { x: 0, y: 5, z: 0 }, direction: { x: 0, y: 1, z: 0 } },
+      0,
+    );
+    assert.strictEqual(hit, null);
+  });
+
+  it('returns the cursor-aligned Y on a vertical line for an oblique ray', () => {
+    // Ray that passes exactly through (anchorX, 7, anchorZ) — the closest
+    // point on the vertical axis is the same point, so Y = 7.
+    const anchorX = 4;
+    const anchorZ = -2;
+    const target = { x: anchorX, y: 7, z: anchorZ };
+    const origin = { x: 0, y: 0, z: 0 };
+    const dx = target.x - origin.x;
+    const dy = target.y - origin.y;
+    const dz = target.z - origin.z;
+    const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    const direction = { x: dx / len, y: dy / len, z: dz / len };
+    const y = closestYOnVerticalLineFromRay({ origin, direction }, anchorX, anchorZ);
+    assert.ok(y !== null);
+    assert.ok(Math.abs((y as number) - 7) < 1e-9);
+  });
+
+  it('preserves vertical drag amount when cursor moves up by a known screen offset', () => {
+    // Two rays that pass through points (anchorX, y1, anchorZ) and
+    // (anchorX, y2, anchorZ) on the vertical line: returned Y values must
+    // equal y1 and y2 exactly — the basis of frame-rate-independent height
+    // dragging at oblique camera angles.
+    const anchorX = 0;
+    const anchorZ = 0;
+    const origin = { x: 6, y: 0, z: 4 };
+
+    const aim = (y: number) => {
+      const dx = anchorX - origin.x;
+      const dy = y - origin.y;
+      const dz = anchorZ - origin.z;
+      const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      return { origin, direction: { x: dx / len, y: dy / len, z: dz / len } };
+    };
+
+    const y1 = closestYOnVerticalLineFromRay(aim(2), anchorX, anchorZ);
+    const y2 = closestYOnVerticalLineFromRay(aim(9), anchorX, anchorZ);
+    assert.ok(y1 !== null && y2 !== null);
+    assert.ok(Math.abs((y1 as number) - 2) < 1e-9);
+    assert.ok(Math.abs((y2 as number) - 9) < 1e-9);
+  });
+
+  it('rejects vertical rays for closest-Y-on-line (degenerate)', () => {
+    const y = closestYOnVerticalLineFromRay(
+      { origin: { x: 0, y: 10, z: 0 }, direction: { x: 0, y: -1, z: 0 } },
+      0,
+      0,
+    );
+    assert.strictEqual(y, null);
+  });
+});

package/src/lib/geo/cesium-placement.ts

@@ -0,0 +1,237 @@
+/* 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 { CoordinateInfo } from '@ifc-lite/geometry';
+import type { MapConversion, ProjectedCRS } from '@ifc-lite/parser';
+
+import { findClampAnchorY } from './clamp-anchor';
+import { computeModelCenterInIfcMeters } from './reproject';
+import { getEffectiveHorizontalScale, resolveMapUnitToMetreScale } from './geo-scale';
+
+export function getMapUnitScale(
+  projectedCRS: Pick<ProjectedCRS, 'mapUnitScale'> | undefined,
+  lengthUnitScale: number,
+): number {
+  return resolveMapUnitToMetreScale(projectedCRS?.mapUnitScale, lengthUnitScale);
+}
+
+export function mapUnitsToMeters(
+  value: number,
+  projectedCRS: Pick<ProjectedCRS, 'mapUnitScale'> | undefined,
+  lengthUnitScale: number,
+): number {
+  return value * getMapUnitScale(projectedCRS, lengthUnitScale);
+}
+
+export function metersToMapUnits(
+  value: number,
+  projectedCRS: Pick<ProjectedCRS, 'mapUnitScale'> | undefined,
+  lengthUnitScale: number,
+): number {
+  return value / getMapUnitScale(projectedCRS, lengthUnitScale);
+}
+
+export function shouldPreferOrthometricTerrain(
+  projectedCRS: Pick<ProjectedCRS, 'verticalDatum'> | undefined,
+): boolean {
+  const verticalDatum = projectedCRS?.verticalDatum?.trim();
+  return Boolean(verticalDatum && verticalDatum !== '$');
+}
+
+export interface CesiumPlacementInput {
+  coordinateInfo?: CoordinateInfo;
+  projectedCRS?: Pick<ProjectedCRS, 'verticalDatum'> | Pick<ProjectedCRS, 'mapUnitScale'> & Pick<ProjectedCRS, 'verticalDatum'>;
+  ifcOriginHeight: number;
+  terrainHeight: number | null;
+  storeyElevations?: Map<number, number>;
+}
+
+export interface CesiumPlacementResult {
+  clampAnchorY: number;
+  minY: number;
+  modelCenterY: number;
+  anchorOffset: number;
+  ifcOriginHeight: number;
+  placementHeight: number;
+  terrainClipY: number | null;
+  preferOrthometricTerrain: boolean;
+}
+
+/**
+ * Resolve where the model sits in Cesium.
+ *
+ * Placement is PURELY the IFC's authored altitude — `ifcOriginHeight`
+ * (IfcMapConversion.OrthogonalHeight + the geometry origin). There is NO
+ * automatic terrain or storey clamp: the model goes exactly where the file
+ * says, full stop. Terrain is queried only to inform the camera and the
+ * optional below-terrain clip plane; it never moves the model.
+ *
+ * `clampAnchorY` / `anchorOffset` are still derived (the placement gizmo and
+ * the clip-plane math consume them) but they no longer feed `placementHeight`.
+ */
+export function computeCesiumPlacement({
+  coordinateInfo,
+  projectedCRS,
+  ifcOriginHeight,
+  terrainHeight,
+  storeyElevations,
+}: CesiumPlacementInput): CesiumPlacementResult {
+  const bounds = coordinateInfo?.originalBounds;
+  const modelCenterY = bounds ? (bounds.min.y + bounds.max.y) / 2 : 0;
+  const minY = bounds?.min.y ?? 0;
+  const clampAnchorY = findClampAnchorY(bounds, storeyElevations);
+  const anchorOffset = modelCenterY - clampAnchorY;
+  // Model placement = authored IFC altitude. No clamp. No auto-adjust.
+  const placementHeight = ifcOriginHeight;
+
+  return {
+    clampAnchorY,
+    minY,
+    modelCenterY,
+    anchorOffset,
+    ifcOriginHeight,
+    placementHeight,
+    terrainClipY: terrainHeight !== null
+      ? terrainHeight - placementHeight + modelCenterY
+      : null,
+    preferOrthometricTerrain: shouldPreferOrthometricTerrain(projectedCRS),
+  };
+}
+
+export interface OrthogonalHeightForBaseAltitudeInput {
+  coordinateInfo?: CoordinateInfo;
+  projectedCRS?: Pick<ProjectedCRS, 'mapUnitScale'>;
+  lengthUnitScale: number;
+  storeyElevations?: Map<number, number>;
+  targetBaseAltitude: number;
+}
+
+export function computeOrthogonalHeightForBaseAltitude({
+  coordinateInfo,
+  projectedCRS,
+  lengthUnitScale,
+  storeyElevations,
+  targetBaseAltitude,
+}: OrthogonalHeightForBaseAltitudeInput): number {
+  const bounds = coordinateInfo?.originalBounds;
+  const anchorY = findClampAnchorY(bounds, storeyElevations);
+  const shiftY = coordinateInfo?.originShift?.y ?? 0;
+  // RTC offset is stored in IFC Z-up; viewer-Y aligns to its Z component.
+  const rtcYupY = coordinateInfo?.wasmRtcOffset?.z ?? 0;
+  const orthogonalHeightMeters = targetBaseAltitude - shiftY - rtcYupY - anchorY;
+
+  return Math.round(
+    metersToMapUnits(orthogonalHeightMeters, projectedCRS, lengthUnitScale) * 100,
+  ) / 100;
+}
+
+export function computeIfcOriginHeight(
+  mapConversion: Pick<MapConversion, 'orthogonalHeight'>,
+  projectedCRS: Pick<ProjectedCRS, 'mapUnitScale'> | undefined,
+  coordinateInfo: CoordinateInfo | undefined,
+  lengthUnitScale: number,
+): number {
+  const mapScale = getMapUnitScale(projectedCRS, lengthUnitScale);
+  return mapConversion.orthogonalHeight * mapScale + computeModelCenterInIfcMeters(coordinateInfo).ifcZ;
+}
+
+export function viewerDeltaToProjectedDelta(
+  deltaX: number,
+  deltaZ: number,
+  mapConversion: Pick<MapConversion, 'xAxisAbscissa' | 'xAxisOrdinate' | 'scale'>,
+  projectedCRS: Pick<ProjectedCRS, 'mapUnitScale'> | undefined,
+  lengthUnitScale: number,
+): { eastings: number; northings: number } {
+  const mapScale = getMapUnitScale(projectedCRS, lengthUnitScale);
+  const hScale = getEffectiveHorizontalScale(
+    mapConversion.scale,
+    mapScale,
+    lengthUnitScale,
+  );
+  const abscissa = mapConversion.xAxisAbscissa ?? 1;
+  const ordinate = mapConversion.xAxisOrdinate ?? 0;
+  const eastMeters = hScale * (abscissa * deltaX + ordinate * deltaZ);
+  const northMeters = hScale * (ordinate * deltaX - abscissa * deltaZ);
+
+  return {
+    eastings: metersToMapUnits(eastMeters, projectedCRS, lengthUnitScale),
+    northings: metersToMapUnits(northMeters, projectedCRS, lengthUnitScale),
+  };
+}
+
+export interface Ray3 {
+  origin: { x: number; y: number; z: number };
+  direction: { x: number; y: number; z: number };
+}
+
+/**
+ * Intersect a ray with the horizontal plane y = planeY. Returns null when the
+ * ray is (near-)parallel to the plane or the hit lies behind the ray origin.
+ *
+ * Used by the placement gizmo's XY drag: a stable horizontal drag plane
+ * through the gizmo anchor avoids the projection-Jacobian instability of
+ * linearised screen-axis approximations, which blow up to "huge jumps" at
+ * oblique camera angles when the gizmo plane is near-edge-on to the camera.
+ */
+export function intersectRayWithHorizontalPlane(
+  ray: Ray3,
+  planeY: number,
+): { x: number; y: number; z: number } | null {
+  const dirY = ray.direction.y;
+  if (!Number.isFinite(dirY) || Math.abs(dirY) < 1e-6) return null;
+  const t = (planeY - ray.origin.y) / dirY;
+  if (!Number.isFinite(t) || t < 0) return null;
+  return {
+    x: ray.origin.x + ray.direction.x * t,
+    y: planeY,
+    z: ray.origin.z + ray.direction.z * t,
+  };
+}
+
+/**
+ * Find the Y-coordinate on the vertical line (anchorX, *, anchorZ) closest
+ * to a ray. Returns null when the ray's horizontal component vanishes (the
+ * ray is parallel to the vertical line — no meaningful "grab" point).
+ *
+ * Used by the placement gizmo's height drag so the slider tracks the cursor
+ * accurately at any camera tilt, instead of linearising screen-space pixels
+ * per metre.
+ */
+export function closestYOnVerticalLineFromRay(
+  ray: Ray3,
+  anchorX: number,
+  anchorZ: number,
+): number | null {
+  const dx = ray.direction.x;
+  const dz = ray.direction.z;
+  const horiz = dx * dx + dz * dz;
+  if (!Number.isFinite(horiz) || horiz < 1e-12) return null;
+  const s = (dx * (anchorX - ray.origin.x) + dz * (anchorZ - ray.origin.z)) / horiz;
+  return ray.origin.y + s * ray.direction.y;
+}
+
+export function projectedDeltaToViewerDelta(
+  eastingsDelta: number,
+  northingsDelta: number,
+  mapConversion: Pick<MapConversion, 'xAxisAbscissa' | 'xAxisOrdinate' | 'scale'>,
+  projectedCRS: Pick<ProjectedCRS, 'mapUnitScale'> | undefined,
+  lengthUnitScale: number,
+): { x: number; z: number } {
+  const mapScale = getMapUnitScale(projectedCRS, lengthUnitScale);
+  const hScale = getEffectiveHorizontalScale(
+    mapConversion.scale,
+    mapScale,
+    lengthUnitScale,
+  );
+  const abscissa = mapConversion.xAxisAbscissa ?? 1;
+  const ordinate = mapConversion.xAxisOrdinate ?? 0;
+  const eastMeters = mapUnitsToMeters(eastingsDelta, projectedCRS, lengthUnitScale);
+  const northMeters = mapUnitsToMeters(northingsDelta, projectedCRS, lengthUnitScale);
+  const denom = Math.max((abscissa * abscissa + ordinate * ordinate) * hScale, 1e-12);
+
+  return {
+    x: (abscissa * eastMeters + ordinate * northMeters) / denom,
+    z: (ordinate * eastMeters - abscissa * northMeters) / denom,
+  };
+}

package/src/lib/geo/effective-georef.test.ts

@@ -5,7 +5,14 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert';
 
-import { detectScaleUnitMismatch, getEffectiveHorizontalScale, inferMapUnitScale, mergeMapConversion, mergeProjectedCRS } from './effective-georef.js';
+import {
+  detectScaleUnitMismatch,
+  getEffectiveHorizontalScale,
+  inferMapUnitScale,
+  mergeMapConversion,
+  mergeProjectedCRS,
+  supportsStandardGeoreferencing,
+} from './effective-georef.js';
 import type { MapConversion, ProjectedCRS } from '@ifc-lite/parser';
 
 describe('effective georeferencing', () => {
@@ -37,6 +44,72 @@ describe('effective georeferencing', () => {
     assert.strictEqual(merged?.mapUnitScale, 2.5);
   });
 
+  it('treats IFC2X3 files with IfcMapConversion and IfcProjectedCRS as standard georeferencing', () => {
+    assert.strictEqual(
+      supportsStandardGeoreferencing('IFC2X3', {
+        source: 'mapConversion',
+        projectedCRS: {
+          id: 1,
+          name: 'EPSG:2056',
+        },
+        mapConversion: {
+          id: 2,
+          sourceCRS: 10,
+          targetCRS: 11,
+          eastings: 2681750,
+          northings: 1225750,
+          orthogonalHeight: 0,
+        },
+      }),
+      true,
+    );
+  });
+
+  it('treats IFC2X3 files with only IfcMapConversion (no IfcProjectedCRS name yet) as editable', () => {
+    // Extension-bearing IFC2X3 files sometimes carry one half of the
+    // georef pair; once we've parsed it, the editor should surface the
+    // data instead of hiding behind a schema notice. See issue #683.
+    assert.strictEqual(
+      supportsStandardGeoreferencing('IFC2X3', {
+        source: 'mapConversion',
+        mapConversion: {
+          id: 2,
+          sourceCRS: 10,
+          targetCRS: 11,
+          eastings: 2681750,
+          northings: 1225750,
+          orthogonalHeight: 0,
+        },
+      }),
+      true,
+    );
+  });
+
+  it('treats IFC2X3 files with only IfcProjectedCRS as editable so users can add IfcMapConversion', () => {
+    assert.strictEqual(
+      supportsStandardGeoreferencing('IFC2X3', {
+        projectedCRS: {
+          id: 1,
+          name: 'EPSG:2056',
+        },
+      }),
+      true,
+    );
+  });
+
+  it('keeps pure IfcSite IFC2X3 geolocation in read-only mode', () => {
+    assert.strictEqual(
+      supportsStandardGeoreferencing('IFC2X3', {
+        source: 'siteLocation',
+        projectedCRS: {
+          id: 226,
+          name: 'EPSG:4326',
+        },
+      }),
+      false,
+    );
+  });
+
   it('overlays edited IfcMapConversion fields without dropping original rotation and scale', () => {
     const original: MapConversion = {
       id: 2,
@@ -93,13 +166,29 @@ describe('effective georeferencing', () => {
       assert.strictEqual(getEffectiveHorizontalScale(2, 1, 1), 2);
     });
 
-    it('defaults Scale to 1 when undefined', () => {
-      // Project mm, map m, Scale undefined (treated as 1):
-      //   effective = 1 * 1 / 0.001 = 1000 → model would appear 1000x too large.
-      // This matches the IFC spec; users who omit Scale in such files have an
-      // inconsistent file. Issue #595 reports that this happens to "work"
-      // because the workaround offsets a different bug — fixed here.
-      assert.strictEqual(getEffectiveHorizontalScale(undefined, 1, 0.001), 1000);
+    it('treats Scale=undefined + unit mismatch as author-meant-Scale=1/lus (Bonsai heuristic)', () => {
+      // Project mm, map m, Scale undefined. Spec-strict effective = 1 * 1 /
+      // 0.001 = 1000 would inflate metre-converted geometry 1000x, pushing
+      // proj4 inputs miles outside the CRS valid range — the model lands at
+      // the projection's antipode (Hans's IXAS_KW 018_georeffed.ifc bug).
+      // Bonsai/IfcOpenShell/Revit exports routinely omit Scale; the author's
+      // intent is "geometry and offsets share the same metric unit", which
+      // corresponds to Scale=lengthUnitScale/mapUnitScale per spec → effective 1.
+      assert.strictEqual(getEffectiveHorizontalScale(undefined, 1, 0.001), 1);
+    });
+
+    it('treats Scale=1 + unit mismatch the same as Scale=undefined (heuristic also fires)', () => {
+      // Same situation as above, but the file wrote Scale=1 explicitly (also
+      // common — Revit's IFC exporter does this). The heuristic must catch
+      // both the missing-Scale and the wrong-Scale=1 cases.
+      assert.strictEqual(getEffectiveHorizontalScale(1, 1, 0.001), 1);
+    });
+
+    it('preserves spec-strict math when Scale ≠ 1 (the author opted in to a real scaling)', () => {
+      // Scale=2 with mm project + m map says "multiply X_local by 2 when
+      // adding to map offsets" — deliberate, not a unit-bridging mistake.
+      // Effective = (2 * 1) / 0.001 = 2000.
+      assert.strictEqual(getEffectiveHorizontalScale(2, 1, 0.001), 2000);
     });
 
     it('falls back to 1 for non-positive lengthUnitScale or mapUnitScale', () => {