fluidcad 0.0.36 → 0.0.38

package/lib/dist/common/transformable-primitive.js

@@ -3,12 +3,39 @@ import { Matrix4 } from "../math/matrix4.js";
 import { Point } from "../math/point.js";
 import { Vector3d } from "../math/vector3d.js";
 import { rad } from "../helpers/math-helpers.js";
+import { ShapeOps } from "../oc/shape-ops.js";
 import { isNumberParam, resolveParam } from "../core/param.js";
 export class TransformablePrimitive extends SceneObject {
     transform(matrix) {
         this.composeAppliedTransform(matrix);
         return this;
     }
+    /**
+     * Adds a primitive's built shape, baking in the clone transform when this
+     * primitive is a repeat/mirror copy. The renderer post-applies the user's
+     * own transform (translate/rotate/mirror) after build, so the clone
+     * transform is conjugated to land outside it:
+     * own · (own⁻¹ · clone · own) = clone · own.
+     */
+    addPrimitiveShape(shape, context) {
+        const cloneTransform = context?.getTransform() ?? null;
+        if (cloneTransform) {
+            const own = this.getAppliedTransform();
+            const matrix = own
+                ? own.inverse().multiply(cloneTransform).multiply(own)
+                : cloneTransform;
+            shape = ShapeOps.transform(shape, matrix);
+        }
+        this.addShape(shape);
+    }
+    /** Carries the user's own transform onto a repeat/mirror copy. */
+    syncPrimitiveWith(source) {
+        const applied = source.getAppliedTransform();
+        if (applied) {
+            this.transform(applied);
+        }
+        return this;
+    }
     translate(a, b, c) {
         let x, y, z;
         if (isNumberParam(a)) {

package/lib/dist/common/vertex.d.ts

@@ -1,4 +1,4 @@
-import type { TopoDS_Vertex } from "occjs-wrapper";
+import type { TopoDS_Vertex } from "ocjs-fluidcad";
 import { ShapeType } from "./shape-type.js";
 import { Shape } from "./shape.js";
 import { Point, Point2D } from "../math/point.js";

package/lib/dist/common/wire.d.ts

@@ -1,4 +1,4 @@
-import type { TopoDS_Wire } from "occjs-wrapper";
+import type { TopoDS_Wire } from "ocjs-fluidcad";
 import { ShapeType } from "./shape-type.js";
 import { Shape } from "./shape.js";
 import { Vector3d } from "../math/vector3d.js";

package/lib/dist/core/2d/index.d.ts

@@ -21,5 +21,6 @@ export { default as offset } from './offset.js';
 export { default as project } from './project.js';
 export { default as intersect } from './intersect.js';
 export { default as bezier } from './bezier.js';
+export { default as text } from './text.js';
 export { default as center } from './center.js';
 export { default as back } from './back.js';

package/lib/dist/core/2d/index.js

@@ -21,5 +21,6 @@ export { default as offset } from './offset.js';
 export { default as project } from './project.js';
 export { default as intersect } from './intersect.js';
 export { default as bezier } from './bezier.js';
+export { default as text } from './text.js';
 export { default as center } from './center.js';
 export { default as back } from './back.js';

package/lib/dist/core/2d/text.d.ts

@@ -0,0 +1,30 @@
+import { PlaneLike } from "../../math/plane.js";
+import { IText, ISceneObject } from "../interfaces.js";
+interface TextFunction {
+    /**
+     * Renders a text string as extrudable outline geometry inside the current
+     * sketch, at the sketch cursor.
+     * @param text - The string to render.
+     */
+    (text: string): IText;
+    /**
+     * Renders a text string on a specific plane (standalone, outside a sketch).
+     * @param plane - The plane (e.g. "xy") or face to render the text on.
+     * @param text - The string to render.
+     */
+    (plane: PlaneLike | ISceneObject, text: string): IText;
+    /**
+     * Renders a text string following a planar curve. Each glyph is placed
+     * upright along the path's arc length; the text plane is the path's plane.
+     * Works inside a sketch (following a curve of that sketch) or standalone.
+     * The path is left in place — mark it `.guide()` to keep it out of
+     * extruded profiles.
+     * @param text - The string to render.
+     * @param path - The curve to follow: a sketch curve (line/arc/circle), a
+     *   whole sketch, a planar primitive, or a selected edge/edge loop
+     *   (e.g. `select(edge().circle())`).
+     */
+    (text: string, path: ISceneObject): IText;
+}
+declare const _default: TextFunction;
+export default _default;

package/lib/dist/core/2d/text.js

@@ -0,0 +1,37 @@
+import { Text } from "../../features/2d/text.js";
+import { registerBuilder } from "../../index.js";
+import { isPlaneLike } from "../../math/plane.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { resolvePlane } from "../../helpers/resolve.js";
+function build(context) {
+    return function text() {
+        const first = arguments[0];
+        const second = arguments[1];
+        // A trailing scene object is a path to follow: `text("Hi", path)`.
+        // Valid both standalone and inside a sketch (following a sketch curve).
+        if (arguments.length >= 2 && second instanceof SceneObject) {
+            if (typeof first !== "string") {
+                throw new Error("text: when following a path, the first argument must be the text string.");
+            }
+            const obj = new Text(first, null, second);
+            context.addSceneObject(obj);
+            return obj;
+        }
+        // A leading plane/face is only valid standalone and only when a string
+        // follows it; `text("xy")` (one arg) renders the literal string "xy".
+        const standalone = arguments.length >= 2 && (isPlaneLike(first) || first instanceof SceneObject);
+        if (standalone) {
+            if (context.getActiveSketch() !== null) {
+                throw new Error("text(plane, ...) cannot be used inside a sketch. Use text(...) instead.");
+            }
+            const planeObj = resolvePlane(first, context);
+            const obj = new Text(String(arguments[1] ?? ""), planeObj);
+            context.addSceneObject(obj);
+            return obj;
+        }
+        const obj = new Text(String(first ?? ""));
+        context.addSceneObject(obj);
+        return obj;
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/helix.d.ts

@@ -0,0 +1,20 @@
+import { AxisLike } from "../math/axis.js";
+import { IHelix, ISceneObject } from "./interfaces.js";
+interface HelixFunction {
+    /**
+     * Creates a helix wire along the given axis. Use chained methods (.pitch(),
+     * .turns(), .height(), .radius(), .endRadius()) to configure geometry.
+     * @param axis - The axis to build the helix around.
+     */
+    (axis: AxisLike): IHelix;
+    /**
+     * Creates a helix wire derived from a scene object's geometry.
+     * - A cylindrical or conical face: axis + radii + height come from the face.
+     * - A line edge: axis = the line, height = line length.
+     * - A circular edge: axis = circle normal at center, radius = circle radius.
+     * @param source - The scene object whose face/edge defines the helix.
+     */
+    (source: ISceneObject): IHelix;
+}
+declare const _default: HelixFunction;
+export default _default;

package/lib/dist/core/helix.js

@@ -0,0 +1,36 @@
+import { registerBuilder } from "../index.js";
+import { Helix } from "../features/helix.js";
+import { isAxisLike } from "../math/axis.js";
+import { AxisObject } from "../features/axis.js";
+import { AxisObjectBase } from "../features/axis-renderable-base.js";
+import { SceneObject } from "../common/scene-object.js";
+import { normalizeAxis } from "../helpers/normalize.js";
+function build(context) {
+    return function helix() {
+        if (arguments.length === 0) {
+            throw new Error("helix() requires an axis or scene object argument.");
+        }
+        const arg = arguments[0];
+        let source;
+        if (arg instanceof AxisObjectBase) {
+            source = arg;
+            context.addSceneObject(source);
+        }
+        else if (isAxisLike(arg)) {
+            const axis = normalizeAxis(arg);
+            source = new AxisObject(axis);
+            context.addSceneObject(source);
+        }
+        else if (arg instanceof SceneObject) {
+            source = arg;
+            context.addSceneObject(source);
+        }
+        else {
+            throw new Error("helix(): first argument must be an AxisLike or SceneObject.");
+        }
+        const result = new Helix(source);
+        context.addSceneObject(result);
+        return result;
+    };
+}
+export default registerBuilder(build);

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

@@ -1,4 +1,4 @@
-export type { ISceneObject, ITransformable, IBooleanOperation, IPlane, IAxis, ISelect, IGeometry, IExtrudableGeometry, IRect, ISlot, IPolygon, ITwoObjectsTangentLine, ITangentArcTwoObjects, IExtrude, ICut, ICommon, ISweep, ILoft, IRevolve, IDraft, IRib } from "./interfaces.js";
+export type { ISceneObject, ITransformable, IBooleanOperation, IPlane, IAxis, ISelect, IGeometry, IExtrudableGeometry, IText, IRect, ISlot, IPolygon, ITwoObjectsTangentLine, ITangentArcTwoObjects, IExtrude, ICut, ICommon, ISweep, ILoft, IRevolve, IDraft, IRib, IHelix, IWrap } from "./interfaces.js";
 export { default as axis } from "./axis.js";
 export { default as local } from "./local.js";
 export { default as plane } from "./plane.js";
@@ -24,6 +24,8 @@ export { default as load } from "./load.js";
 export { default as loft } from "./loft.js";
 export { default as sweep } from "./sweep.js";
 export { default as rib } from "./rib.js";
+export { default as wrap } from "./wrap.js";
+export { default as helix } from "./helix.js";
 export { default as color } from "./color.js";
 export { default as draft } from "./draft.js";
 export { default as remove } from "./remove.js";

package/lib/dist/core/index.js

@@ -23,6 +23,8 @@ export { default as load } from "./load.js";
 export { default as loft } from "./loft.js";
 export { default as sweep } from "./sweep.js";
 export { default as rib } from "./rib.js";
+export { default as wrap } from "./wrap.js";
+export { default as helix } from "./helix.js";
 export { default as color } from "./color.js";
 export { default as draft } from "./draft.js";
 export { default as remove } from "./remove.js";

package/lib/dist/core/interfaces.d.ts

@@ -144,6 +144,82 @@ export interface IGeometry extends ISceneObject {
 }
 export interface IExtrudableGeometry extends IGeometry {
 }
+export interface IText extends IExtrudableGeometry {
+    /**
+     * Sets the text height (em size) in model units. Default 10.
+     * @param value - The em size.
+     */
+    size(value: number): this;
+    /**
+     * Sets the font. A name without a font extension (e.g. `"Arial"`) is resolved
+     * to a system font; a value ending in `.ttf`/`.otf`/`.ttc`/`.woff` (e.g.
+     * `"fonts/Brand.ttf"`) is loaded as a workspace-relative file. When omitted, a
+     * default system font is used.
+     * @param name - A system family name or a workspace-relative font file path.
+     */
+    font(name: string): this;
+    /**
+     * Sets the font weight: a number (100–900) or a name such as `"regular"`,
+     * `"medium"`, or `"bold"`. Resolves to the matching face (or the wght axis of a
+     * variable font).
+     * @param value - The weight as a number or name.
+     */
+    weight(value: number | string): this;
+    /**
+     * Shortcut for `weight(700)`.
+     */
+    bold(): this;
+    /**
+     * Renders the italic/oblique face of the font.
+     * @param value - Whether to use italic (defaults to true).
+     */
+    italic(value?: boolean): this;
+    /**
+     * Horizontal alignment of the text. For straight text it is relative to the
+     * origin point; for text along a path it positions the run against the
+     * path: `"start"` begins at the path's start, `"center"` centers on the
+     * midpoint, `"end"` finishes at the path's end, `"space-between"` justifies
+     * the glyphs evenly across the whole path, and `"space-around"` spreads
+     * them with half a gap before the first glyph and after the last, like the
+     * CSS flexbox value (both path text only). `"left"` and `"right"` are
+     * synonyms of `"start"` and `"end"`.
+     * @param value - `"left"`/`"start"` (default), `"center"`,
+     *   `"right"`/`"end"`, `"space-between"`, or `"space-around"`.
+     */
+    align(value: "left" | "center" | "right" | "start" | "end" | "space-between" | "space-around"): this;
+    /**
+     * Line-height multiplier for multi-line text (newlines in the string).
+     * @param value - Multiplier on the font's natural line height (default 1).
+     */
+    lineSpacing(value: number): this;
+    /**
+     * Extra spacing added between glyphs, in model units (default 0).
+     * @param value - The additional advance per glyph.
+     */
+    letterSpacing(value: number): this;
+    /**
+     * Shifts the baseline perpendicular to the path, in model units: positive
+     * values move the text toward its "up" side, negative below the path.
+     * Only applies to text following a path (`text(string, path)`).
+     * @param value - The perpendicular baseline shift.
+     */
+    offset(value: number): this;
+    /**
+     * Mirrors the text to the other side of the path, reversing the reading
+     * direction. On a closed path (circle, loop) text sits on the outside by
+     * default — `.flip()` moves it inside. On an open path it mirrors the text
+     * below the curve. Only applies to text following a path.
+     * @param value - Whether to flip (defaults to true).
+     */
+    flip(value?: boolean): this;
+    /**
+     * Shifts where the text starts along the path, as an arc-length distance
+     * from the path's start (combines with `align()`). On a closed path the
+     * text wraps around. Only applies to text following a path.
+     * @param distance - The arc-length shift in model units.
+     */
+    startAt(distance: number): this;
+}
 export interface IOffset extends IExtrudableGeometry {
     /**
      * Closes an open offset by joining it back to the source wire with
@@ -794,6 +870,59 @@ export interface IRib extends IBooleanOperation {
      */
     extend(): this;
 }
+export interface IWrap extends IBooleanOperation {
+    /**
+     * Selects the faces lying on the target surface (the base of the wrap).
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    startFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects the raised (or recessed) faces offset from the target surface by the wrap thickness.
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    endFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges on the base faces of the wrap.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    startEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges on the offset faces of the wrap.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    endEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects the wall faces created from the outer boundary of each wrapped region.
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    sideFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges on the wall faces, excluding edges shared with base/offset faces.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    sideEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects the wall faces created from holes inside a wrapped region.
+     * @param args - Numeric indices or {@link FaceFilterBuilder} instances to filter the selection.
+     */
+    internalFaces(...args: (number | FaceFilterBuilder)[]): ISceneObject;
+    /**
+     * Selects edges bounding the hole walls of the wrap.
+     * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
+     */
+    internalEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Enables or disables drill mode, which partitions the sketch into face regions
+     * before wrapping.
+     * @param value - `true` to enable (default), `false` to disable.
+     */
+    drill(value?: boolean): this;
+    /**
+     * Restricts wrapping to only the sketch regions containing the given points.
+     * @param points - 2D points in the sketch plane identifying regions to wrap.
+     */
+    pick(...points: Point2DLike[]): this;
+}
 export type ShellJoinType = 'arc' | 'intersection' | 'tangent';
 export interface IShell extends ISceneObject {
     /**
@@ -814,3 +943,54 @@ export interface IShell extends ISceneObject {
      */
     join(type: ShellJoinType): this;
 }
+/**
+ * A 3D helix wire — a single edge that traces a helix curve on a cylindrical or
+ * conical surface. Used as a path for `sweep()` to produce springs, threads, and
+ * coils.
+ *
+ * Created from one of:
+ * - An axis (`AxisLike`): user supplies geometry via chained config.
+ * - A cylindrical or conical face: axis + radii + height derived from the face.
+ * - A line edge: axis = the line, height = line length.
+ * - A circular edge: axis = circle normal, radius = circle radius.
+ */
+export interface IHelix extends ISceneObject {
+    /**
+     * Axial rise per turn (distance along the helix axis covered per full revolution).
+     * If unset, derived from `height / turns`.
+     */
+    pitch(pitch: number): this;
+    /**
+     * Number of full turns. Fractional values are allowed. Default 1.
+     */
+    turns(turns: number): this;
+    /**
+     * Shifts the start of the helix along its axis, in axial mm. Positive values
+     * trim the start (move it toward the end); negative values extend it. Default 0.
+     */
+    startOffset(offset: number): this;
+    /**
+     * Extends (positive) or trims (negative) the helix at its end, in axial mm.
+     * Default 0.
+     */
+    endOffset(offset: number): this;
+    /**
+     * Total axial height. Overrides face/edge-derived height when set. For line-edge
+     * input, defaults to the line length. For circular-edge / pure-axis input,
+     * defaults to 50 if neither this nor `pitch * turns` determine it.
+     */
+    height(height: number): this;
+    /**
+     * Start radius. Defaults to 20 for axis/line-edge input. For a cylindrical
+     * face input, defaults to the face's radius and may be overridden (useful for
+     * sweep/fuse workflows where the helix tube must overlap the cylinder
+     * volumetrically — offset by ~1mm to avoid pure tangency). Ignored on
+     * conical face input (radius is derived from face geometry).
+     */
+    radius(radius: number): this;
+    /**
+     * End radius — when different from `radius()`, produces a conical helix.
+     * Defaults to `radius()`. Ignored on face/circle inputs.
+     */
+    endRadius(radius: number): this;
+}

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

@@ -1,6 +1,11 @@
 import { PlaneLike, PlaneTransformOptions } from "../math/plane.js";
 import { IPlane, ISceneObject } from "./interfaces.js";
 export type PlaneRenderableOptions = PlaneTransformOptions;
+/**
+ * Where to place a plane along an edge: a named position, or a normalized
+ * distance from the edge start (`0`) to its end (`1`). `0.5` is the midpoint.
+ */
+export type EdgePlanePosition = 'start' | 'middle' | 'end' | number;
 interface PlaneFunction {
     /**
      * Creates a plane from a standard plane or normal vector.
@@ -20,8 +25,10 @@ interface PlaneFunction {
      */
     (plane: PlaneLike, offset: number): IPlane;
     /**
-     * Creates a plane from a face selection.
-     * @param selection - The selected face to create a plane from
+     * Creates a plane from a selection. A selected face yields that face's
+     * plane; a selected edge yields a plane at the edge start, oriented normal
+     * to the edge and facing outward (away from the edge body), like a start cap.
+     * @param selection - The selected face or edge to create a plane from
      */
     (selection: ISceneObject): IPlane;
     /**
@@ -31,11 +38,24 @@ interface PlaneFunction {
      */
     (selection: ISceneObject, options: PlaneRenderableOptions): IPlane;
     /**
-     * Creates a plane from a face selection with an offset.
-     * @param selection - The selected face to create a plane from
-     * @param offset - The offset distance
+     * Creates a plane from a selection with a numeric second argument. For a
+     * face, the number is the offset distance along the face normal. For an
+     * edge, it is a normalized position from `0` (start) to `1` (end), and the
+     * plane is created at that point oriented normal to the edge. The normal
+     * follows the edge's forward direction, except at the start (`0`) where it
+     * faces outward (away from the edge body), so both ends read like caps.
+     * @param selection - The selected face or edge
+     * @param offsetOrPosition - Face: offset distance. Edge: normalized 0–1 position.
+     */
+    (selection: ISceneObject, offsetOrPosition: number): IPlane;
+    /**
+     * Creates a plane at a named position along an edge, oriented normal to the
+     * edge. At `'start'` the normal faces outward (away from the edge body);
+     * `'middle'` and `'end'` follow the edge's forward direction.
+     * @param edge - The selected edge
+     * @param position - `'start'`, `'middle'`, or `'end'`
      */
-    (selection: ISceneObject, offset: number): IPlane;
+    (edge: ISceneObject, position: 'start' | 'middle' | 'end'): IPlane;
     /**
      * Transforms an existing plane with options.
      * @param plane - The existing plane to transform

package/lib/dist/core/plane.js

@@ -23,56 +23,33 @@ function build(context) {
             }
         }
         if (arguments.length === 2) {
-            if (typeof arguments[1] === 'number') {
-                const options = { offset: arguments[1] };
-                if (arguments[0] instanceof SceneObject) {
-                    context.addSceneObject(arguments[0]);
-                    const pln = new PlaneFromObject(arguments[0], options);
-                    context.addSceneObject(pln);
-                    return pln;
-                }
-                else if (isPlaneLike(arguments[0])) {
-                    const axis = normalizePlane(arguments[0]);
-                    const pln = new PlaneObject(axis, options);
-                    context.addSceneObject(pln);
-                    return pln;
-                }
-            }
-            if ((arguments[0] instanceof PlaneObjectBase || isPlaneLike(arguments[0])) &&
-                (arguments[1] instanceof PlaneObjectBase || isPlaneLike(arguments[1]))) {
-                // axis between two others
-                let a1;
-                let a2;
-                if (arguments[0] instanceof PlaneObjectBase) {
-                    a1 = arguments[0];
-                }
-                else {
-                    const axis = normalizePlane(arguments[0]);
-                    a1 = new PlaneObject(axis);
-                }
-                if (arguments[1] instanceof PlaneObjectBase) {
-                    a2 = arguments[1];
-                }
-                else {
-                    const axis = normalizePlane(arguments[1]);
-                    a2 = new PlaneObject(axis);
-                }
-                context.addSceneObject(a1);
-                context.addSceneObject(a2);
-                const pln = new PlaneMiddleRenderable(a1, a2);
+            const a0 = arguments[0];
+            const a1 = arguments[1];
+            // Plane midway between two planes / plane-likes.
+            if ((a0 instanceof PlaneObjectBase || isPlaneLike(a0)) &&
+                (a1 instanceof PlaneObjectBase || isPlaneLike(a1))) {
+                const p1 = a0 instanceof PlaneObjectBase ? a0 : new PlaneObject(normalizePlane(a0));
+                const p2 = a1 instanceof PlaneObjectBase ? a1 : new PlaneObject(normalizePlane(a1));
+                context.addSceneObject(p1);
+                context.addSceneObject(p2);
+                const pln = new PlaneMiddleRenderable(p1, p2);
                 context.addSceneObject(pln);
                 return pln;
             }
-            else if (arguments[0] instanceof SceneObject) {
-                context.addSceneObject(arguments[0]);
-                const pln = new PlaneFromObject(arguments[0], arguments[1]);
+            // From a scene object. A face reads the second argument as an offset
+            // distance / transform options; an edge reads it as a normalized 0–1
+            // position (or 'start'/'middle'/'end'). The face-vs-edge decision is
+            // deferred to PlaneFromObject.build(), where the source shape is known.
+            if (a0 instanceof SceneObject) {
+                context.addSceneObject(a0);
+                const pln = new PlaneFromObject(a0, a1);
                 context.addSceneObject(pln);
                 return pln;
             }
-            else if (isPlaneLike(arguments[0])) {
-                const axis1 = normalizePlane(arguments[0]);
-                const options = arguments[1];
-                const pln = new PlaneObject(axis1, options);
+            // From a plane-like: number → offset, object → transform options.
+            if (isPlaneLike(a0)) {
+                const options = typeof a1 === 'number' ? { offset: a1 } : a1;
+                const pln = new PlaneObject(normalizePlane(a0), options);
                 context.addSceneObject(pln);
                 return pln;
             }

package/lib/dist/core/wrap.d.ts

@@ -0,0 +1,17 @@
+import { IWrap, ISceneObject } from "./interfaces.js";
+import { type NumberParam } from "./param.js";
+interface WrapFunction {
+    /**
+     * Wraps the given sketch onto a curved face, raising it from the surface by
+     * the given thickness (emboss). Chain `.remove()` to sink it into the
+     * surface instead (deboss), or `.new()` to keep the wrapped pad standalone.
+     * The sketch is developed onto the surface with its lengths preserved — a
+     * true wrap, not a projection. Cylindrical and conical faces are supported.
+     * @param thickness - Pad thickness measured along the surface normal (must be positive)
+     * @param sketch - The sketch to wrap onto the face
+     * @param face - The target face to wrap onto
+     */
+    (thickness: NumberParam, sketch: ISceneObject, face: ISceneObject): IWrap;
+}
+declare const _default: WrapFunction;
+export default _default;

package/lib/dist/core/wrap.js

@@ -0,0 +1,39 @@
+import { SceneObject } from "../common/scene-object.js";
+import { registerBuilder } from "../index.js";
+import { Wrap } from "../features/wrap.js";
+import { isNumberParam, resolveParam } from "./param.js";
+function isExtrudable(obj) {
+    return obj instanceof SceneObject && obj.isExtrudable();
+}
+function build(context) {
+    //@ts-ignore
+    return function wrap() {
+        const args = [...arguments];
+        if (args.length !== 3) {
+            throw new Error("wrap() expects (thickness, sketch, face).");
+        }
+        if (!isNumberParam(args[0])) {
+            throw new Error("wrap() thickness must be a positive number.");
+        }
+        const thickness = resolveParam(args[0]);
+        if (!(thickness > 0)) {
+            throw new Error("wrap() thickness must be a positive number.");
+        }
+        const source = args[1];
+        if (!(source instanceof SceneObject)) {
+            throw new Error("wrap() sketch must be a sketch or face-bearing scene object.");
+        }
+        const face = args[2];
+        if (!(face instanceof SceneObject) || isExtrudable(face)) {
+            throw new Error("wrap() requires a target face selection as its last argument.");
+        }
+        if (!isExtrudable(source)) {
+            context.addSceneObject(source);
+        }
+        context.addSceneObject(face);
+        const result = new Wrap(thickness, face, source);
+        context.addSceneObject(result);
+        return result;
+    };
+}
+export default registerBuilder(build);

package/lib/dist/features/2d/offset.js

@@ -55,9 +55,9 @@ export class Offset extends ExtrudableGeometryBase {
             });
         }
         let lastOffsetWire = null;
+        const plane = this.getPlane();
         for (const wireInfo of wires) {
-            const isOpen = !wireInfo.wire.isClosed();
-            const offsetWire = WireOps.offsetWire(wireInfo.wire, this.distance, isOpen);
+            const offsetWire = WireOps.offsetWireOnPlane(wireInfo.wire, this.distance, wireInfo.wire.isClosed(), plane);
             lastOffsetWire = offsetWire;
             const edges = offsetWire.getEdges();
             for (const edge of edges) {