@ifc-lite/viewer 1.21.0 → 1.22.1

package/src/lib/polygon-clip.ts

@@ -0,0 +1,199 @@
+/* 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/. */
+
+/**
+ * 2D polygon half-plane clipping. Used by slab / roof / plate /
+ * space split to divide a footprint polygon into two halves by a
+ * cut line.
+ *
+ * The cut line is defined by two points in the polygon's local
+ * plane. We derive the line's normal (rotated 90° CCW from the
+ * direction) and use it to assign each polygon vertex to one of
+ * the two half-planes. Sutherland-Hodgman-style edge walk
+ * produces the clipped polygon for each side; the union of the
+ * two output polygons reconstructs the input (minus any sliver
+ * vertices that landed exactly on the cut line, which both halves
+ * include as boundary).
+ *
+ * Returns:
+ *
+ *   - `{ ok: true, left, right }` when the cut intersects the
+ *     polygon and both halves have ≥ 3 vertices (a valid polygon).
+ *   - `{ ok: false, reason }` when the cut misses the polygon, is
+ *     tangent to a single vertex, or produces a degenerate sliver
+ *     (< 3 vertices on either side).
+ *
+ * "Left" / "right" naming follows the cut-line direction: walking
+ * from A to B, "left" is the half-plane on the user's left
+ * (positive cross product of (B-A) with (vertex-A)).
+ */
+
+export type Point2D = [number, number];
+
+export type PolygonClipResult =
+  | { ok: true; left: Point2D[]; right: Point2D[] }
+  | { ok: false; reason: string };
+
+const EPS = 1e-9;
+
+/**
+ * Signed perpendicular distance of `p` to the directed line through
+ * `a → b`. Positive means `p` is to the LEFT of A→B in standard
+ * math coords (y-up) — i.e. the side reached by rotating the A→B
+ * direction 90° counter-clockwise.
+ */
+function signedDistance(a: Point2D, b: Point2D, p: Point2D): number {
+  // Standard 2D cross product (b - a) × (p - a).
+  return (b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0]);
+}
+
+/**
+ * Linear interpolation between two polygon vertices at the cut line.
+ * `da`, `db` are signed distances of `a` and `b` from the line; the
+ * intersection sits where the signed distance crosses zero.
+ */
+function intersectEdge(a: Point2D, b: Point2D, da: number, db: number): Point2D {
+  const t = da / (da - db); // never 0/0 because callers ensure signs differ
+  return [a[0] + t * (b[0] - a[0]), a[1] + t * (b[1] - a[1])];
+}
+
+/**
+ * Clip a polygon to one side of the cut line. `keep` selects which
+ * side to retain: `'positive'` keeps vertices with signed distance
+ * > 0 (left of A→B); `'negative'` keeps vertices with signed
+ * distance < 0 (right). On-line vertices (|d| < EPS) belong to
+ * both halves and are emitted unchanged.
+ *
+ * Standard Sutherland-Hodgman: walk each edge of the input polygon,
+ * decide whether to emit the current vertex and/or an intersection
+ * with the cut line based on which side current and previous
+ * vertices are on.
+ */
+function clipPolygonHalfPlane(
+  polygon: Point2D[],
+  a: Point2D,
+  b: Point2D,
+  keep: 'positive' | 'negative',
+): Point2D[] {
+  if (polygon.length === 0) return [];
+  const out: Point2D[] = [];
+  const sign = keep === 'positive' ? 1 : -1;
+  const pushUnique = (p: Point2D) => {
+    // Skip duplicate emits — the on-line edge case (prev outside,
+    // curr on the line) would otherwise emit the intersection AND
+    // curr, which are the same point. Cheap O(1) check against the
+    // most recent vertex; the polygon body itself is allowed to
+    // have repeated adjacent vertices in pathological input but we
+    // don't want to manufacture them.
+    if (out.length > 0) {
+      const last = out[out.length - 1];
+      if (Math.abs(last[0] - p[0]) < EPS && Math.abs(last[1] - p[1]) < EPS) return;
+    }
+    out.push(p);
+  };
+
+  let prev = polygon[polygon.length - 1];
+  let prevD = signedDistance(a, b, prev) * sign;
+  for (const curr of polygon) {
+    const currD = signedDistance(a, b, curr) * sign;
+    if (currD >= -EPS) {
+      // Current vertex is inside (or on the line).
+      if (prevD < -EPS) {
+        // Crossing into the half-plane — emit the intersection.
+        pushUnique(intersectEdge(prev, curr, prevD, currD));
+      }
+      pushUnique(curr);
+    } else if (prevD >= -EPS) {
+      // Crossing out of the half-plane — emit the intersection.
+      pushUnique(intersectEdge(prev, curr, prevD, currD));
+    }
+    // Else both outside — skip.
+    prev = curr;
+    prevD = currD;
+  }
+  // The pushUnique guard runs against the previous push; the
+  // wrap-around (last vs first) can also produce a dup when the
+  // polygon closes on a near-coincident pair. Trim once.
+  if (out.length > 1) {
+    const first = out[0];
+    const last = out[out.length - 1];
+    if (Math.abs(last[0] - first[0]) < EPS && Math.abs(last[1] - first[1]) < EPS) {
+      out.pop();
+    }
+  }
+  return out;
+}
+
+/**
+ * Split a polygon into two halves by a cut line.
+ *
+ * Inputs:
+ *   - `polygon` — outer curve as an ordered list of 2D vertices
+ *     (CW or CCW; the algorithm is orientation-independent).
+ *     First vertex should NOT repeat at the end.
+ *   - `a`, `b` — two points defining the cut line. The line
+ *     extends infinitely in both directions through these points,
+ *     so the user-clicked endpoints don't need to lie on the
+ *     polygon edge.
+ *
+ * Returns `{ ok: true, left, right }` when both halves are valid
+ * polygons (≥ 3 vertices). Otherwise returns `{ ok: false, reason }`.
+ */
+export function clipPolygonByLine(
+  polygon: Point2D[],
+  a: Point2D,
+  b: Point2D,
+): PolygonClipResult {
+  if (polygon.length < 3) {
+    return { ok: false, reason: 'Polygon must have at least 3 vertices' };
+  }
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  if (Math.hypot(dx, dy) < EPS) {
+    return { ok: false, reason: 'Cut endpoints are coincident' };
+  }
+
+  // Count how many vertices land strictly on each side. If all
+  // vertices are on one side, the cut line misses the polygon.
+  let pos = 0;
+  let neg = 0;
+  for (const p of polygon) {
+    const d = signedDistance(a, b, p);
+    if (d > EPS) pos++;
+    else if (d < -EPS) neg++;
+  }
+  if (pos === 0 || neg === 0) {
+    return { ok: false, reason: 'Cut line does not cross the polygon' };
+  }
+
+  const left = clipPolygonHalfPlane(polygon, a, b, 'positive');
+  const right = clipPolygonHalfPlane(polygon, a, b, 'negative');
+
+  if (left.length < 3 || right.length < 3) {
+    return { ok: false, reason: 'Cut produces a degenerate half (< 3 vertices)' };
+  }
+
+  return { ok: true, left, right };
+}
+
+/**
+ * Test helper: is `p` strictly inside `polygon` (ray-cast). Used by
+ * the slab-split tool to figure out which half the user clicked on
+ * after committing the cut, so we can move selection to that half.
+ */
+export function pointInPolygon(polygon: Point2D[], p: Point2D): boolean {
+  if (polygon.length < 3) return false;
+  let inside = false;
+  let j = polygon.length - 1;
+  for (let i = 0; i < polygon.length; i++) {
+    const a = polygon[i];
+    const b = polygon[j];
+    const intersects =
+      (a[1] > p[1]) !== (b[1] > p[1]) &&
+      p[0] < ((b[0] - a[0]) * (p[1] - a[1])) / (b[1] - a[1] + EPS) + a[0];
+    if (intersects) inside = !inside;
+    j = i;
+  }
+  return inside;
+}

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

