fluidcad 0.0.13 → 0.0.15

package/lib/dist/features/extrude-base.d.ts

@@ -14,6 +14,7 @@ export declare abstract class ExtrudeBase extends SceneObject implements IExtrud
     protected _drill?: boolean;
     protected _picking: boolean;
     protected _pickPoints: LazyVertex[];
+    protected _thin?: [number] | [number, number];
     constructor(extrudable?: Extrudable);
     get extrudable(): Extrudable;
     startFaces(...args: number[] | FaceFilterBuilder[]): SceneObject;
@@ -35,6 +36,9 @@ export declare abstract class ExtrudeBase extends SceneObject implements IExtrud
     draft(value: number | [number, number]): this;
     endOffset(value: number): this;
     drill(value?: boolean): this;
+    thin(offset1: number, offset2?: number): this;
+    isThin(): boolean;
+    getThinOffsets(): [number] | [number, number] | undefined;
     protected serializePickFields(): {
         picking: true;
         pickPoints: number[][];

package/lib/dist/features/extrude-base.js

@@ -13,6 +13,7 @@ export class ExtrudeBase extends SceneObject {
     _drill = true;
     _picking = false;
     _pickPoints = [];
+    _thin;
     constructor(extrudable) {
         super();
         this._extrudable = extrudable ?? null;
@@ -198,6 +199,16 @@ export class ExtrudeBase extends SceneObject {
         this._drill = value;
         return this;
     }
+    thin(offset1, offset2) {
+        this._thin = offset2 !== undefined ? [offset1, offset2] : [offset1];
+        return this;
+    }
+    isThin() {
+        return this._thin !== undefined;
+    }
+    getThinOffsets() {
+        return this._thin;
+    }
     serializePickFields() {
         const plane = this._extrudable?.getPlane();
         return {
@@ -307,6 +318,7 @@ export class ExtrudeBase extends SceneObject {
         this._symmetric = other._symmetric;
         this._picking = other._picking;
         this._pickPoints = other._pickPoints;
+        this._thin = other._thin;
         return this;
     }
     compareTo(other) {
@@ -328,6 +340,21 @@ export class ExtrudeBase extends SceneObject {
                 return false;
             }
         }
+        const thisThin = this._thin;
+        const otherThin = other._thin;
+        if ((thisThin === undefined) !== (otherThin === undefined)) {
+            return false;
+        }
+        if (thisThin && otherThin) {
+            if (thisThin.length !== otherThin.length) {
+                return false;
+            }
+            for (let i = 0; i < thisThin.length; i++) {
+                if (thisThin[i] !== otherThin[i]) {
+                    return false;
+                }
+            }
+        }
         let thisDraft = this._draft || [0, 0];
         let otherDraft = other._draft || [0, 0];
         thisDraft = this._draft instanceof Array ? this._draft : [this._draft, this._draft];

package/lib/dist/features/extrude-to-face.d.ts

@@ -39,5 +39,6 @@ export declare class ExtrudeToFace extends ExtrudeBase {
         draft: [number, number];
         endOffset: number;
         face: string;
+        thin: [number, number] | [number];
     };
 }

package/lib/dist/features/extrude-to-face.js

@@ -9,6 +9,7 @@ import { BooleanOps } from "../oc/boolean-ops.js";
 import { ShapeOps } from "../oc/shape-ops.js";
 import { Explorer } from "../oc/explorer.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
+import { ThinFaceMaker } from "../oc/thin-face-maker.js";
 import { Point } from "../math/point.js";
 export class ExtrudeToFace extends ExtrudeBase {
     face;
@@ -31,7 +32,9 @@ export class ExtrudeToFace extends ExtrudeBase {
         const allEndFaces = [];
         const allSideFaces = [];
         const allInternalFaces = [];
-        const faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane);
+        const faces = this.isThin()
+            ? ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1])
+            : pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane);
         for (const startFace of faces) {
             if (isPlanar && FaceQuery.areFacePlanesParallel(startFace, targetFace)) {
                 const { shapes, extruder } = this.createSimpleExtrude(startFace, targetFace, plane);
@@ -269,6 +272,7 @@ export class ExtrudeToFace extends ExtrudeBase {
             draft: this.getDraft(),
             endOffset: this.getEndOffset(),
             face: typeof (this.face) === 'string' ? this.face : 'selection',
+            thin: this._thin,
             ...this.serializePickFields(),
         };
     }

package/lib/dist/features/extrude-two-distances.d.ts

@@ -24,5 +24,6 @@ export declare class ExtrudeTwoDistances extends ExtrudeBase {
         distance1: number;
         distance2: number;
         operationMode: "new" | "remove";
+        thin: [number, number] | [number];
     };
 }

package/lib/dist/features/extrude-two-distances.js

@@ -4,6 +4,7 @@ import { BooleanOps } from "../oc/boolean-ops.js";
 import { Explorer } from "../oc/explorer.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
 import { Extruder } from "./simple-extruder.js";
+import { ThinFaceMaker } from "../oc/thin-face-maker.js";
 export class ExtrudeTwoDistances extends ExtrudeBase {
     distance1;
     distance2;
@@ -19,8 +20,9 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
         if (pickedFaces !== null && pickedFaces.length === 0) {
             return;
         }
-        const faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
-        console.log("Extruding faces:", faces);
+        const faces = this.isThin()
+            ? ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1])
+            : pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
         const extruder1 = new Extruder(faces, plane, this.distance1, this.getDraft(), this.getEndOffset());
         const extrusions1 = extruder1.extrude();
         const startFaces = extruder1.getEndFaces();
@@ -110,6 +112,7 @@ export class ExtrudeTwoDistances extends ExtrudeBase {
             distance1: this.distance1,
             distance2: this.distance2,
             operationMode: this._operationMode !== 'add' ? this._operationMode : undefined,
+            thin: this._thin,
             ...this.serializePickFields(),
         };
     }

