fluidcad 0.0.35 → 0.0.37

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/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/text.d.ts

@@ -0,0 +1,67 @@
+import { SceneObject } from "../../common/scene-object.js";
+import { PlaneObjectBase } from "../plane-renderable-base.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+import { IText } from "../../core/interfaces.js";
+import { type TextAlign } from "../../oc/text-outline.js";
+import { Plane } from "../../math/plane.js";
+/**
+ * 3D text as an extrudable outline profile. Glyph outlines are produced via
+ * fontkit and converted to sketch edges; extruding the result gives raised or
+ * cut lettering. Works standalone on a plane (`text("xy", "Hi")`), inside a
+ * `sketch()` (`text("Hi")`), or following a planar curve
+ * (`text("Hi", path)`).
+ */
+export declare class Text extends ExtrudableGeometryBase implements IText {
+    text: string;
+    private path;
+    private _size;
+    private _font?;
+    private _weight;
+    private _italic;
+    private _align;
+    private _lineSpacing;
+    private _letterSpacing;
+    private _pathOffset;
+    private _flip;
+    private _startAt;
+    private _pathPlane;
+    constructor(text: string, targetPlane?: PlaneObjectBase, path?: SceneObject);
+    build(): void;
+    private buildAlongPath;
+    /**
+     * The plane the text lies in: the path object's own plane when it has one
+     * (sketch, planar primitive), otherwise a plane fitted through the path.
+     * Also verifies the path actually is planar.
+     */
+    private resolvePathPlane;
+    private pathOwnPlane;
+    getPlane(): Plane;
+    size(value: number): this;
+    font(name: string): this;
+    weight(value: number | string): this;
+    bold(): this;
+    italic(value?: boolean): this;
+    align(value: TextAlign): this;
+    lineSpacing(value: number): this;
+    letterSpacing(value: number): this;
+    offset(value: number): this;
+    flip(value?: boolean): this;
+    startAt(distance: number): this;
+    getType(): string;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: Text): boolean;
+    serialize(): {
+        text: string;
+        size: number;
+        font: string;
+        weight: number;
+        italic: boolean;
+        align: TextAlign;
+        lineSpacing: number;
+        letterSpacing: number;
+        offset: number;
+        flip: boolean;
+        startAt: number;
+    };
+}

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

