fluidcad 0.0.28 → 0.0.30

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

@@ -0,0 +1,12 @@
+export type ProfileCategory = {
+    category: string;
+    durationMs: number;
+};
+export declare class Profiler {
+    private categories;
+    private stack;
+    start(category: string): void;
+    end(category: string): void;
+    record<T>(category: string, fn: () => T): T;
+    getCategories(): ProfileCategory[];
+}

package/lib/dist/common/profiler.js

@@ -0,0 +1,35 @@
+export class Profiler {
+    categories = new Map();
+    stack = [];
+    start(category) {
+        this.stack.push({ category, startTime: performance.now() });
+    }
+    end(category) {
+        for (let i = this.stack.length - 1; i >= 0; i--) {
+            if (this.stack[i].category === category) {
+                const entry = this.stack.splice(i, 1)[0];
+                const elapsed = performance.now() - entry.startTime;
+                const current = this.categories.get(category) || 0;
+                this.categories.set(category, current + elapsed);
+                this.stack.length = i;
+                return;
+            }
+        }
+    }
+    record(category, fn) {
+        this.start(category);
+        try {
+            return fn();
+        }
+        finally {
+            this.end(category);
+        }
+    }
+    getCategories() {
+        const result = [];
+        for (const [category, durationMs] of this.categories.entries()) {
+            result.push({ category, durationMs: Math.round(durationMs * 10) / 10 });
+        }
+        return result;
+    }
+}

package/lib/dist/common/scene-object.d.ts

@@ -5,6 +5,7 @@ import { Matrix4 } from "../math/matrix4.js";
 import { ISceneObject } from "../core/interfaces.js";
 import { FusionScope, OperationMode } from "../features/extrude-options.js";
 import { ShapeType } from "./shape-type.js";
