@ifc-lite/viewer 1.26.0 → 1.27.0

package/src/lib/search/filter-match.ts

@@ -0,0 +1,167 @@
+/* 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/. */
+
+/**
+ * Per-rule value resolution + matching for the path-B evaluator.
+ *
+ * Split out of `filter-evaluate.ts` (which keeps the iteration /
+ * orchestration logic) to stay under the module size cap. These helpers
+ * are pure given their inputs, which is what makes them unit-testable in
+ * `filter-evaluate.test.ts` via the evaluator's `__internal` re-export.
+ */
+
+import {
+  extractPropertiesOnDemand,
+  extractQuantitiesOnDemand,
+  type IfcDataStore,
+  type MaterialInfo,
+  type ClassificationInfo,
+} from '@ifc-lite/parser';
+
+import {
+  valueOpMatches,
+  numericOpMatches,
+  matchStringAnyNone,
+  type PropertyRule,
+  type QuantityRule,
+  type ClassificationRule,
+} from './filter-rules.js';
+
+// ── Pset / Qto matching ──────────────────────────────────────────────────────
+
+export interface PsetRow { setName: string; propertyName: string; value: string }
+export type PsetRows = ReadonlyArray<PsetRow>;
+
+export interface QtyRow { setName: string; quantityName: string; value: number }
+export type QtyRows = ReadonlyArray<QtyRow>;
+
+export function flattenPsets(
+  psets: ReturnType<typeof extractPropertiesOnDemand>,
+): PsetRows {
+  const out: PsetRow[] = [];
+  for (const set of psets) {
+    for (const p of set.properties) {
+      out.push({
+        setName: set.name,
+        propertyName: p.name,
+        // Stringify everything — `valueOpMatches` re-parses numeric ops
+        // from this representation. Booleans render as "true"/"false"
+        // which matches the chip UI's lowercased input convention.
+        value: stringifyValue(p.value),
+      });
+    }
+  }
+  return out;
+}
+
+export function flattenQtys(
+  qtos: ReturnType<typeof extractQuantitiesOnDemand>,
+): QtyRows {
+  const out: QtyRow[] = [];
+  for (const set of qtos) {
+    for (const q of set.quantities) {
+      out.push({ setName: set.name, quantityName: q.name, value: q.value });
+    }
+  }
+  return out;
+}
+
+export function stringifyValue(value: unknown): string {
+  if (value === null || value === undefined) return '';
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  if (typeof value === 'number') return String(value);
+  return String(value);
+}
+
+export function matchPropertyRule(rule: PropertyRule, rows: PsetRows): boolean {
+  // isSet / isNotSet are presence checks against (setName, propertyName).
+  if (rule.op === 'isSet' || rule.op === 'isNotSet') {
+    const present = rows.some(
+      (r) =>
+        r.setName.toLowerCase() === rule.setName.toLowerCase() &&
+        r.propertyName.toLowerCase() === rule.propertyName.toLowerCase(),
+    );
+    return rule.op === 'isSet' ? present : !present;
+  }
+
+  return rows.some(
+    (r) =>
+      r.setName.toLowerCase() === rule.setName.toLowerCase() &&
+      r.propertyName.toLowerCase() === rule.propertyName.toLowerCase() &&
+      valueOpMatches(rule.op, r.value, rule.value),
+  );
+}
+
+export function matchQuantityRule(rule: QuantityRule, rows: QtyRows): boolean {
+  return rows.some(
+    (r) =>
+      r.setName.toLowerCase() === rule.setName.toLowerCase() &&
+      r.quantityName.toLowerCase() === rule.quantityName.toLowerCase() &&
+      numericOpMatches(rule.op, r.value, rule.value),
+  );
+}
+
+// ── Storey lookup fallback ────────────────────────────────────────────────────
+
+export function defaultStoreyName(store: IfcDataStore, expressId: number): string {
+  const hierarchy = store.spatialHierarchy;
+  if (!hierarchy) return '';
+  const storeyId = hierarchy.elementToStorey.get(expressId);
+  if (!storeyId) return '';
+  return store.entities.getName(storeyId);
+}
+
+// ── Material / classification / elevation resolution ─────────────────────────
+
+/** Collect every material-name string an element exposes — top-level
+ *  material, plus layer / constituent / profile names and list members.
+ *  Used by the multi-valued `material` rule matcher. */
+export function materialNamesOf(info: MaterialInfo | null): string[] {
+  if (!info) return [];
+  const names: string[] = [];
+  const push = (s: string | undefined) => { if (s) names.push(s); };
+  push(info.name);
+  for (const l of info.layers ?? []) { push(l.materialName); push(l.name); }
+  for (const c of info.constituents ?? []) { push(c.materialName); push(c.name); }
+  for (const p of info.profiles ?? []) { push(p.materialName); push(p.name); }
+  for (const m of info.materials ?? []) push(m.name);
+  return names;
+}
+
+/** Match a classification rule against an element's classification refs.
+ *  `system` (when set) scopes to one classification system; value ops
+ *  match a ref's code (identification) OR name. */
+export function matchClassificationRule(
+  rule: ClassificationRule,
+  refs: readonly ClassificationInfo[],
+): boolean {
+  const sys = rule.system?.trim().toLowerCase();
+  const scoped = sys
+    ? refs.filter((r) => (r.system ?? '').toLowerCase() === sys)
+    : refs;
+
+  if (rule.op === 'isSet') return scoped.length > 0;
+  if (rule.op === 'isNotSet') return scoped.length === 0;
+
+  // Value ops — match against identification (code) and name of each ref.
+  const candidates: string[] = [];
+  for (const r of scoped) {
+    if (r.identification) candidates.push(r.identification);
+    if (r.name) candidates.push(r.name);
+  }
+  // rule.op is now eq | ne | contains | notContains — a StringOp subset.
+  return matchStringAnyNone(rule.op, candidates, rule.value);
+}
+
+/** Element elevation in metres, derived from its building storey's
+ *  elevation. Returns null when the element isn't placed in the spatial
+ *  hierarchy (so an elevation rule simply doesn't match it). */
+export function elevationOf(store: IfcDataStore, expressId: number): number | null {
+  const hierarchy = store.spatialHierarchy;
+  if (!hierarchy) return null;
+  const storeyId = hierarchy.elementToStorey.get(expressId);
+  if (!storeyId) return null;
+  const elev = hierarchy.storeyElevations.get(storeyId);
+  return typeof elev === 'number' ? elev : null;
+}

