onshape 0.1.0 → 0.1.2

package/dist/api/featurestudio.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureStudioManager = void 0;
+exports.loadText = loadText;
+const node_fs_1 = require("node:fs");
+class FeatureStudioManager {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async create(documentId, workspaceId, name) {
+        return this.client.post(`/api/v6/featurestudios/d/${documentId}/w/${workspaceId}`, { name });
+    }
+    async getContents(documentId, workspaceId, elementId) {
+        return this.client.get(`/api/v6/featurestudios/d/${documentId}/w/${workspaceId}/e/${elementId}`);
+    }
+    async setContents(documentId, workspaceId, elementId, contents) {
+        return this.client.post(`/api/v6/featurestudios/d/${documentId}/w/${workspaceId}/e/${elementId}`, { contents });
+    }
+    async getSpecs(documentId, workspaceId, elementId) {
+        return this.client.get(`/api/v6/featurestudios/d/${documentId}/w/${workspaceId}/e/${elementId}/featurespecs`);
+    }
+}
+exports.FeatureStudioManager = FeatureStudioManager;
+function loadText(inline, file) {
+    const raw = file ? (0, node_fs_1.readFileSync)(file, "utf8") : inline;
+    if (!raw)
+        throw new Error("Expected text via --contents or --contents-file");
+    return raw;
+}

package/dist/api/partstudio.js

@@ -47,6 +47,34 @@ class PartStudioManager {
             rollbackIndex: index,
         });
     }
