@bitbybit-dev/ifc 0.0.0-stage → 1.5.0-rc.0

package/lib/build/wall-geometry.js

@@ -0,0 +1,159 @@
+import { pointToLocal, vectorToLocal } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { signedArea2 } from "@bitbybit-dev/base/lib/api/services/helpers/polygons";
+import { add2, leftOf2, length2, scale2, subtract2 } from "@bitbybit-dev/base/lib/api/services/helpers/vectors";
+import * as Inputs from "../api/inputs";
+import { isEnumeration, isReference } from "../step/values";
+import { requiredReference } from "./checks";
+import { PARALLEL_TOLERANCE, VERTICAL_COSINE } from "./constants";
+import { layerSetThickness, materialOf } from "./materials";
+import { distanceToLine, intersectLines, normalize2, parameterOnLine, placedOnPlan } from "./math";
+import { absoluteFrame, axisPlacementFrame, directionOf, objectPlacementOf } from "./placement";
+import { describeObject } from "./spatial";
+import { firstItem, representationOf, unwrapClippings } from "./representations";
+import { polylinePoints } from "./curves";
+function axisPoints(reader, wall) {
+    const axis = representationOf(reader, wall, "Axis");
+    if (axis === undefined) {
+        throw new Error(`${describeObject(reader, wall)} has no Axis representation, so it is not a wall this library can edit`);
+    }
+    const curve = firstItem(reader, axis);
+    const points = polylinePoints(reader, curve);
+    if (points === undefined) {
+        throw new Error(`${describeObject(reader, wall)} has an ${reader.entity(curve).type} axis, which this library does not edit`);
+    }
+    if (points.length < 2) {
+        throw new Error(`${describeObject(reader, wall)} has an axis of fewer than two points`);
+    }
+    const start = points[0];
+    const end = points[points.length - 1];
+    const run = end[0] - start[0];
+    if (!(run > 0) || Math.abs(end[1] - start[1]) > run * PARALLEL_TOLERANCE) {
+        throw new Error(`${describeObject(reader, wall)} has an axis that does not run along its placement's X axis, so the layers IFC offsets along that placement's Y axis do not lie across it`);
+    }
+    return [start, end];
+}
+function layerBounds(reader, wall) {
+    const usage = materialOf(reader, wall);
+    if (usage === undefined || reader.entity(usage).type !== "IfcMaterialLayerSetUsage") {
+        throw new Error(`${describeObject(reader, wall)} has no material layer set usage, so its thickness is unknown`);
+    }
+    const layerSet = reader.attribute(usage, "ForLayerSet");
+    const offset = reader.attribute(usage, "OffsetFromReferenceLine");
+    const sense = reader.attribute(usage, "DirectionSense");
+    const thickness = isReference(layerSet) ? layerSetThickness(reader, layerSet.ref) : 0;
+    const start = typeof offset === "number" ? offset : 0;
+    return isEnumeration(sense) && sense.enum === "NEGATIVE" ? [start - thickness, start, usage] : [start, start + thickness, usage];
+}
+function verticalExtrusion(reader, wall, body) {
+    var _a;
+    const [solid] = unwrapClippings(reader, firstItem(reader, body));
+    const refusal = `${describeObject(reader, wall)} has a body this library does not edit as a wall: `;
+    if (reader.entity(solid).type !== "IfcExtrudedAreaSolid") {
+        throw new Error(`${refusal}an ${reader.entity(solid).type}, where a plan outline extruded upwards is expected`);
+    }
+    const depth = reader.attribute(solid, "Depth");
+    const position = reader.attribute(solid, "Position");
+    const frame = isReference(position) ? axisPlacementFrame(reader, position.ref) : undefined;
+    const direction = directionOf(reader, reader.attribute(solid, "ExtrudedDirection"), [0, 0, 1]);
+    const upwards = Math.hypot(direction[0], direction[1], direction[2]);
+    if (typeof depth !== "number" || !(depth > 0) || (frame !== undefined && frame.z[2] < VERTICAL_COSINE) || !(direction[2] / upwards >= VERTICAL_COSINE)) {
+        throw new Error(`${refusal}its extrusion does not rise straight up from a plan outline`);
+    }
+    return [depth, (_a = frame === null || frame === void 0 ? void 0 : frame.origin[2]) !== null && _a !== void 0 ? _a : 0];
+}
+export function readWall(reader, wall) {
+    const frame = absoluteFrame(reader, objectPlacementOf(reader, wall));
+    if (frame.z[2] < VERTICAL_COSINE) {
+        throw new Error(`${describeObject(reader, wall)} is not upright, so it is not a wall this library can edit`);
+    }
+    const [localStart, localEnd] = axisPoints(reader, wall);
+    const start = placedOnPlan(frame, localStart);
+    const end = placedOnPlan(frame, localEnd);
+    const [low, high, usage] = layerBounds(reader, wall);
+    const body = representationOf(reader, wall, "Body");
+    const [height, base] = body === undefined ? [0, 0] : verticalExtrusion(reader, wall, body);
+    return { wall, frame, start, end, direction: normalize2(subtract2(end, start)), length: length2(subtract2(end, start)), low, high, height, base, body, usage };
+}
+export function axisFrame(geometry) {
+    const start = pointToLocal(geometry.frame, [geometry.start[0], geometry.start[1], 0]);
+    const end = pointToLocal(geometry.frame, [geometry.end[0], geometry.end[1], 0]);
+    const direction = normalize2([end[0] - start[0], end[1] - start[1]]);
+    return { origin: [start[0], start[1], geometry.base], x: [direction[0], direction[1], 0], y: [-direction[1], direction[0], 0], z: [0, 0, 1] };
+}
+export function alignmentOf(geometry, tolerance) {
+    if (Math.abs(geometry.low) <= tolerance) {
+        return Inputs.IFC.wallAlignmentEnum.left;
+    }
+    if (Math.abs(geometry.high) <= tolerance) {
+        return Inputs.IFC.wallAlignmentEnum.right;
+    }
+    return Math.abs(geometry.low + geometry.high) <= tolerance ? Inputs.IFC.wallAlignmentEnum.center : undefined;
+}
+export function layerSetOf(reader, geometry) {
+    return requiredReference(reader, geometry.usage, "ForLayerSet");
+}
+export function sideLine(geometry, across) {
+    return { point: add2(geometry.start, scale2(leftOf2(geometry.direction), across)), direction: geometry.direction };
+}
+export function axisLine(geometry) {
+    return { point: geometry.start, direction: geometry.direction };
+}
+export function endPoint(geometry, end) {
+    return end === "ATSTART" ? geometry.start : geometry.end;
+}
+export function mitreCut(wall, wallEnd, other, otherEnd, tolerance, parallelTolerance) {
+    const sameFlow = wallEnd !== otherEnd;
+    const pairs = sameFlow ? [[wall.high, other.high], [wall.low, other.low]] : [[wall.high, other.low], [wall.low, other.high]];
+    const corners = pairs.map(([mine, theirs]) => intersectLines(sideLine(wall, mine), sideLine(other, theirs), parallelTolerance));
+    const [first, second] = corners;
+    if (!first || !second) {
+        return undefined;
+    }
+    const along = subtract2(second, first);
+    if (length2(along) <= tolerance) {
+        return undefined;
+    }
+    return { point: first, direction: normalize2(along) };
+}
+export function buttCut(stem, stemEnd, through) {
+    const far = stemEnd === "ATSTART" ? stem.end : stem.start;
+    return sideLine(through, distanceToLine(far, axisLine(through)) >= 0 ? through.high : through.low);
+}
+export function footprintOf(geometry, cuts, tolerance, parallelTolerance) {
+    const toLocalLine = (line) => {
+        const point = pointToLocal(geometry.frame, [line.point[0], line.point[1], 0]);
+        const direction = vectorToLocal(geometry.frame, [line.direction[0], line.direction[1], 0]);
+        return { point: [point[0], point[1]], direction: normalize2([direction[0], direction[1]]) };
+    };
+    const startLocal = pointToLocal(geometry.frame, [geometry.start[0], geometry.start[1], 0]);
+    const endLocal = pointToLocal(geometry.frame, [geometry.end[0], geometry.end[1], 0]);
+    const axisDirection = normalize2([endLocal[0] - startLocal[0], endLocal[1] - startLocal[1]]);
+    const across = leftOf2(axisDirection);
+    const squareAt = (point) => ({ point: [point[0], point[1]], direction: across });
+    const startCut = cuts.start ? toLocalLine(cuts.start) : squareAt(startLocal);
+    const endCut = cuts.end ? toLocalLine(cuts.end) : squareAt(endLocal);
+    const side = (offset) => ({ point: add2([startLocal[0], startLocal[1]], scale2(across, offset)), direction: axisDirection });
+    const corner = (line, cut, fallback) => { var _a; return (_a = intersectLines(line, cut, parallelTolerance)) !== null && _a !== void 0 ? _a : intersectLines(line, fallback, parallelTolerance); };
+    const low = side(geometry.low);
+    const high = side(geometry.high);
+    const outline = [
+        corner(low, startCut, squareAt(startLocal)),
+        corner(low, endCut, squareAt(endLocal)),
+        corner(high, endCut, squareAt(endLocal)),
+        corner(high, startCut, squareAt(startLocal)),
+    ];
+    const lowSpan = parameterOnLine(outline[1], low) - parameterOnLine(outline[0], low);
+    const highSpan = parameterOnLine(outline[2], high) - parameterOnLine(outline[3], high);
+    if (!(lowSpan > tolerance) || !(highSpan > tolerance) || !(signedArea2(outline) > 0)) {
+        throw new Error(`The joins of wall #${geometry.wall} leave it with no length on one face; it is too short for the walls it meets`);
+    }
+    return outline;
+}
+export function readableWall(reader, wall) {
+    try {
+        return readWall(reader, wall);
+    }
+    catch (_a) {
+        return undefined;
+    }
+}

