fluidcad 0.0.34 → 0.0.36

package/bin/lib/model-config.js

@@ -0,0 +1,61 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+// `fluidcad.json` at the workspace root holds the stable, hub-minted model
+// identity (and room to grow: default visibility, name, …). It's meant to be
+// committed — like `fly.toml`, it ties a workspace to the model it publishes
+// to, so re-publishing creates a new VERSION rather than an unrelated model.
+const FILENAME = 'fluidcad.json';
+
+export function modelConfigPath(workspace) {
+  return join(workspace, FILENAME);
+}
+
+/** Read `fluidcad.json`, or an empty object if missing/unreadable. */
+export function readModelConfig(workspace) {
+  try {
+    const cfg = JSON.parse(readFileSync(modelConfigPath(workspace), 'utf8'));
+    return cfg && typeof cfg === 'object' ? cfg : {};
+  } catch {
+    return {};
+  }
+}
+
+/** The persisted hub model id for this workspace, or null on first publish. */
+export function readModelId(workspace) {
+  const cfg = readModelConfig(workspace);
+  return typeof cfg.modelId === 'string' && cfg.modelId ? cfg.modelId : null;
+}
+
+/**
+ * The persisted identity for this workspace: the hub model `id` and its
+ * last-known `name`. Both come back null when absent — first publish, or a
+ * `fluidcad.json` the user deleted. The name is shown in the publish prompt so
+ * we can name the model offline without a round-trip.
+ */
+export function readModelIdentity(workspace) {
+  const cfg = readModelConfig(workspace);
+  return {
+    modelId: typeof cfg.modelId === 'string' && cfg.modelId ? cfg.modelId : null,
+    name: typeof cfg.name === 'string' && cfg.name ? cfg.name : null,
+  };
+}
+
+/**
+ * Shallow-merge `patch` into `fluidcad.json`, preserving any other fields, and
+ * write it back (creating the file if needed). `undefined`/`null` values in the
+ * patch are skipped, so callers can pass a partial identity without clobbering
+ * what's already there.
+ */
+export function writeModelConfig(workspace, patch) {
+  const cfg = readModelConfig(workspace);
+  for (const [key, value] of Object.entries(patch)) {
+    if (value !== undefined && value !== null) cfg[key] = value;
+  }
+  writeFileSync(modelConfigPath(workspace), JSON.stringify(cfg, null, 2) + '\n');
+}
+
+/** Persist just the hub-minted model id (thin wrapper over `writeModelConfig`). */
+export function writeModelId(workspace, modelId) {
+  writeModelConfig(workspace, { modelId });
+}

package/bin/lib/prompt.js

@@ -0,0 +1,97 @@
+import { emitKeypressEvents } from 'readline';
+
+/**
+ * Minimal interactive prompts for the CLI, built on Node's built-in `readline`
+ * keypress events — no dependency (the CLI only ships `commander`). Used by
+ * `publish` to choose between a new model and a new version.
+ */
+
+/**
+ * Whether we can run an interactive prompt — both stdin and stdout must be a
+ * TTY. CI and piped input are not, so callers fall back to flags/defaults there.
+ */
+export function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+const HIDE_CURSOR = '\x1b[?25l';
+const SHOW_CURSOR = '\x1b[?25h';
+const CLEAR_LINE = '\x1b[2K';
+const CYAN = '\x1b[36m';
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+
+/**
+ * Arrow-key (or j/k) single-select. Renders a menu with one highlighted row,
+ * moves the highlight on ↑/↓/k/j, confirms on Enter, and aborts on Ctrl-C.
+ * Resolves to the chosen entry's `value`. Assumes `isInteractive()` — it puts
+ * stdin in raw mode, so don't call it without a TTY.
+ *
+ * `choices`: `[{ label, value }]`.
+ */
+export function select(message, choices) {
+  return new Promise((resolveChoice) => {
+    const input = process.stdin;
+    const output = process.stdout;
+    let active = 0;
+
+    // Truncate labels so a long one never wraps — a wrapped row would occupy two
+    // terminal lines and throw off the cursor-up redraw math below.
+    const width = Math.max(8, (output.columns || 80) - 2);
+    const fit = (s) => (s.length > width ? s.slice(0, width - 1) + '…' : s);
+
+    output.write(`${message}\n`);
+    output.write(`${DIM}  ↑/↓ or j/k to move · Enter to confirm${RESET}\n`);
+    output.write(HIDE_CURSOR);
+
+    const draw = (initial) => {
+      if (!initial) output.write(`\x1b[${choices.length}A`); // back up to the first row
+      choices.forEach((c, i) => {
+        const on = i === active;
+        const row = `${on ? '❯' : ' '} ${fit(c.label)}`;
+        output.write(`${CLEAR_LINE}${on ? `${CYAN}${row}${RESET}` : row}\n`);
+      });
+    };
+    draw(true);
+
+    emitKeypressEvents(input);
+    const wasRaw = Boolean(input.isRaw);
+    input.setRawMode(true);
+    input.resume();
+
+    const restore = () => {
+      input.removeListener('keypress', onKey);
+      input.setRawMode(wasRaw);
+      input.pause();
+      output.write(SHOW_CURSOR);
+    };
+
+    const onKey = (_str, key) => {
+      if (!key) return;
+      if (key.ctrl && key.name === 'c') {
+        restore();
+        output.write('\n');
+        process.exit(130); // 128 + SIGINT, the shell convention for Ctrl-C
+      }
+      switch (key.name) {
+        case 'up':
+        case 'k':
+          active = (active - 1 + choices.length) % choices.length;
+          draw(false);
+          break;
+        case 'down':
+        case 'j':
+          active = (active + 1) % choices.length;
+          draw(false);
+          break;
+        case 'return':
+        case 'enter':
+          restore();
+          resolveChoice(choices[active].value);
+          break;
+      }
+    };
+
+    input.on('keypress', onKey);
+  });
+}