@@ -0,0 +1,169 @@
+/* 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 {
+  resolveSlabEditChain,
+  computeSlabSplitGeometry,
+} from './slab-edit.js';
+
+import { StubStoreEditor, StubView, makeStubDataStore, type OverlayEntity } from './__test__/stubs.js';
+
+const dataStoreStub = makeStubDataStore() as unknown as Parameters<typeof resolveSlabEditChain>[0];
+
+/**
+ * Rectangle-profile slab fixture mirroring `addSlabToStore`:
+ *   #100 IfcSlab
+ *     placement → #99 IfcLocalPlacement → #98 IfcAxis2Placement3D
+ *                   Location → #97 IfcCartesianPoint([1, 2, 0])
+ *     representation → #95 IfcProductDefinitionShape
+ *       → #94 IfcShapeRepresentation
+ *         → Items[0] = #93 IfcExtrudedAreaSolid
+ *             SweptArea = #92 IfcRectangleProfileDef (W=4, D=3)
+ *               Position = #91 IfcAxis2Placement2D
+ *                 Location = #90 IfcCartesianPoint([2, 1.5])
+ *             Depth = 0.3
+ */
+function makeRectangleSlabFixture() {
+  return [
+    { expressId: 97, type: 'IFCCARTESIANPOINT', attributes: [[1, 2, 0]] },
+    { expressId: 98, type: 'IFCAXIS2PLACEMENT3D', attributes: [97, null, null] },
+    { expressId: 99, type: 'IFCLOCALPLACEMENT', attributes: [null, 98] },
+    { expressId: 90, type: 'IFCCARTESIANPOINT', attributes: [[2, 1.5]] },
+    { expressId: 91, type: 'IFCAXIS2PLACEMENT2D', attributes: [90, null] },
+    { expressId: 92, type: 'IFCRECTANGLEPROFILEDEF', attributes: ['.AREA.', null, 91, 4, 3] },
+    { expressId: 93, type: 'IFCEXTRUDEDAREASOLID', attributes: [92, null, null, 0.3] },
+    { expressId: 94, type: 'IFCSHAPEREPRESENTATION', attributes: [null, 'Body', 'SweptSolid', [93]] },
+    { expressId: 95, type: 'IFCPRODUCTDEFINITIONSHAPE', attributes: [null, null, [94]] },
+    { expressId: 100, type: 'IFCSLAB', attributes: ['guid', null, 'Slab-1', null, null, 99, 95, null] },
+  ];
+}
+
+/**
+ * Polygon-profile slab fixture (triangle footprint).
+ *   IfcArbitraryClosedProfileDef → IfcPolyline with three points
+ *   (0,0), (2,0), (1,2) in profile-local 2D.
+ */
+function makePolygonSlabFixture() {
+  return [
+    { expressId: 97, type: 'IFCCARTESIANPOINT', attributes: [[10, 20, 0]] },
+    { expressId: 98, type: 'IFCAXIS2PLACEMENT3D', attributes: [97, null, null] },
+    { expressId: 99, type: 'IFCLOCALPLACEMENT', attributes: [null, 98] },
+    { expressId: 80, type: 'IFCCARTESIANPOINT', attributes: [[0, 0]] },
+    { expressId: 81, type: 'IFCCARTESIANPOINT', attributes: [[2, 0]] },
+    { expressId: 82, type: 'IFCCARTESIANPOINT', attributes: [[1, 2]] },
+    { expressId: 83, type: 'IFCPOLYLINE', attributes: [[80, 81, 82]] },
+    { expressId: 92, type: 'IFCARBITRARYCLOSEDPROFILEDEF', attributes: ['.AREA.', null, 83] },
+    { expressId: 93, type: 'IFCEXTRUDEDAREASOLID', attributes: [92, null, null, 0.25] },
+    { expressId: 94, type: 'IFCSHAPEREPRESENTATION', attributes: [null, 'Body', 'SweptSolid', [93]] },
+    { expressId: 95, type: 'IFCPRODUCTDEFINITIONSHAPE', attributes: [null, null, [94]] },
+    { expressId: 100, type: 'IFCSLAB', attributes: ['guid', null, 'Slab-1', null, null, 99, 95, null] },
+  ];
+}
+
+describe('slab-edit', () => {
+  it('resolves a rectangle-profile slab footprint with placement-origin added', () => {
+    const entities = makeRectangleSlabFixture();
+    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);
+    assert.strictEqual(chain.elementType, 'IfcSlab');
+    assert.strictEqual(chain.thickness, 0.3);
+    assert.strictEqual(chain.profileKind, 'rectangle');
+    // Profile centered at (2, 1.5) with XDim=4, YDim=3 means it
+    // spans [0..4] x [0..3] in profile-local. Plus placement origin
+    // (1, 2) gives [1..5] x [2..5] in storey-local.
+    assert.deepStrictEqual(chain.footprint, [
+      [1, 2],
+      [5, 2],
+      [5, 5],
+      [1, 5],
+    ]);
+  });
+
+  it('resolves a polygon-profile slab footprint with placement-origin added', () => {
+    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);
+    assert.ok(chain);
+    assert.strictEqual(chain.profileKind, 'polygon');
+    // Triangle vertices (0,0), (2,0), (1,2) with placement (10, 20)
+    // and no explicit profile origin → footprint at (10,20), (12,20), (11,22).
+    assert.strictEqual(chain.footprint.length, 3);
+    assert.deepStrictEqual(chain.footprint[0], [10, 20]);
+    assert.deepStrictEqual(chain.footprint[1], [12, 20]);
+    assert.deepStrictEqual(chain.footprint[2], [11, 22]);
+  });
+
+  it('strips the redundant closing vertex from an IfcPolyline', () => {
+    const entities = makePolygonSlabFixture();
+    // Append a duplicate of the first vertex to the polyline.
+    const polyline = entities.find((e) => e.expressId === 83)!;
+    polyline.attributes = [[80, 81, 82, 80]];
+    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);
+    assert.strictEqual(chain.footprint.length, 3);
+  });
+
+  it('rejects non-slab-like element types', () => {
+    const entities = makeRectangleSlabFixture();
+    entities.find((e) => e.expressId === 100)!.type = 'IFCWALL';
+    const editor = new StubStoreEditor(entities) as unknown as Parameters<typeof resolveSlabEditChain>[2];
+    const view = new StubView() as unknown as Parameters<typeof resolveSlabEditChain>[1];
+    assert.strictEqual(resolveSlabEditChain(dataStoreStub, view, editor, 100), null);
+  });
+
+  it('computeSlabSplitGeometry halves a rectangle slab', () => {
+    const entities = makeRectangleSlabFixture();
+    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);
+    // Slab spans x:[1..5], y:[2..5]. Vertical cut at x=3.
+    const result = computeSlabSplitGeometry(chain, [3, 0], [3, 10]);
+    assert.ok(result.ok);
+    assert.strictEqual(result.leftFootprint.length, 4);
+    assert.strictEqual(result.rightFootprint.length, 4);
+    // One half covers x:[1..3], other x:[3..5]. Total area = 12 (4*3).
+    const area = (poly: [number, number][]) => {
+      let a = 0;
+      for (let i = 0; i < poly.length; i++) {
+        const [x1, y1] = poly[i];
+        const [x2, y2] = poly[(i + 1) % poly.length];
+        a += x1 * y2 - x2 * y1;
+      }
+      return Math.abs(a) / 2;
+    };
+    const totalArea = area(result.leftFootprint) + area(result.rightFootprint);
+    assert.ok(Math.abs(totalArea - 12) < 1e-9);
+  });
+
+  it('rejects cut lines that miss the slab', () => {
+    const entities = makeRectangleSlabFixture();
+    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);
+    // Cut line at x=100 — entirely outside the slab.
+    const result = computeSlabSplitGeometry(chain, [100, 0], [100, 10]);
+    assert.strictEqual(result.ok, false);
+  });
+
+  it('preserves thickness + element type through split', () => {
+    const entities = makeRectangleSlabFixture();
+    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);
+    const result = computeSlabSplitGeometry(chain, [3, 0], [3, 10]);
+    assert.ok(result.ok);
+    assert.strictEqual(result.thickness, 0.3);
+    assert.strictEqual(result.elementType, 'IfcSlab');
+  });
+});