package/lib/build/wall-parameters.d.ts

@@ -0,0 +1,3 @@
+import * as Inputs from "../api/inputs";
+import type { ModelReader } from "./build-types";
+export declare function wallParametersOf(reader: ModelReader, wall: number, tolerance: number): Inputs.IFC.WallParametersDto;

package/lib/build/wall-parameters.js

@@ -0,0 +1,47 @@
+import { WORLD_AXES, pointToLocal, pointToWorld } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import * as Inputs from "../api/inputs";
+import { textValue } from "../step/values";
+import { TYPE_DEFINITION } from "./constants";
+import { openingsOf } from "./openings";
+import { relatingOf } from "./relationships";
+import { containerOf, storeyFrame } from "./spatial";
+import { alignmentOf, layerSetOf, readWall } from "./wall-geometry";
+import { joinsOf } from "./walls";
+import { firstItem, unwrapClippings } from "./representations";
+const END_OF = {
+    ATSTART: Inputs.IFC.wallEndEnum.start,
+    ATEND: Inputs.IFC.wallEndEnum.end,
+    ATPATH: Inputs.IFC.wallEndEnum.along,
+};
+function globalIdOf(reader, id) {
+    var _a;
+    return (_a = textValue(reader.attribute(id, "GlobalId"))) !== null && _a !== void 0 ? _a : "";
+}
+export function wallParametersOf(reader, wall, tolerance) {
+    var _a, _b, _c;
+    const geometry = readWall(reader, wall);
+    const storey = containerOf(reader, wall);
+    const plan = storey === undefined ? WORLD_AXES : storeyFrame(reader, storey);
+    const inPlan = (point) => {
+        const local = pointToLocal(plan, [point[0], point[1], plan.origin[2]]);
+        return [local[0], local[1]];
+    };
+    const type = relatingOf(reader, TYPE_DEFINITION, wall);
+    return {
+        globalId: globalIdOf(reader, wall),
+        name: (_a = textValue(reader.attribute(wall, "Name"))) !== null && _a !== void 0 ? _a : "",
+        storey: storey === undefined ? "" : globalIdOf(reader, storey),
+        start: inPlan(geometry.start),
+        end: inPlan(geometry.end),
+        height: geometry.height,
+        baseOffset: pointToLocal(plan, pointToWorld(geometry.frame, [0, 0, geometry.base]))[2],
+        thickness: geometry.high - geometry.low,
+        offset: geometry.low,
+        alignment: (_b = alignmentOf(geometry, tolerance)) !== null && _b !== void 0 ? _b : "",
+        layerSet: (_c = textValue(reader.attribute(layerSetOf(reader, geometry), "LayerSetName"))) !== null && _c !== void 0 ? _c : "",
+        wallType: type === undefined ? "" : globalIdOf(reader, type),
+        joins: joinsOf(reader, wall).map((join) => ({ other: globalIdOf(reader, join.other), at: END_OF[join.mine], otherAt: END_OF[join.theirs] })),
+        openings: openingsOf(reader, wall).map((opening) => globalIdOf(reader, opening)),
+        clippings: geometry.body === undefined ? 0 : unwrapClippings(reader, firstItem(reader, geometry.body))[1].length,
+    };
+}

