fluidcad 0.0.35 → 0.0.37

package/bin/commands/publish.js

@@ -2,7 +2,8 @@ import { resolve } from 'path';
 import { getHubUrl, readCredentials } from '../lib/config.js';
 import { HubClient } from '../lib/api-client.js';
 import { findEntry, readPackageVersion, readWorkspacePackage } from '../lib/workspace.js';
-import { readModelId, writeModelId } from '../lib/model-config.js';
+import { readModelIdentity, writeModelConfig } from '../lib/model-config.js';
+import { isInteractive, select } from '../lib/prompt.js';
 import { openBrowser } from '../lib/browser.js';
 
 async function runPublish(opts) {
@@ -20,7 +21,31 @@ async function runPublish(opts) {
   const pkg = readWorkspacePackage(workspace);
   const name = opts.name ?? pkg.name;
   const description = opts.description ?? pkg.description;
-  const modelId = readModelId(workspace);
+  const { modelId: priorModelId, name: priorName } = readModelIdentity(workspace);
+
+  // Surface who we are and where this is going *before* any bytes leave the
+  // machine, so a wrong account or hub is caught before the upload starts.
+  // (The model's own page URL is minted by the hub and printed afterwards.)
+  console.log('Publishing to the FluidCAD hub:');
+  console.log(`  account: ${creds.email || '(unknown account)'}`);
+  console.log(`  url:     ${hubUrl}`);
+  console.log('');
+
+  // Decide new-model vs new-version BEFORE the heavy build, so the user makes
+  // the call (and we do any model-list lookup) without first waiting ~110ms for
+  // the engine to load. A null target ⇒ the hub mints a fresh model.
+  const targetModelId = await resolveTargetModel({
+    opts,
+    hubUrl,
+    token: creds.token,
+    priorModelId,
+    priorName,
+  });
+  console.log(
+    targetModelId
+      ? `Publishing a new version${priorName ? ` of ${priorName}` : ''}.\n`
+      : 'Publishing as a new model.\n',
+  );
 
   // Render once to capture the full param schema for the manifest. This also
   // acts as a build gate — a compile/runtime error fails the publish here,
@@ -66,8 +91,8 @@ async function runPublish(opts) {
 
   const form = new FormData();
   form.append('fluidpkg', new Blob([zip], { type: 'application/zip' }), 'model.fluidpkg');
-  if (modelId) {
-    form.append('modelId', modelId);
+  if (targetModelId) {
+    form.append('modelId', targetModelId);
   }
   if (name) {
     form.append('name', name);
@@ -90,10 +115,12 @@ async function runPublish(opts) {
     throw new Error(body.error || `Publish failed (HTTP ${status})`);
   }
 
-  // First publish for this workspace → persist the hub-minted id so the next
-  // publish lands as a new version of the same model.
-  if (!modelId && body.modelId) {
-    writeModelId(workspace, body.modelId);
+  // Persist the hub-authoritative id (and the name we used) whenever it changed
+  // or the workspace had no config — covers the first publish, a deliberate new
+  // model, and re-attaching a deleted fluidcad.json (the user picked an existing
+  // model from the list). An owned-match with an unchanged name is a no-op.
+  if (body.modelId && (body.modelId !== priorModelId || (name && name !== priorName))) {
+    writeModelConfig(workspace, { modelId: body.modelId, name });
   }
 
   console.log('');
@@ -113,6 +140,72 @@ async function runPublish(opts) {
   }
 }
 
+/**
+ * Decide which model this publish targets: an existing model id (→ a new
+ * version) or null (→ the hub mints a new model). Honors --new-model /
+ * --new-version; otherwise asks when interactive; and with no TTY falls back to
+ * today's behavior (a saved fluidcad.json id ⇒ a version, else a new model).
+ */
+async function resolveTargetModel({ opts, hubUrl, token, priorModelId, priorName }) {
+  if (opts.newModel && opts.newVersion) {
+    throw new Error('Pass only one of --new-model / --new-version.');
+  }
+  if (opts.newModel) return null;
+  if (opts.newVersion) {
+    if (priorModelId) return priorModelId;
+    if (isInteractive()) return pickExistingModel(hubUrl, token);
+    throw new Error(
+      'No fluidcad.json here, so there is no model to version. Drop --new-version to ' +
+        'publish a new model, or run interactively to pick an existing one.',
+    );
+  }
+
+  // No explicit flag.
+  if (!isInteractive()) {
+    // Non-interactive (CI, piped input): keep the historical default.
+    return priorModelId;
+  }
+  if (priorModelId) {
+    const label = priorName ? `${priorName} (${priorModelId})` : priorModelId;
+    return select('How should this publish go up?', [
+      { label: `Publish a new version of ${label}`, value: priorModelId },
+      { label: 'Publish as a new model', value: null },
+    ]);
+  }
+  const choice = await select('How should this publish go up?', [
+    { label: 'Publish a new version of an existing model', value: '__existing__' },
+    { label: 'Publish as a new model', value: null },
+  ]);
+  return choice === '__existing__' ? pickExistingModel(hubUrl, token) : null;
+}
+
+/**
+ * Fetch the user's own models from the hub and let them pick which one this is a
+ * new version of. Returns the chosen model id, or null when they have none yet
+ * (the caller then mints a new model).
+ */
+async function pickExistingModel(hubUrl, token) {
+  const { status, body } = await new HubClient(hubUrl, token).getJson('/api/cli/models');
+  if (status === 401) {
+    throw new Error('Your session has expired. Run `fluidcad login` again.');
+  }
+  if (status !== 200) {
+    throw new Error(body.error || `Could not list your models (HTTP ${status})`);
+  }
+  const models = Array.isArray(body.models) ? body.models : [];
+  if (models.length === 0) {
+    console.log('\nYou have no models on the hub yet — publishing this as a new model.\n');
+    return null;
+  }
+  return select(
+    'Which model is this a new version of?',
+    models.map((m) => ({
+      label: `${m.name} · ${m.latestVersion ? 'v' + m.latestVersion : 'no versions yet'}`,
+      value: m.id,
+    })),
+  );
+}
+
 export function registerPublishCommand(program) {
   program
     .command('publish')
@@ -121,6 +214,8 @@ export function registerPublishCommand(program) {
     .option('-e, --entry <file>', 'Entry .fluid.js file (auto-detected if only one exists)')
     .option('-n, --name <name>', 'Model name (defaults to the package name)')
     .option('-d, --description <text>', 'Optional human description')
+    .option('--new-model', 'Publish as a new model, ignoring any saved model id')
+    .option('--new-version', 'Publish a new version of the saved (or chosen) model')
     .option('--visibility <visibility>', 'public | unlisted | private (default: unlisted)')
     .option('--hub <url>', 'Hub base URL (default: the hub you logged into)')
     .action((opts) => {

package/bin/lib/api-client.js

@@ -20,6 +20,14 @@ export class HubClient {
     return { status: res.status, body };
   }
 
+  async getJson(path) {
+    const res = await fetch(this.base + path, {
+      method: 'GET',
+      headers: this.#authHeaders(),
+    });
+    return this.#result(res);
+  }
+
   async postJson(path, body) {
     const res = await fetch(this.base + path, {
       method: 'POST',

package/bin/lib/model-config.js

@@ -28,11 +28,34 @@ export function readModelId(workspace) {
 }
 
 /**
- * Persist the hub-minted model id, preserving any other fields already in
- * `fluidcad.json`. Called after the first publish writes back the new id.
+ * 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 writeModelId(workspace, modelId) {
+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);
-  cfg.modelId = modelId;
+  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/lib/dist/common/edge.d.ts

@@ -1,5 +1,5 @@
 import { ShapeType } from "./shape-type.js";
-import type { TopoDS_Edge } from "occjs-wrapper";
+import type { TopoDS_Edge } from "ocjs-fluidcad";
 import { Shape } from "./shape.js";
 import { Vertex } from "./vertex.js";
 export declare class Edge extends Shape<TopoDS_Edge> {

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

@@ -1,4 +1,4 @@
-import type { TopoDS_Edge, TopoDS_Face } from "occjs-wrapper";
+import type { TopoDS_Edge, TopoDS_Face } from "ocjs-fluidcad";
 import { BoundingBox } from "../helpers/types.js";
 import { ShapeType } from "./shape-type.js";
 import { Wire } from "./wire.js";

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

@@ -93,6 +93,12 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     clone(): SceneObject[];
     setTransform(matrix: Matrix4 | LazyMatrix): void;
     getTransform(): Matrix4 | null;
+    /**
+     * The raw clone-transform reference set by cloneWithTransform. All clones
+     * belonging to one repeat/mirror instance share the same LazyMatrix, so
+     * reference identity distinguishes instances of the same container.
+     */
+    getTransformRef(): LazyMatrix | null;
     setCloneSource(source: SceneObject): void;
     getCloneSource(): SceneObject | null;
     getTransformMatrix(): Matrix4 | null;

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

@@ -206,6 +206,14 @@ export class SceneObject {
     getTransform() {
         return this._transform ? this._transform.resolve() : null;
     }
+    /**
+     * The raw clone-transform reference set by cloneWithTransform. All clones
+     * belonging to one repeat/mirror instance share the same LazyMatrix, so
+     * reference identity distinguishes instances of the same container.
+     */
+    getTransformRef() {
+        return this._transform;
+    }
     setCloneSource(source) {
         this._cloneSource = source;
     }

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

@@ -1,4 +1,4 @@
-import type { TopoDS_Shape } from "occjs-wrapper";
+import type { TopoDS_Shape } from "ocjs-fluidcad";
 import { Solid } from "./solid.js";
 import { Wire } from "./wire.js";
 import { Face } from "./face.js";

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

@@ -1,4 +1,4 @@
-import type { BRepBuilderAPI_MakeShape } from "occjs-wrapper";
+import type { BRepBuilderAPI_MakeShape } from "ocjs-fluidcad";
 import { Face } from "./face.js";
 import { Edge } from "./edge.js";
 import { Shape } from "./shape.js";

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

@@ -1,4 +1,4 @@
-import type { TopoDS_Shape } from "occjs-wrapper";
+import type { TopoDS_Shape } from "ocjs-fluidcad";
 import { ShapeType } from "./shape-type.js";
 import { SceneObjectMesh } from "../rendering/scene.js";
 import { Matrix4 } from "../math/matrix4.js";

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

@@ -1,4 +1,4 @@
-import type { TopoDS_Edge, TopoDS_Face, TopoDS_Solid, TopTools_IndexedDataMapOfShapeListOfShape } from "occjs-wrapper";
+import type { TopoDS_Edge, TopoDS_Face, TopoDS_Solid, TopTools_IndexedDataMapOfShapeListOfShape } from "ocjs-fluidcad";
 import { ShapeType } from "./shape-type.js";
 import { Shape } from "./shape.js";
 import { Face } from "./face.js";

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

@@ -1,4 +1,5 @@
-import { SceneObject } from "./scene-object.js";
+import { BuildSceneObjectContext, SceneObject } from "./scene-object.js";
+import { Shape } from "./shape.js";
 import { Matrix4 } from "../math/matrix4.js";
 import type { AxisLike } from "../math/axis.js";
 import type { PlaneLike } from "../math/plane.js";
@@ -6,6 +7,16 @@ 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;
+    /**
+     * Adds a primitive's built shape, baking in the clone transform when this
+     * primitive is a repeat/mirror copy. The renderer post-applies the user's
+     * own transform (translate/rotate/mirror) after build, so the clone
+     * transform is conjugated to land outside it:
+     * own · (own⁻¹ · clone · own) = clone · own.
+     */
+    protected addPrimitiveShape(shape: Shape, context?: BuildSceneObjectContext): void;
+    /** Carries the user's own transform onto a repeat/mirror copy. */
+    protected syncPrimitiveWith(source: TransformablePrimitive): this;
     translate(x: NumberParam): this;
     translate(x: NumberParam, y: NumberParam): this;
     translate(x: NumberParam, y: NumberParam, z: NumberParam): this;

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

@@ -3,12 +3,39 @@ 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 { ShapeOps } from "../oc/shape-ops.js";
 import { isNumberParam, resolveParam } from "../core/param.js";
 export class TransformablePrimitive extends SceneObject {
     transform(matrix) {
         this.composeAppliedTransform(matrix);
         return this;
     }
+    /**
+     * Adds a primitive's built shape, baking in the clone transform when this
+     * primitive is a repeat/mirror copy. The renderer post-applies the user's
+     * own transform (translate/rotate/mirror) after build, so the clone
+     * transform is conjugated to land outside it:
+     * own · (own⁻¹ · clone · own) = clone · own.
+     */
+    addPrimitiveShape(shape, context) {
+        const cloneTransform = context?.getTransform() ?? null;
+        if (cloneTransform) {
+            const own = this.getAppliedTransform();
+            const matrix = own
+                ? own.inverse().multiply(cloneTransform).multiply(own)
+                : cloneTransform;
+            shape = ShapeOps.transform(shape, matrix);
+        }
+        this.addShape(shape);
+    }
+    /** Carries the user's own transform onto a repeat/mirror copy. */
+    syncPrimitiveWith(source) {
+        const applied = source.getAppliedTransform();
+        if (applied) {
+            this.transform(applied);
+        }
+        return this;
+    }
     translate(a, b, c) {
         let x, y, z;
         if (isNumberParam(a)) {

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

@@ -1,4 +1,4 @@
-import type { TopoDS_Vertex } from "occjs-wrapper";
+import type { TopoDS_Vertex } from "ocjs-fluidcad";
 import { ShapeType } from "./shape-type.js";
 import { Shape } from "./shape.js";
 import { Point, Point2D } from "../math/point.js";

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

@@ -1,4 +1,4 @@
-import type { TopoDS_Wire } from "occjs-wrapper";
+import type { TopoDS_Wire } from "ocjs-fluidcad";
 import { ShapeType } from "./shape-type.js";
 import { Shape } from "./shape.js";
 import { Vector3d } from "../math/vector3d.js";

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

@@ -21,5 +21,6 @@ export { default as offset } from './offset.js';
 export { default as project } from './project.js';
 export { default as intersect } from './intersect.js';
 export { default as bezier } from './bezier.js';
+export { default as text } from './text.js';
 export { default as center } from './center.js';
 export { default as back } from './back.js';

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

@@ -21,5 +21,6 @@ export { default as offset } from './offset.js';
 export { default as project } from './project.js';
 export { default as intersect } from './intersect.js';
 export { default as bezier } from './bezier.js';
+export { default as text } from './text.js';
 export { default as center } from './center.js';
 export { default as back } from './back.js';

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

@@ -0,0 +1,30 @@
+import { PlaneLike } from "../../math/plane.js";
+import { IText, ISceneObject } from "../interfaces.js";
+interface TextFunction {
+    /**
+     * Renders a text string as extrudable outline geometry inside the current
+     * sketch, at the sketch cursor.
+     * @param text - The string to render.
+     */
+    (text: string): IText;
+    /**
+     * Renders a text string on a specific plane (standalone, outside a sketch).
+     * @param plane - The plane (e.g. "xy") or face to render the text on.
+     * @param text - The string to render.
+     */
+    (plane: PlaneLike | ISceneObject, text: string): IText;
+    /**
+     * Renders a text string following a planar curve. Each glyph is placed
+     * upright along the path's arc length; the text plane is the path's plane.
+     * Works inside a sketch (following a curve of that sketch) or standalone.
+     * The path is left in place — mark it `.guide()` to keep it out of
+     * extruded profiles.
+     * @param text - The string to render.
+     * @param path - The curve to follow: a sketch curve (line/arc/circle), a
+     *   whole sketch, a planar primitive, or a selected edge/edge loop
+     *   (e.g. `select(edge().circle())`).
+     */
+    (text: string, path: ISceneObject): IText;
+}
+declare const _default: TextFunction;
+export default _default;

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

@@ -0,0 +1,37 @@
+import { Text } from "../../features/2d/text.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 build(context) {
+    return function text() {
+        const first = arguments[0];
+        const second = arguments[1];
+        // A trailing scene object is a path to follow: `text("Hi", path)`.
+        // Valid both standalone and inside a sketch (following a sketch curve).
+        if (arguments.length >= 2 && second instanceof SceneObject) {
+            if (typeof first !== "string") {
+                throw new Error("text: when following a path, the first argument must be the text string.");
+            }
+            const obj = new Text(first, null, second);
+            context.addSceneObject(obj);
+            return obj;
+        }
+        // A leading plane/face is only valid standalone and only when a string
+        // follows it; `text("xy")` (one arg) renders the literal string "xy".
+        const standalone = arguments.length >= 2 && (isPlaneLike(first) || first instanceof SceneObject);
+        if (standalone) {
+            if (context.getActiveSketch() !== null) {
+                throw new Error("text(plane, ...) cannot be used inside a sketch. Use text(...) instead.");
+            }
+            const planeObj = resolvePlane(first, context);
+            const obj = new Text(String(arguments[1] ?? ""), planeObj);
+            context.addSceneObject(obj);
+            return obj;
+        }
+        const obj = new Text(String(first ?? ""));
+        context.addSceneObject(obj);
+        return obj;
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/helix.d.ts

@@ -0,0 +1,20 @@
+import { AxisLike } from "../math/axis.js";
+import { IHelix, ISceneObject } from "./interfaces.js";
+interface HelixFunction {
+    /**
+     * Creates a helix wire along the given axis. Use chained methods (.pitch(),
+     * .turns(), .height(), .radius(), .endRadius()) to configure geometry.
+     * @param axis - The axis to build the helix around.
+     */
+    (axis: AxisLike): IHelix;
+    /**
+     * Creates a helix wire derived from a scene object's geometry.
+     * - A cylindrical or conical face: axis + radii + height come from the face.
+     * - A line edge: axis = the line, height = line length.
+     * - A circular edge: axis = circle normal at center, radius = circle radius.
+     * @param source - The scene object whose face/edge defines the helix.
+     */
+    (source: ISceneObject): IHelix;
+}
+declare const _default: HelixFunction;
+export default _default;

package/lib/dist/core/helix.js

@@ -0,0 +1,36 @@
+import { registerBuilder } from "../index.js";
+import { Helix } from "../features/helix.js";
+import { isAxisLike } from "../math/axis.js";
+import { AxisObject } from "../features/axis.js";
+import { AxisObjectBase } from "../features/axis-renderable-base.js";
+import { SceneObject } from "../common/scene-object.js";
+import { normalizeAxis } from "../helpers/normalize.js";
+function build(context) {
+    return function helix() {
+        if (arguments.length === 0) {
+            throw new Error("helix() requires an axis or scene object argument.");
+        }
+        const arg = arguments[0];
+        let source;
+        if (arg instanceof AxisObjectBase) {
+            source = arg;
+            context.addSceneObject(source);
+        }
+        else if (isAxisLike(arg)) {
+            const axis = normalizeAxis(arg);
+            source = new AxisObject(axis);
+            context.addSceneObject(source);
+        }
+        else if (arg instanceof SceneObject) {
+            source = arg;
+            context.addSceneObject(source);
+        }
+        else {
+            throw new Error("helix(): first argument must be an AxisLike or SceneObject.");
+        }
+        const result = new Helix(source);
+        context.addSceneObject(result);
+        return result;
+    };
+}
+export default registerBuilder(build);

package/lib/dist/core/index.d.ts

@@ -1,4 +1,4 @@
-export type { ISceneObject, ITransformable, IBooleanOperation, IPlane, IAxis, ISelect, IGeometry, IExtrudableGeometry, IRect, ISlot, IPolygon, ITwoObjectsTangentLine, ITangentArcTwoObjects, IExtrude, ICut, ICommon, ISweep, ILoft, IRevolve, IDraft, IRib } from "./interfaces.js";
+export type { ISceneObject, ITransformable, IBooleanOperation, IPlane, IAxis, ISelect, IGeometry, IExtrudableGeometry, IText, IRect, ISlot, IPolygon, ITwoObjectsTangentLine, ITangentArcTwoObjects, IExtrude, ICut, ICommon, ISweep, ILoft, IRevolve, IDraft, IRib, IHelix, IWrap } from "./interfaces.js";
 export { default as axis } from "./axis.js";
 export { default as local } from "./local.js";
 export { default as plane } from "./plane.js";
@@ -24,6 +24,8 @@ export { default as load } from "./load.js";
 export { default as loft } from "./loft.js";
 export { default as sweep } from "./sweep.js";
 export { default as rib } from "./rib.js";
+export { default as wrap } from "./wrap.js";
+export { default as helix } from "./helix.js";
 export { default as color } from "./color.js";
 export { default as draft } from "./draft.js";
 export { default as remove } from "./remove.js";

package/lib/dist/core/index.js

@@ -23,6 +23,8 @@ export { default as load } from "./load.js";
 export { default as loft } from "./loft.js";
 export { default as sweep } from "./sweep.js";
 export { default as rib } from "./rib.js";
+export { default as wrap } from "./wrap.js";
+export { default as helix } from "./helix.js";
 export { default as color } from "./color.js";
 export { default as draft } from "./draft.js";
 export { default as remove } from "./remove.js";