package/src/lib/slab-edit.ts

@@ -0,0 +1,312 @@
+/* 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/. */
+
+/**
+ * Footprint reader + cut helpers for slab-like elements (IfcSlab,
+ * IfcRoof, IfcPlate, IfcSpace) shaped by the in-store builders in
+ * `@ifc-lite/create`. The shared shape is:
+ *
+ *   IfcExtrudedAreaSolid
+ *     ├── SweptArea : IfcRectangleProfileDef (W × D) — rectangle mode
+ *     │              OR IfcArbitraryClosedProfileDef → IfcPolyline — polygon mode
+ *     └── Depth     : thickness along +Z (storey-local)
+ *
+ * The "footprint" is the profile polygon in storey-local 2D (XY).
+ * For rectangle mode we derive it from (placementOrigin, W, D); for
+ * polygon mode we read the polyline's vertex list.
+ *
+ * The split workflow:
+ *
+ *   1. user clicks twice on the slab (in storey-local 2D)
+ *   2. polygon-clip cuts the footprint into two halves
+ *   3. caller builds two fresh slabs via `addSlab` polygon-mode
+ *      (cleaner than trying to detect "rectangle still fits" — most
+ *       cuts produce non-rectangular halves)
+ *   4. source is tombstoned + its mesh hidden
+ *
+ * Source-buffer slabs with unusual representations (mapped shapes,
+ * tessellated faces, …) refuse with a clear reason and the caller's
+ * Split tool stays armed.
+ */
+
+import type { IfcDataStore } from '@ifc-lite/parser';
+import type { MutablePropertyView, StoreEditor } from '@ifc-lite/mutations';
+import {
+  asExpressIdRef,
+  asCoordinateTriple,
+  readAttributes,
+  resolvePlacementChain,
+} from './placement-core.js';
+import { clipPolygonByLine, type Point2D, type PolygonClipResult } from './polygon-clip.js';
+
+/**
+ * Slab-like element types this module handles. Matches the STEP
+ * storage form (`IFCSLAB`, …) so the slice's split action can
+ * dispatch to the right `addSlab` / `addRoof` / `addPlate` /
+ * `addSpace` follow-up. (Roof/plate/space are added in subsequent
+ * commits but their representation is identical, so this resolver
+ * already accepts them.)
+ */
+export type SlabLikeType = 'IfcSlab' | 'IfcRoof' | 'IfcPlate' | 'IfcSpace';
+
+const SLAB_LIKE_STEP_TYPES: Record<string, SlabLikeType> = {
+  IFCSLAB: 'IfcSlab',
+  IFCROOF: 'IfcRoof',
+  IFCPLATE: 'IfcPlate',
+  IFCSPACE: 'IfcSpace',
+};
+
+function stepTypeToSlabLike(stepType: string): SlabLikeType | null {
+  return SLAB_LIKE_STEP_TYPES[stepType.toUpperCase()] ?? null;
+}
+
+export interface SlabEditChain {
+  /** STEP type name, for the slice's dispatch. */
+  elementType: SlabLikeType;
+  /** Placement origin (storey-local). The footprint polygon is in
+   * world-XY space, with the origin already added. */
+  placementOrigin: [number, number, number];
+  /** Footprint polygon as an ordered list of 2D vertices (storey-
+   * local world XY). First vertex does NOT repeat at the end. */
+  footprint: Point2D[];
+  /** IfcExtrudedAreaSolid id — holds the thickness on attr 3. */
+  extrudedSolidId: number;
+  /** Current extrusion thickness (metres along +Z). */
+  thickness: number;
+  /**
+   * Whether the source profile was a rectangle (XDim/YDim) or an
+   * arbitrary polygon (IfcArbitraryClosedProfileDef → IfcPolyline).
+   * Surface for telemetry; not required by the split flow.
+   */
+  profileKind: 'rectangle' | 'polygon';
+}
+
+function readEntityType(
+  dataStore: IfcDataStore,
+  view: MutablePropertyView,
+  editor: StoreEditor,
+  expressId: number,
+): string | null {
+  void view;
+  const overlay = editor.getNewEntity(expressId);
+  if (overlay) return overlay.type;
+  const ref = dataStore.entityIndex.byId.get(expressId);
+  return ref?.type ?? null;
+}
+
+/**
+ * Derive a rectangle profile's outline from its centred placement.
+ * `IfcRectangleProfileDef` extends from `-XDim/2` to `+XDim/2`
+ * along the profile's local X (and same for YDim along local Y),
+ * centred at the IfcAxis2Placement2D's Location point.
+ */
+function rectangleFootprint(
+  placementOrigin: [number, number, number],
+  profileOrigin2D: [number, number],
+  xdim: number,
+  ydim: number,
+): 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).
+  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],
+  ];
+}
+
+/**
+ * Read an IfcPolyline's vertex list and return them as 2D storey-
+ * local points (adding the placement origin so the result is in
+ * the same frame as a rectangle footprint).
+ */
+function polylineFootprint(
+  dataStore: IfcDataStore,
+  view: MutablePropertyView,
+  editor: StoreEditor,
+  polylineId: number,
+  placementOrigin: [number, number, number],
+  profileOrigin2D: [number, number],
+): Point2D[] | null {
+  const attrs = readAttributes(dataStore, view, editor, polylineId);
+  if (!attrs) return null;
+  // IfcPolyline.Points is a list of IfcCartesianPoint refs at attr 0.
+  const refList = attrs[0];
+  if (!Array.isArray(refList) || refList.length < 3) return null;
+  const [px, py] = placementOrigin;
+  const [cx, cy] = profileOrigin2D;
+  const out: Point2D[] = [];
+  for (const ref of refList) {
+    const ptId = asExpressIdRef(ref);
+    if (ptId === null) return null;
+    const ptAttrs = readAttributes(dataStore, view, editor, ptId);
+    if (!ptAttrs) return null;
+    // IfcCartesianPoint.Coordinates is a list of doubles at attr 0.
+    // Polyline points are 2D here (slab profiles), but treat 3D
+    // 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]]);
+  }
+  // IfcPolyline for a closed profile may or may not repeat the
+  // first vertex at the end — strip if present, our clip API
+  // wants the implicit-close form.
+  if (out.length >= 2) {
+    const first = out[0];
+    const last = out[out.length - 1];
+    if (Math.abs(first[0] - last[0]) < 1e-9 && Math.abs(first[1] - last[1]) < 1e-9) {
+      out.pop();
+    }
+  }
+  return out.length >= 3 ? out : null;
+}
+
+/**
+ * Resolve the slab chain (placement + footprint + extrusion). Works
+ * for IfcSlab / IfcRoof / IfcPlate / IfcSpace whose representation
+ * matches the in-store builder shape; null otherwise.
+ */
+export function resolveSlabEditChain(
+  dataStore: IfcDataStore,
+  view: MutablePropertyView,
+  editor: StoreEditor,
+  expressId: number,
+): SlabEditChain | null {
+  const rawType = readEntityType(dataStore, view, editor, expressId);
+  if (!rawType) return null;
+  const elementType = stepTypeToSlabLike(rawType);
+  if (!elementType) return null;
+
+  const chain = resolvePlacementChain(dataStore, view, editor, expressId);
+  if (!chain) return null;
+  const placementOrigin = chain.coordinates;
+
+  const elementAttrs = readAttributes(dataStore, view, editor, expressId);
+  if (!elementAttrs) return null;
+  const productShapeId = asExpressIdRef(elementAttrs[6]);
+  if (productShapeId === null) return null;
+  const productShapeAttrs = readAttributes(dataStore, view, editor, productShapeId);
+  if (!productShapeAttrs) return null;
+  const reps = productShapeAttrs[2];
+  if (!Array.isArray(reps) || reps.length === 0) return null;
+  const shapeRepId = asExpressIdRef(reps[0]);
+  if (shapeRepId === null) return null;
+  const shapeRepAttrs = readAttributes(dataStore, view, editor, shapeRepId);
+  if (!shapeRepAttrs) return null;
+  const items = shapeRepAttrs[3];
+  if (!Array.isArray(items) || items.length === 0) return null;
+  const solidId = asExpressIdRef(items[0]);
+  if (solidId === null) return null;
+  const solidAttrs = readAttributes(dataStore, view, editor, solidId);
+  if (!solidAttrs) return null;
+  const profileId = asExpressIdRef(solidAttrs[0]);
+  const thicknessRaw = solidAttrs[3];
+  if (profileId === null || typeof thicknessRaw !== 'number') return null;
+
+  // 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
+  // surfaces a "not supported" toast.
+  const profileAttrs = readAttributes(dataStore, view, editor, profileId);
+  if (!profileAttrs) return null;
+  const overlay = editor.getNewEntity(profileId);
+  const profileType = overlay?.type ?? dataStore.entityIndex.byId.get(profileId)?.type ?? null;
+
+  // Profile-local origin (IfcAxis2Placement2D.Location) — both
+  // profile kinds share this. May be null for the slot, in which
+  // case the spec defaults to origin = (0, 0).
+  const profilePosId = asExpressIdRef(profileAttrs[2]);
+  let profileOrigin2D: [number, number] = [0, 0];
+  if (profilePosId !== null) {
+    const profilePosAttrs = readAttributes(dataStore, view, editor, profilePosId);
+    if (profilePosAttrs) {
+      const profileOriginPtId = asExpressIdRef(profilePosAttrs[0]);
+      if (profileOriginPtId !== null) {
+        const profileOriginAttrs = readAttributes(dataStore, view, editor, profileOriginPtId);
+        if (profileOriginAttrs) {
+          const c = asCoordinateTriple(profileOriginAttrs[0]);
+          if (c) profileOrigin2D = [c[0], c[1]];
+        }
+      }
+    }
+  }
+
+  if (profileType && profileType.toUpperCase() === 'IFCRECTANGLEPROFILEDEF') {
+    const xdim = profileAttrs[3];
+    const ydim = profileAttrs[4];
+    if (typeof xdim !== 'number' || typeof ydim !== 'number') return null;
+    return {
+      elementType,
+      placementOrigin,
+      footprint: rectangleFootprint(placementOrigin, profileOrigin2D, xdim, ydim),
+      extrudedSolidId: solidId,
+      thickness: thicknessRaw,
+      profileKind: 'rectangle',
+    };
+  }
+  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);
+    if (!fp) return null;
+    return {
+      elementType,
+      placementOrigin,
+      footprint: fp,
+      extrudedSolidId: solidId,
+      thickness: thicknessRaw,
+      profileKind: 'polygon',
+    };
+  }
+  return null;
+}
+
+export interface SlabSplitResult {
+  ok: true;
+  leftFootprint: Point2D[];
+  rightFootprint: Point2D[];
+  thickness: number;
+  placementOrigin: [number, number, number];
+  elementType: SlabLikeType;
+}
+
+export type SlabSplitOutcome = SlabSplitResult | { ok: false; reason: string };
+
+/**
+ * Pure split-geometry helper. Clips the slab's footprint by a cut
+ * line (defined by two storey-local 2D points) and returns the two
+ * halves so the caller can build new slabs with `addSlab`. Both
+ * halves carry the source's thickness + storey placement; only the
+ * outer-curve polygon changes.
+ *
+ * Returns the underlying polygon-clip reason on failure so the UI
+ * can surface "Cut line does not cross the slab" verbatim.
+ */
+export function computeSlabSplitGeometry(
+  chain: SlabEditChain,
+  cutA: Point2D,
+  cutB: Point2D,
+): SlabSplitOutcome {
+  const clipped: PolygonClipResult = clipPolygonByLine(chain.footprint, cutA, cutB);
+  if (!clipped.ok) {
+    return { ok: false, reason: clipped.reason };
+  }
+  return {
+    ok: true,
+    leftFootprint: clipped.left,
+    rightFootprint: clipped.right,
+    thickness: chain.thickness,
+    placementOrigin: chain.placementOrigin,
+    elementType: chain.elementType,
+  };
+}