fluidcad 0.0.33 → 0.0.35

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

@@ -1,27 +1,28 @@
 import { Point2DLike } from "../../math/point.js";
 import { PlaneLike } from "../../math/plane.js";
 import { IExtrudableGeometry, ISceneObject } from "../interfaces.js";
+import { type NumberParam } from "../param.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;
+    (rx: NumberParam, ry: NumberParam): 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;
+    (center: Point2DLike, rx: NumberParam, ry: NumberParam): 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;
+    (targetPlane: PlaneLike | ISceneObject, rx: NumberParam, ry: NumberParam): IExtrudableGeometry;
     /**
      * Draws an ellipse at a given center on a specific plane.
      * @param targetPlane - The plane to draw on
@@ -29,7 +30,7 @@ interface EllipseFunction {
      * @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;
+    (targetPlane: PlaneLike | ISceneObject, center: Point2DLike, rx: NumberParam, ry: NumberParam): IExtrudableGeometry;
 }
 declare const _default: EllipseFunction;
 export default _default;

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

@@ -7,6 +7,7 @@ import { registerBuilder } from "../../index.js";
 import { isPlaneLike } from "../../math/plane.js";
 import { SceneObject } from "../../common/scene-object.js";
 import { resolvePlane } from "../../helpers/resolve.js";
+import { resolveParam } from "../param.js";
 function toPoint2D(p) {
     if (p instanceof Point2D) {
         return p;
@@ -35,16 +36,16 @@ function build(context) {
         }
         const argCount = arguments.length - argOffset;
         if (argCount === 2) {
-            const rx = arguments[argOffset];
-            const ry = arguments[argOffset + 1];
+            const rx = resolveParam(arguments[argOffset]);
+            const ry = resolveParam(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];
+            const rx = resolveParam(arguments[argOffset + 1]);
+            const ry = resolveParam(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

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

@@ -1,13 +1,14 @@
 import { Point2DLike } from "../../math/point.js";
 import { PlaneLike } from "../../math/plane.js";
 import { IHLine, ISceneObject } from "../interfaces.js";
+import { type NumberParam } from "../param.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
      */
-    (distance: number): IHLine;
+    (distance: NumberParam): 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.
@@ -20,7 +21,7 @@ interface HLineFunction {
      * @param start - The start point
      * @param distance - The line length
      */
-    (start: Point2DLike, distance: number): IHLine;
+    (start: Point2DLike, distance: NumberParam): IHLine;
     /**
      * Draws a horizontal line from a start point that ends where it intersects
      * the target geometry. The nearest intersection (in either direction along
@@ -34,7 +35,7 @@ interface HLineFunction {
      * @param targetPlane - The plane to draw on
      * @param distance - The line length
      */
-    (targetPlane: PlaneLike | ISceneObject, distance: number): IHLine;
+    (targetPlane: PlaneLike | ISceneObject, distance: NumberParam): IHLine;
 }
 declare const _default: HLineFunction;
 export default _default;

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

@@ -6,6 +6,7 @@ import { registerBuilder } from "../../index.js";
 import { isPlaneLike } from "../../math/plane.js";
 import { SceneObject } from "../../common/scene-object.js";
 import { resolvePlane } from "../../helpers/resolve.js";