package/lib/build/walls.d.ts

@@ -0,0 +1,12 @@
+import type { Base } from "@bitbybit-dev/base";
+import * as Inputs from "../api/inputs";
+import type { IfcTransaction } from "../model/transaction";
+import type { ModelReader, WallBody, WallEnd, WallGeometry, WallJoin, WallSpec } from "./build-types";
+import type { EntityWriter } from "./entity-writer";
+export declare function offsetFor(alignment: Inputs.IFC.wallAlignmentEnum, thickness: number): number;
+export declare function createWall(tx: IfcTransaction, writer: EntityWriter, spec: WallSpec, tolerance: number): number;
+export declare function joinsOf(reader: ModelReader, wall: number): WallJoin[];
+export declare function regenerateWall(tx: IfcTransaction, writer: EntityWriter, wall: number, tolerance: number, parallelTolerance: number, body?: WallBody): void;
+export declare function stillMeet(a: WallGeometry, aEnd: WallEnd, b: WallGeometry, bEnd: WallEnd, tolerance: number, parallelTolerance: number): boolean;
+export declare function connectWalls(tx: IfcTransaction, writer: EntityWriter, first: number, second: number, tolerance: number, parallelTolerance: number): void;
+export declare function clipWall(tx: IfcTransaction, writer: EntityWriter, wall: number, origin: Base.Point3, normal: Base.Vector3): void;

