fluidcad 0.0.33 → 0.0.35

package/bin/fluidcad.js

@@ -1,115 +1,29 @@
 #!/usr/bin/env node
 
-import { fork } from 'child_process';
-import { resolve, dirname } from 'path';
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
-import { parseArgs } from 'util';
-import { writeFileSync, existsSync } from 'fs';
-import { createFileWatcher, findFluidFiles } from './watcher.js';
+import { registerInitCommand } from './commands/init.js';
+import { registerServeCommand } from './commands/serve.js';
+import { registerMcpCommand } from './commands/mcp.js';
+import { registerPackCommand } from './commands/pack.js';
+import { registerLoginCommand } from './commands/login.js';
+import { registerPublishCommand } from './commands/publish.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(resolve(__dirname, '..', 'package.json'), 'utf8'));
 
-const { values, positionals } = parseArgs({
-  options: {
-    port: { type: 'string', short: 'p', default: '3100' },
-    workspace: { type: 'string', short: 'w', default: process.cwd() },
-  },
-  allowPositionals: true,
-});
+const program = new Command()
+  .name('fluidcad')
+  .description('FluidCAD CLI')
+  .version(pkg.version);
 
-if (positionals[0] === 'init') {
-  const cwd = process.cwd();
+registerInitCommand(program);
+registerServeCommand(program);
+registerMcpCommand(program);
+registerPackCommand(program);
+registerLoginCommand(program);
+registerPublishCommand(program);
 
-  const initPath = resolve(cwd, 'init.js');
-  if (existsSync(initPath)) {
-    console.error('init.js already exists in this directory.');
-    process.exit(1);
-  }
-
-  writeFileSync(initPath, `import { init } from 'fluidcad'\n\nexport default await init()\n`);
-
-  const testPath = resolve(cwd, 'test.fluid.js');
-  if (!existsSync(testPath)) {
-    writeFileSync(testPath, `import { extrude, fillet, rect, shell, sketch } from "fluidcad/core";
-
-sketch("xy", () => {
-    rect(100, 50).radius(10).centered();
-});
-
-const e = extrude(30);
-
-fillet(4, e.startEdges());
-
-shell(-2, e.endFaces());
-`);
-  }
-
-  const jsconfigPath = resolve(cwd, 'jsconfig.json');
-  if (!existsSync(jsconfigPath)) {
-    writeFileSync(jsconfigPath, JSON.stringify({
-      compilerOptions: {
-        checkJs: true,
-        module: 'node20',
-      },
-    }, null, 2) + '\n');
-  }
-
-  console.log('FluidCAD initialized.');
-  process.exit(0);
-}
-
-const serverEntry = resolve(__dirname, '..', 'server', 'dist', 'index.js');
-
-const server = fork(serverEntry, [], {
-  env: {
-    ...process.env,
-    FLUIDCAD_SERVER_PORT: values.port,
-    FLUIDCAD_WORKSPACE_PATH: resolve(values.workspace),
-  },
-  stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
-});
-
-server.stdout.on('data', (data) => {
-  process.stdout.write(data);
-});
-
-server.stderr.on('data', (data) => {
-  process.stderr.write(data);
-});
-
-const workspacePath = resolve(values.workspace);
-let watcher;
-
-server.on('message', (msg) => {
-  if (msg.type === 'ready') {
-    console.log(`FluidCAD server ready at ${msg.url}`);
-  }
-  if (msg.type === 'init-complete') {
-    if (msg.success) {
-      console.log('FluidCAD initialized successfully.');
-      watcher = createFileWatcher(workspacePath, server);
-
-      const files = findFluidFiles(workspacePath);
-      if (files.length > 0) {
-        server.send({ type: 'process-file', filePath: files[0] });
-      }
-    } else {
-      console.error(`FluidCAD initialization failed: ${msg.error}`);
-      process.exit(1);
-    }
-  }
-});
-
-server.on('exit', (code) => {
-  process.exit(code || 0);
-});
-
-process.on('SIGINT', () => {
-  if (watcher) { watcher.close(); }
-  server.kill('SIGINT');
-});
-
-process.on('SIGTERM', () => {
-  if (watcher) { watcher.close(); }
-  server.kill('SIGTERM');
-});
+program.parseAsync(process.argv);

package/bin/lib/api-client.js