+import { isNumberParam, resolveParam } from "../param.js";
 function build(context) {
     return function line() {
         let planeObj = null;
@@ -35,18 +36,19 @@ function build(context) {
             context.addSceneObject(hline);
             return hline;
         }
-        if (argOffset === 0 && typeof arguments[0] !== 'number') {
+        if (argOffset === 0 && !isNumberParam(arguments[0])) {
             // hLine(start, distance) or hLine(start, target)
             const start = normalizePoint2D(arguments[0]);
             const second = arguments[1];
             const distanceOrTarget = second instanceof SceneObject
                 ? second
-                : second;
+                : resolveParam(second);
             const hline = new HorizontalLine(distanceOrTarget, planeObj);
+            hline.setHasExplicitStart();
             context.addSceneObjects([new Move(start), hline]);
             return hline;
         }
-        const distance = arguments[argOffset];
+        const distance = resolveParam(arguments[argOffset]);
         const hline = new HorizontalLine(distance, planeObj);
         context.addSceneObject(hline);
         return hline;

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

@@ -33,6 +33,7 @@ function build(context) {
             const start = normalizePoint2D(arguments[argOffset]);
             const end = normalizePoint2D(arguments[argOffset + 1]);
             line = new LineTo(end, planeObj);
+            line.setHasExplicitStart();
             context.addSceneObjects([new Move(start), line]);
         }
         else {

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

@@ -1,13 +1,14 @@
 import { PlaneLike } from "../../math/plane.js";
 import { IOffset, ISceneObject } from "../interfaces.js";
 import { Extrudable } from "../../helpers/types.js";
+import { type NumberParam, type BooleanParam } from "../param.js";
 interface OffsetFunction {
     /**
      * Offsets the current sketch geometry by the given distance.
      * @param distance - The offset distance (defaults to 1)
      * @param removeOriginal - Whether to remove the original geometry
      */
-    (distance?: number, removeOriginal?: boolean): IOffset;
+    (distance?: NumberParam, removeOriginal?: BooleanParam): IOffset;
     /**
      * Offsets source geometries onto a target plane.
      * @param targetPlane - The plane to offset onto
@@ -15,7 +16,7 @@ interface OffsetFunction {
      * @param removeOriginal - Whether to remove the original geometry
      * @param sourceGeometries - The geometries to offset
      */
-    (targetPlane: PlaneLike | ISceneObject, distance: number, removeOriginal: boolean, ...sourceGeometries: Extrudable[]): IOffset;
+    (targetPlane: PlaneLike | ISceneObject, distance: NumberParam, removeOriginal: BooleanParam, ...sourceGeometries: Extrudable[]): IOffset;
 }
 declare const _default: OffsetFunction;
 export default _default;

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

@@ -1,25 +1,26 @@
 import { Offset } from "../../features/2d/offset.js";
 import { registerBuilder } from "../../index.js";
 import { resolvePlane } from "../../helpers/resolve.js";
+import { isNumberParam, isBooleanParam, resolveParam } from "../param.js";
 function build(context) {
     return function offset(...args) {
         // Plane-first mode: offset(plane, distance, removeOriginal, ...sourceGeometries)
         // Detected when first arg is not a number/undefined.
-        if (args.length > 0 && args[0] !== undefined && typeof args[0] !== 'number' && typeof args[0] !== 'boolean') {
+        if (args.length > 0 && args[0] !== undefined && !isNumberParam(args[0]) && !isBooleanParam(args[0])) {
             if (context.getActiveSketch() !== null) {
                 throw new Error("offset(plane, ...) cannot be used inside a sketch. Use offset(...) instead.");
             }
             const planeObj = resolvePlane(args[0], context);
-            const distance = args[1] ?? 1;
-            const removeOriginal = args[2] ?? false;
+            const distance = resolveParam(args[1]) ?? 1;
+            const removeOriginal = resolveParam(args[2]) ?? false;
             const sourceObjects = args.slice(3);
             const off = new Offset(distance, removeOriginal, sourceObjects, planeObj);
             context.addSceneObject(off);
             return off;
         }
         // In-sketch mode: offset(distance, removeOriginal)
-        const distance = args[0] ?? 1;
-        const removeOriginal = args[1] ?? false;
+        const distance = isNumberParam(args[0]) ? resolveParam(args[0]) : 1;
+        const removeOriginal = isBooleanParam(args[1]) ? resolveParam(args[1]) : false;
         const off = new Offset(distance, removeOriginal);
         context.addSceneObject(off);
         return off;

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

@@ -2,6 +2,7 @@ import { Point2DLike } from "../../math/point.js";
 import { PolygonMode } from "../../features/2d/polygon.js";
 import { PlaneLike } from "../../math/plane.js";
 import { IPolygon, ISceneObject } from "../interfaces.js";
+import { type NumberParam } from "../param.js";
 interface PolygonFunction {
     /**
      * Draws a regular polygon with the given number of sides and diameter.
@@ -9,7 +10,7 @@ interface PolygonFunction {
      * @param diameter - The circumscribed or inscribed diameter
      * @param mode - `'inscribed'` or `'circumscribed'` (defaults to `'inscribed'`)
      */
-    (numberOfSides: number, diameter: number, mode?: PolygonMode): IPolygon;
+    (numberOfSides: NumberParam, diameter: NumberParam, mode?: PolygonMode): IPolygon;
     /**
      * Draws a regular polygon at a given center point.
      * @param center - The center point
@@ -17,14 +18,14 @@ interface PolygonFunction {
      * @param diameter - The circumscribed or inscribed diameter
      * @param mode - `'inscribed'` or `'circumscribed'` (defaults to `'inscribed'`)
      */
-    (center: Point2DLike, numberOfSides: number, diameter: number, mode?: PolygonMode): IPolygon;
+    (center: Point2DLike, numberOfSides: NumberParam, diameter: NumberParam, mode?: PolygonMode): IPolygon;
     /**
      * Draws a regular polygon on a specific plane.
      * @param targetPlane - The plane to draw on
      * @param numberOfSides - The number of sides
      * @param diameter - The circumscribed or inscribed diameter
      */
-    (targetPlane: PlaneLike | ISceneObject, numberOfSides: number, diameter: number): IPolygon;
+    (targetPlane: PlaneLike | ISceneObject, numberOfSides: NumberParam, diameter: NumberParam): IPolygon;
     /**
      * Draws a regular polygon with a given mode on a specific plane.
      * @param targetPlane - The plane to draw on
@@ -32,7 +33,7 @@ interface PolygonFunction {
      * @param diameter - The circumscribed or inscribed diameter
      * @param mode - `'inscribed'` or `'circumscribed'`
      */
-    (targetPlane: PlaneLike | ISceneObject, numberOfSides: number, diameter: number, mode: PolygonMode): IPolygon;
+    (targetPlane: PlaneLike | ISceneObject, numberOfSides: NumberParam, diameter: NumberParam, mode: PolygonMode): IPolygon;
 }
 declare const _default: PolygonFunction;
 export default _default;

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

@@ -6,6 +6,7 @@ import { registerBuilder } from "../../index.js";
 import { isPlaneLike } from "../../math/plane.js";
 import { SceneObject } from "../../common/scene-object.js";
 import { resolvePlane } from "../../helpers/resolve.js";
+import { isNumberParam, resolveParam } from "../param.js";
 function build(context) {
     return function polygon() {
         let numberOfSides;
@@ -30,24 +31,24 @@ function build(context) {
         }
         const argCount = arguments.length - argOffset;
         if (argCount === 2) {
-            numberOfSides = arguments[argOffset];
-            diameter = arguments[argOffset + 1];
+            numberOfSides = resolveParam(arguments[argOffset]);
+            diameter = resolveParam(arguments[argOffset + 1]);
             mode = 'inscribed';
             poly = new Polygon(numberOfSides, diameter, mode, planeObj);
             context.addSceneObject(poly);
         }
         else if (argCount === 3) {
-            if (typeof arguments[argOffset] === 'number') {
-                numberOfSides = arguments[argOffset];
-                diameter = arguments[argOffset + 1];
+            if (isNumberParam(arguments[argOffset])) {
+                numberOfSides = resolveParam(arguments[argOffset]);
+                diameter = resolveParam(arguments[argOffset + 1]);
                 mode = arguments[argOffset + 2];
                 poly = new Polygon(numberOfSides, diameter, mode, planeObj);
                 context.addSceneObject(poly);
             }
             else {
                 center = normalizePoint2D(arguments[argOffset]);
-                numberOfSides = arguments[argOffset + 1];
-                diameter = arguments[argOffset + 2];
+                numberOfSides = resolveParam(arguments[argOffset + 1]);
+                diameter = resolveParam(arguments[argOffset + 2]);
                 mode = 'inscribed';
                 poly = new Polygon(numberOfSides, diameter, mode, planeObj);
                 context.addSceneObjects([new Move(center), poly]);
@@ -55,8 +56,8 @@ function build(context) {
         }
         else if (argCount === 4) {
             center = normalizePoint2D(arguments[argOffset]);
-            numberOfSides = arguments[argOffset + 1];
-            diameter = arguments[argOffset + 2];
+            numberOfSides = resolveParam(arguments[argOffset + 1]);
+            diameter = resolveParam(arguments[argOffset + 2]);
             mode = arguments[argOffset + 3];
             poly = new Polygon(numberOfSides, diameter, mode, planeObj);
             context.addSceneObjects([new Move(center), poly]);

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

@@ -1,27 +1,28 @@
 import { Point2DLike } from "../../math/point.js";
 import { PlaneLike } from "../../math/plane.js";
 import { IRect, ISceneObject } from "../interfaces.js";
+import { type NumberParam } from "../param.js";
 interface RectFunction {
     /**
      * Draws a rectangle with the given width and optional height.
      * @param width - The rectangle width
      * @param height - The rectangle height (defaults to width)
      */
-    (width: number, height?: number): IRect;
+    (width: NumberParam, height?: NumberParam): IRect;
     /**
      * Draws a rectangle at a given start point.
      * @param start - The start point (bottom-left corner)
      * @param width - The rectangle width
      * @param height - The rectangle height (defaults to width)
      */
-    (start: Point2DLike, width: number, height?: number): IRect;
+    (start: Point2DLike, width: NumberParam, height?: NumberParam): IRect;
     /**
      * Draws a rectangle with given dimensions on a specific plane.
      * @param targetPlane - The plane to draw on
      * @param width - The rectangle width
      * @param height - The rectangle height
      */
-    (targetPlane: PlaneLike | ISceneObject, width: number, height: number): IRect;
+    (targetPlane: PlaneLike | ISceneObject, width: NumberParam, height: NumberParam): IRect;
 }
 declare const _default: RectFunction;
 export default _default;

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

@@ -6,6 +6,7 @@ import { registerBuilder } from "../../index.js";
 import { isPlaneLike } from "../../math/plane.js";
 import { SceneObject } from "../../common/scene-object.js";
 import { resolvePlane } from "../../helpers/resolve.js";
+import { isNumberParam, resolveParam } from "../param.js";
 function build(context) {
     return function cRect() {
         // Detect plane as first argument (only valid outside a sketch)
@@ -16,8 +17,8 @@ function build(context) {
                     throw new Error("rect(plane, ...) cannot be used inside a sketch. Use rect(...) instead.");
                 }
                 const planeObj = resolvePlane(firstArg, context);
-                const width = arguments[1];
-                const height = arguments[2];
+                const width = resolveParam(arguments[1]);
+                const height = resolveParam(arguments[2]);
                 const rect = new Rect(width, height, planeObj);
                 context.addSceneObject(rect);
                 return rect;
@@ -25,22 +26,22 @@ function build(context) {
         }
         const argCount = arguments.length;
         if (argCount === 1) {
-            const width = arguments[0];
+            const width = resolveParam(arguments[0]);
             const rect = new Rect(width, width);
             context.addSceneObject(rect);
             return rect;
         }
         else if (argCount === 2) {
-            if (typeof arguments[0] === 'number') {
-                const width = arguments[0];
-                const height = arguments[1];
+            if (isNumberParam(arguments[0])) {
+                const width = resolveParam(arguments[0]);
+                const height = resolveParam(arguments[1]);
                 const rect = new Rect(width, height);
                 context.addSceneObject(rect);
                 return rect;
             }
             else {
                 const start = normalizePoint2D(arguments[0]);
-                const width = arguments[1];
+                const width = resolveParam(arguments[1]);
                 const rect = new Rect(width, width);
                 context.addSceneObjects([new Move(start), rect]);
                 return rect;
@@ -48,8 +49,8 @@ function build(context) {
         }
         else if (argCount === 3) {
             const start = normalizePoint2D(arguments[0]);
-            const width = arguments[1];
-            const height = arguments[2];
+            const width = resolveParam(arguments[1]);
+            const height = resolveParam(arguments[2]);
             const rect = new Rect(width, height);
             context.addSceneObjects([new Move(start), rect]);
             return rect;

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

@@ -1,41 +1,49 @@
 import { Point2DLike } from "../../math/point.js";
 import { PlaneLike } from "../../math/plane.js";
 import { ISlot, ISceneObject } from "../interfaces.js";
+import { type NumberParam, type BooleanParam } from "../param.js";
 interface SlotFunction {
     /**
      * Draws a slot with the given length and end radius.
      * @param distance - The slot length
      * @param radius - The end cap radius
      */
-    (distance: number, radius: number): ISlot;
+    (distance: NumberParam, radius: NumberParam): ISlot;
     /**
      * Draws a slot on a specific plane.
      * @param targetPlane - The plane to draw on
      * @param distance - The slot length
      * @param radius - The end cap radius
      */
-    (targetPlane: PlaneLike | ISceneObject, distance: number, radius: number): ISlot;
+    (targetPlane: PlaneLike | ISceneObject, distance: NumberParam, radius: NumberParam): ISlot;
     /**
      * Draws a slot from a start point with the given length and end radius.
      * @param start - The start point
      * @param distance - The slot length
      * @param radius - The end cap radius
      */
-    (start: Point2DLike, distance: number, radius: number): ISlot;
+    (start: Point2DLike, distance: NumberParam, radius: NumberParam): ISlot;
+    /**
+     * Draws a slot between two cap-center points with the given radius.
+     * @param start - Center of the first cap
+     * @param end - Center of the second cap
+     * @param radius - The end cap radius
+     */
+    (start: Point2DLike, end: Point2DLike, radius: number): ISlot;
     /**
      * Creates a slot from a geometry edge with the given radius.
      * @param geometry - The source geometry edge
      * @param radius - The end cap radius
      * @param deleteSource - Whether to delete the source geometry (defaults to true)
      */
-    (geometry: ISceneObject, radius: number, deleteSource?: boolean): ISlot;
+    (geometry: ISceneObject, radius: NumberParam, deleteSource?: BooleanParam): ISlot;
     /**
      * Creates a slot from a geometry edge on a specific plane.
      * @param targetPlane - The plane to draw on
      * @param geometry - The source geometry edge
      * @param radius - The end cap radius
      */
-    (targetPlane: PlaneLike | ISceneObject, geometry: ISceneObject, radius: number): ISlot;
+    (targetPlane: PlaneLike | ISceneObject, geometry: ISceneObject, radius: NumberParam): ISlot;
     /**
      * Creates a slot from a geometry edge, optionally keeping the source, on a specific plane.
      * @param targetPlane - The plane to draw on
@@ -43,7 +51,7 @@ interface SlotFunction {
      * @param radius - The end cap radius
      * @param deleteSource - Whether to delete the source geometry
      */
-    (targetPlane: PlaneLike | ISceneObject, geometry: ISceneObject, radius: number, deleteSource: boolean): ISlot;
+    (targetPlane: PlaneLike | ISceneObject, geometry: ISceneObject, radius: NumberParam, deleteSource: BooleanParam): ISlot;
 }
 declare const _default: SlotFunction;
 export default _default;

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

@@ -7,6 +7,7 @@ import { registerBuilder } from "../../index.js";
 import { SceneObject } from "../../common/scene-object.js";
 import { isPlaneLike } from "../../math/plane.js";
 import { resolvePlane } from "../../helpers/resolve.js";
+import { isNumberParam, isBooleanParam, resolveParam } from "../param.js";
 function build(context) {
     return function slot() {
         const inSketch = context.getActiveSketch() !== null;
@@ -29,10 +30,10 @@ function build(context) {
         // SlotFromEdge path: first non-plane arg is a SceneObject (geometry)
         if (arguments[argOffset] instanceof SceneObject && !isPoint2DLike(arguments[argOffset])) {
             const geometry = arguments[argOffset];
-            const radius = arguments[argOffset + 1];
+            const radius = resolveParam(arguments[argOffset + 1]);
             let deleteSource = true;
-            if (arguments.length > argOffset + 2 && typeof arguments[argOffset + 2] === 'boolean') {
-                deleteSource = arguments[argOffset + 2];
+            if (arguments.length > argOffset + 2 && isBooleanParam(arguments[argOffset + 2])) {
+                deleteSource = resolveParam(arguments[argOffset + 2]);
             }
             const slotFromEdge = new SlotFromEdge(geometry, radius, deleteSource, planeObj);
             context.addSceneObject(slotFromEdge);
@@ -40,18 +41,28 @@ function build(context) {
         }
         const argCount = arguments.length - argOffset;
         // slot(distance, radius)
-        if (argCount === 2 && typeof arguments[argOffset] === 'number') {
-            const distance = arguments[argOffset];
-            const radius = arguments[argOffset + 1];
+        if (argCount === 2 && isNumberParam(arguments[argOffset])) {
+            const distance = resolveParam(arguments[argOffset]);
+            const radius = resolveParam(arguments[argOffset + 1]);
             const s = new Slot(distance, radius, planeObj);
             context.addSceneObject(s);
             return s;
         }
+        // slot(start, end, radius) — in-sketch only
+        if (argCount === 3 && argOffset === 0
+            && isPoint2DLike(arguments[0]) && isPoint2DLike(arguments[1])) {
+            const start = normalizePoint2D(arguments[0]);
+            const end = normalizePoint2D(arguments[1]);
+            const radius = arguments[2];
+            const s = Slot.fromTwoPoints(start, end, radius, planeObj);
+            context.addSceneObjects([new Move(start), s]);
+            return s;
+        }
         // slot(start, distance, radius) — in-sketch only
         if (argCount === 3 && argOffset === 0) {
             const start = normalizePoint2D(arguments[0]);
-            const distance = arguments[1];
-            const radius = arguments[2];
+            const distance = resolveParam(arguments[1]);
+            const radius = resolveParam(arguments[2]);
             const s = new Slot(distance, radius, planeObj);
             context.addSceneObjects([new Move(start), s]);
             return s;

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

@@ -1,7 +1,25 @@
 import { Point2DLike } from "../../math/point.js";
 import { QualifiedSceneObject } from "../../features/2d/constraints/qualified-geometry.js";
-import { IGeometry, ISceneObject, ITangentArcTwoObjects } from "../interfaces.js";
+import { IGeometry, ISceneObject, ITangentArcToObject, ITangentArcTwoObjects } from "../interfaces.js";
 interface TArcFunction {
+    /**
+     * Draws a tangent arc from the current position using the current tangent
+     * direction, ending tangent to a target line. The radius is solved
+     * automatically; the arc must be tangent to the target but does not need
+     * to touch its finite extent. By default the arc curves to the left of
+     * the start tangent — chain `.flip()` to curve to the right instead.
+     * @param target - The target line (or a qualified line)
+     */
+    (target: ISceneObject | QualifiedSceneObject): ITangentArcToObject;
+    /**
+     * Draws a tangent arc from the current position using the current tangent
+     * direction, with the given radius, ending at the first intersection with
+     * the target geometry along the arc's sweep direction. A negative radius
+     * flips the sweep direction. Supported targets: lines, circles, and arcs.
+     * @param radius - The arc radius. A negative value flips the sweep direction.
+     * @param target - The target geometry to intersect with
+     */
+    (radius: number, target: ISceneObject | QualifiedSceneObject): IGeometry;
     /**
      * Draws a tangent arc with a given radius and end angle.
      * @param radius - The arc radius (defaults to 100). A negative value flips the sweep direction.
@@ -34,7 +52,7 @@ interface TArcFunction {
      */
     (startPoint: Point2DLike, endPoint: Point2DLike, tangent: Point2DLike): IGeometry;
     /**
-     * Draws a tangent arc between two geometry objects.
+     * Draws all possible tangent arcs between two geometry objects.
      * @param c1 - The first geometry object
      * @param c2 - The second geometry object
      * @param radius - The arc radius

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

@@ -3,13 +3,37 @@ import { TangentArc } from "../../features/2d/tarc.js";
 import { TangentArcToPoint } from "../../features/2d/tarc-to-point.js";
 import { TangentArcToPointTangent } from "../../features/2d/tarc-to-point-tangent.js";
 import { TangentArcWithTangent } from "../../features/2d/tarc-with-tangent.js";
+import { TangentArcToObject } from "../../features/2d/tarc-to-object.js";
+import { TangentArcRadiusToObject } from "../../features/2d/tarc-radius-to-object.js";
 import { Move } from "../../features/2d/move.js";
 import { normalizePoint2D } from "../../helpers/normalize.js";
 import { registerBuilder } from "../../index.js";
 import { QualifiedSceneObject } from "../../features/2d/constraints/qualified-geometry.js";
 import { TangentArcTwoObjects } from "../../features/2d/tarc-constrained.js";
+import { SceneObject } from "../../common/scene-object.js";
 function build(context) {
     return function tarc() {
+        // tArc(target): single scene-object target, radius solved automatically.
+        // LazyVertex extends SceneObject but represents a point — fall through to the
+        // Point2DLike branch below so tArc(lazyVertex) becomes tArc(endPoint).
+        if (arguments.length === 1 &&
+            ((arguments[0] instanceof SceneObject && !isPoint2DLike(arguments[0])) ||
+                arguments[0] instanceof QualifiedSceneObject)) {
+            const target = QualifiedSceneObject.from(arguments[0]);
+            const arc = new TangentArcToObject(target);
+            context.addSceneObject(arc);
+            return arc;
+        }
+        // tArc(radius, target): explicit radius, end at first intersection with target
+        if (arguments.length === 2 &&
+            typeof arguments[0] === 'number' &&
+            (arguments[1] instanceof SceneObject || arguments[1] instanceof QualifiedSceneObject)) {
+            const radius = arguments[0];
+            const target = QualifiedSceneObject.from(arguments[1]);
+            const arc = new TangentArcRadiusToObject(radius, target);
+            context.addSceneObject(arc);
+            return arc;
+        }
         // tarc(c1, c2, radius): fillet arc tangent to two circles/points
         if ((arguments.length === 3 || arguments.length === 4) && typeof arguments[2] === 'number') {
             const o1 = isPoint2DLike(arguments[0]) ? normalizePoint2D(arguments[0]) : arguments[0];

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

@@ -1,13 +1,14 @@
 import { Point2DLike } from "../../math/point.js";
 import { PlaneLike } from "../../math/plane.js";
 import { IVLine, ISceneObject } from "../interfaces.js";
+import { type NumberParam } from "../param.js";
 interface VLineFunction {
     /**
      * Draws a vertical line of the given distance.
      * Chain `.centered()` to center the line on the current position.
      * @param distance - The line length
      */
-    (distance: number): IVLine;
+    (distance: NumberParam): IVLine;
     /**
      * Draws a vertical line that ends where it intersects the target geometry.
      * The nearest intersection (in either direction along the Y axis) is used.
@@ -20,7 +21,7 @@ interface VLineFunction {
      * @param start - The start point
      * @param distance - The line length
      */
-    (start: Point2DLike, distance: number): IVLine;
+    (start: Point2DLike, distance: NumberParam): IVLine;
     /**
      * Draws a vertical line from a start point that ends where it intersects
      * the target geometry. The nearest intersection (in either direction along
@@ -34,7 +35,7 @@ interface VLineFunction {
      * @param targetPlane - The plane to draw on
      * @param distance - The line length
      */
-    (targetPlane: PlaneLike | ISceneObject, distance: number): IVLine;
+    (targetPlane: PlaneLike | ISceneObject, distance: NumberParam): IVLine;
 }
 declare const _default: VLineFunction;
 export default _default;