+    async validateFeature(documentId, workspaceId, elementId, featureId) {
+        const features = await this.getFeatures(documentId, workspaceId, elementId);
+        const states = isRecord(features) && isRecord(features.featureStates) ? features.featureStates : {};
+        const state = isRecord(states[featureId]) ? states[featureId] : {};
+        const status = typeof state.featureStatus === "string" ? state.featureStatus : null;
+        if (status === "ERROR") {
+            throw new Error(`Feature ${featureId} regenerated with status ERROR.`);
+        }
+        return { featureId, featureStatus: status };
+    }
+    async validatePartStudio(documentId, workspaceId, elementId, expectations = {}) {
+        const partsRaw = await this.getParts(documentId, workspaceId, elementId);
+        const parts = Array.isArray(partsRaw) ? partsRaw : [];
+        const massRaw = await this.client.get(`/api/v6/partstudios/d/${documentId}/w/${workspaceId}/e/${elementId}/massproperties`);
+        const bodiesRecord = isRecord(massRaw) && isRecord(massRaw.bodies) ? massRaw.bodies : {};
+        const bodyCount = Object.keys(bodiesRecord).length;
+        if (expectations.parts !== undefined && parts.length !== expectations.parts) {
+            throw new Error(`Expected ${expectations.parts} part(s), found ${parts.length}.`);
+        }
+        if (expectations.bodies !== undefined && bodyCount !== expectations.bodies) {
+            throw new Error(`Expected ${expectations.bodies} bod(y/ies), found ${bodyCount}.`);
+        }
+        return {
+            parts: parts.length,
+            bodies: bodyCount,
+            partIds: parts.map((part) => (isRecord(part) ? part.partId : undefined)).filter(Boolean),
+        };
+    }
 }
 exports.PartStudioManager = PartStudioManager;
 function loadJson(inline, file) {
@@ -55,3 +83,6 @@ function loadJson(inline, file) {
         throw new Error("Expected JSON via --json or --json-file");
     return JSON.parse(raw);
 }
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/builders/modeling.js

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planeId = planeId;
+exports.parsePoint2 = parsePoint2;
+exports.buildCircleSketch = buildCircleSketch;
+exports.buildCircleAxisSketch = buildCircleAxisSketch;
+exports.buildCandyCanePathSketch = buildCandyCanePathSketch;
+exports.buildExtrude = buildExtrude;
+exports.buildRevolve = buildRevolve;
+exports.buildOffsetPlane = buildOffsetPlane;
+exports.buildSweep = buildSweep;
+exports.buildBooleanUnion = buildBooleanUnion;
+const INCH_TO_METER = 0.0254;
+const PLANE_IDS = {
+    front: "JCC",
+    top: "JDC",
+    right: "JEC",
+};
+function planeId(name) {
+    const value = PLANE_IDS[name.toLowerCase()];
+    if (!value)
+        throw new Error(`Unknown plane '${name}'. Use Front, Top, or Right.`);
+    return value;
+}
+function parsePoint2(value) {
+    const parts = value.split(",").map((part) => Number(part.trim()));
+    if (parts.length !== 2 || parts.some((part) => !Number.isFinite(part))) {
+        throw new Error(`Expected a 2D point as x,y; got '${value}'.`);
+    }
+    return [parts[0], parts[1]];
+}
+function toMeters(value) {
+    return value * INCH_TO_METER;
+}
+function circleEntity(id, center, radius) {
+    return {
+        btType: "BTMSketchCurve-4",
+        entityId: id,
+        centerId: `${id}.center`,
+        geometry: {
+            btType: "BTCurveGeometryCircle-115",
+            radius: toMeters(radius),
+            xCenter: toMeters(center[0]),
+            yCenter: toMeters(center[1]),
+            xDir: 1,
+            yDir: 0,
+            clockwise: false,
+        },
+        isConstruction: false,
+    };
+}
+function lineEntity(id, start, end, isConstruction = false) {
+    const x1 = toMeters(start[0]);
+    const y1 = toMeters(start[1]);
+    const x2 = toMeters(end[0]);
+    const y2 = toMeters(end[1]);
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    const length = Math.hypot(dx, dy);
+    if (length === 0)
+        throw new Error("Line start and end must be different.");
+    return {
+        btType: "BTMSketchCurveSegment-155",
+        entityId: id,
+        startPointId: `${id}.start`,
+        endPointId: `${id}.end`,
+        startParam: 0,
+        endParam: length,
+        geometry: {
+            btType: "BTCurveGeometryLine-117",
+            pntX: x1,
+            pntY: y1,
+            dirX: dx / length,
+            dirY: dy / length,
+        },
+        isConstruction,
+    };
+}
+function arcEntity(id, center, radius, startAngle, endAngle) {
+    if (radius <= 0)
+        throw new Error("Arc radius must be positive.");
+    return {
+        btType: "BTMSketchCurveSegment-155",
+        entityId: id,
+        startPointId: `${id}.start`,
+        endPointId: `${id}.end`,
+        centerId: `${id}.center`,
+        startParam: (startAngle * Math.PI) / 180,
+        endParam: (endAngle * Math.PI) / 180,
+        geometry: {
+            btType: "BTCurveGeometryCircle-115",
+            radius: toMeters(radius),
+            xCenter: toMeters(center[0]),
+            yCenter: toMeters(center[1]),
+            xDir: 1,
+            yDir: 0,
+            clockwise: false,
+        },
+        isConstruction: false,
+    };
+}
+function sketchPlaneParameter(sketchPlaneId, featureId) {
+    if (featureId) {
+        return pQuery("sketchPlane", `query = qCreatedBy(makeId("${featureId}"), EntityType.FACE);`, featureId);
+    }
+    return {
+        btType: "BTMParameterQueryList-148",
+        queries: [{ btType: "BTMIndividualQuery-138", deterministicIds: [sketchPlaneId] }],
+        parameterId: "sketchPlane",
+    };
+}
+function sketch(name, sketchPlaneId, entities, featureId) {
+    return {
+        feature: {
+            btType: "BTMSketch-151",
+            featureType: "newSketch",
+            name,
+            suppressed: false,
+            parameters: [sketchPlaneParameter(sketchPlaneId, featureId)],
+            entities,
+            constraints: [],
+        },
+    };
+}
+function pEnum(parameterId, enumName, value) {
+    return {
+        btType: "BTMParameterEnum-145",
+        namespace: "",
+        enumName,
+        value,
+        parameterId,
+        parameterName: "",
+        libraryRelationType: "NONE",
+    };
+}
+function pBool(parameterId, value) {
+    return {
+        btType: "BTMParameterBoolean-144",
+        value,
+        parameterId,
+        parameterName: "",
+        libraryRelationType: "NONE",
+    };
+}
+function pQuantity(parameterId, value, units) {
+    return {
+        btType: "BTMParameterQuantity-147",
+        isInteger: false,
+        value,
+        units: "",
+        expression: `${value} ${units}`,
+        parameterId,
+        parameterName: "",
+        libraryRelationType: "NONE",
+    };
+}
+function pQuery(parameterId, queryString, featureId) {
+    return {
+        btType: "BTMParameterQueryList-148",
+        queries: [
+            {
+                btType: "BTMIndividualQuery-138",
+                queryStatement: null,
+                queryString,
+                ...(featureId ? { featureId } : {}),
+                deterministicIds: [],
+            },
+        ],
+        parameterId,
+        parameterName: "",
+        libraryRelationType: "NONE",
+    };
+}
+function pDeterministicQuery(parameterId, deterministicIds) {
+    return {
+        btType: "BTMParameterQueryList-148",
+        queries: [
+            {
+                btType: "BTMIndividualQuery-138",
+                deterministicIds,
+            },
+        ],
+        parameterId,
+        parameterName: "",
+        libraryRelationType: "NONE",
+    };
+}
+function sketchRegion(parameterId, sketchFeatureId) {
+    return {
+        btType: "BTMParameterQueryList-148",
+        queries: [
+            {
+                btType: "BTMIndividualSketchRegionQuery-140",
+                queryStatement: null,
+                filterInnerLoops: true,
+                queryString: `query = qSketchRegion(id + "${sketchFeatureId}", true);`,
+                featureId: sketchFeatureId,
+                deterministicIds: [],
+            },
+        ],
+        parameterId,
+        parameterName: "",
+        libraryRelationType: "NONE",
+    };
+}
+function sketchEdges(parameterId, sketchFeatureId) {
+    return pQuery(parameterId, `query = qCreatedBy(makeId("${sketchFeatureId}"), EntityType.EDGE);`, sketchFeatureId);
+}
+function buildCircleSketch(input) {
+    return sketch(input.name, planeId(input.plane), [circleEntity("circle.1", input.center, input.radius)], input.planeFeatureId);
+}
+function buildCircleAxisSketch(input) {
+    return sketch(input.name, planeId(input.plane), [
+        circleEntity("profile.circle", input.center, input.radius),
+        lineEntity("axis.1", input.axisStart, input.axisEnd, true),
+    ]);
+}
+function buildCandyCanePathSketch(input) {
+    const top = input.bottom + input.straightHeight;
+    const center = [input.x - input.hookRadius, top];
+    const totalSegments = Math.max(2, Math.floor(input.segments));
+    const arcLength = input.hookRadius * Math.abs((input.hookAngle * Math.PI) / 180);
+    const straightShare = input.straightHeight / (input.straightHeight + arcLength);
+    const straightSegments = Math.max(1, Math.round(totalSegments * straightShare));
+    const arcSegments = Math.max(1, totalSegments - straightSegments);
+    const entities = [];
+    for (let index = 0; index < straightSegments; index += 1) {
+        const y1 = input.bottom + (input.straightHeight * index) / straightSegments;
+        const y2 = input.bottom + (input.straightHeight * (index + 1)) / straightSegments;
+        entities.push(lineEntity(`path.stem.${index + 1}`, [input.x, y1], [input.x, y2]));
+    }
+    for (let index = 0; index < arcSegments; index += 1) {
+        const start = (input.hookAngle * index) / arcSegments;
+        const end = (input.hookAngle * (index + 1)) / arcSegments;
+        entities.push(arcEntity(`path.hook.${index + 1}`, center, input.hookRadius, start, end));
+    }
+    return sketch(input.name, planeId(input.plane), entities);
+}
+function buildExtrude(input) {
+    return {
+        btType: "BTFeatureDefinitionCall-1406",
+        feature: {
+            btType: "BTMFeature-134",
+            featureType: "extrude",
+            name: input.name,
+            suppressed: false,
+            namespace: "",
+            parameters: [
+                sketchRegion("entities", input.sketchFeatureId),
+                pEnum("operationType", "NewBodyOperationType", input.operationType),
+                pQuantity("depth", input.depth, "in"),
+                pBool("oppositeDirection", false),
+                pBool("defaultScope", true),
+            ],
+        },
+    };
+}
+function buildRevolve(input) {
+    return {
+        btType: "BTFeatureDefinitionCall-1406",
+        feature: {
+            btType: "BTMFeature-134",
+            featureType: "revolve",
+            name: input.name,
+            suppressed: false,
+            namespace: "",
+            parameters: [
+                pEnum("bodyType", "ExtendedToolBodyType", "SOLID"),
+                pEnum("operationType", "NewBodyOperationType", input.operationType),
+                sketchRegion("entities", input.sketchFeatureId),
+                pQuery("axis", `query = qConstructionFilter(qCreatedBy(makeId("${input.sketchFeatureId}"), EntityType.EDGE), ConstructionObject.YES);`, input.sketchFeatureId),
+                pBool("fullRevolve", false),
+                pEnum("endBound", "RevolveBoundingType", "BLIND"),
+                pQuantity("angle", input.angle, "deg"),
+                pBool("defaultScope", true),
+            ],
+        },
+    };
+}
+function buildOffsetPlane(input) {
+    return {
+        btType: "BTFeatureDefinitionCall-1406",
+        feature: {
+            btType: "BTMFeature-134",
+            featureType: "cPlane",
+            name: input.name,
+            suppressed: false,
+            namespace: "",
+            parameters: [
+                pEnum("cplaneType", "CPlaneType", "OFFSET"),
+                pDeterministicQuery("entities", [planeId(input.basePlane)]),
+                pQuantity("offset", input.offset, "in"),
+                pBool("oppositeDirection", false),
+            ],
+        },
+    };
+}
+function buildSweep(input) {
+    return {
+        btType: "BTFeatureDefinitionCall-1406",
+        feature: {
+            btType: "BTMFeature-134",
+            featureType: "sweep",
+            name: input.name,
+            suppressed: false,
+            namespace: "",
+            parameters: [
+                pEnum("bodyType", "ExtendedToolBodyType", "SOLID"),
+                pEnum("operationType", "NewBodyOperationType", input.operationType),
+                sketchRegion("profiles", input.profileSketchFeatureId),
+                sketchEdges("path", input.pathSketchFeatureId),
+                pEnum("profileControl", "ProfileControlMode", "NONE"),
+                pBool("hasTwist", false),
+                pBool("hasScale", false),
+                pBool("trimEnds", true),
+                pBool("defaultScope", true),
+            ],
+        },
+    };
+}
+function buildBooleanUnion() {
+    return {
+        btType: "BTFeatureDefinitionCall-1406",
+        feature: {
+            btType: "BTMFeature-134",
+            featureType: "booleanBodies",
+            name: "Union bodies",
+            suppressed: false,
+            namespace: "",
+            parameters: [
+                pEnum("operationType", "BooleanOperationType", "UNION"),
+                pBool("defaultScope", false),
+                pQuery("tools", "query = qAllModifiableSolidBodies();"),
+                pBool("toolsExplicit", true),
+            ],
+        },
+    };
+}

package/dist/cli.js

@@ -40,7 +40,9 @@ const credentials_1 = require("./credentials");
 const client_1 = require("./api/client");
 const documents_1 = require("./api/documents");
 const edges_1 = require("./api/edges");
+const featurestudio_1 = require("./api/featurestudio");
 const partstudio_1 = require("./api/partstudio");
+const modeling_1 = require("./builders/modeling");
 const output_1 = require("./output");
 async function main(argv) {
     try {
@@ -101,9 +103,22 @@ async function run(argv) {
         case "create-part-studio":
         case "delete-feature":
         case "delete-element":
+        case "create-feature-studio":
+        case "get-feature-studio":
+        case "set-feature-studio":
+        case "get-feature-studio-specs":
         case "add-feature":
         case "update-feature":
         case "rollback":
+        case "sketch-circle":
+        case "sketch-circle-axis":
+        case "sketch-candy-cane-path":
+        case "extrude":
+        case "revolve":
+        case "sweep":
+        case "offset-plane":
+        case "boolean-union":
+        case "validate-partstudio":
         case "get-edges":
         case "find-circular-edges":
         case "find-edges-by-feature":
@@ -127,7 +142,7 @@ function parseArgs(argv) {
             if (eq !== -1) {
                 options[key] = item.slice(eq + 1);
             }
-            else if (argv[index + 1] && !argv[index + 1].startsWith("-")) {
+            else if (argv[index + 1] && (!argv[index + 1].startsWith("-") || isNegativeValue(argv[index + 1]))) {
                 options[key] = argv[index + 1];
                 index += 1;
             }
@@ -147,6 +162,9 @@ function parseArgs(argv) {
     }
     return { command, positionals, options };
 }
+function isNegativeValue(value) {
+    return /^-\d/.test(value) || /^-\.\d/.test(value);
+}
 async function handleConfig(parsed) {
     const action = parsed.positionals[0];
     const store = new credentials_1.CredentialStore();
@@ -229,6 +247,7 @@ async function handleReadCommand(parsed) {
     const client = new client_1.OnshapeClient(creds);
     const docs = new documents_1.DocumentManager(client);
     const partstudios = new partstudio_1.PartStudioManager(client);
+    const featurestudios = new featurestudio_1.FeatureStudioManager(client);
     const edges = new edges_1.EdgeQuery(client);
     switch (parsed.command) {
         case "list-documents": {
@@ -321,10 +340,36 @@ async function handleReadCommand(parsed) {
             (0, output_1.emit)(await client.delete(`/api/v9/elements/d/${doc}/w/${ws}/e/${elem}`));
             return;
         }
+        case "create-feature-studio": {
+            const { doc, ws } = docWorkspace(parsed.options);
+            (0, output_1.emit)(await featurestudios.create(doc, ws, requiredOption(parsed.options, "name")));
+            return;
+        }
+        case "get-feature-studio": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await featurestudios.getContents(doc, ws, elem));
+            return;
+        }
+        case "set-feature-studio": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            try {
+                (0, output_1.emit)(await featurestudios.setContents(doc, ws, elem, (0, featurestudio_1.loadText)(stringOption(parsed.options, "contents"), stringOption(parsed.options, "contentsFile"))));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new output_1.CliError(message, null, 2);
+            }
+            return;
+        }
+        case "get-feature-studio-specs": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await featurestudios.getSpecs(doc, ws, elem));
+            return;
+        }
         case "add-feature": {
             const { doc, ws, elem } = dwe(parsed.options);
             const feature = requiredJson(parsed.options);
-            (0, output_1.emit)(await withFeatureId(partstudios.addFeature(doc, ws, elem, feature)));
+            (0, output_1.emit)(await addFeatureResult(partstudios, doc, ws, elem, feature, !parsed.options.noValidate));
             return;
         }
         case "update-feature": {
@@ -338,6 +383,101 @@ async function handleReadCommand(parsed) {
             (0, output_1.emit)(await partstudios.rollback(doc, ws, elem, requiredNumberOption(parsed.options, "index")));
             return;
         }
+        case "sketch-circle": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await addFeatureResult(partstudios, doc, ws, elem, (0, modeling_1.buildCircleSketch)({
+                name: stringOption(parsed.options, "name") ?? "Sketch circle",
+                plane: stringOption(parsed.options, "plane") ?? "Front",
+                planeFeatureId: stringOption(parsed.options, "planeFeature"),
+                center: parsePointOption(parsed.options, "center"),
+                radius: requiredNumberOption(parsed.options, "radius"),
+            }), !parsed.options.noValidate));
+            return;
+        }
+        case "sketch-circle-axis": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await addFeatureResult(partstudios, doc, ws, elem, (0, modeling_1.buildCircleAxisSketch)({
+                name: stringOption(parsed.options, "name") ?? "Sketch circle and axis",
+                plane: stringOption(parsed.options, "plane") ?? "Front",
+                center: parsePointOption(parsed.options, "center"),
+                radius: requiredNumberOption(parsed.options, "radius"),
+                axisStart: parsePointOption(parsed.options, "axisStart"),
+                axisEnd: parsePointOption(parsed.options, "axisEnd"),
+            }), !parsed.options.noValidate));
+            return;
+        }
+        case "sketch-candy-cane-path": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await addFeatureResult(partstudios, doc, ws, elem, (0, modeling_1.buildCandyCanePathSketch)({
+                name: stringOption(parsed.options, "name") ?? "Candy cane centerline",
+                plane: stringOption(parsed.options, "plane") ?? "Front",
+                x: numberOption(parsed.options, "x", 0),
+                bottom: numberOption(parsed.options, "bottom", 0),
+                straightHeight: requiredNumberOption(parsed.options, "straightHeight"),
+                hookRadius: requiredNumberOption(parsed.options, "hookRadius"),
+                hookAngle: numberOption(parsed.options, "hookAngle", 210),
+                segments: numberOption(parsed.options, "segments", 24),
+            }), !parsed.options.noValidate));
+            return;
+        }
+        case "extrude": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await addFeatureResult(partstudios, doc, ws, elem, (0, modeling_1.buildExtrude)({
+                name: stringOption(parsed.options, "name") ?? "Extrude",
+                sketchFeatureId: requiredOption(parsed.options, "sketch"),
+                depth: requiredNumberOption(parsed.options, "depth"),
+                operationType: stringOption(parsed.options, "op") ?? "NEW",
+            }), !parsed.options.noValidate));
+            return;
+        }
+        case "revolve": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await addFeatureResult(partstudios, doc, ws, elem, (0, modeling_1.buildRevolve)({
+                name: stringOption(parsed.options, "name") ?? "Revolve",
+                sketchFeatureId: requiredOption(parsed.options, "sketch"),
+                angle: numberOption(parsed.options, "angle", 360),
+                operationType: stringOption(parsed.options, "op") ?? "NEW",
+            }), !parsed.options.noValidate));
+            return;
+        }
+        case "sweep": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await addFeatureResult(partstudios, doc, ws, elem, (0, modeling_1.buildSweep)({
+                name: stringOption(parsed.options, "name") ?? "Sweep",
+                profileSketchFeatureId: requiredOption(parsed.options, "profile"),
+                pathSketchFeatureId: requiredOption(parsed.options, "path"),
+                operationType: stringOption(parsed.options, "op") ?? "NEW",
+            }), !parsed.options.noValidate));
+            return;
+        }
+        case "offset-plane": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await addFeatureResult(partstudios, doc, ws, elem, (0, modeling_1.buildOffsetPlane)({
+                name: stringOption(parsed.options, "name") ?? "Offset plane",
+                basePlane: stringOption(parsed.options, "basePlane") ?? "Top",
+                offset: requiredNumberOption(parsed.options, "offset"),
+            }), !parsed.options.noValidate));
+            return;
+        }
+        case "boolean-union": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            (0, output_1.emit)(await addFeatureResult(partstudios, doc, ws, elem, (0, modeling_1.buildBooleanUnion)(), !parsed.options.noValidate));
+            return;
+        }
+        case "validate-partstudio": {
+            const { doc, ws, elem } = dwe(parsed.options);
+            try {
+                (0, output_1.emit)(await partstudios.validatePartStudio(doc, ws, elem, {
+                    parts: optionalNumberOption(parsed.options, "expectParts"),
+                    bodies: optionalNumberOption(parsed.options, "expectBodies"),
+                }));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new output_1.CliError(message, null, 1);
+            }
+            return;
+        }
         case "get-edges": {
             const { doc, ws, elem } = dwe(parsed.options);
             (0, output_1.emit)(await edges.getEdges(doc, ws, elem));
@@ -362,10 +502,20 @@ async function handleReadCommand(parsed) {
         }
     }
 }