package/bin/lib/workspace.js

@@ -0,0 +1,57 @@
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Shared by `pack` and `publish`: both resolve the entry `.fluid.js` the same
+// way and stamp the same fluidcad version onto the package.
+
+/** The installed fluidcad version (from the package's own package.json). */
+export function readPackageVersion() {
+  try {
+    const pkgPath = resolve(__dirname, '..', '..', 'package.json');
+    return JSON.parse(readFileSync(pkgPath, 'utf8')).version ?? '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+/**
+ * Read the MODEL workspace's own `package.json` for publish prefills: name and
+ * description (→ short description). Distinct from `readPackageVersion`, which
+ * reads the fluidcad engine's version. Missing/unreadable fields come back
+ * undefined. (The published version number is hub-assigned, not read here.)
+ */
+export function readWorkspacePackage(workspace) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(workspace, 'package.json'), 'utf8'));
+    return {
+      name: typeof pkg.name === 'string' ? pkg.name : undefined,
+      description: typeof pkg.description === 'string' ? pkg.description : undefined,
+    };
+  } catch {
+    return {};
+  }
+}
+
+/** Resolve the entry `.fluid.js`: the override if given, else the sole one. */
+export function findEntry(workspace, override) {
+  if (override) {
+    const abs = resolve(workspace, override);
+    if (!existsSync(abs)) {
+      throw new Error(`Entry file not found: ${abs}`);
+    }
+    return abs;
+  }
+  const candidates = readdirSync(workspace).filter((f) => f.endsWith('.fluid.js'));
+  if (candidates.length === 0) {
+    throw new Error('No .fluid.js files found in the workspace. Pass --entry to specify one.');
+  }
+  if (candidates.length > 1) {
+    throw new Error(
+      `Multiple .fluid.js files found: ${candidates.join(', ')}. Pass --entry to choose one.`,
+    );
+  }
+  return resolve(workspace, candidates[0]);
+}

package/lib/dist/common/shape-factory.d.ts

@@ -3,6 +3,7 @@ import { Solid } from "./solid.js";
 import { Wire } from "./wire.js";
 import { Face } from "./face.js";
 import { Edge } from "./edge.js";
+import { Vertex } from "./vertex.js";
 export declare class ShapeFactory {
-    static fromShape(shape: TopoDS_Shape): Edge | Wire | Solid | Face;
+    static fromShape(shape: TopoDS_Shape): Vertex | Edge | Wire | Solid | Face;
 }

package/lib/dist/common/shape-factory.js

@@ -3,6 +3,7 @@ import { Solid } from "./solid.js";
 import { Wire } from "./wire.js";
 import { Face } from "./face.js";
 import { Edge } from "./edge.js";