@@ -0,0 +1,40 @@
+import { getHubUrl } from './config.js';
+
+/**
+ * Tiny client for the hub API. The CLI commands are pure API clients — open a
+ * browser, store a token, POST a package — so this just wraps `fetch` with the
+ * bearer header and a uniform `{ status, body }` result.
+ */
+export class HubClient {
+  constructor(hubUrl, token) {
+    this.base = getHubUrl(hubUrl);
+    this.token = token;
+  }
+
+  #authHeaders(extra = {}) {
+    return { ...(this.token ? { authorization: `Bearer ${this.token}` } : {}), ...extra };
+  }
+
+  async #result(res) {
+    const body = await res.json().catch(() => ({}));
+    return { status: res.status, body };
+  }
+
+  async postJson(path, body) {
+    const res = await fetch(this.base + path, {
+      method: 'POST',
+      headers: this.#authHeaders({ 'content-type': 'application/json' }),
+      body: JSON.stringify(body),
+    });
+    return this.#result(res);
+  }
+
+  async postForm(path, form) {
+    const res = await fetch(this.base + path, {
+      method: 'POST',
+      headers: this.#authHeaders(),
+      body: form,
+    });
+    return this.#result(res);
+  }
+}

package/bin/lib/browser.js

@@ -0,0 +1,16 @@
+import open from 'open';
+
+/**
+ * Best-effort browser open, shared by `login` and `publish`. The caller always
+ * prints the URL too, so a failure here (headless box, SSH, no DISPLAY) is
+ * non-fatal — the user can open it manually.
+ */
+export async function openBrowser(url) {
+  try {
+    const child = await open(url);
+    // Detach so a one-shot CLI process isn't held open by the browser handle.
+    child.unref?.();
+  } catch {
+    /* ignore — the URL is printed regardless */
+  }
+}

package/bin/lib/config.js

@@ -0,0 +1,39 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { mkdirSync, readFileSync, writeFileSync, existsSync, chmodSync } from 'fs';
+
+// Where the CLI keeps its hub credentials. XDG-ish; one file, mode 0600.
+const CONFIG_DIR = join(homedir(), '.config', 'fluidcad');
+export const CREDENTIALS_PATH = join(CONFIG_DIR, 'credentials.json');
+
+const DEFAULT_HUB_URL = 'https://hub.fluidcad.io';
+
+/** Resolve the hub base URL: explicit override → $FLUIDCAD_HUB_URL → default. */
+export function getHubUrl(override) {
+  const url = override || process.env.FLUIDCAD_HUB_URL || DEFAULT_HUB_URL;
+  return url.replace(/\/+$/, '');
+}
+
+/** Read saved credentials, or null if not logged in / unreadable. */
+export function readCredentials() {
+  try {
+    const creds = JSON.parse(readFileSync(CREDENTIALS_PATH, 'utf8'));
+    return creds && creds.token ? creds : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Persist credentials at mode 0600 (re-chmod in case the file pre-existed). */
+export function writeCredentials(creds) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2) + '\n', { mode: 0o600 });
+  chmodSync(CREDENTIALS_PATH, 0o600);
+}
+
+/** Forget saved credentials (used by `logout`). */
+export function clearCredentials() {
+  if (existsSync(CREDENTIALS_PATH)) {
+    writeFileSync(CREDENTIALS_PATH, '{}\n', { mode: 0o600 });
+  }
+}

package/bin/lib/model-config.js

@@ -0,0 +1,38 @@
+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;
+}
+
+/**
+ * Persist the hub-minted model id, preserving any other fields already in
+ * `fluidcad.json`. Called after the first publish writes back the new id.
+ */
+export function writeModelId(workspace, modelId) {
+  const cfg = readModelConfig(workspace);
+  cfg.modelId = modelId;
+  writeFileSync(modelConfigPath(workspace), JSON.stringify(cfg, null, 2) + '\n');
+}

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

@@ -2,6 +2,7 @@ import { Shape, ShapeFilter } from "./shape.js";
 import { Face } from "./face.js";
 import { Edge } from "./edge.js";
 import { Matrix4 } from "../math/matrix4.js";
+import { LazyMatrix } from "../math/lazy-matrix.js";
 import { ISceneObject } from "../core/interfaces.js";
 import { FusionScope, OperationMode } from "../features/extrude-options.js";
 import { ShapeType } from "./shape-type.js";
@@ -90,7 +91,7 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     clone(): SceneObject[];
-    setTransform(matrix: Matrix4): void;
+    setTransform(matrix: Matrix4 | LazyMatrix): void;
     getTransform(): Matrix4 | null;
     setCloneSource(source: SceneObject): void;
     getCloneSource(): SceneObject | null;

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

@@ -1,4 +1,5 @@
 import { randomUUID } from "crypto";
+import { LazyMatrix } from "../math/lazy-matrix.js";
 export class SceneObject {
     state;
     children = [];
@@ -200,10 +201,10 @@ export class SceneObject {
         return result;
     }
     setTransform(matrix) {
-        this._transform = matrix;
+        this._transform = matrix instanceof LazyMatrix ? matrix : LazyMatrix.of(matrix);
     }
     getTransform() {
-        return this._transform;
+        return this._transform ? this._transform.resolve() : null;
     }
     setCloneSource(source) {
         this._cloneSource = source;

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]);