@@ -0,0 +1,320 @@
+import { Sketch } from "./sketch.js";
+import { ExtrudableGeometryBase } from "./extrudable-base.js";
+import { FontRegistry } from "../../io/font-registry.js";
+import { TextOutline } from "../../oc/text-outline.js";
+import { PathSampler } from "../../oc/path-sampler.js";
+import { WireOps } from "../../oc/wire-ops.js";
+import { BuildError } from "../../common/build-error.js";
+import { GeometrySceneObject } from "./geometry.js";
+import { Plane } from "../../math/plane.js";
+import { Point } from "../../math/point.js";
+import { Vector3d } from "../../math/vector3d.js";
+const WEIGHT_NAMES = {
+    thin: 100, extralight: 200, ultralight: 200, light: 300, regular: 400,
+    normal: 400, medium: 500, semibold: 600, demibold: 600, bold: 700,
+    extrabold: 800, ultrabold: 800, black: 900, heavy: 900,
+};
+/**
+ * Fits a plane through sampled path points (Newell-style accumulation of
+ * cross products around the centroid). Returns null when the points are
+ * colinear — a straight path carries no orientation of its own.
+ */
+function fitPathPlane(samples, startTangent, pathLength) {
+    const n = samples.length;
+    let cx = 0, cy = 0, cz = 0;
+    for (const p of samples) {
+        cx += p.x;
+        cy += p.y;
+        cz += p.z;
+    }
+    const centroid = new Point(cx / n, cy / n, cz / n);
+    let nx = 0, ny = 0, nz = 0;
+    for (let i = 0; i + 1 < n; i++) {
+        const a = centroid.vectorTo(samples[i]);
+        const b = centroid.vectorTo(samples[i + 1]);
+        const cross = a.cross(b);
+        nx += cross.x;
+        ny += cross.y;
+        nz += cross.z;
+    }
+    const mag = Math.hypot(nx, ny, nz);
+    if (mag < 1e-9 * pathLength * pathLength) {
+        return null;
+    }
+    const normal = new Vector3d(nx / mag, ny / mag, nz / mag);
+    const xDirection = startTangent
+        .subtract(normal.multiply(startTangent.dot(normal)))
+        .normalize();
+    return new Plane(samples[0], xDirection, normal);
+}
+/**
+ * 3D text as an extrudable outline profile. Glyph outlines are produced via
+ * fontkit and converted to sketch edges; extruding the result gives raised or
+ * cut lettering. Works standalone on a plane (`text("xy", "Hi")`), inside a
+ * `sketch()` (`text("Hi")`), or following a planar curve
+ * (`text("Hi", path)`).
+ */
+export class Text extends ExtrudableGeometryBase {
+    text;
+    path;
+    _size = 10;
+    _font;
+    _weight = 400;
+    _italic = false;
+    _align = "left";
+    _lineSpacing = 1;
+    _letterSpacing = 0;
+    _pathOffset = 0;
+    _flip = false;
+    _startAt = 0;
+    _pathPlane = null;
+    constructor(text, targetPlane = null, path = null) {
+        super(targetPlane);
+        this.text = text;
+        this.path = path;
+    }
+    build() {
+        if (this.path) {
+            this.buildAlongPath();
+            return;
+        }
+        if (this._pathOffset !== 0 || this._flip || this._startAt !== 0) {
+            throw new BuildError("text: .offset(), .flip() and .startAt() only apply to text following a path.", "Use the text(string, path) form, or remove these modifiers.");
+        }
+        if (this._align === "space-between" || this._align === "space-around") {
+            throw new BuildError(`text: align('${this._align}') only applies to text following a path.`, "Use the text(string, path) form, or pick left/center/right.");
+        }
+        const plane = this.targetPlane
+            ? this.targetPlane.getPlane()
+            : this.getParent().getPlane();
+        const origin = this.targetPlane
+            ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
+            : this.getCurrentPosition();
+        const font = FontRegistry.resolve({ font: this._font, weight: this._weight, italic: this._italic });
+        const edges = TextOutline.buildEdges(font, this.text, {
+            size: this._size,
+            align: this._align,
+            lineSpacing: this._lineSpacing,
+            letterSpacing: this._letterSpacing,
+        }, plane, origin);
+        this.addShapes(edges);
+        if (this.targetPlane) {
+            this.targetPlane.removeShapes(this);
+        }
+    }
+    buildAlongPath() {
+        // Guide curves are included: marking the path `.guide()` is the natural
+        // way to keep it out of the sketch profile while text follows it.
+        const shapes = this.path.getShapes({ excludeMeta: false, excludeGuide: false });
+        const pathEdges = shapes.flatMap(s => s.getSubShapes('edge'));
+        if (pathEdges.length === 0) {
+            throw new BuildError("text: path contains no edges.");
+        }
+        const wire = WireOps.makeWireFromEdges(pathEdges);
+        const sampler = new PathSampler(wire);
+        try {
+            const plane = this.resolvePathPlane(sampler);
+            this._pathPlane = plane;
+            // On a closed loop, normalize the (arbitrary) wire winding so text
+            // sits on the OUTSIDE by default; `.flip()` then moves it inside.
+            // A clockwise loop (w.r.t. the plane normal) already has its glyph
+            // "up" (normal × tangent) pointing outward.
+            let flip = this._flip;
+            if (sampler.closed && !WireOps.isCW(wire, plane.normal)) {
+                flip = !flip;
+            }
+            const font = FontRegistry.resolve({ font: this._font, weight: this._weight, italic: this._italic });
+            const edges = TextOutline.buildEdgesAlongPath(font, this.text, {
+                size: this._size,
+                align: this._align,
+                lineSpacing: this._lineSpacing,
+                letterSpacing: this._letterSpacing,
+            }, {
+                evalAt: (s) => sampler.evalAt(s),
+                length: sampler.length,
+                normal: plane.normal,
+                offset: this._pathOffset,
+                startAt: this._startAt,
+                flip,
+                closed: sampler.closed,
+            });
+            this.addShapes(edges);
+        }
+        finally {
+            sampler.dispose();
+        }
+    }
+    /**
+     * The plane the text lies in: the path object's own plane when it has one
+     * (sketch, planar primitive), otherwise a plane fitted through the path.
+     * Also verifies the path actually is planar.
+     */
+    resolvePathPlane(sampler) {
+        const samples = sampler.sample(64);
+        let plane = this.pathOwnPlane();
+        if (!plane) {
+            plane = fitPathPlane(samples, sampler.evalAt(0).tangent, sampler.length);
+        }
+        if (!plane) {
+            throw new BuildError("text: cannot derive the path's orientation — a straight-line path carries no plane of its own.", "Draw the path in a sketch (or use a planar primitive) so the text knows which way is up.");
+        }
+        const tol = Math.max(1e-5, sampler.length * 1e-6);
+        for (const p of samples) {
+            if (plane.distanceToPoint(p) > tol) {
+                throw new BuildError("text: path must be planar.", "Text can only follow a curve lying in a single plane (e.g. a sketch curve or a planar edge loop).");
+            }
+        }
+        return plane;
+    }
+    pathOwnPlane() {
+        if (this.path instanceof Sketch) {
+            return this.path.getPlane();
+        }
+        if (this.path instanceof ExtrudableGeometryBase) {
+            try {
+                return this.path.getPlane();
+            }
+            catch {
+                return null;
+            }
+        }
+        // Plain sketch geometry (arc, line, …) lies in its sketch's plane.
+        if (this.path instanceof GeometrySceneObject) {
+            const sketch = this.path.sketch;
+            return sketch ? sketch.getPlane() : null;
+        }
+        return null;
+    }
+    getPlane() {
+        if (this.path) {
+            if (!this._pathPlane) {
+                throw new Error("text: the path plane is resolved during build; render the scene first.");
+            }
+            return this._pathPlane;
+        }
+        return super.getPlane();
+    }
+    size(value) {
+        this._size = value;
+        return this;
+    }
+    font(name) {
+        this._font = name;
+        return this;
+    }
+    weight(value) {
+        this._weight = typeof value === "number" ? value : (WEIGHT_NAMES[value.toLowerCase()] ?? 400);
+        return this;
+    }
+    bold() {
+        this._weight = 700;
+        return this;
+    }
+    italic(value = true) {
+        this._italic = value;
+        return this;
+    }
+    align(value) {
+        this._align = value;
+        return this;
+    }
+    lineSpacing(value) {
+        this._lineSpacing = value;
+        return this;
+    }
+    letterSpacing(value) {
+        this._letterSpacing = value;
+        return this;
+    }
+    offset(value) {
+        this._pathOffset = value;
+        return this;
+    }
+    flip(value = true) {
+        this._flip = value;
+        return this;
+    }
+    startAt(distance) {
+        this._startAt = distance;
+        return this;
+    }
+    getType() {
+        return "text";
+    }
+    getDependencies() {
+        const deps = [];
+        if (this.targetPlane) {
+            deps.push(this.targetPlane);
+        }
+        if (this.path) {
+            deps.push(this.path);
+        }
+        return deps;
+    }
+    createCopy(remap) {
+        const targetPlane = this.targetPlane
+            ? (remap.get(this.targetPlane) || this.targetPlane)
+            : null;
+        const path = this.path
+            ? (remap.get(this.path) || this.path)
+            : null;
+        const copy = new Text(this.text, targetPlane, path);
+        copy._size = this._size;
+        copy._font = this._font;
+        copy._weight = this._weight;
+        copy._italic = this._italic;
+        copy._align = this._align;
+        copy._lineSpacing = this._lineSpacing;
+        copy._letterSpacing = this._letterSpacing;
+        copy._pathOffset = this._pathOffset;
+        copy._flip = this._flip;
+        copy._startAt = this._startAt;
+        return copy;
+    }
+    compareTo(other) {
+        if (!(other instanceof Text)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.targetPlane?.constructor !== other.targetPlane?.constructor) {
+            return false;
+        }
+        if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
+            return false;
+        }
+        if (this.path?.constructor !== other.path?.constructor) {
+            return false;
+        }
+        if (this.path && other.path && !this.path.compareTo(other.path)) {
+            return false;
+        }
+        return this.text === other.text
+            && this._size === other._size
+            && this._font === other._font
+            && this._weight === other._weight
+            && this._italic === other._italic
+            && this._align === other._align
+            && this._lineSpacing === other._lineSpacing
+            && this._letterSpacing === other._letterSpacing
+            && this._pathOffset === other._pathOffset
+            && this._flip === other._flip
+            && this._startAt === other._startAt;
+    }
+    serialize() {
+        return {
+            text: this.text,
+            size: this._size,
+            font: this._font,
+            weight: this._weight,
+            italic: this._italic,
+            align: this._align,
+            lineSpacing: this._lineSpacing,
+            letterSpacing: this._letterSpacing,
+            offset: this._pathOffset,
+            flip: this._flip,
+            startAt: this._startAt,
+        };
+    }
+}

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