+import { Vertex } from "./vertex.js";
 export class ShapeFactory {
     static fromShape(shape) {
         if (Explorer.isSolid(shape)) {
@@ -17,6 +18,9 @@ export class ShapeFactory {
         if (Explorer.isEdge(shape)) {
             return Edge.fromTopoDSEdge(Explorer.toEdge(shape));
         }
+        if (Explorer.isVertex(shape)) {
+            return Vertex.fromTopoDSVertex(Explorer.toVertex(shape));
+        }
         if (Explorer.isCompound(shape) || Explorer.isCompoundSolid(shape)) {
             const solids = Explorer.findShapes(shape, Explorer.getOcShapeType("solid"));
             if (solids.length === 1) {

package/lib/dist/common/transformable-primitive.d.ts

@@ -3,14 +3,15 @@ import { Matrix4 } from "../math/matrix4.js";
 import type { AxisLike } from "../math/axis.js";
 import type { PlaneLike } from "../math/plane.js";
 import type { PointLike } from "../math/point.js";
+import { type NumberParam } from "../core/param.js";
 export declare abstract class TransformablePrimitive extends SceneObject {
     transform(matrix: Matrix4): this;
-    translate(x: number): this;
-    translate(x: number, y: number): this;
-    translate(x: number, y: number, z: number): this;
+    translate(x: NumberParam): this;
+    translate(x: NumberParam, y: NumberParam): this;
+    translate(x: NumberParam, y: NumberParam, z: NumberParam): this;
     translate(p: PointLike): this;
-    rotate(angle: number): this;
-    rotate(axis: AxisLike, angle: number): this;
+    rotate(angle: NumberParam): this;
+    rotate(axis: AxisLike, angle: NumberParam): this;
     mirror(plane: PlaneLike): this;
     mirror(axis: AxisLike): this;
 }

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

@@ -3,6 +3,7 @@ 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 { isNumberParam, resolveParam } from "../core/param.js";
 export class TransformablePrimitive extends SceneObject {
     transform(matrix) {
         this.composeAppliedTransform(matrix);
@@ -10,10 +11,10 @@ export class TransformablePrimitive extends SceneObject {
     }
     translate(a, b, c) {
         let x, y, z;
-        if (typeof a === 'number') {
-            x = a;
-            y = b ?? 0;
-            z = c ?? 0;
+        if (isNumberParam(a)) {
+            x = resolveParam(a);
+            y = b != null ? resolveParam(b) : 0;
+            z = c != null ? resolveParam(c) : 0;
         }
         else if (Array.isArray(a)) {
             x = a[0] ?? 0;
@@ -31,16 +32,16 @@ export class TransformablePrimitive extends SceneObject {
         let origin;
         let direction;
         let angleDeg;
-        if (typeof a === 'number') {
+        if (isNumberParam(a)) {
             origin = new Point(0, 0, 0);
             direction = Vector3d.unitZ();
-            angleDeg = a;
+            angleDeg = resolveParam(a);
         }
         else {
             const resolved = resolveAxisLike(a);
             origin = resolved.origin;
             direction = resolved.direction;
-            angleDeg = b;
+            angleDeg = resolveParam(b);
         }
         return this.transform(Matrix4.fromRotationAroundAxis(origin, direction, rad(angleDeg)));
     }

package/lib/dist/common/vertex.js

@@ -29,7 +29,6 @@ export class Vertex extends Shape {
         return new Vertex(vertex);
     }
     static fromPoint2D(point) {
-        console.log("Creating vertex from point2D:", point);
         return Vertex.fromPoint(new Point(point.x, point.y, 0));
     }
     compareTo(other) {

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

@@ -1,5 +1,6 @@
 import { PlaneLike } from "../../math/plane.js";
 import { IALine, ISceneObject } from "../interfaces.js";
+import { type NumberParam } from "../param.js";
 interface ALineFunction {
     /**
      * Draws a line at the given angle with the given length.
@@ -7,7 +8,7 @@ interface ALineFunction {
      * @param angle - The angle in degrees
      * @param length - The line length
      */
-    (angle: number, length: number): IALine;
+    (angle: NumberParam, length: NumberParam): IALine;
     /**
      * 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
@@ -15,14 +16,14 @@ interface ALineFunction {
      * @param angle - The angle in degrees
      * @param target - The geometry to intersect with
      */
-    (angle: number, target: ISceneObject): IALine;
+    (angle: NumberParam, target: ISceneObject): IALine;
     /**
      * 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
      */
-    (targetPlane: PlaneLike | ISceneObject, angle: number, length: number): IALine;
+    (targetPlane: PlaneLike | ISceneObject, angle: NumberParam, length: NumberParam): IALine;
 }
 declare const _default: ALineFunction;
 export default _default;

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

@@ -3,6 +3,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 build(context) {
     return function line() {
         let planeObj = null;
@@ -22,11 +23,11 @@ function build(context) {
                 argOffset = 1;
             }
         }
-        const angle = arguments[argOffset];
+        const angle = resolveParam(arguments[argOffset]);
         const second = arguments[argOffset + 1];
         const lengthOrTarget = second instanceof SceneObject
             ? second
-            : second;
+            : resolveParam(second);
         const aline = new AngledLine(angle, lengthOrTarget, planeObj);
         context.addSceneObject(aline);
         return aline;

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

@@ -1,6 +1,7 @@
 import { Point2DLike } from "../../math/point.js";
 import { PlaneLike } from "../../math/plane.js";
 import { IArcPoints, IArcAngles, ISceneObject } from "../interfaces.js";
+import { type NumberParam } from "../param.js";
 interface ArcFunction {
     /**
      * Draws an arc to an end point from the current position.
@@ -25,7 +26,7 @@ interface ArcFunction {
      * @param startAngle - The start angle in degrees, relative to the current tangent (defaults to 0)
      * @param endAngle - The end angle in degrees, relative to the current tangent (defaults to 180)
      */
-    (radius: number, startAngle?: number, endAngle?: number): IArcAngles;
+    (radius: NumberParam, startAngle?: NumberParam, endAngle?: NumberParam): IArcAngles;
     /**
      * Draws an arc to an end point on a specific plane.
      * @param targetPlane - The plane to draw on
@@ -46,7 +47,7 @@ interface ArcFunction {
      * @param startAngle - The start angle in degrees
      * @param endAngle - The end angle in degrees
      */
-    (targetPlane: PlaneLike | ISceneObject, radius: number, startAngle: number, endAngle: number): IArcAngles;
+    (targetPlane: PlaneLike | ISceneObject, radius: NumberParam, startAngle: NumberParam, endAngle: NumberParam): IArcAngles;
 }
 declare const _default: ArcFunction;
 export default _default;

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

@@ -5,6 +5,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 build(context) {
     return function arc() {
         let planeObj = null;
@@ -37,9 +38,9 @@ function build(context) {
             return arcObj;
         }
         // (radius, startAngle?, endAngle?) — all numeric args
-        const radius = arguments[argOffset] || 100;
-        const startAngle = arguments[argOffset + 1] || 0;
-        const endAngle = argCount >= 3 ? arguments[argOffset + 2] : 180;
+        const radius = resolveParam(arguments[argOffset]) || 100;
+        const startAngle = resolveParam(arguments[argOffset + 1]) || 0;
+        const endAngle = argCount >= 3 ? resolveParam(arguments[argOffset + 2]) : 180;
         const arcObj = Arc.fromAngles(radius, startAngle, endAngle, planeObj);
         context.addSceneObject(arcObj);
         return arcObj;

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

@@ -2,13 +2,15 @@ import { Point2DLike } from "../../math/point.js";
 import { IGeometry } from "../interfaces.js";
 interface BezierFunction {
     /**
-     * Draws a bezier curve from the current position through control points to the end point.
-     * The last argument is the endpoint; all preceding arguments are control points.
+     * Draws a bezier curve through the given points. The first argument is the
+     * explicit start, the last is the endpoint, and any in between are control
+     * points. Sets the sketch cursor to the endpoint.
      * With 0 args: interactive mode placeholder (no geometry).
-     * With 1 arg: degree 1 (line).
-     * With 2 args: degree 2 (quadratic bezier).
-     * With 3 args: degree 3 (cubic bezier).
-     * @param points - Control points and end point
+     * With 1 arg: places only the start point (no curve yet).
+     * With 2 args: degree 1 (straight line from start to end).
+     * With 3 args: degree 2 (quadratic bezier with 1 control point).
+     * With 4 args: degree 3 (cubic bezier with 2 control points).
+     * @param points - Start, optional control points, and end point
      */
     (...points: Point2DLike[]): IGeometry;
 }

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

@@ -1,24 +1,25 @@
 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 CircleFunction {
     /**
      * Draws a circle at a given center with an optional diameter.
      * @param center - The center point
      * @param diameter - The circle diameter (defaults to 40)
      */
-    (center: Point2DLike, diameter?: number): IExtrudableGeometry;
+    (center: Point2DLike, diameter?: NumberParam): IExtrudableGeometry;
     /**
      * Draws a circle at the origin with an optional diameter.
      * @param diameter - The circle diameter (defaults to 40)
      */
-    (diameter?: number): IExtrudableGeometry;
+    (diameter?: NumberParam): IExtrudableGeometry;
     /**
      * Draws a circle with a given diameter on a specific plane.
      * @param targetPlane - The plane to draw on
      * @param diameter - The circle diameter
      */
-    (targetPlane: PlaneLike | ISceneObject, diameter: number): IExtrudableGeometry;
+    (targetPlane: PlaneLike | ISceneObject, diameter: NumberParam): IExtrudableGeometry;
 }
 declare const _default: CircleFunction;
 export default _default;

package/lib/dist/core/2d/circle.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 { resolveParam } from "../param.js";
 function build(context) {
     return function circle() {
         let diameter;
@@ -31,13 +32,13 @@ function build(context) {
             context.addSceneObject(circle);
         }
         else if (argCount === 1) {
-            diameter = arguments[argOffset] || 40;
+            diameter = resolveParam(arguments[argOffset]) || 40;
             circle = new Circle(diameter, null, planeObj);
             context.addSceneObject(circle);
         }
         else {
             center = normalizePoint2D(arguments[argOffset]);
-            diameter = arguments[argOffset + 1] || 40;
+            diameter = resolveParam(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

@@ -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 {