package/lib/build/walls.js

@@ -0,0 +1,238 @@
+import { WORLD_AXES, pointToLocal, vectorToLocal } from "@bitbybit-dev/base/lib/api/services/helpers/frame-axes";
+import { cross2, length2, subtract2 } from "@bitbybit-dev/base/lib/api/services/helpers/vectors";
+import * as Inputs from "../api/inputs";
+import { enumValue, isEnumeration, isReference, ref } from "../step/values";
+import { WALL_CONNECTION, WALL_ENDS } from "./constants";
+import { axisContext, bodyContext } from "./contexts";
+import { associateNewMaterial, layerSetThickness, layerSetUsage } from "./materials";
+import { distanceToLine, normalize2, parameterOnLine } from "./math";
+import { objectPlacementOf } from "./placement";
+import { containIn, describeObject } from "./spatial";
+import { defineByType } from "./type-objects";
+import { axisLine, buttCut, endPoint, footprintOf, mitreCut, readWall } from "./wall-geometry";
+import { firstItem, replaceRepresentation, unwrapClippings } from "./representations";
+const END_NAMES = { ATSTART: "start", ATEND: "end", ATPATH: "length" };
+export function offsetFor(alignment, thickness) {
+    if (alignment === Inputs.IFC.wallAlignmentEnum.left) {
+        return 0;
+    }
+    return alignment === Inputs.IFC.wallAlignmentEnum.right ? -thickness : -thickness / 2;
+}
+function isWallEnd(value) {
+    return WALL_ENDS.includes(value);
+}
+function clippedBody(writer, solid, halfSpaces) {
+    let item = solid;
+    for (const halfSpace of halfSpaces) {
+        item = writer.clipping(item, halfSpace);
+    }
+    return writer.shapeRepresentation(bodyContext(writer.tx, writer), "Body", halfSpaces.length ? "Clipping" : "SweptSolid", [item]);
+}
+function extrudedBody(writer, footprint, base, height, halfSpaces) {
+    const solid = writer.extrusion(writer.profile({ outer: footprint, holes: [] }), Object.assign(Object.assign({}, WORLD_AXES), { origin: [0, 0, base] }), height);
+    return clippedBody(writer, solid, halfSpaces);
+}
+export function createWall(tx, writer, spec, tolerance) {
+    var _a;
+    const along = subtract2(spec.end, spec.start);
+    const length = length2(along);
+    if (!(length > tolerance)) {
+        throw new Error("A wall's start and end must be apart");
+    }
+    if (!(spec.height > 0)) {
+        throw new Error(`A wall's height must be more than zero, got ${spec.height}`);
+    }
+    const thickness = layerSetThickness(tx, spec.layerSet);
+    if (!(thickness > 0)) {
+        throw new Error("A wall's layers must add up to more than zero thickness");
+    }
+    const direction = normalize2(along);
+    const offset = offsetFor(spec.alignment, thickness);
+    const placement = writer.localPlacement(objectPlacementOf(tx, spec.storey), {
+        origin: [spec.start[0], spec.start[1], spec.baseOffset],
+        x: [direction[0], direction[1], 0],
+        y: [-direction[1], direction[0], 0],
+        z: [0, 0, 1],
+    });
+    const axis = writer.shapeRepresentation(axisContext(tx, writer), "Axis", "Curve2D", [writer.polyCurve2([[0, 0], [length, 0]], false)]);
+    const footprint = [[0, offset], [length, offset], [length, offset + thickness], [0, offset + thickness]];
+    const wall = writer.create("IfcWall", {
+        GlobalId: tx.globalId(spec.id),
+        Name: (_a = spec.name) !== null && _a !== void 0 ? _a : null,
+        ObjectPlacement: ref(placement),
+        Representation: ref(writer.productShape([axis, extrudedBody(writer, footprint, 0, spec.height, [])])),
+        PredefinedType: spec.predefinedType === undefined ? null : enumValue(spec.predefinedType),
+    });
+    containIn(tx, writer, spec.storey, wall);
+    associateNewMaterial(tx, writer, [wall], layerSetUsage(writer, spec.layerSet, "AXIS2", "POSITIVE", offset));
+    if (spec.wallType !== undefined) {
+        defineByType(tx, writer, wall, spec.wallType);
+    }
+    return wall;
+}
+export function joinsOf(reader, wall) {
+    const joins = [];
+    for (const user of reader.referencesTo(wall)) {
+        if (reader.typeOf(user) !== WALL_CONNECTION) {
+            continue;
+        }
+        const relating = reader.attribute(user, "RelatingElement");
+        const related = reader.attribute(user, "RelatedElement");
+        const relatingType = reader.attribute(user, "RelatingConnectionType");
+        const relatedType = reader.attribute(user, "RelatedConnectionType");
+        if (!isReference(relating) || !isReference(related) || !isEnumeration(relatingType) || !isEnumeration(relatedType) || !isWallEnd(relatingType.enum) || !isWallEnd(relatedType.enum)) {
+            continue;
+        }
+        if (relating.ref === wall) {
+            joins.push({ mine: relatingType.enum, other: related.ref, theirs: relatedType.enum, relationship: user });
+        }
+        else if (related.ref === wall) {
+            joins.push({ mine: relatedType.enum, other: relating.ref, theirs: relatingType.enum, relationship: user });
+        }
+    }
+    return joins;
+}
+function cutsOf(reader, geometry, tolerance, parallelTolerance) {
+    let start;
+    let end;
+    for (const { mine, other, theirs } of joinsOf(reader, geometry.wall)) {
+        if (mine === "ATPATH") {
+            continue;
+        }
+        const otherGeometry = readWall(reader, other);
+        const cut = theirs === "ATPATH" ? buttCut(geometry, mine, otherGeometry) : mitreCut(geometry, mine, otherGeometry, theirs, tolerance, parallelTolerance);
+        if (mine === "ATSTART") {
+            start = cut;
+        }
+        else {
+            end = cut;
+        }
+    }
+    return { start, end };
+}
+export function regenerateWall(tx, writer, wall, tolerance, parallelTolerance, body) {
+    var _a;
+    const read = readWall(tx, wall);
+    const geometry = body === undefined ? read : Object.assign(Object.assign({}, read), { height: body.height, base: body.base });
+    const footprint = footprintOf(geometry, cutsOf(tx, geometry, tolerance, parallelTolerance), tolerance, parallelTolerance);
+    const halfSpaces = (_a = body === null || body === void 0 ? void 0 : body.halfSpaces) !== null && _a !== void 0 ? _a : (read.body === undefined ? [] : unwrapClippings(tx, firstItem(tx, read.body))[1]);
+    replaceRepresentation(tx, wall, read.body, extrudedBody(writer, footprint, geometry.base, geometry.height, halfSpaces));
+}
+function overlapHeights(a, b, tolerance) {
+    const bottom = (wall) => wall.frame.origin[2] + wall.base;
+    return bottom(a) < bottom(b) + b.height - tolerance && bottom(b) < bottom(a) + a.height - tolerance;
+}
+function cornerGap(a, aEnd, b, bEnd) {
+    return length2(subtract2(endPoint(a, aEnd), endPoint(b, bEnd)));
+}
+function teeGap(stem, stemEnd, through, reach, tolerance, parallelTolerance) {
+    if (!(Math.abs(cross2(stem.direction, through.direction)) > parallelTolerance)) {
+        return undefined;
+    }
+    const point = endPoint(stem, stemEnd);
+    const across = distanceToLine(point, axisLine(through));
+    const along = parameterOnLine(point, axisLine(through));
+    if (across < through.low - reach || across > through.high + reach || along <= tolerance || along >= through.length - tolerance) {
+        return undefined;
+    }
+    return Math.max(0, through.low - across, across - through.high);
+}
+function reachOf(a, b) {
+    return Math.max(a.high - a.low, b.high - b.low);
+}
+export function stillMeet(a, aEnd, b, bEnd, tolerance, parallelTolerance) {
+    const reach = reachOf(a, b);
+    if (!overlapHeights(a, b, tolerance)) {
+        return false;
+    }
+    if (aEnd === "ATPATH") {
+        return bEnd !== "ATPATH" && teeGap(b, bEnd, a, reach, tolerance, parallelTolerance) !== undefined;
+    }
+    if (bEnd === "ATPATH") {
+        return teeGap(a, aEnd, b, reach, tolerance, parallelTolerance) !== undefined;
+    }
+    return cornerGap(a, aEnd, b, bEnd) <= reach;
+}
+function findMeeting(stem, other, reach, tolerance, parallelTolerance) {
+    let corner;
+    let tee;
+    for (const stemEnd of ["ATSTART", "ATEND"]) {
+        for (const otherEnd of ["ATSTART", "ATEND"]) {
+            const gap = cornerGap(stem, stemEnd, other, otherEnd);
+            if (gap <= reach && (!corner || gap < corner.gap)) {
+                corner = { stemEnd, otherEnd, gap };
+            }
+        }
+        const gap = teeGap(stem, stemEnd, other, reach, tolerance, parallelTolerance);
+        if (gap !== undefined && (!tee || gap < tee.gap)) {
+            tee = { stemEnd, otherEnd: "ATPATH", gap };
+        }
+    }
+    return corner !== null && corner !== void 0 ? corner : tee;
+}
+function refuseJoinedEnd(tx, wall, end, partner) {
+    if (end === "ATPATH") {
+        return;
+    }
+    const taken = joinsOf(tx, wall).find((join) => join.mine === end && join.other !== partner);
+    if (taken) {
+        throw new Error(`The ${END_NAMES[end]} of ${describeObject(tx, wall)} is already joined to ${describeObject(tx, taken.other)}; a wall end joins one other wall`);
+    }
+}
+export function connectWalls(tx, writer, first, second, tolerance, parallelTolerance) {
+    if (first === second) {
+        throw new Error("A wall cannot be joined to itself");
+    }
+    const a = readWall(tx, first);
+    const b = readWall(tx, second);
+    for (const geometry of [a, b]) {
+        if (geometry.body === undefined) {
+            throw new Error(`${describeObject(tx, geometry.wall)} has no Body representation, so its height is unknown and it cannot be joined`);
+        }
+    }
+    if (!overlapHeights(a, b, tolerance)) {
+        throw new Error("The walls do not meet: they stand at heights that do not overlap");
+    }
+    const reach = reachOf(a, b);
+    const forward = findMeeting(a, b, reach, tolerance, parallelTolerance);
+    const backward = findMeeting(b, a, reach, tolerance, parallelTolerance);
+    const useBackward = !forward || (forward.otherEnd === "ATPATH" && backward !== undefined && backward.otherEnd !== "ATPATH");
+    const meeting = useBackward ? backward : forward;
+    if (!meeting) {
+        throw new Error("The walls do not meet: neither ends at the other's end or along its length");
+    }
+    const relating = useBackward ? second : first;
+    const related = useBackward ? first : second;
+    refuseJoinedEnd(tx, relating, meeting.stemEnd, related);
+    refuseJoinedEnd(tx, related, meeting.otherEnd, relating);
+    for (const join of joinsOf(tx, first)) {
+        if (join.other === second) {
+            tx.delete(join.relationship);
+        }
+    }
+    writer.create(WALL_CONNECTION, {
+        GlobalId: tx.globalId(undefined),
+        RelatingElement: ref(relating),
+        RelatedElement: ref(related),
+        RelatingPriorities: [],
+        RelatedPriorities: [],
+        RelatedConnectionType: enumValue(meeting.otherEnd),
+        RelatingConnectionType: enumValue(meeting.stemEnd),
+    });
+    regenerateWall(tx, writer, relating, tolerance, parallelTolerance);
+    if (meeting.otherEnd !== "ATPATH") {
+        regenerateWall(tx, writer, related, tolerance, parallelTolerance);
+    }
+}
+export function clipWall(tx, writer, wall, origin, normal) {
+    const geometry = readWall(tx, wall);
+    if (geometry.body === undefined) {
+        throw new Error(`${describeObject(tx, wall)} has no body to clip`);
+    }
+    if (!(Math.hypot(normal[0], normal[1], normal[2]) > 0)) {
+        throw new Error("A clipping plane needs a normal of some length");
+    }
+    const halfSpace = writer.halfSpace(pointToLocal(geometry.frame, origin), vectorToLocal(geometry.frame, normal), [1, 0, 0]);
+    const [solid, halfSpaces] = unwrapClippings(tx, firstItem(tx, geometry.body));
+    replaceRepresentation(tx, wall, geometry.body, clippedBody(writer, solid, [...halfSpaces, halfSpace]));
+}

package/lib/geometry/advanced.d.ts

@@ -0,0 +1,27 @@
+import type { RefinedSurfaceMesh } from "@bitbybit-dev/base/lib/api/services/helpers/helper-types";
+import type { ModelSnapshot } from "../model/snapshot";
+import type { CurveSampler } from "./curves";
+import type { EdgeSampler } from "./edges";
+export declare class AdvancedFaces {
+    private readonly model;
+    private readonly curves;
+    private readonly edges;
+    private readonly surfaces;
+    constructor(model: ModelSnapshot, curves: CurveSampler, edges: EdgeSampler);
+    face(face: number, bounds: readonly number[]): RefinedSurfaceMesh;
+    private surface;
+    private fitting;
+    private bound;
+    private parameters;
+    private windingOf;
+    private leastWound;
+    private assembled;
+    private shiftedInto;
+    private stitched;
+    private closedAtPole;
+    private across;
+    private oriented;
+    private surfaceNormal;
+    private value;
+}
+export declare function faceBounds(model: ModelSnapshot, face: number): readonly number[];