@@ -1,9 +1,11 @@
 import { TransformablePrimitive } from "../common/transformable-primitive.js";
+import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
 export declare class Cylinder extends TransformablePrimitive {
     radius: number;
     height: number;
     constructor(radius: number, height: number);
-    build(): void;
+    build(context?: BuildSceneObjectContext): void;
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: Cylinder): boolean;
     getType(): string;
     serialize(): {

package/lib/dist/features/cylinder.js

@@ -8,9 +8,12 @@ export class Cylinder extends TransformablePrimitive {
         this.radius = radius;
         this.height = height;
     }
-    build() {
+    build(context) {
         const cyl = Primitives.makeCylinder(this.radius, this.height);
-        this.addShapes([cyl]);
+        this.addPrimitiveShape(cyl, context);
+    }
+    createCopy(remap) {
+        return new Cylinder(this.radius, this.height).syncPrimitiveWith(this);
     }
     compareTo(other) {
         if (!(other instanceof Cylinder)) {

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

@@ -87,6 +87,7 @@ export declare abstract class ExtrudeBase extends SceneObject implements IExtrud
      */
     protected finalizeAndFuse(shapes: Shape[], classified: ClassifiedFaces, context: BuildSceneObjectContext, fuseOpts?: {
         glue?: 'full' | 'shift';
+        skipSimplify?: boolean;
     }): void;
     /**
      * One-shot edge classification: derive start/end/side/internal/cap edges

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

@@ -11,6 +11,7 @@ export declare class ExtrudeToFace extends ExtrudeBase {
     private createAdvancedExtrude;
     private resizePlanarFace;
     private resizeCylindricalFace;
+    private resizeConicalFace;
     /**
      * Computes the signed distance from the sketch plane to the farthest
      * bounding-box corner of the target face, measured along the sketch