-async function withFeatureId(responsePromise) {
-    const response = await responsePromise;
+async function addFeatureResult(partstudios, doc, ws, elem, feature, validate) {
+    const response = await partstudios.addFeature(doc, ws, elem, feature);
     const featureId = isRecord(response) && isRecord(response.feature) ? response.feature.featureId ?? null : null;
-    return { featureId, response };
+    const result = { featureId, response };
+    if (validate && typeof featureId === "string") {
+        try {
+            result.validation = await partstudios.validateFeature(doc, ws, elem, featureId);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new output_1.CliError(message, { featureId, response }, 1);
+        }
+    }
+    return result;
 }
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -419,6 +569,15 @@ function requiredNumberOption(options, key) {
 function requiredOption(options, key) {
     return stringOption(options, key) ?? missing(key);
 }
+function parsePointOption(options, key) {
+    try {
+        return (0, modeling_1.parsePoint2)(requiredOption(options, key));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new output_1.CliError(message, null, 2);
+    }
+}
 function requiredJson(options) {
     try {
         return (0, partstudio_1.loadJson)(stringOption(options, "json"), stringOption(options, "jsonFile"));
@@ -467,9 +626,22 @@ Commands:
   create-part-studio
   delete-feature
   delete-element
+  create-feature-studio
+  get-feature-studio
+  set-feature-studio
+  get-feature-studio-specs
   add-feature
   update-feature
   rollback
+  sketch-circle
+  sketch-circle-axis
+  sketch-candy-cane-path
+  extrude
+  revolve
+  sweep
+  offset-plane
+  boolean-union
+  validate-partstudio
   get-edges
   find-circular-edges
   find-edges-by-feature

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onshape",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Node.js CLI for Onshape CAD automation with the same JSON contract as onshape-cli.",
   "license": "MIT",
   "type": "commonjs",