package/src/lib/search/filter-rules.test.ts

@@ -7,6 +7,7 @@ import assert from 'node:assert';
 import {
   setOpMatches,
   stringOpMatches,
+  matchStringAnyNone,
   numericOpMatches,
   valueOpMatches,
   combineRuleResults,
@@ -46,6 +47,27 @@ describe('stringOpMatches', () => {
   });
 });
 
+describe('matchStringAnyNone', () => {
+  const layers = ['Concrete C30/37', 'Rigid Insulation', 'Gypsum Board'];
+  it('positive ops match if ANY candidate satisfies them', () => {
+    assert.strictEqual(matchStringAnyNone('contains', layers, 'insulation'), true);
+    assert.strictEqual(matchStringAnyNone('eq', layers, 'gypsum board'), true);
+    assert.strictEqual(matchStringAnyNone('startsWith', layers, 'concrete'), true);
+    assert.strictEqual(matchStringAnyNone('contains', layers, 'timber'), false);
+  });
+  it('negative ops match only if NO candidate violates them', () => {
+    assert.strictEqual(matchStringAnyNone('notContains', layers, 'timber'), true);
+    assert.strictEqual(matchStringAnyNone('notContains', layers, 'concrete'), false);
+    assert.strictEqual(matchStringAnyNone('ne', layers, 'steel'), true);
+    assert.strictEqual(matchStringAnyNone('ne', layers, 'gypsum board'), false);
+  });
+  it('an empty candidate set never matches — including negative ops', () => {
+    assert.strictEqual(matchStringAnyNone('contains', [], 'concrete'), false);
+    assert.strictEqual(matchStringAnyNone('notContains', [], 'concrete'), false);
+    assert.strictEqual(matchStringAnyNone('ne', [], 'concrete'), false);
+  });
+});
+
 describe('numericOpMatches', () => {
   it('eq uses 1e-9 epsilon (matches Rust impl)', () => {
     assert.strictEqual(numericOpMatches('eq', 1.0 + 1e-12, 1.0), true);
@@ -101,6 +123,9 @@ describe('isFilterRule / parseFilterRules', () => {
     assert.strictEqual(isFilterRule(Rule.name('contains', 'wall')), true);
     assert.strictEqual(isFilterRule(Rule.property('Pset_X', 'P', 'eq', 'v')), true);
     assert.strictEqual(isFilterRule(Rule.quantity('Qto_X', 'Q', 'gt', 1)), true);
+    assert.strictEqual(isFilterRule(Rule.material('contains', 'Concrete')), true);
+    assert.strictEqual(isFilterRule(Rule.classification('Uniclass', 'contains', 'Pr_')), true);
+    assert.strictEqual(isFilterRule(Rule.elevation('gt', 3)), true);
   });
   it('rejects unknown kinds and non-objects', () => {
     assert.strictEqual(isFilterRule({ kind: 'bogus' }), false);

package/src/lib/search/filter-rules.ts

@@ -37,6 +37,11 @@ export type ValueOp =
   | 'isSet'
   | 'isNotSet';
 
+/** Classification value+presence ops. A classification is matched against
+ *  its code / name string, so this is the StringOp comparison subset plus
+ *  presence — numeric ops don't apply. */
+export type ClassificationOp = 'eq' | 'ne' | 'contains' | 'notContains' | 'isSet' | 'isNotSet';
+
 /** Top-level rule combinator. */
 export type Combinator = 'AND' | 'OR';
 
@@ -83,13 +88,47 @@ export interface QuantityRule {
   value: number;
 }
 
+/** Match against an element's material name(s) — top-level material,
+ *  layer / constituent / profile names, and list members. Multi-valued:
+ *  the evaluator matches if ANY name satisfies a positive op, or NONE
+ *  violates a negative op (ne / notContains). */
+export interface MaterialRule {
+  kind: 'material';
+  op: StringOp;
+  value: string;
+}
+
+/** Match against an element's classification references (e.g. Uniclass,
+ *  OmniClass). `system` optionally scopes to one classification system;
+ *  the value matches a reference's code (identification) OR name. */
+export interface ClassificationRule {
+  kind: 'classification';
+  /** Optional system scope (e.g. "Uniclass 2015"). Empty = any system. */
+  system?: string;
+  op: ClassificationOp;
+  /** Matched against identification (code) OR name. Ignored for isSet/isNotSet. */
+  value: string;
+}
+
+/** Match against an element's elevation in metres — derived from the
+ *  elevation of the building storey the element belongs to. */
+export interface ElevationRule {
+  kind: 'elevation';
+  op: NumericOp;
+  /** Threshold in metres. */
+  value: number;
+}
+
 export type FilterRule =
   | StoreyRule
   | IfcTypeRule
   | PredefinedTypeRule
   | NameRule
   | PropertyRule
-  | QuantityRule;
+  | QuantityRule
+  | MaterialRule
+  | ClassificationRule
+  | ElevationRule;
 
 // ── Pure op helpers (ported verbatim from filter.rs) ──────────────────────────
 
@@ -110,6 +149,33 @@ export function stringOpMatches(op: StringOp, candidate: string, value: string):
   }
 }
 
+/**
+ * Match a StringOp against a *set* of candidate strings — used for
+ * multi-valued dimensions (an element's material names, a classification's
+ * code+name pair). Positive ops (eq / contains / startsWith) match if ANY
+ * candidate satisfies them; negative ops (ne / notContains) match only if
+ * NO candidate violates them. An empty candidate set never matches: an
+ * element with no materials/classifications shouldn't satisfy a filter on
+ * that dimension (including the negative ops).
+ */
+export function matchStringAnyNone(
+  op: StringOp,
+  candidates: readonly string[],
+  value: string,
+): boolean {
+  if (candidates.length === 0) return false;
+  switch (op) {
+    case 'eq':
+    case 'contains':
+    case 'startsWith':
+      return candidates.some((c) => stringOpMatches(op, c, value));
+    case 'ne':
+      return candidates.every((c) => stringOpMatches('eq', c, value) === false);
+    case 'notContains':
+      return candidates.every((c) => stringOpMatches('contains', c, value) === false);
+  }
+}
+
 export function numericOpMatches(op: NumericOp, candidate: number, value: number): boolean {
   // The Rust side uses 1e-9 as the epsilon for eq/ne. Match it here for
   // IDS-style parity — IFC quantities are stored as IFC4 IfcReal so the
@@ -175,6 +241,10 @@ export const Rule = {
     ({ kind: 'property', setName, propertyName, op, value }),
   quantity: (setName: string, quantityName: string, op: NumericOp, value: number): QuantityRule =>
     ({ kind: 'quantity', setName, quantityName, op, value }),
+  material: (op: StringOp, value: string): MaterialRule => ({ kind: 'material', op, value }),
+  classification: (system: string, op: ClassificationOp, value: string): ClassificationRule =>
+    ({ kind: 'classification', system: system || undefined, op, value }),
+  elevation: (op: NumericOp, value: number): ElevationRule => ({ kind: 'elevation', op, value }),
 } as const;
 
 // ── JSON guards ──────────────────────────────────────────────────────────────
@@ -188,7 +258,10 @@ export function isFilterRule(value: unknown): value is FilterRule {
     kind === 'predefinedType' ||
     kind === 'name' ||
     kind === 'property' ||
-    kind === 'quantity'
+    kind === 'quantity' ||
+    kind === 'material' ||
+    kind === 'classification' ||
+    kind === 'elevation'
   );
 }
 

package/src/lib/slab-edit.test.ts

@@ -99,6 +99,78 @@ describe('slab-edit', () => {
     assert.deepStrictEqual(chain.footprint[2], [11, 22]);
   });
 
+  it('applies the IfcExtrudedAreaSolid.Position transform (offset + axis flip)', () => {
+    // Real authoring tools bake the slab's plan offset/rotation into the
+    // solid Position rather than the IfcLocalPlacement. Here the solid is
+    // placed at (100, 50) with RefDirection (-1,0,0) + Axis (0,0,-1) — the
+    // 180°-about-the-vertical flip seen in the BIMcollab fixture (#90).
+    const entities = makePolygonSlabFixture();
+    entities.push(
+      { expressId: 70, type: 'IFCCARTESIANPOINT', attributes: [[100, 50, 0]] },
+      { expressId: 71, type: 'IFCDIRECTION', attributes: [[0, 0, -1]] }, // Axis (Z)
+      { expressId: 72, type: 'IFCDIRECTION', attributes: [[-1, 0, 0]] }, // RefDirection (X)
+      { expressId: 73, type: 'IFCAXIS2PLACEMENT3D', attributes: [70, 71, 72] },
+    );
+    // Point the solid's Position slot (attr 1) at the new placement.
+    entities.find((e) => e.expressId === 93)!.attributes = [92, 73, null, 0.25];
+
+    const editor = new StubStoreEditor(entities) as unknown as Parameters<typeof resolveSlabEditChain>[2];
+    const view = new StubView() as unknown as Parameters<typeof resolveSlabEditChain>[1];
+    const chain = resolveSlabEditChain(dataStoreStub, view, editor, 100);
+    assert.ok(chain);
+    // X = (-1,0,0), Y = Z×X = (0,1,0) → solidXform(p) = (100 - p.x, 50 + p.y).
+    // Then + placement origin (10, 20).
+    //   (0,0) → (100,50) → (110,70)
+    //   (2,0) → (98,50)  → (108,70)
+    //   (1,2) → (99,52)  → (109,72)
+    assert.deepStrictEqual(chain.footprint[0], [110, 70]);
+    assert.deepStrictEqual(chain.footprint[1], [108, 70]);
+    assert.deepStrictEqual(chain.footprint[2], [109, 72]);
+  });
+
+  it('normalizes a non-unit-length Axis/RefDirection in the solid Position', () => {
+    // IfcDirection.DirectionRatios are ratios, not guaranteed unit
+    // vectors. A valid Axis=(0,0,2) must not leak its length into the
+    // Y basis (Y = Z×X) or skew the Gram-Schmidt projection — otherwise
+    // the footprint disagrees with the (normalizing) renderer. With
+    // proper normalization the result matches an identity-rotation
+    // placement: solidXform(p) = (100 + p.x, 50 + p.y).
+    const entities = makePolygonSlabFixture();
+    entities.push(
+      { expressId: 70, type: 'IFCCARTESIANPOINT', attributes: [[100, 50, 0]] },
+      { expressId: 71, type: 'IFCDIRECTION', attributes: [[0, 0, 2]] }, // non-unit Axis (Z)
+      { expressId: 72, type: 'IFCDIRECTION', attributes: [[3, 0, 0]] }, // non-unit RefDirection (X)
+      { expressId: 73, type: 'IFCAXIS2PLACEMENT3D', attributes: [70, 71, 72] },
+    );
+    entities.find((e) => e.expressId === 93)!.attributes = [92, 73, null, 0.25];
+
+    const editor = new StubStoreEditor(entities) as unknown as Parameters<typeof resolveSlabEditChain>[2];
+    const view = new StubView() as unknown as Parameters<typeof resolveSlabEditChain>[1];
+    const chain = resolveSlabEditChain(dataStoreStub, view, editor, 100);
+    assert.ok(chain);
+    //   (0,0) → (100,50) → +placement(10,20) → (110,70)
+    //   (2,0) → (102,50) → (112,70)
+    //   (1,2) → (101,52) → (111,72)   [buggy raw-Axis would give y=74]
+    assert.deepStrictEqual(chain.footprint[0], [110, 70]);
+    assert.deepStrictEqual(chain.footprint[1], [112, 70]);
+    assert.deepStrictEqual(chain.footprint[2], [111, 72]);
+  });
+
+  it('ignores lengthUnitScale for authored (overlay) entities', () => {
+    // The in-store builders already emit metres, so a freshly-authored
+    // slab must NOT be re-scaled even on a millimetre model — otherwise
+    // re-splitting a just-cut half would shrink it 1000×. The stub serves
+    // overlay entities, so the footprint stays in its given units despite
+    // the 0.001 scale.
+    const entities = makePolygonSlabFixture();
+    const editor = new StubStoreEditor(entities) as unknown as Parameters<typeof resolveSlabEditChain>[2];
+    const view = new StubView() as unknown as Parameters<typeof resolveSlabEditChain>[1];
+    const chain = resolveSlabEditChain(dataStoreStub, view, editor, 100, 0.001);
+    assert.ok(chain);
+    assert.deepStrictEqual(chain.footprint[0], [10, 20]);
+    assert.strictEqual(chain.thickness, 0.25);
+  });
+
   it('strips the redundant closing vertex from an IfcPolyline', () => {
     const entities = makePolygonSlabFixture();
     // Append a duplicate of the first vertex to the polyline.

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;
 }