+import { Profiler } from "./profiler.js";
 export type SourceLocation = {
     filePath: string;
     line: number;
@@ -35,6 +36,7 @@ export type BuildSceneObjectContext = {
     getSceneObjectsFromTo(obj: SceneObject, to: SceneObject, type?: string): SceneObject[];
     getTransform(): Matrix4 | null;
     getLastObject(): SceneObject | null;
+    getProfiler(): Profiler;
 };
 export declare abstract class SceneObject implements Comparable<SceneObject>, Serializable, ISceneObject {
     private state;
@@ -67,6 +69,7 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     getPreviousSibling(obj: SceneObject): SceneObject | null;
     getPreviousSiblings(obj: SceneObject): SceneObject[];
     isContainer(): boolean;
+    isLazy(): boolean;
     saveShapesSnapshot(context: BuildSceneObjectContext): void;
     getSnapshot(): Map<SceneObject, Shape[]>;
     abstract serialize(scope?: Set<SceneObject>): any;

package/lib/dist/common/scene-object.js

@@ -85,6 +85,9 @@ export class SceneObject {
     isContainer() {
         return false;
     }
+    isLazy() {
+        return false;
+    }
     // called by containers to save the shapes state up to this object
     saveShapesSnapshot(context) {
         const upToHere = context.getSceneObjects();

package/lib/dist/common/shape-history-tracker.d.ts

@@ -30,6 +30,14 @@ export declare class ShapeHistoryTracker {
      */
     static remapFaces(faces: Face[], history: ShapeHistory): Face[];
     static remapEdges(edges: Edge[], history: ShapeHistory): Edge[];
-    static collect(maker: BRepBuilderAPI_MakeShape, inputs: Shape[]): ShapeHistory;
+    /**
+     * Collect history for `inputs` against `maker`'s output. When `opts.skipAdded`
+     * is set, the added* fields come back empty — callers that compute additions
+     * themselves (e.g. `recordFusionHistory` aggregates across all scene shapes)
+     * skip the per-call output traversal and per-result claimed-map updates.
+     */
+    static collect(maker: BRepBuilderAPI_MakeShape, inputs: Shape[], opts?: {
+        skipAdded?: boolean;
+    }): ShapeHistory;
     private static collectForType;
 }

package/lib/dist/common/shape-history-tracker.js

@@ -41,15 +41,22 @@ export class ShapeHistoryTracker {
         }
         return result;
     }
-    static collect(maker, inputs) {
+    /**
+     * Collect history for `inputs` against `maker`'s output. When `opts.skipAdded`
+     * is set, the added* fields come back empty — callers that compute additions
+     * themselves (e.g. `recordFusionHistory` aggregates across all scene shapes)
+     * skip the per-call output traversal and per-result claimed-map updates.
+     */
+    static collect(maker, inputs, opts = {}) {
         const oc = getOC();
         const FACE = oc.TopAbs_ShapeEnum.TopAbs_FACE;
         const EDGE = oc.TopAbs_ShapeEnum.TopAbs_EDGE;
-        const output = maker.Shape();
-        const outputFaces = Explorer.findShapes(output, FACE);
-        const outputEdges = Explorer.findShapes(output, EDGE);
-        const faces = ShapeHistoryTracker.collectForType(maker, inputs, FACE, outputFaces, (raw) => Face.fromTopoDSFace(Explorer.toFace(raw)));
-        const edges = ShapeHistoryTracker.collectForType(maker, inputs, EDGE, outputEdges, (raw) => Edge.fromTopoDSEdge(Explorer.toEdge(raw)));
+        const skipAdded = opts.skipAdded === true;
+        const output = skipAdded ? null : maker.Shape();
+        const outputFaces = output ? Explorer.findShapes(output, FACE) : [];
+        const outputEdges = output ? Explorer.findShapes(output, EDGE) : [];
+        const faces = ShapeHistoryTracker.collectForType(maker, inputs, FACE, outputFaces, (raw) => Face.fromTopoDSFace(Explorer.toFace(raw)), skipAdded);
+        const edges = ShapeHistoryTracker.collectForType(maker, inputs, EDGE, outputEdges, (raw) => Edge.fromTopoDSEdge(Explorer.toEdge(raw)), skipAdded);
         return {
             addedFaces: faces.added,
             modifiedFaces: faces.modified,
@@ -61,28 +68,30 @@ export class ShapeHistoryTracker {
             removedEdges: edges.removed,
         };
     }
-    static collectForType(maker, inputs, type, outputRaws, wrap) {
+    static collectForType(maker, inputs, type, outputRaws, wrap, skipAdded) {
         const oc = getOC();
         const modified = [];
         const generated = [];
         const removed = [];
-        // Collect every output raw that was either Modified or Generated from an input,
-        // so we can later classify the remaining outputs as pure additions.
-        const claimed = new oc.TopTools_MapOfShape();
+        // Track which output raws are claimed by a Modified/Generated record so the
+        // remaining outputs can be reported as pure additions. When `skipAdded`,
+        // we don't compute additions, so skip the bookkeeping entirely.
+        const claimed = skipAdded ? null : new oc.TopTools_MapOfShape();
         const isOfType = (raw) => raw.ShapeType() === type;
         for (const input of inputs) {
             const inputRaws = Explorer.findShapes(input.getShape(), type);
             for (const inputRaw of inputRaws) {
                 const modifiedRaws = ShapeOps.shapeListToArray(maker.Modified(inputRaw)).filter(isOfType);
                 const generatedRaws = ShapeOps.shapeListToArray(maker.Generated(inputRaw)).filter(isOfType);
-                const isDeleted = maker.IsDeleted(inputRaw);
                 if (modifiedRaws.length > 0) {
                     modified.push({
                         sources: [wrap(inputRaw)],
                         results: modifiedRaws.map(wrap),
                     });
-                    for (const r of modifiedRaws) {
-                        claimed.Add(r);
+                    if (claimed) {
+                        for (const r of modifiedRaws) {
+                            claimed.Add(r);
+                        }
                     }
                 }
                 if (generatedRaws.length > 0) {
@@ -90,25 +99,30 @@ export class ShapeHistoryTracker {
                         sources: [wrap(inputRaw)],
                         results: generatedRaws.map(wrap),
                     });
-                    for (const r of generatedRaws) {
-                        claimed.Add(r);
+                    if (claimed) {
+                        for (const r of generatedRaws) {
+                            claimed.Add(r);
+                        }
                     }
                 }
-                // An input that is deleted with no successor is a removal. If it was
-                // Modified into something, the modification record already captures
-                // its fate — don't double-count as removed.
-                if (isDeleted && modifiedRaws.length === 0 && generatedRaws.length === 0) {
+                // IsDeleted is only meaningful when the input has no successor. If
+                // Modified or Generated produced anything, that record already
+                // captures its fate — skip the (relatively expensive) IsDeleted call.
+                if (modifiedRaws.length === 0 && generatedRaws.length === 0
+                    && maker.IsDeleted(inputRaw)) {
                     removed.push(wrap(inputRaw));
                 }
             }
         }
         const added = [];
-        for (const raw of outputRaws) {
-            if (!claimed.Contains(raw)) {
-                added.push(wrap(raw));
+        if (claimed) {
+            for (const raw of outputRaws) {
+                if (!claimed.Contains(raw)) {
+                    added.push(wrap(raw));
+                }
             }
+            claimed.delete();
         }
-        claimed.delete();
         return { added, modified, generated, removed };
     }
 }

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

@@ -1,28 +1,28 @@
 import { PlaneLike } from "../../math/plane.js";
-import { IGeometry, ISceneObject } from "../interfaces.js";
+import { IALine, ISceneObject } from "../interfaces.js";
 interface ALineFunction {
     /**
      * Draws a line at the given angle with the given length.
-     * @param length - The line length
+     * Chain `.centered()` to center the line on the current position.
      * @param angle - The angle in degrees
-     * @param centered - Whether to center the line on the current position
+     * @param length - The line length
      */
-    (length: number, angle: number, centered?: boolean): IGeometry;
+    (angle: number, length: number): IALine;
     /**
-     * Draws a line at the given angle on a specific plane.
-     * @param length - The line length
+     * Draws a line at the given angle that ends where it intersects the target
+     * geometry. The nearest intersection along the line's direction (in either
+     * sign) is used.
      * @param angle - The angle in degrees
-     * @param targetPlane - The plane to draw on
+     * @param target - The geometry to intersect with
      */
-    (length: number, angle: number, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    (angle: number, target: ISceneObject): IALine;
     /**
-     * Draws a centered line at the given angle on a specific plane.
-     * @param length - The line length
-     * @param angle - The angle in degrees
-     * @param centered - Whether to center the line on the current position
+     * Draws a line at the given angle on a specific plane.
      * @param targetPlane - The plane to draw on
+     * @param angle - The angle in degrees
+     * @param length - The line length
      */
-    (length: number, angle: number, centered: boolean, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    (targetPlane: PlaneLike | ISceneObject, angle: number, length: number): IALine;
 }
 declare const _default: ALineFunction;
 export default _default;

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

@@ -6,19 +6,28 @@ import { resolvePlane } from "../../helpers/resolve.js";
 function build(context) {
     return function line() {
         let planeObj = null;
-        let argCount = arguments.length;
-        // Detect plane as last argument
-        if (argCount > 0) {
-            const lastArg = arguments[argCount - 1];
-            if (isPlaneLike(lastArg) || lastArg instanceof SceneObject) {
-                planeObj = resolvePlane(lastArg, context);
-                argCount--;
+        let argOffset = 0;
+        const inSketch = context.getActiveSketch() !== null;
+        if (arguments.length > 0) {
+            const firstArg = arguments[0];
+            if (isPlaneLike(firstArg)) {
+                if (inSketch) {
+                    throw new Error("aLine(plane, ...) cannot be used inside a sketch. Use aLine(...) instead.");
+                }
+                planeObj = resolvePlane(firstArg, context);
+                argOffset = 1;
+            }
+            else if (!inSketch && firstArg instanceof SceneObject) {
+                planeObj = resolvePlane(firstArg, context);
+                argOffset = 1;
             }
         }
-        const length = arguments[0];
-        const angle = arguments[1];
-        const centered = argCount >= 3 ? arguments[2] : false;
-        const aline = new AngledLine(length, angle, centered, planeObj);
+        const angle = arguments[argOffset];
+        const second = arguments[argOffset + 1];
+        const lengthOrTarget = second instanceof SceneObject
+            ? second
+            : second;
+        const aline = new AngledLine(angle, lengthOrTarget, planeObj);
         context.addSceneObject(aline);
         return aline;
     };

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

@@ -26,25 +26,25 @@ interface ArcFunction {
     (radius: number, startAngle?: number, endAngle?: number): IArcAngles;
     /**
      * Draws an arc to an end point on a specific plane.
-     * @param endPoint - The end point of the arc
      * @param targetPlane - The plane to draw on
+     * @param endPoint - The end point of the arc
      */
-    (endPoint: Point2DLike, targetPlane: PlaneLike | ISceneObject): IArcPoints;
+    (targetPlane: PlaneLike | ISceneObject, endPoint: Point2DLike): IArcPoints;
     /**
      * Draws an arc between two points on a specific plane.
+     * @param targetPlane - The plane to draw on
      * @param startPoint - The start point of the arc
      * @param endPoint - The end point of the arc
-     * @param targetPlane - The plane to draw on
      */
-    (startPoint: Point2DLike, endPoint: Point2DLike, targetPlane: PlaneLike | ISceneObject): IArcPoints;
+    (targetPlane: PlaneLike | ISceneObject, startPoint: Point2DLike, endPoint: Point2DLike): IArcPoints;
     /**
      * Draws an arc by radius and angle range on a specific plane.
+     * @param targetPlane - The plane to draw on
      * @param radius - The arc radius
      * @param startAngle - The start angle in degrees
      * @param endAngle - The end angle in degrees
-     * @param targetPlane - The plane to draw on
      */
-    (radius: number, startAngle: number, endAngle: number, targetPlane: PlaneLike | ISceneObject): IArcAngles;
+    (targetPlane: PlaneLike | ISceneObject, radius: number, startAngle: number, endAngle: number): IArcAngles;
 }
 declare const _default: ArcFunction;
 export default _default;

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

@@ -8,34 +8,38 @@ import { resolvePlane } from "../../helpers/resolve.js";
 function build(context) {
     return function arc() {
         let planeObj = null;
-        let argCount = arguments.length;
-        // Detect plane as last argument
-        if (argCount > 0) {
-            const lastArg = arguments[argCount - 1];
-            if (isPlaneLike(lastArg) || (lastArg instanceof SceneObject && !isPoint2DLike(lastArg))) {
-                planeObj = resolvePlane(lastArg, context);
-                argCount--;
+        let argOffset = 0;
+        // Detect plane as first argument (only valid outside a sketch)
+        if (arguments.length > 0) {
+            const firstArg = arguments[0];
+            if (isPlaneLike(firstArg) || (firstArg instanceof SceneObject && !isPoint2DLike(firstArg))) {
+                if (context.getActiveSketch() !== null) {
+                    throw new Error("arc(plane, ...) cannot be used inside a sketch. Use arc(...) instead.");
+                }
+                planeObj = resolvePlane(firstArg, context);
+                argOffset = 1;
             }
         }
+        const argCount = arguments.length - argOffset;
         // (startPoint, endPoint) — two Point2DLike args, default center = current position
-        if (argCount >= 2 && isPoint2DLike(arguments[0]) && isPoint2DLike(arguments[1])) {
-            const start = normalizePoint2D(arguments[0]);
-            const end = normalizePoint2D(arguments[1]);
+        if (argCount >= 2 && isPoint2DLike(arguments[argOffset]) && isPoint2DLike(arguments[argOffset + 1])) {
+            const start = normalizePoint2D(arguments[argOffset]);
+            const end = normalizePoint2D(arguments[argOffset + 1]);
             const arcObj = Arc.twoPoints(start, end, planeObj);
             context.addSceneObject(arcObj);
             return arcObj;
         }
         // (endPoint) — single Point2DLike arg
-        if (isPoint2DLike(arguments[0])) {
-            const end = normalizePoint2D(arguments[0]);
+        if (isPoint2DLike(arguments[argOffset])) {
+            const end = normalizePoint2D(arguments[argOffset]);
             const arcObj = Arc.toPoint(end, planeObj);
             context.addSceneObject(arcObj);
             return arcObj;
         }
         // (radius, startAngle?, endAngle?) — all numeric args
-        const radius = arguments[0] || 100;
-        const startAngle = arguments[1] || 0;
-        const endAngle = argCount >= 3 ? arguments[2] : 180;
+        const radius = arguments[argOffset] || 100;
+        const startAngle = arguments[argOffset + 1] || 0;
+        const endAngle = argCount >= 3 ? arguments[argOffset + 2] : 180;
         const arcObj = Arc.fromAngles(radius, startAngle, endAngle, planeObj);
         context.addSceneObject(arcObj);
         return arcObj;

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

@@ -0,0 +1,12 @@
+import { IGeometry } from "../interfaces.js";
+interface BackFunction {
+    /** Reverts the cursor to the previous position. */
+    (): IGeometry;
+    /**
+     * Reverts the cursor `count` position-changes back.
+     * @param count - How many prior cursor changes to undo (default 1).
+     */
+    (count: number): IGeometry;
+}
+declare const _default: BackFunction;
+export default _default;

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

@@ -0,0 +1,11 @@
+import { Back } from "../../features/2d/back.js";
+import { registerBuilder } from "../../index.js";
+function build(context) {
+    return function back() {
+        const count = arguments[0] ?? 1;
+        const obj = new Back(count);
+        context.addSceneObject(obj);
+        return obj;
+    };
+}
+export default registerBuilder(build);

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

@@ -15,10 +15,10 @@ interface CircleFunction {
     (diameter?: number): IExtrudableGeometry;
     /**
      * Draws a circle with a given diameter on a specific plane.
-     * @param diameter - The circle diameter
      * @param targetPlane - The plane to draw on
+     * @param diameter - The circle diameter
      */
-    (diameter: number, targetPlane: PlaneLike | ISceneObject): IExtrudableGeometry;
+    (targetPlane: PlaneLike | ISceneObject, diameter: number): IExtrudableGeometry;
 }
 declare const _default: CircleFunction;
 export default _default;

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

@@ -12,28 +12,32 @@ function build(context) {
         let center;
         let circle;
         let planeObj = null;
-        let argCount = arguments.length;
-        // Detect plane as last argument
-        if (argCount > 0) {
-            const lastArg = arguments[argCount - 1];
-            if (isPlaneLike(lastArg) || (lastArg instanceof SceneObject && !isPoint2DLike(lastArg))) {
-                planeObj = resolvePlane(lastArg, context);
-                argCount--;
+        let argOffset = 0;
+        // Detect plane as first argument (only valid outside a sketch)
+        if (arguments.length > 0) {
+            const firstArg = arguments[0];
+            if (isPlaneLike(firstArg) || (firstArg instanceof SceneObject && !isPoint2DLike(firstArg))) {
+                if (context.getActiveSketch() !== null) {
+                    throw new Error("circle(plane, ...) cannot be used inside a sketch. Use circle(...) instead.");
+                }
+                planeObj = resolvePlane(firstArg, context);
+                argOffset = 1;
             }
         }
+        const argCount = arguments.length - argOffset;
         if (argCount === 0) {
             diameter = 40;
             circle = new Circle(diameter, null, planeObj);
             context.addSceneObject(circle);
         }
         else if (argCount === 1) {
-            diameter = arguments[0] || 40;
+            diameter = arguments[argOffset] || 40;
             circle = new Circle(diameter, null, planeObj);
             context.addSceneObject(circle);
         }
         else {
-            center = normalizePoint2D(arguments[0]);
-            diameter = arguments[1] || 40;
+            center = normalizePoint2D(arguments[argOffset]);
+            diameter = arguments[argOffset + 1] || 40;
             circle = new Circle(diameter, null, planeObj);
             const move = new Move(center);
             context.addSceneObjects([move, circle]);

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

@@ -0,0 +1,35 @@
+import { Point2DLike } from "../../math/point.js";
+import { PlaneLike } from "../../math/plane.js";
+import { IExtrudableGeometry, ISceneObject } from "../interfaces.js";
+interface EllipseFunction {
+    /**
+     * Draws an ellipse at the current position.
+     * @param rx - Semi-radius along the plane's X axis
+     * @param ry - Semi-radius along the plane's Y axis
+     */
+    (rx: number, ry: number): IExtrudableGeometry;
+    /**
+     * Draws an ellipse at a given center.
+     * @param center - The center point
+     * @param rx - Semi-radius along the plane's X axis
+     * @param ry - Semi-radius along the plane's Y axis
+     */
+    (center: Point2DLike, rx: number, ry: number): IExtrudableGeometry;
+    /**
+     * Draws an ellipse on a specific plane.
+     * @param targetPlane - The plane to draw on
+     * @param rx - Semi-radius along the plane's X axis
+     * @param ry - Semi-radius along the plane's Y axis
+     */
+    (targetPlane: PlaneLike | ISceneObject, rx: number, ry: number): IExtrudableGeometry;
+    /**
+     * Draws an ellipse at a given center on a specific plane.
+     * @param targetPlane - The plane to draw on
+     * @param center - The center point in plane-local coordinates
+     * @param rx - Semi-radius along the plane's X axis
+     * @param ry - Semi-radius along the plane's Y axis
+     */
+    (targetPlane: PlaneLike | ISceneObject, center: Point2DLike, rx: number, ry: number): IExtrudableGeometry;
+}
+declare const _default: EllipseFunction;
+export default _default;

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

@@ -0,0 +1,65 @@
+import { Point2D, isPoint2DLike } from "../../math/point.js";
+import { LazyVertex } from "../../features/lazy-vertex.js";
+import { Ellipse } from "../../features/2d/ellipse.js";
+import { Move } from "../../features/2d/move.js";
+import { normalizePoint2D } from "../../helpers/normalize.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 toPoint2D(p) {
+    if (p instanceof Point2D) {
+        return p;
+    }
+    if (p instanceof LazyVertex) {
+        return p.asPoint2D();
+    }
+    if (Array.isArray(p)) {
+        return new Point2D(p[0], p[1]);
+    }
+    return new Point2D(p.x, p.y);
+}
+function build(context) {
+    return function ellipse() {
+        let planeObj = null;
+        let argOffset = 0;
+        if (arguments.length > 0) {
+            const firstArg = arguments[0];
+            if (isPlaneLike(firstArg) || (firstArg instanceof SceneObject && !isPoint2DLike(firstArg))) {
+                if (context.getActiveSketch() !== null) {
+                    throw new Error("ellipse(plane, ...) cannot be used inside a sketch. Use ellipse(...) instead.");
+                }
+                planeObj = resolvePlane(firstArg, context);
+                argOffset = 1;
+            }
+        }
+        const argCount = arguments.length - argOffset;
+        if (argCount === 2) {
+            const rx = arguments[argOffset];
+            const ry = arguments[argOffset + 1];
+            const e = new Ellipse(rx, ry, planeObj);
+            context.addSceneObject(e);
+            return e;
+        }
+        if (argCount === 3) {
+            const centerArg = arguments[argOffset];
+            const rx = arguments[argOffset + 1];
+            const ry = arguments[argOffset + 2];
+            if (planeObj) {
+                // Standalone (plane, center, rx, ry): center is plane-local. Move
+                // can't run outside a sketch, so resolve the center eagerly into the
+                // Ellipse via centerOverride.
+                const center = toPoint2D(centerArg);
+                const e = new Ellipse(rx, ry, planeObj, center);
+                context.addSceneObject(e);
+                return e;
+            }
+            const center = normalizePoint2D(centerArg);
+            const e = new Ellipse(rx, ry, null);
+            context.addSceneObjects([new Move(center), e]);
+            return e;
+        }
+        throw new Error("Invalid arguments for ellipse()");
+    };
+}
+export default registerBuilder(build);

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

@@ -1,33 +1,40 @@
 import { Point2DLike } from "../../math/point.js";
 import { PlaneLike } from "../../math/plane.js";
-import { IGeometry, ISceneObject } from "../interfaces.js";
+import { IHLine, ISceneObject } from "../interfaces.js";
 interface HLineFunction {
     /**
      * Draws a horizontal line of the given distance.
+     * Chain `.centered()` to center the line on the current position.
      * @param distance - The line length
-     * @param centered - Whether to center the line on the current position
      */
-    (distance: number, centered?: boolean): IGeometry;
+    (distance: number): IHLine;
+    /**
+     * Draws a horizontal line that ends where it intersects the target geometry.
+     * The nearest intersection (in either direction along the X axis) is used.
+     * @param target - The geometry to intersect with
+     */
+    (target: ISceneObject): IHLine;
     /**
      * Draws a horizontal line from a start point.
+     * Chain `.centered()` to center the line on the start point.
      * @param start - The start point
      * @param distance - The line length
-     * @param centered - Whether to center the line on the start point
      */
-    (start: Point2DLike, distance: number, centered?: boolean): IGeometry;
+    (start: Point2DLike, distance: number): IHLine;
     /**
-     * Draws a horizontal line on a specific plane.
-     * @param distance - The line length
-     * @param targetPlane - The plane to draw on
+     * Draws a horizontal line from a start point that ends where it intersects
+     * the target geometry. The nearest intersection (in either direction along
+     * the X axis) is used.
+     * @param start - The start point
+     * @param target - The geometry to intersect with
      */
-    (distance: number, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    (start: Point2DLike, target: ISceneObject): IHLine;
     /**
-     * Draws a horizontal line with centering on a specific plane.
-     * @param distance - The line length
-     * @param centered - Whether to center the line on the current position
+     * Draws a horizontal line on a specific plane.
      * @param targetPlane - The plane to draw on
+     * @param distance - The line length
      */
-    (distance: number, centered: boolean, targetPlane: PlaneLike | ISceneObject): IGeometry;
+    (targetPlane: PlaneLike | ISceneObject, distance: number): IHLine;
 }
 declare const _default: HLineFunction;
 export default _default;