package/lib/dist/features/extrude.d.ts

@@ -28,5 +28,6 @@ export declare class Extrude extends ExtrudeBase {
         symmetric: true;
         draft: [number, number];
         endOffset: number;
+        thin: [number, number] | [number];
     };
 }

package/lib/dist/features/extrude.js

@@ -5,6 +5,7 @@ import { FaceMaker2 } from "../oc/face-maker2.js";
 import { BooleanOps } from "../oc/boolean-ops.js";
 import { Explorer } from "../oc/explorer.js";
 import { ExtrudeThroughAll } from "./infinite-extrude.js";
+import { ThinFaceMaker } from "../oc/thin-face-maker.js";
 export class Extrude extends ExtrudeBase {
     distance;
     constructor(distance, extrudable) {
@@ -17,7 +18,9 @@ export class Extrude extends ExtrudeBase {
         if (pickedFaces !== null && pickedFaces.length === 0) {
             return;
         }
-        const faces = pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
+        const faces = this.isThin()
+            ? ThinFaceMaker.make(this.extrudable.getGeometries(), plane, this._thin[0], this._thin[1])
+            : pickedFaces ?? FaceMaker2.getRegions(this.extrudable.getGeometries(), plane, this.getDrill());
         if (this._operationMode === 'remove') {
             this.buildRemove(faces, plane, context);
         }
@@ -176,6 +179,7 @@ export class Extrude extends ExtrudeBase {
             symmetric: this._symmetric || undefined,
             draft: this.getDraft(),
             endOffset: this.getEndOffset(),
+            thin: this._thin,
             ...this.serializePickFields(),
         };
     }

package/lib/dist/features/plane-renderable-base.d.ts

@@ -1,9 +1,10 @@
 import { Plane } from "../math/plane.js";
 import { SceneObject } from "../common/scene-object.js";
 import { IPlane } from "../core/interfaces.js";
+import { Point } from "../math/point.js";
 export declare abstract class PlaneObjectBase extends SceneObject implements IPlane {
     constructor();
     getPlane(): Plane;
-    getPlaneCenter(): any;
+    getPlaneCenter(): Point;
     getType(): string;
 }

package/lib/dist/features/plane-renderable-base.js

@@ -7,7 +7,7 @@ export class PlaneObjectBase extends SceneObject {
         return this.getState('plane');
     }
     getPlaneCenter() {
-        return this.getState('plane-center') || this.getPlane().origin;
+        return (this.getState('plane-center') || this.getPlane().origin);
     }
     getType() {
         return 'plane';

package/lib/dist/features/plane.d.ts

@@ -15,7 +15,7 @@ export declare class PlaneObject extends PlaneObjectBase {
         xDirection: import("../math/vector3d.js").Vector3d;
         yDirection: import("../math/vector3d.js").Vector3d;
         normal: import("../math/vector3d.js").Vector3d;
-        center: any;
+        center: import("../math/point.js").Point;
         options: PlaneRenderableOptions;
     };
 }

package/lib/dist/filters/face/face-filter.d.ts

@@ -80,6 +80,16 @@ export declare class FaceFilterBuilder extends FilterBuilderBase<Face> {
      * Excludes conical faces.
      */
     notCone(): this;
+    /**
+     * Selects faces that intersect with the given plane.
+     * @param plane - The reference plane to test intersection against.
+     */
+    intersectsWith(plane: PlaneLike | PlaneObjectBase): this;
+    /**
+     * Excludes faces that intersect with the given plane.
+     * @param plane - The reference plane to test intersection against.
+     */
+    notIntersectsWith(plane: PlaneLike | PlaneObjectBase): this;
     /**
      * Selects faces that share an edge with the given scene object.
      * @param sceneObject - A scene object whose edges are matched against.

package/lib/dist/filters/face/face-filter.js

@@ -12,6 +12,7 @@ import { AtIndexFilter, NotAtIndexFilter } from "./at-index.js";
 import { HasEdgeFilter, NotHasEdgeFilter } from "./has-edge.js";
 import { HasEdgeFromSceneObjectFilter, NotHasEdgeFromSceneObjectFilter } from "./has-object.js";
 import { EdgeCountFilter, NotEdgeCountFilter } from "./edge-count.js";
+import { IntersectsWithFilter, NotIntersectsWithFilter } from "./intersects-with.js";
 import { SceneObject } from "../../common/scene-object.js";
 export class FaceFilterBuilder extends FilterBuilderBase {
     constructor() {
@@ -195,6 +196,44 @@ export class FaceFilterBuilder extends FilterBuilderBase {
         this.filters.push(filter);
         return this;
     }
+    /**
+     * Selects faces that intersect with the given plane.
+     * @param plane - The reference plane to test intersection against.
+     */
+    intersectsWith(plane) {
+        if (!plane) {
+            throw new Error('Plane is required');
+        }
+        let planeObj;
+        if (plane instanceof PlaneObjectBase) {
+            planeObj = plane;
+        }
+        else {
+            planeObj = new PlaneObject(normalizePlane(plane));
+        }
+        const filter = new IntersectsWithFilter(planeObj);
+        this.filters.push(filter);
+        return this;
+    }
+    /**
+     * Excludes faces that intersect with the given plane.
+     * @param plane - The reference plane to test intersection against.
+     */
+    notIntersectsWith(plane) {
+        if (!plane) {
+            throw new Error('Plane is required');
+        }
+        let planeObj;
+        if (plane instanceof PlaneObjectBase) {
+            planeObj = plane;
+        }
+        else {
+            planeObj = new PlaneObject(normalizePlane(plane));
+        }
+        const filter = new NotIntersectsWithFilter(planeObj);
+        this.filters.push(filter);
+        return this;
+    }
     hasEdge(...args) {
         const filterBuilders = [];
         for (const arg of args) {

package/lib/dist/filters/face/intersects-with.d.ts

@@ -0,0 +1,18 @@
+import { Matrix4 } from "../../math/matrix4.js";
+import { Face } from "../../common/shapes.js";
+import { FilterBase } from "../filter-base.js";
+import { PlaneObjectBase } from "../../features/plane-renderable-base.js";
+export declare class IntersectsWithFilter extends FilterBase<Face> {
+    private plane;
+    constructor(plane: PlaneObjectBase);
+    match(shape: Face): boolean;
+    compareTo(other: IntersectsWithFilter): boolean;
+    transform(matrix: Matrix4): IntersectsWithFilter;
+}
+export declare class NotIntersectsWithFilter extends FilterBase<Face> {
+    private plane;
+    constructor(plane: PlaneObjectBase);
+    match(shape: Face): boolean;
+    compareTo(other: NotIntersectsWithFilter): boolean;
+    transform(matrix: Matrix4): NotIntersectsWithFilter;
+}

package/lib/dist/filters/face/intersects-with.js

@@ -0,0 +1,41 @@
+import { FilterBase } from "../filter-base.js";
+import { FaceQuery } from "../../oc/face-query.js";
+import { PlaneObject } from "../../features/plane.js";
+export class IntersectsWithFilter extends FilterBase {
+    plane;
+    constructor(plane) {
+        super();
+        this.plane = plane;
+    }
+    match(shape) {
+        const plane = this.plane.getPlane();
+        return FaceQuery.doesFaceIntersectPlane(shape, plane);
+    }
+    compareTo(other) {
+        return this.plane.compareTo(other.plane);
+    }
+    transform(matrix) {
+        const plane = this.plane.getPlane();
+        const planeObj = new PlaneObject(plane.applyMatrix(matrix));
+        return new IntersectsWithFilter(planeObj);
+    }
+}
+export class NotIntersectsWithFilter extends FilterBase {
+    plane;
+    constructor(plane) {
+        super();
+        this.plane = plane;
+    }
+    match(shape) {
+        const plane = this.plane.getPlane();
+        return !FaceQuery.doesFaceIntersectPlane(shape, plane);
+    }
+    compareTo(other) {
+        return this.plane.compareTo(other.plane);
+    }
+    transform(matrix) {
+        const plane = this.plane.getPlane();
+        const planeObj = new PlaneObject(plane.applyMatrix(matrix));
+        return new NotIntersectsWithFilter(planeObj);
+    }
+}

package/lib/dist/helpers/clone-transform.js

@@ -33,6 +33,7 @@ export function cloneWithTransform(objects, transform, container) {
         const copy = obj.createCopy(remap);
         remap.set(obj, copy);
         copy.setTransform(transform);
+        copy.setCloneSource(obj);
         allCloned.push(copy);
         const parent = obj.getParent();
         if (parent && remap.has(parent)) {

package/lib/dist/oc/boolean-ops.js

@@ -137,7 +137,6 @@ export class BooleanOps {
         builder.Build(progress);
         builder.SimplifyResult(false, true, oc.Precision.Angular());
         const resultShape = builder.Shape();
-        console.log('FuseMultiShape: Result shape type:', Explorer.getShapeType(resultShape));
         const rawShapes = Explorer.findAllShapes(resultShape);
         console.log('FuseMultiShape: Result shapes count:', rawShapes.length);
         const result = rawShapes.map(s => ShapeFactory.fromShape(s));
@@ -175,7 +174,6 @@ export class BooleanOps {
         const progress = new oc.Message_ProgressRange();
         builder.Build(progress);
         const resultShape = builder.Shape();
-        console.log('FuseMultiShape: Result shape type:', Explorer.getShapeType(resultShape));
         const unify = new oc.ShapeUpgrade_UnifySameDomain(resultShape, true, true, false);
         unify.Build();
         const mergedShape = unify.Shape();

package/lib/dist/oc/face-query.d.ts

@@ -9,6 +9,7 @@ export declare class FaceQuery {
     static isCylinderFace(face: Shape, diameter?: number): boolean;
     static isCylinderCurveFace(face: Shape, diameter?: number): boolean;
     static isFaceOnPlane(face: Shape, plane: Plane): boolean;
+    static doesFaceIntersectPlane(face: Shape, plane: Plane): boolean;
     static isFaceParallelToPlane(face: Shape, plane: Plane): boolean;
     static isPlanarFace(face: Shape): boolean;
     static getSurfaceType(face: Shape): string;

package/lib/dist/oc/face-query.js

@@ -23,6 +23,21 @@ export class FaceQuery {
         dispose();
         return result;
     }
+    static doesFaceIntersectPlane(face, plane) {
+        const oc = getOC();
+        const [gpPln, dispose] = Convert.toGpPln(plane);
+        const planeFace = FaceOps.makeFaceFromPlane(gpPln);
+        const tool = new oc.IntTools_FaceFace();
+        tool.Perform(oc.TopoDS.Face(face.getShape()), planeFace, false);
+        let result = false;
+        if (tool.IsDone()) {
+            result = tool.Lines().Length() > 0 || tool.Points().Length() > 0;
+        }
+        tool.delete();
+        planeFace.delete();
+        dispose();
+        return result;
+    }
     static isFaceParallelToPlane(face, plane) {
         const [gpPln, dispose] = Convert.toGpPln(plane);
         const result = FaceQuery.isFaceParallelToPlaneRaw(face.getShape(), gpPln);

package/lib/dist/oc/index.d.ts

@@ -21,4 +21,5 @@ export type { MeshData } from "./mesh.js";
 export { OcIO } from "./io.js";
 export { ShapeProps } from './props.js';
 export { SweepOps } from "./sweep-ops.js";
+export { SectionOps } from "./section-ops.js";
 export type { ShapeProperties } from './props.js';

package/lib/dist/oc/index.js

@@ -19,3 +19,4 @@ export { Mesh } from "./mesh.js";
 export { OcIO } from "./io.js";
 export { ShapeProps } from './props.js';
 export { SweepOps } from "./sweep-ops.js";
+export { SectionOps } from "./section-ops.js";

package/lib/dist/oc/section-ops.d.ts

@@ -0,0 +1,6 @@
+import { Plane } from "../math/plane.js";
+import { Shape } from "../common/shape.js";
+import { Edge } from "../common/edge.js";
+export declare class SectionOps {
+    static sectionShapeWithPlane(plane: Plane, shape: Shape): Edge[];
+}

package/lib/dist/oc/section-ops.js

@@ -0,0 +1,26 @@
+import { getOC } from "./init.js";
+import { Convert } from "./convert.js";
+import { Explorer } from "./explorer.js";
+import { Edge } from "../common/edge.js";
+export class SectionOps {
+    static sectionShapeWithPlane(plane, shape) {
+        const oc = getOC();
+        const [pln, disposePln] = Convert.toGpPln(plane);
+        const progress = new oc.Message_ProgressRange();
+        const section = new oc.BRepAlgoAPI_Section(shape.getShape(), pln, false);
+        section.Build(progress);
+        if (!section.IsDone()) {
+            section.delete();
+            progress.delete();
+            disposePln();
+            return [];
+        }
+        const result = section.Shape();
+        const rawEdges = Explorer.findShapes(result, oc.TopAbs_ShapeEnum.TopAbs_EDGE);
+        const edges = rawEdges.map(e => Edge.fromTopoDSEdge(Explorer.toEdge(e)));
+        section.delete();
+        progress.delete();
+        disposePln();
+        return edges;
+    }
+}

package/lib/dist/oc/thin-face-maker.d.ts

@@ -0,0 +1,29 @@
+import { Edge } from "../common/edge.js";
+import { Face } from "../common/face.js";
+import { Wire } from "../common/wire.js";
+import { Plane } from "../math/plane.js";
+export declare class ThinFaceMaker {
+    static make(edges: (Wire | Edge)[], plane: Plane, offset1: number, offset2?: number): Face[];
+    private static makeSingleOffsetFace;
+    private static makeDualOffsetFace;
+    /**
+     * Offsets a wire by the given distance, handling both closed and open wires.
+     * For closed wires, WireOps.offsetWire handles negative distances natively.
+     * For open wires, negative distances are handled by reversing the wire,
+     * offsetting with the absolute value, then reversing back.
+     */
+    private static doOffset;
+    /**
+     * Offsets an open wire on a given plane, using a planar face as reference
+     * so that BRepOffsetAPI_MakeOffset knows the offset direction.
+     * Only handles positive distances — use doOffset for sign handling.
+     */
+    private static offsetWireOnPlane;
+    private static makeLineEdge;
+    /**
+     * Creates a closed face from two open wires by capping the ends with straight lines.
+     * wire1 goes A->B, wire2 goes C->D.
+     * Result: A->B (wire1) + B->D (cap) + D->C (reversed wire2) + C->A (cap)
+     */
+    private static makeOpenFaceWithCaps;
+}

package/lib/dist/oc/thin-face-maker.js

@@ -0,0 +1,163 @@
+import { Edge } from "../common/edge.js";
+import { Face } from "../common/face.js";
+import { Wire } from "../common/wire.js";
+import { WireOps } from "./wire-ops.js";
+import { FaceOps } from "./face-ops.js";
+import { Explorer } from "./explorer.js";
+import { Convert } from "./convert.js";
+import { getOC } from "./init.js";
+export class ThinFaceMaker {
+    static make(edges, plane, offset1, offset2) {
+        const edgesOnly = [];
+        for (const shape of edges) {
+            if (shape instanceof Wire) {
+                for (const edge of shape.getEdges()) {
+                    edgesOnly.push(edge);
+                }
+            }
+            else {
+                edgesOnly.push(shape);
+            }
+        }
+        const groups = WireOps.groupConnectedEdges(edgesOnly);
+        const faces = [];
+        for (const group of groups) {
+            const wire = WireOps.makeWireFromEdges(group);
+            const isClosed = wire.isClosed();
+            if (offset2 !== undefined) {
+                faces.push(this.makeDualOffsetFace(wire, isClosed, plane, offset1, offset2));
+            }
+            else {
+                faces.push(this.makeSingleOffsetFace(wire, isClosed, plane, offset1));
+            }
+        }
+        return faces;
+    }
+    static makeSingleOffsetFace(wire, isClosed, plane, offset) {
+        const offsetWire = this.doOffset(wire, plane, offset, isClosed);
+        if (isClosed) {
+            // Determine which wire is outer (larger) vs inner based on offset sign
+            const [outer, inner] = offset >= 0
+                ? [offsetWire, wire]
+                : [wire, offsetWire];
+            const reversedInner = WireOps.reverseWire(inner);
+            return Face.fromTopoDSFace(FaceOps.makeFaceFromWires([
+                outer.getShape(),
+                reversedInner.getShape(),
+            ]));
+        }
+        return this.makeOpenFaceWithCaps(wire, offsetWire);
+    }
+    static makeDualOffsetFace(wire, isClosed, plane, offset1, offset2) {
+        // Ensure offset2 goes in the opposite direction of offset1
+        if (Math.sign(offset1) === Math.sign(offset2)) {
+            offset2 = -offset2;
+        }
+        const wire1 = this.doOffset(wire, plane, offset1, isClosed);
+        const wire2 = this.doOffset(wire, plane, offset2, isClosed);
+        if (isClosed) {
+            // The wire with the larger offset is the outer boundary
+            const [outer, inner] = offset1 >= offset2
+                ? [wire1, wire2]
+                : [wire2, wire1];
+            const reversedInner = WireOps.reverseWire(inner);
+            return Face.fromTopoDSFace(FaceOps.makeFaceFromWires([
+                outer.getShape(),
+                reversedInner.getShape(),
+            ]));
+        }
+        return this.makeOpenFaceWithCaps(wire1, wire2);
+    }
+    /**
+     * Offsets a wire by the given distance, handling both closed and open wires.
+     * For closed wires, WireOps.offsetWire handles negative distances natively.
+     * For open wires, negative distances are handled by reversing the wire,
+     * offsetting with the absolute value, then reversing back.
+     */
+    static doOffset(wire, plane, distance, isClosed) {
+        if (isClosed) {
+            return WireOps.offsetWire(wire, distance, false);
+        }
+        if (distance < 0) {
+            const reversed = WireOps.reverseWire(wire);
+            const offsetResult = this.offsetWireOnPlane(reversed, plane, -distance, true);
+            return WireOps.reverseWire(offsetResult);
+        }
+        return this.offsetWireOnPlane(wire, plane, distance, true);
+    }
+    /**
+     * Offsets an open wire on a given plane, using a planar face as reference
+     * so that BRepOffsetAPI_MakeOffset knows the offset direction.
+     * Only handles positive distances — use doOffset for sign handling.
+     */
+    static offsetWireOnPlane(wire, plane, distance, isOpen) {
+        const oc = getOC();
+        const [pln, disposePlane] = Convert.toGpPln(plane);
+        const faceMaker = new oc.BRepBuilderAPI_MakeFace(pln);
+        if (!faceMaker.IsDone()) {
+            faceMaker.delete();
+            disposePlane();
+            throw new Error("Failed to create reference face for thin offset");
+        }
+        const face = faceMaker.Face();
+        faceMaker.delete();
+        disposePlane();
+        const maker = new oc.BRepOffsetAPI_MakeOffset();
+        maker.Init(face, oc.GeomAbs_JoinType.GeomAbs_Arc, isOpen);
+        maker.AddWire(wire.getShape());
+        maker.Perform(distance, 0);
+        if (!maker.IsDone()) {
+            maker.delete();
+            throw new Error("Failed to offset wire for thin extrude");
+        }
+        const result = maker.Shape();
+        maker.delete();
+        if (Explorer.isWire(result)) {
+            return Wire.fromTopoDSWire(oc.TopoDS.Wire(result));
+        }
+        const wires = Explorer.findShapes(result, oc.TopAbs_ShapeEnum.TopAbs_WIRE);
+        if (wires.length === 0) {
+            throw new Error("Thin offset produced no usable wire");
+        }
+        return Wire.fromTopoDSWire(oc.TopoDS.Wire(wires[0]));
+    }
+    static makeLineEdge(p1, p2) {
+        const oc = getOC();
+        const [gp1, dispose1] = Convert.toGpPnt(p1);
+        const [gp2, dispose2] = Convert.toGpPnt(p2);
+        const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(gp1, gp2);
+        if (!edgeMaker.IsDone()) {
+            edgeMaker.delete();
+            dispose1();
+            dispose2();
+            throw new Error("Failed to create cap edge for thin extrude");
+        }
+        const edge = edgeMaker.Edge();
+        edgeMaker.delete();
+        dispose1();
+        dispose2();
+        return Edge.fromTopoDSEdge(edge);
+    }
+    /**
+     * Creates a closed face from two open wires by capping the ends with straight lines.
+     * wire1 goes A->B, wire2 goes C->D.
+     * Result: A->B (wire1) + B->D (cap) + D->C (reversed wire2) + C->A (cap)
+     */
+    static makeOpenFaceWithCaps(wire1, wire2) {
+        const wire1End = wire1.getLastVertex().toPoint();
+        const wire2Start = wire2.getFirstVertex().toPoint();
+        const wire2End = wire2.getLastVertex().toPoint();
+        const wire1Start = wire1.getFirstVertex().toPoint();
+        const cap1 = this.makeLineEdge(wire1End, wire2End);
+        const cap2 = this.makeLineEdge(wire2Start, wire1Start);
+        const reversedWire2 = WireOps.reverseWire(wire2);
+        const allEdges = [
+            ...wire1.getEdges(),
+            cap1,
+            ...reversedWire2.getEdges(),
+            cap2,
+        ];
+        const closedWire = WireOps.makeWireFromEdges(allEdges);
+        return Face.fromTopoDSFace(FaceOps.makeFaceFromWires([closedWire.getShape()]));
+    }
+}