onshape 0.1.3 → 0.2.0

package/README.md

@@ -0,0 +1,115 @@
+# onshape (Node CLI)
+
+Command-line automation for [Onshape](https://www.onshape.com) CAD, as an npm package.
+Build and inspect parametric models — sketches, extrudes, holes, fillets, chamfers,
+shells, booleans, mirrors, patterns — query geometry, read mass properties, drive
+assemblies and drawings, and export **STL / STEP / 3MF** straight from your terminal.
+
+This is a Node/TypeScript port of [`onshape-cli`](https://github.com/am-will/onshape-cli)
+with **full command parity**: the same command names, the same flags, and the same JSON
+contract. It talks directly to the Onshape REST API over HTTP Basic auth and emits JSON.
+
+## Install
+
+```bash
+npm install -g onshape      # global `onshape` command
+# or
+npx onshape <command>       # run without installing
+```
+
+Requires Node ≥ 18. The optional `@napi-rs/keyring` dependency enables OS-keychain
+credential storage; without it credentials fall back to a `0600` file.
+
+## Authenticate
+
+Create an API key pair at https://dev.onshape.com → **API keys**, then save it once:
+
+```bash
+onshape login                 # import from env / ~/.claude/mcp.json, or prompt, then save
+onshape config show           # show saved credentials (secret redacted)
+onshape logout                # delete saved credentials
+```
+
+Credentials resolve in this order: `--access-key`/`--secret-key` flags →
+`ONSHAPE_ACCESS_KEY`/`ONSHAPE_SECRET_KEY` env vars → `~/.onshape/credentials.json`
+(or `ONSHAPE_CONFIG`) → Linux `$XDG_CONFIG_HOME/onshape/credentials.json` → the
+`onshape` block of `~/.claude/mcp.json`. `ONSHAPE_BASE_URL`/`--base-url` overrides the
+API base URL.
+
+## Quickstart
+
+```bash
+# find a document and part studio
+onshape list-documents --limit 5
+onshape get-document-summary --doc <documentId>
+
+# target a part studio once
+export ONSHAPE_DOC=... ONSHAPE_WS=... ONSHAPE_ELEM=...
+
+# build: sketch -> extrude -> fillet -> export
+SK=$(onshape sketch-rectangle --plane Top --corner1 0,0 --corner2 3,2 | jq -r .result.featureId)
+EX=$(onshape extrude --sketch "$SK" --depth 0.25 | jq -r .result.featureId)
+onshape fillet --feature "$EX" --radius 0.1
+onshape export-stl --out bracket.stl
+```
+
+Every command prints `{"ok": true, "result": ...}` or
+`{"ok": false, "error": ..., "detail": ...}`.
+
+## Selecting geometry
+
+Edges/faces are chosen with a **FeatureScript query**, evaluated server-side. `fillet`,
+`chamfer`, `shell`, `boolean`, `mirror`, and the patterns all accept:
+
+| flag | selects |
+|---|---|
+| `--all` | every edge of every solid body |
+| `--feature FID` | every edge created by that feature |
+| `--circular` | every circular/arc edge |
+| `--query "<FeatureScript>"` | any custom query |
+| `--edges id1,id2` | explicit deterministic IDs |
+
+Patterns need a real edge for `--direction-ids`/`--axis-ids` (from `get-edges`).
+
+## Commands
+
+Run `onshape --help` for the grouped list. Categories:
+
+- **Documents & discovery:** `list-documents`, `search-documents`, `get-document`,
+  `get-document-summary`, `create-document`, `delete-document`, `update-document`,
+  `get-elements`, `find-part-studios`, `get-workspaces`, `list-versions`,
+  `create-version`, `get-parts`, `get-features`, `get-feature-specs`,
+  `get-sketch-info`, `get-body-details`, `get-assembly`
+- **Part studio management:** `create-part-studio`, `delete-feature`, `delete-element`,
+  `add-feature`, `update-feature`, `rollback`, `validate-partstudio`
+- **Sketching:** `create-sketch`, `sketch-rectangle`, `sketch-circle`, `sketch-line`,
+  `sketch-circle-axis`, `sketch-candy-cane-path`
+- **Solids & modifiers:** `extrude`, `hole`, `thicken`, `revolve`, `sweep`, `draft`,
+  `fillet`, `chamfer`, `shell`
+- **Patterns & boolean:** `boolean`, `boolean-union`, `mirror`, `linear-pattern`,
+  `circular-pattern`, `offset-plane`
+- **Geometry / measure:** `get-edges`, `find-circular-edges`, `find-edges-by-feature`,
+  `measure`, `eval-featurescript`, `mass-properties`
+- **Variables & configurations:** `get-variables`, `set-variable`, `get-configuration`,
+  `encode-configuration`
+- **Export & images:** `export-stl`, `export`, `thumbnail-info`, `get-thumbnail`,
+  `shaded-view`
+- **Assemblies:** `create-assembly`, `insert-instance`, `get-assembly-features`,
+  `assembly-add-feature`, `assembly-mate-connector`, `assembly-mate`, `assembly-group`,
+  `get-bom`, `assembly-mass-properties`, `delete-instance`, `transform-instance`
+- **Drawings:** `create-drawing`, `get-drawing-views`, `export-drawing`
+- **Feature studios:** `create-feature-studio`, `get-feature-studio`,
+  `set-feature-studio`, `get-feature-studio-specs`
+- **Metadata:** `get-metadata`, `set-metadata`
+
+> Sketch/feature dimensions are in **inches**. Free Onshape accounts can only create
+> **public** documents (`create-document --public`; private → HTTP 409). Cross-document
+> inserts and drawings reference geometry by **version**, so run `create-version` first.
+> `revolve`/`offset-plane` payloads are spec-shaped but can regen-reject — check the
+> returned `featureStatus`.
+
+## License
+
+[MIT](../LICENSE) © 2026 William Ryan.
+
+*Not affiliated with or endorsed by Onshape / PTC.*

package/dist/api/assemblies.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssemblyManager = void 0;
+/** Assembly create/read/insert/mate/BOM/transform. Port of onshape_cli/api/assemblies.py.
+ *  Mates, mate connectors, and groups are added as raw feature envelopes via addFeature
+ *  (see builders/advanced.ts buildAssembly*). */
+class AssemblyManager {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async createAssembly(documentId, workspaceId, name) {
+        return this.client.post(`/api/v6/assemblies/d/${documentId}/w/${workspaceId}`, { name });
+    }
+    async getFeatures(documentId, workspaceId, elementId) {
+        return this.client.get(`/api/v6/assemblies/d/${documentId}/w/${workspaceId}/e/${elementId}/features`);
+    }
+    async getBom(documentId, workspaceId, elementId, opts = {}) {
+        return this.client.get(`/api/v6/assemblies/d/${documentId}/w/${workspaceId}/e/${elementId}/bom`, {
+            indented: String(opts.indented ?? true),
+            multiLevel: String(opts.multiLevel ?? false),
+            generateIfAbsent: String(opts.generateIfAbsent ?? true),
+        });
+    }
+    async massProperties(documentId, workspaceId, elementId) {
+        return this.client.get(`/api/v6/assemblies/d/${documentId}/w/${workspaceId}/e/${elementId}/massproperties`);
+    }
+    async insertInstance(documentId, workspaceId, elementId, opts) {
+        const body = { documentId: opts.sourceDocumentId, elementId: opts.sourceElementId };
+        if (opts.sourceVersionId)
+            body.versionId = opts.sourceVersionId;
+        if (opts.partId) {
+            body.partId = opts.partId;
+            body.includePartTypes = ["PARTS"];
+        }
+        if (opts.isAssembly)
+            body.isAssembly = true;
+        if (opts.isWholePartStudio)
+            body.isWholePartStudio = true;
+        if (opts.configuration)
+            body.configuration = opts.configuration;
+        return this.client.post(`/api/v6/assemblies/d/${documentId}/w/${workspaceId}/e/${elementId}/instances`, body);
+    }
+    async addFeature(documentId, workspaceId, elementId, feature) {
+        return this.client.post(`/api/v6/assemblies/d/${documentId}/w/${workspaceId}/e/${elementId}/features`, feature);
+    }
+    async deleteInstance(documentId, workspaceId, elementId, nodeId) {
+        return this.client.delete(`/api/v6/assemblies/d/${documentId}/w/${workspaceId}/e/${elementId}/instance/nodeid/${nodeId}`);
+    }
+    /** Apply a 16-float row-major 4x4 transform to occurrence paths (POST, not PATCH). */
+    async transformOccurrences(documentId, workspaceId, elementId, occurrencePaths, transform, opts = {}) {
+        const body = {
+            isRelative: opts.isRelative ?? true,
+            occurrences: occurrencePaths.map((path) => ({ path })),
+            transform,
+        };
+        return this.client.post(`/api/v6/assemblies/d/${documentId}/w/${workspaceId}/e/${elementId}/occurrencetransforms`, body);
+    }
+}
+exports.AssemblyManager = AssemblyManager;

package/dist/api/client.js

@@ -4,8 +4,11 @@ exports.OnshapeClient = exports.HttpError = void 0;
 const node_url_1 = require("node:url");
 const promises_1 = require("node:timers/promises");
 const READ_RETRY_STATUSES = new Set([408, 429, 500, 502, 503, 504]);
-const MAX_READ_ATTEMPTS = 5;
-const MAX_RETRY_DELAY_MS = 10_000;
+const MAX_READ_ATTEMPTS = 8;
+const MAX_RETRY_DELAY_MS = 30_000;
+// Per-request wall-clock timeout. Without this a stalled/throttled connection
+// hangs forever (Node fetch has no default timeout). Override with ONSHAPE_TIMEOUT_MS.
+const REQUEST_TIMEOUT_MS = Number(process.env.ONSHAPE_TIMEOUT_MS) || 120_000;
 class HttpError extends Error {
     status;
     detail;
@@ -53,6 +56,37 @@ class OnshapeClient {
         }
         return responseJsonOrStatus(response, "deleted");
     }
+    /**
+     * GET raw bytes (e.g. an STL or a thumbnail PNG). Follows Onshape's regional /
+     * S3 redirects with the Authorization header re-attached on every hop, which
+     * `fetchWithAuthRedirects` already does. `accept` overrides the Accept header.
+     */
+    async getBinary(path, params, accept = "*/*") {
+        const url = new URL(path, this.creds.baseUrl);
+        if (params) {
+            const search = new node_url_1.URLSearchParams();
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined)
+                    search.set(key, String(value));
+            }
+            url.search = search.toString();
+        }
+        const response = await this.fetchWithAuthRedirects(url, { Accept: accept });
+        if (!response.ok) {
+            throw new HttpError(response.status, await responseDetail(response));
+        }
+        const buffer = Buffer.from(await response.arrayBuffer());
+        return { buffer, contentType: response.headers.get("content-type") ?? "", status: response.status };
+    }
+    /** GET an absolute URL for raw bytes (already-resolved href, auth re-attached). */
+    async getBinaryUrl(href, accept = "*/*") {
+        const response = await this.fetchWithAuthRedirects(new URL(href), { Accept: accept });
+        if (!response.ok) {
+            throw new HttpError(response.status, await responseDetail(response));
+        }
+        const buffer = Buffer.from(await response.arrayBuffer());
+        return { buffer, contentType: response.headers.get("content-type") ?? "", status: response.status };
+    }
     async requestJson(url) {
         for (let attempt = 1; attempt <= MAX_READ_ATTEMPTS; attempt += 1) {
             const response = await this.fetchWithAuthRedirects(url, {
@@ -71,9 +105,10 @@ class OnshapeClient {
     async fetchWithAuthRedirects(url, headers, method = "GET", body) {
         const auth = Buffer.from(`${this.creds.accessKey}:${this.creds.secretKey}`).toString("base64");
         const requestHeaders = { ...headers, Authorization: `Basic ${auth}` };
+        const fetchOnce = (target) => fetch(target, { method, body, headers: requestHeaders, redirect: "manual", signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) });
         let current = url;
         for (let hop = 0; hop < 5; hop += 1) {
-            const response = await fetch(current, { method, body, headers: requestHeaders, redirect: "manual" });
+            const response = await fetchOnce(current);
             if (![301, 302, 303, 307, 308].includes(response.status))
                 return response;
             const location = response.headers.get("location");
@@ -81,7 +116,7 @@ class OnshapeClient {
                 return response;
             current = new URL(location, current);
         }
-        return fetch(current, { method, body, headers: requestHeaders, redirect: "manual" });
+        return fetchOnce(current);
     }
 }
 exports.OnshapeClient = OnshapeClient;
@@ -117,5 +152,5 @@ function retryDelayMs(response, attempt) {
             return Math.min(Math.max(dateMs - Date.now(), 0), MAX_RETRY_DELAY_MS);
         }
     }
-    return Math.min(500 * 2 ** (attempt - 1), MAX_RETRY_DELAY_MS);
+    return Math.min(1000 * 2 ** (attempt - 1), MAX_RETRY_DELAY_MS);
 }

package/dist/api/configurations.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationManager = void 0;
+/** Element configurations. Port of onshape_cli/api/configurations.py. */
+class ConfigurationManager {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getConfiguration(documentId, workspaceId, elementId) {
+        return this.client.get(`/api/v6/elements/d/${documentId}/w/${workspaceId}/e/${elementId}/configuration`);
+    }
+    /** Encode [{parameterId, parameterValue}, ...] -> {encodedId, queryParam}. No ws segment. */
+    async encodeConfiguration(documentId, elementId, parameters) {
+        return this.client.post(`/api/v6/elements/d/${documentId}/e/${elementId}/configurationencodings`, { parameters });
+    }
+}
+exports.ConfigurationManager = ConfigurationManager;

package/dist/api/documents.js

@@ -79,6 +79,13 @@ class DocumentManager {
         const pattern = namePattern.toLowerCase();
         return elements.filter((element) => String(element.name ?? "").toLowerCase().includes(pattern));
     }
+    async getAssembly(documentId, workspaceId, elementId, opts = {}) {
+        return this.client.get(`/api/v6/assemblies/d/${documentId}/w/${workspaceId}/e/${elementId}`, {
+            includeMateFeatures: String(opts.includeMateFeatures ?? true),
+            includeMateConnectors: String(opts.includeMateConnectors ?? true),
+            includeNonSolids: String(opts.includeNonSolids ?? false),
+        });
+    }
     async getDocumentSummary(documentId) {
         const document = await this.getDocument(documentId);
         const workspaces = await this.getWorkspaces(documentId);

package/dist/api/drawings.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrawingManager = void 0;
+/** Drawing create + view read. Port of onshape_cli/api/drawings.py.
+ *  Export goes through ExportManager.exportTranslation(kind="drawings"). */
+class DrawingManager {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /** Create a drawing of a part / Part Studio / assembly. References the source
+     *  by version (create a version first). */
+    async createDrawing(documentId, workspaceId, opts) {
+        const body = {
+            drawingName: opts.name,
+            externalDocumentId: opts.sourceDocumentId ?? documentId,
+            externalDocumentVersionId: opts.sourceVersionId,
+            elementId: opts.sourceElementId,
+        };
+        if (opts.partId)
+            body.partId = opts.partId;
+        return this.client.post(`/api/v6/drawings/d/${documentId}/w/${workspaceId}/create`, body);
+    }
+    async getViews(documentId, workspaceId, elementId) {
+        return this.client.get(`/api/v6/drawings/d/${documentId}/w/${workspaceId}/e/${elementId}/views`);
+    }
+}
+exports.DrawingManager = DrawingManager;

package/dist/api/export.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportManager = void 0;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:timers/promises");
+// Isometric camera (3x4 row-major view matrix) — a sensible default.
+const ISO_VIEW = "0.707,0.707,0,0,-0.408,0.408,0.816,0,0.577,-0.577,0.577,0";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+/** STL/STEP/3MF export, thumbnails, shaded renders, and mass properties.
+ *  Port of onshape_cli/api/export.py. */
+class ExportManager {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async massProperties(documentId, workspaceId, elementId, configuration) {
+        return this.client.get(`/api/v6/partstudios/d/${documentId}/w/${workspaceId}/e/${elementId}/massproperties`, {
+            configuration,
+        });
+    }
+    async exportStl(documentId, workspaceId, elementId, outputPath, opts = {}) {
+        const path = `/api/v6/partstudios/d/${documentId}/w/${workspaceId}/e/${elementId}/stl`;
+        const { buffer } = await this.client.getBinary(path, {
+            mode: opts.binary === false ? "text" : "binary",
+            units: opts.units ?? "inch",
+            grouping: "true",
+            scale: opts.scale ?? 1.0,
+            resolution: opts.resolution ?? "medium",
+            configuration: opts.configuration,
+        }, "application/vnd.onshape.v1+octet-stream");
+        (0, node_fs_1.writeFileSync)(outputPath, buffer);
+        return outputPath;
+    }
+    async exportTranslation(documentId, workspaceId, elementId, outputPath, opts = {}) {
+        const formatName = opts.formatName ?? "STEP";
+        const elementKind = opts.elementKind ?? "partstudios";
+        const pollInterval = opts.pollInterval ?? 1.5;
+        const timeout = opts.timeout ?? 120.0;
+        const createPath = `/api/v6/${elementKind}/d/${documentId}/w/${workspaceId}/e/${elementId}/translations`;
+        const body = { formatName, storeInDocument: false, flattenAssemblies: false };
+        if (opts.configuration)
+            body.configuration = opts.configuration;
+        const job = (await this.client.post(createPath, body));
+        const translationId = isRecord(job) ? job.id : undefined;
+        if (!translationId)
+            throw new Error(`Translation not started: ${JSON.stringify(job)}`);
+        let elapsed = 0;
+        let state = (isRecord(job) && job.requestState) || "ACTIVE";
+        let result = job;
+        while (state === "ACTIVE" && elapsed < timeout) {
+            await (0, promises_1.setTimeout)(pollInterval * 1000);
+            elapsed += pollInterval;
+            result = (await this.client.get(`/api/v6/translations/${translationId}`));
+            state = (isRecord(result) && result.requestState) || "ACTIVE";
+        }
+        if (state !== "DONE")
+            throw new Error(`Translation failed/timeout (state=${state}): ${JSON.stringify(result)}`);
+        const externalIds = (isRecord(result) && Array.isArray(result.resultExternalDataIds) ? result.resultExternalDataIds : []);
+        if (!externalIds.length)
+            throw new Error(`No result data: ${JSON.stringify(result)}`);
+        const resultDid = (isRecord(result) && result.resultDocumentId) || documentId;
+        const { buffer } = await this.client.getBinary(`/api/v6/documents/d/${resultDid}/externaldata/${externalIds[0]}`);
+        (0, node_fs_1.writeFileSync)(outputPath, buffer);
+        return outputPath;
+    }
+    async thumbnailInfo(documentId, workspaceId, elementId) {
+        return this.client.get(`/api/v6/thumbnails/d/${documentId}/w/${workspaceId}/e/${elementId}`);
+    }
+    async getThumbnail(documentId, workspaceId, elementId, outputPath, opts = {}) {
+        const size = opts.size ?? "600x340";
+        const info = (await this.thumbnailInfo(documentId, workspaceId, elementId));
+        const sizes = isRecord(info) && Array.isArray(info.sizes) ? info.sizes : [];
+        if (!sizes.length) {
+            throw new Error("No thumbnail available yet — Onshape renders thumbnails asynchronously; retry shortly after the element is created/edited.");
+        }
+        const chosen = sizes.find((s) => s.size === size) ?? sizes[0];
+        const href = chosen.href;
+        if (!href)
+            throw new Error(`Thumbnail entry has no href: ${JSON.stringify(chosen)}`);
+        const { buffer } = await this.client.getBinaryUrl(String(href));
+        (0, node_fs_1.writeFileSync)(outputPath, buffer);
+        return outputPath;
+    }
+    async shadedView(documentId, workspaceId, elementId, outputPath, opts = {}) {
+        const elementKind = opts.elementKind ?? "partstudios";
+        const path = `/api/v6/${elementKind}/d/${documentId}/w/${workspaceId}/e/${elementId}/shadedviews`;
+        const params = {
+            viewMatrix: opts.viewMatrix ?? ISO_VIEW,
+            outputWidth: opts.width ?? 600,
+            outputHeight: opts.height ?? 340,
+            pixelSize: 0,
+        };
+        if (opts.showEdges ?? true) {
+            params.edges = "show";
+            params.showAllParts = "true";
+        }
+        if (opts.configuration)
+            params.configuration = opts.configuration;
+        const resp = (await this.client.get(path, params));
+        const images = isRecord(resp) && Array.isArray(resp.images) ? resp.images : [];
+        if (!images.length)
+            throw new Error(`No shaded image returned: ${JSON.stringify(resp)}`);
+        (0, node_fs_1.writeFileSync)(outputPath, Buffer.from(images[0], "base64"));
+        return outputPath;
+    }
+}
+exports.ExportManager = ExportManager;

package/dist/api/metadata.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataManager = void 0;
+/** Element/part properties. Port of onshape_cli/api/metadata.py. */
+class MetadataManager {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getElementMetadata(documentId, workspaceId, elementId) {
+        return this.client.get(`/api/v6/metadata/d/${documentId}/w/${workspaceId}/e/${elementId}`);
+    }
+    async getPartMetadata(documentId, workspaceId, elementId, partId) {
+        return this.client.get(`/api/v6/metadata/d/${documentId}/w/${workspaceId}/e/${elementId}/p/${partId}`);
+    }
+    /** Set element (or part) properties. `properties` is [{propertyId, value}, ...].
+     *  POST (PATCH returns 405); only editable, non-null properties are accepted. */
+    async setElementMetadata(documentId, workspaceId, elementId, properties, partId) {
+        const path = partId
+            ? `/api/v6/metadata/d/${documentId}/w/${workspaceId}/e/${elementId}/p/${partId}`
+            : `/api/v6/metadata/d/${documentId}/w/${workspaceId}/e/${elementId}`;
+        return this.client.post(path, { properties });
+    }
+}
+exports.MetadataManager = MetadataManager;

package/dist/api/partstudio.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PartStudioManager = void 0;
 exports.loadJson = loadJson;
 const node_fs_1 = require("node:fs");
+const fsvalue_1 = require("./fsvalue");
+const round4 = (n) => Math.round(n * 1e4) / 1e4;
 class PartStudioManager {
     client;
     constructor(client) {
@@ -39,6 +41,41 @@ class PartStudioManager {
     async addFeature(documentId, workspaceId, elementId, feature) {
         return this.client.post(`/api/v9/partstudios/d/${documentId}/w/${workspaceId}/e/${elementId}/features`, feature);
     }
+    async evaluateFeatureScript(documentId, workspaceId, elementId, script) {
+        return this.client.post(`/api/v6/partstudios/d/${documentId}/w/${workspaceId}/e/${elementId}/featurescript`, { script });
+    }
+    /** Measure solid bodies: bounding box (inches), volume, body count. */
+    async measure(documentId, workspaceId, elementId) {
+        const script = "function(context is Context, queries){" +
+            " var bs = evaluateQuery(context, qAllModifiableSolidBodies());" +
+            " if (size(bs) == 0) { return { bodies: 0 }; }" +
+            " var b = evBox3d(context, { topology: qAllModifiableSolidBodies(), tight: true });" +
+            " var vol = evVolume(context, { entities: qAllModifiableSolidBodies() });" +
+            " return { bodies: size(bs)," +
+            "   minx: b.minCorner[0]/inch, miny: b.minCorner[1]/inch, minz: b.minCorner[2]/inch," +
+            "   maxx: b.maxCorner[0]/inch, maxy: b.maxCorner[1]/inch, maxz: b.maxCorner[2]/inch," +
+            "   vol_in3: vol/(inch*inch*inch) }; }";
+        const resp = (await this.evaluateFeatureScript(documentId, workspaceId, elementId, script));
+        if (!isRecord(resp) || resp.result === null || resp.result === undefined) {
+            throw new fsvalue_1.FeatureScriptError((0, fsvalue_1.featurescriptMessages)(resp));
+        }
+        const d = (0, fsvalue_1.decodeFsValue)(resp.result) || {};
+        const n = Number(d.bodies ?? 0) || 0;
+        if (n === 0) {
+            return { bodies: 0, bbox: { x: 0, y: 0, z: 0, min: [0, 0, 0], max: [0, 0, 0] }, volume_in3: 0 };
+        }
+        return {
+            bodies: n,
+            bbox: {
+                x: round4(d.maxx - d.minx),
+                y: round4(d.maxy - d.miny),
+                z: round4(d.maxz - d.minz),
+                min: [round4(d.minx), round4(d.miny), round4(d.minz)],
+                max: [round4(d.maxx), round4(d.maxy), round4(d.maxz)],
+            },
+            volume_in3: round4(Number(d.vol_in3 ?? 0)),
+        };
+    }
     async updateFeature(documentId, workspaceId, elementId, featureId, feature) {
         return this.client.post(`/api/v9/partstudios/d/${documentId}/w/${workspaceId}/e/${elementId}/features/featureid/${featureId}`, feature);
     }

package/dist/api/variables.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariableManager = void 0;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+/** Part Studio variable table. Port of onshape_cli/api/variables.py. */
+class VariableManager {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getVariables(documentId, workspaceId, elementId) {
+        const response = await this.client.get(`/api/v9/partstudios/d/${documentId}/w/${workspaceId}/e/${elementId}/variables`);
+        const items = Array.isArray(response) ? response : [];
+        return items.map((item) => ({
+            name: isRecord(item) ? item.name ?? "" : "",
+            expression: isRecord(item) ? item.expression ?? "" : "",
+            description: isRecord(item) ? item.description ?? null : null,
+        }));
+    }
+    async setVariable(documentId, workspaceId, elementId, name, expression, description) {
+        const data = { name, expression };
+        if (description)
+            data.description = description;
+        return this.client.post(`/api/v9/partstudios/d/${documentId}/w/${workspaceId}/e/${elementId}/variables`, data);
+    }
+}
+exports.VariableManager = VariableManager;