mcp-3d-printer-server 1.2.24 → 1.2.26

package/dist/stl/stl-manipulator.d.ts

@@ -2,6 +2,11 @@ import * as THREE from 'three';
 import { EventEmitter } from 'events';
 import { type BambuSliceOptions } from '../slicer/bambu-cli.js';
 export type { BambuSliceOptions } from '../slicer/bambu-cli.js';
+/** A sliced file, with the slicer's own result.json when it wrote one. */
+export type SliceOutput = {
+    path: string;
+    slicer_result?: Record<string, unknown>;
+};
 /** Print-sheet slicing overrides (PRD §8.4), applied on top of the selected profile. */
 export interface ProcessOverrides {
     /** mm */
@@ -154,6 +159,13 @@ export declare class STLManipulator extends EventEmitter {
      * @returns Path to the generated G-code or sliced 3MF file
      */
     sliceSTL(stlFilePath: string, slicerType: SlicerType, slicerPath: string, slicerProfile?: string, progressCallback?: ProgressCallback, printerPreset?: string, filamentProfile?: string, bambuOptions?: BambuSliceOptions, processOverrides?: ProcessOverrides): Promise<string>;
+    /**
+     * sliceSTL with the Bambu-compatible CLI's own result.json, parsed verbatim.
+     * A failure's SlicerError carries it too, and its message starts with the
+     * slicer's error_string and plate warnings.
+     */
+    sliceSTLWithResult(stlFilePath: string, slicerType: SlicerType, slicerPath: string, slicerProfile?: string, progressCallback?: ProgressCallback, printerPreset?: string, filamentProfile?: string, bambuOptions?: BambuSliceOptions, processOverrides?: ProcessOverrides): Promise<SliceOutput>;
+    private sliceSTLOnce;
     /**
      * Enhanced version of confirmTemperatures with better error handling
      * @param gcodePath Path to the G-code file
@@ -193,7 +205,21 @@ export declare class STLManipulator extends EventEmitter {
      */
     centerModel(stlFilePath: string, progressCallback?: ProgressCallback): Promise<string>;
     /**
-     * Rotate the model so its largest flat face lies on the XY plane (Z=0).
+     * Rotate the model so a face rests on the bed, in the pose with the least
+     * part and support material per mm² of bed contact, then move it down to
+     * Z=0. Returns the new file's path, or the input path when no pose qualifies.
      */
     layFlat(stlFilePath: string, progressCallback?: ProgressCallback): Promise<string>;
+    /**
+     * layFlat with its outcome. A pose qualifies only when some face, turned to
+     * face down, lies on the rotated mesh's lowest plane; `laid_flat` is false
+     * and the model is unchanged when none does.
+     */
+    layFlatWithResult(stlFilePath: string, progressCallback?: ProgressCallback): Promise<LayFlatResult>;
 }
+export type LayFlatResult = {
+    /** The laid-flat STL, or the unchanged input when `laid_flat` is false. */
+    path: string;
+    laid_flat: boolean;
+    message: string;
+};

package/dist/stl/stl-manipulator.js

@@ -9,9 +9,10 @@ import { EventEmitter } from 'events';
 import * as crypto from 'crypto';
 import { detectProfilesRoot } from '../slicer/profile-flatten.js';
 import { flattenOrcaFilament } from '../slicer/filament-profiles.js';
-import { BambuCliProfilePreparer, assertSlicedProjectOutput, bambuCliFailureReason, buildBambuCliArgs, planBambuCliInput, } from '../slicer/bambu-cli.js';
+import { BambuCliProfilePreparer, assertSlicedProjectOutput, bambuCliFailureReason, readCliResult, buildBambuCliArgs, planBambuCliInput, } from '../slicer/bambu-cli.js';
 import { runSlicerProcess } from '../slicer/run-slicer.js';
 import { SlicerError, asPreparationError } from '../slicer/slicer-error.js';
+import { customGcodesWithPauses, layerTops, machinePauseGcode, pausedLayers, readPlateGcode, readProjectCustomGcodes } from '../slicer/layer-pauses.js';
 /** Orca/Bambu Studio process keys; profile JSON values are strings. */
 export function orcaProcessOverrides(overrides) {
     const keys = {};
@@ -840,6 +841,53 @@ export class STLManipulator extends EventEmitter {
      * @returns Path to the generated G-code or sliced 3MF file
      */
     async sliceSTL(stlFilePath, slicerType, slicerPath, slicerProfile, progressCallback, printerPreset, filamentProfile, bambuOptions, processOverrides) {
+        return (await this.sliceSTLWithResult(stlFilePath, slicerType, slicerPath, slicerProfile, progressCallback, printerPreset, filamentProfile, bambuOptions, processOverrides)).path;
+    }
+    /**
+     * sliceSTL with the Bambu-compatible CLI's own result.json, parsed verbatim.
+     * A failure's SlicerError carries it too, and its message starts with the
+     * slicer's error_string and plate warnings.
+     */
+    async sliceSTLWithResult(stlFilePath, slicerType, slicerPath, slicerProfile, progressCallback, printerPreset, filamentProfile, bambuOptions, processOverrides) {
+        const once = (options) => this.sliceSTLOnce(stlFilePath, slicerType, slicerPath, slicerProfile, progressCallback, printerPreset, filamentProfile, options, processOverrides);
+        const layers = bambuOptions?.pauseAtLayers?.length ? bambuOptions.pauseAtLayers : undefined;
+        const cli = STLManipulator.usesBambuCliPreparation(slicerType, printerPreset);
+        const plate = bambuOptions?.slicePlate && bambuOptions.slicePlate > 0 ? bambuOptions.slicePlate : 1;
+        const project = cli && /\.3mf$/i.test(stlFilePath) ? await readProjectCustomGcodes(stlFilePath, plate) : undefined;
+        if (!layers && !project?.gcodes.length)
+            return once(bambuOptions);
+        if (layers && !cli)
+            throw new Error(`Pausing at a layer needs the Bambu Studio or OrcaSlicer CLI, not ${slicerType}.`);
+        const customGcodesFile = path.join(this.tempDir, `custom-gcodes-${crypto.randomUUID()}.json`);
+        try {
+            let tops = [];
+            if (layers) {
+                if (progressCallback)
+                    progressCallback(10, `Finding layer heights for the pause before layer ${layers.join(", ")}`);
+                const plain = await once({ ...bambuOptions, pauseAtLayers: undefined, customGcodesFile: undefined });
+                const gcode = await readPlateGcode(plain.path, plate);
+                if (!gcode)
+                    throw new Error('The slicer wrote no plate G-code, so the pause layers cannot be placed.');
+                tops = layerTops(gcode);
+            }
+            const info = layers ? customGcodesWithPauses(tops, layers, project) : project;
+            await fs.promises.writeFile(customGcodesFile, JSON.stringify(info));
+            const result = await once({ ...bambuOptions, customGcodesFile });
+            if (layers) {
+                const gcode = await readPlateGcode(result.path, plate);
+                const placed = gcode ? pausedLayers(gcode, machinePauseGcode(gcode)) : [];
+                const missing = layers.filter(layer => !placed.includes(layer));
+                if (!gcode || missing.length || layerTops(gcode).length !== tops.length) {
+                    throw new Error(`The slicer did not place the pause before layer ${(missing.length ? missing : layers).join(", ")}. Nothing was sent to the printer.`);
+                }
+            }
+            return result;
+        }
+        finally {
+            await fs.promises.rm(customGcodesFile, { force: true });
+        }
+    }
+    async sliceSTLOnce(stlFilePath, slicerType, slicerPath, slicerProfile, progressCallback, printerPreset, filamentProfile, bambuOptions, processOverrides) {
         const operationId = this.generateOperationId();
         this.activeOperations.set(operationId, true);
         const bambuCli = STLManipulator.usesBambuCliPreparation(slicerType, printerPreset);
@@ -979,14 +1027,31 @@ export class STLManipulator extends EventEmitter {
                 progressCallback(20, `Executing slicer: ${slicerPath} ${args.join(' ')}`);
             console.error(`Executing: ${slicerPath} ${args.join(' ')}`);
             const cliOutputDir = bambuOutputDir;
-            await runSlicerProcess({
-                command: slicerPath,
-                args,
-                timeoutMs: this.resolveSlicerTimeoutMs(),
-                slicerType,
-                isCancelled: () => !this.activeOperations.get(operationId),
-                failureReason: cliOutputDir ? (exitCode) => bambuCliFailureReason(exitCode, cliOutputDir) : undefined,
-            });
+            try {
+                await runSlicerProcess({
+                    command: slicerPath,
+                    args,
+                    timeoutMs: this.resolveSlicerTimeoutMs(),
+                    slicerType,
+                    isCancelled: () => !this.activeOperations.get(operationId),
+                    failureReason: cliOutputDir ? (exitCode) => bambuCliFailureReason(exitCode, cliOutputDir) : undefined,
+                });
+            }
+            catch (error) {
+                // Keep the CLI's own result.json before the output directory is removed.
+                const failedResult = cliOutputDir ? readCliResult(cliOutputDir) : undefined;
+                if (failedResult && error instanceof SlicerError)
+                    throw new SlicerError(error.phase, error.message, error.details, failedResult);
+                throw error;
+            }
+            const slicerResult = cliOutputDir ? readCliResult(cliOutputDir) : undefined;
+            if (cliOutputDir && !slicerResult) {
+                // Older or Linux CLIs may write result.json only for handled errors.
+                console.error(`${slicerType} wrote no result.json for this slice, so its own checks are not available.`);
+            }
+            if (typeof slicerResult?.return_code === "number" && slicerResult.return_code !== 0) {
+                throw new SlicerError('execution', `Slicer exited with code 0, but its result.json reports return_code ${slicerResult.return_code}.`, { slicerType, slicerPath, exitCode: 0 }, slicerResult);
+            }
             if (!this.activeOperations.get(operationId)) {
                 throw new SlicerError('execution', 'Slicing operation cancelled after process finished', { slicerType, slicerPath });
             }
@@ -1013,7 +1078,7 @@ export class STLManipulator extends EventEmitter {
             catch (error) {
                 if (error instanceof SlicerError)
                     throw error;
-                throw new SlicerError('output', error instanceof Error ? error.message : String(error), { slicerType, slicerPath });
+                throw new SlicerError('output', error instanceof Error ? error.message : String(error), { slicerType, slicerPath }, slicerResult);
             }
             if (progressCallback)
                 progressCallback(100, "Slicing completed successfully");
@@ -1023,7 +1088,7 @@ export class STLManipulator extends EventEmitter {
                 success: true,
                 output: outputFilePath
             });
-            return outputFilePath;
+            return slicerResult ? { path: outputFilePath, slicer_result: slicerResult } : { path: outputFilePath };
         }
         catch (error) {
             console.error(`Slicing failed for ${stlFilePath}:`, error instanceof Error ? error.message : error);
@@ -1202,9 +1267,19 @@ export class STLManipulator extends EventEmitter {
         }
     }
     /**
-     * Rotate the model so its largest flat face lies on the XY plane (Z=0).
+     * Rotate the model so a face rests on the bed, in the pose with the least
+     * part and support material per mm² of bed contact, then move it down to
+     * Z=0. Returns the new file's path, or the input path when no pose qualifies.
      */
     async layFlat(stlFilePath, progressCallback) {
+        return (await this.layFlatWithResult(stlFilePath, progressCallback)).path;
+    }
+    /**
+     * layFlat with its outcome. A pose qualifies only when some face, turned to
+     * face down, lies on the rotated mesh's lowest plane; `laid_flat` is false
+     * and the model is unchanged when none does.
+     */
+    async layFlatWithResult(stlFilePath, progressCallback) {
         const operationId = this.generateOperationId();
         this.activeOperations.set(operationId, true);
         try {
@@ -1218,91 +1293,96 @@ export class STLManipulator extends EventEmitter {
             const positionAttribute = geometry.getAttribute('position');
             if (!positionAttribute)
                 throw new Error("Geometry has no position attribute.");
-            const faces = [];
+            const faceCount = Math.floor(positionAttribute.count / 3);
+            if (faceCount === 0)
+                throw new Error("No faces found in geometry.");
+            const mesh = {
+                positions: new Float64Array(faceCount * 9),
+                normals: new Float64Array(faceCount * 3),
+                areas: new Float64Array(faceCount),
+                volume: 0,
+            };
+            const center = new THREE.Vector3();
+            boundingBox.getCenter(center);
             const vA = new THREE.Vector3();
             const vB = new THREE.Vector3();
             const vC = new THREE.Vector3();
-            const faceNormal = new THREE.Vector3();
             const cb = new THREE.Vector3(), ab = new THREE.Vector3();
-            // Iterate through faces (triangles)
-            for (let i = 0; i < positionAttribute.count; i += 3) {
-                vA.fromBufferAttribute(positionAttribute, i);
-                vB.fromBufferAttribute(positionAttribute, i + 1);
-                vC.fromBufferAttribute(positionAttribute, i + 2);
-                // Calculate face normal
+            const fromA = new THREE.Vector3(), fromB = new THREE.Vector3(), fromC = new THREE.Vector3();
+            for (let face = 0; face < faceCount; face++) {
+                vA.fromBufferAttribute(positionAttribute, face * 3);
+                vB.fromBufferAttribute(positionAttribute, face * 3 + 1);
+                vC.fromBufferAttribute(positionAttribute, face * 3 + 2);
+                vA.toArray(mesh.positions, face * 9);
+                vB.toArray(mesh.positions, face * 9 + 3);
+                vC.toArray(mesh.positions, face * 9 + 6);
+                // Signed tetrahedron volumes about the center sum to the enclosed volume.
+                fromA.subVectors(vA, center);
+                fromB.subVectors(vB, center);
+                fromC.subVectors(vC, center);
+                mesh.volume += fromA.dot(fromB.cross(fromC)) / 6;
+                // The cross product's direction is the outward normal; half its length is the area.
                 cb.subVectors(vC, vB);
                 ab.subVectors(vA, vB);
                 cb.cross(ab);
-                faceNormal.copy(cb).normalize();
-                // Calculate face area (using cross product magnitude / 2)
-                const area = cb.length() / 2;
-                faces.push({
-                    normal: faceNormal.clone(),
-                    area: area,
-                    vertices: [vA.clone(), vB.clone(), vC.clone()] // Store vertices if needed for center calculation
-                });
+                mesh.areas[face] = cb.length() / 2;
+                cb.normalize().toArray(mesh.normals, face * 3);
             }
-            if (faces.length === 0)
-                throw new Error("No faces found in geometry.");
+            mesh.volume = Math.abs(mesh.volume);
             if (!this.activeOperations.get(operationId))
                 throw new Error("Operation cancelled");
             if (progressCallback)
                 progressCallback(65, "Grouping faces by normal...");
             // Group faces by similar normal vectors (tolerance for floating point errors)
-            const normalGroups = new Map();
+            const normalGroups = [];
             const tolerance = 1e-5;
-            for (const face of faces) {
-                let foundGroup = false;
-                for (const [key, group] of normalGroups.entries()) {
-                    if (face.normal.distanceToSquared(group.representativeNormal) < tolerance) {
-                        group.totalArea += face.area;
-                        // Optional: Average the normal? For now, just use the first one.
-                        foundGroup = true;
-                        break;
-                    }
-                }
-                if (!foundGroup) {
-                    const key = `${face.normal.x.toFixed(5)},${face.normal.y.toFixed(5)},${face.normal.z.toFixed(5)}`;
-                    if (!normalGroups.has(key)) { // Ensure unique key even if floats slightly differ after toFixed
-                        normalGroups.set(key, { totalArea: face.area, representativeNormal: face.normal });
-                    }
-                }
+            const faceNormal = new THREE.Vector3();
+            for (let face = 0; face < faceCount; face++) {
+                if (!(mesh.areas[face] > 0))
+                    continue;
+                faceNormal.fromArray(mesh.normals, face * 3);
+                const group = normalGroups.find(candidate => faceNormal.distanceToSquared(candidate.representativeNormal) < tolerance);
+                if (group)
+                    group.totalArea += mesh.areas[face];
+                else
+                    normalGroups.push({ totalArea: mesh.areas[face], representativeNormal: faceNormal.clone() });
             }
-            if (normalGroups.size === 0)
-                throw new Error("Could not group faces by normal.");
             if (!this.activeOperations.get(operationId))
                 throw new Error("Operation cancelled");
             if (progressCallback)
-                progressCallback(75, "Finding largest flat surface...");
-            // Include already-horizontal faces: excluding Z-aligned normals can
-            // stand a flat model on its edge, including on a repeated layFlat call.
-            let largestArea = 0;
-            let targetNormal = null;
-            const downVector = new THREE.Vector3(0, 0, -1); // Target normal (pointing down)
-            // Faces are grouped by direction, so a part whose flat faces are all
-            // horizontal has equal up- and down-facing areas. On a tie, keep the
-            // face that already points down so a seated part is not flipped.
-            for (const group of normalGroups.values()) {
-                const tied = targetNormal !== null && Math.abs(group.totalArea - largestArea) <= largestArea * 1e-6;
-                if (tied ? group.representativeNormal.z < targetNormal.z : group.totalArea > largestArea) {
-                    largestArea = group.totalArea;
-                    targetNormal = group.representativeNormal;
-                }
+                progressCallback(75, "Finding the pose that rests on the bed...");
+            // Candidate directions to turn down: the largest face groups, plus the
+            // model's own axes so a part with a domed side can be flipped exactly.
+            const candidates = normalGroups
+                .sort((a, b) => b.totalArea - a.totalArea)
+                .slice(0, LAY_FLAT_MAX_GROUP_CANDIDATES)
+                .map(group => group.representativeNormal);
+            for (const axis of [[0, 0, -1], [0, 0, 1], [1, 0, 0], [-1, 0, 0], [0, 1, 0], [0, -1, 0]]) {
+                const normal = new THREE.Vector3(axis[0], axis[1], axis[2]);
+                if (!candidates.some(candidate => candidate.distanceToSquared(normal) < tolerance))
+                    candidates.push(normal);
+            }
+            let best = null;
+            for (const normal of candidates) {
+                const pose = evaluateLayFlatPose(mesh, normal);
+                if (pose && (!best || isBetterLayFlatPose(pose, best)))
+                    best = pose;
             }
-            if (!targetNormal) {
-                // Only a mesh without any face area reaches this.
-                console.warn("Could not find a suitable large flat face to lay down. No changes made.");
-                this.emit('operationComplete', { operationId, type: 'layFlat', success: true, output: stlFilePath, message: "No suitable flat face found." });
-                return stlFilePath;
+            if (!best) {
+                const message = "No face lies on the model's lowest plane in any candidate orientation, so the model is unchanged.";
+                console.error(`lay_flat: ${message}`);
+                this.emit('operationComplete', { operationId, type: 'layFlat', success: true, output: stlFilePath, message });
+                return { path: stlFilePath, laid_flat: false, message };
             }
             if (progressCallback)
                 progressCallback(80, "Calculating rotation...");
-            // Calculate the rotation needed to align targetNormal with downVector
-            const quaternion = new THREE.Quaternion().setFromUnitVectors(targetNormal, downVector);
-            const rotationMatrix = new THREE.Matrix4().makeRotationFromQuaternion(quaternion);
+            // Turn the chosen normal to face straight down. Turning +Z down rotates
+            // half a turn about X, which keeps the model's X layout.
+            const downVector = new THREE.Vector3(0, 0, -1);
+            const rotationMatrix = best.normal.dot(downVector) < -1 + 1e-9
+                ? new THREE.Matrix4().makeRotationX(Math.PI)
+                : new THREE.Matrix4().makeRotationFromQuaternion(new THREE.Quaternion().setFromUnitVectors(best.normal, downVector));
             // Rotate around the model's center
-            const center = new THREE.Vector3();
-            boundingBox.getCenter(center);
             const toOriginMatrix = new THREE.Matrix4().makeTranslation(-center.x, -center.y, -center.z);
             const fromOriginMatrix = new THREE.Matrix4().makeTranslation(center.x, center.y, center.z);
             // Apply rotation
@@ -1320,8 +1400,9 @@ export class STLManipulator extends EventEmitter {
             const outputFileName = path.basename(stlFilePath, '.stl') + '_flat.stl';
             const outputFilePath = this.operationOutputPath(operationId, outputFileName);
             await this.saveSTL(geometry, outputFilePath, progressCallback); // 90-100% progress
-            this.emit('operationComplete', { operationId, type: 'layFlat', success: true, output: outputFilePath });
-            return outputFilePath;
+            const message = `Rests on ${best.contactArea.toFixed(1)} mm² of bed contact; overhangs more than 45° from vertical need about ${best.supportVolume.toFixed(0)} mm³ of support.`;
+            this.emit('operationComplete', { operationId, type: 'layFlat', success: true, output: outputFilePath, message });
+            return { path: outputFilePath, laid_flat: true, message };
         }
         catch (error) {
             this.emit('operationError', { operationId, type: 'layFlat', error: error instanceof Error ? error.message : String(error) });
@@ -1332,3 +1413,62 @@ export class STLManipulator extends EventEmitter {
         }
     }
 }
+const LAY_FLAT_MAX_GROUP_CANDIDATES = 64;
+/** Faces tilted more than 45° from vertical overhang and need support. */
+const LAY_FLAT_OVERHANG_COS = Math.SQRT1_2 + 1e-6;
+/**
+ * Score turning `normal` to face the bed. The bed is the mesh's lowest plane in
+ * that pose, its support plane. Faces lying on it, within 0.5% of the model's
+ * height there (at most 0.2 mm), are bed contact. Overhanging faces above it
+ * need support up from the bed: their projected area times their height.
+ * Returns null when no face lies on the bed: turning that normal down would
+ * rest the model on an edge or a point, not a face.
+ */
+function evaluateLayFlatPose(mesh, normal) {
+    const { positions, normals, areas } = mesh;
+    const nx = normal.x, ny = normal.y, nz = normal.z;
+    // Distance along the normal grows toward the bed: the bed is at its maximum.
+    let bed = -Infinity, top = Infinity;
+    for (let index = 0; index < positions.length; index += 3) {
+        const along = positions[index] * nx + positions[index + 1] * ny + positions[index + 2] * nz;
+        if (along > bed)
+            bed = along;
+        if (along < top)
+            top = along;
+    }
+    const tolerance = Math.min(0.2, Math.max(0.005 * (bed - top), 1e-4));
+    let contactArea = 0;
+    let supportVolume = 0;
+    for (let face = 0; face < areas.length; face++) {
+        const facing = normals[face * 3] * nx + normals[face * 3 + 1] * ny + normals[face * 3 + 2] * nz;
+        if (!(facing > 0))
+            continue;
+        const base = face * 9;
+        let heightSum = 0, heightMax = 0;
+        for (let corner = base; corner < base + 9; corner += 3) {
+            const height = bed - (positions[corner] * nx + positions[corner + 1] * ny + positions[corner + 2] * nz);
+            heightSum += height;
+            if (height > heightMax)
+                heightMax = height;
+        }
+        if (heightMax <= tolerance)
+            contactArea += areas[face];
+        else if (facing > LAY_FLAT_OVERHANG_COS)
+            supportVolume += areas[face] * facing * (heightSum / 3);
+    }
+    if (!(contactArea > 0))
+        return null;
+    return { normal, contactArea, supportVolume, stackHeight: (mesh.volume + supportVolume) / contactArea };
+}
+/**
+ * Prefer the pose with the lowest stack height, then the larger contact. On a
+ * tie, keep the face that already points down so a seated part is not flipped.
+ */
+function isBetterLayFlatPose(pose, best) {
+    const same = (a, b) => Math.abs(a - b) <= 1e-9 + 1e-6 * Math.max(Math.abs(a), Math.abs(b));
+    if (!same(pose.stackHeight, best.stackHeight))
+        return pose.stackHeight < best.stackHeight;
+    if (!same(pose.contactArea, best.contactArea))
+        return pose.contactArea > best.contactArea;
+    return pose.normal.z < best.normal.z;
+}

package/dist/studio-print-options.d.ts

@@ -0,0 +1,57 @@
+export type StudioOptionValue = "off" | "on" | "auto";
+export type StudioOptionSource = "caller" | "studio-config" | "studio-default";
+/** Explicit caller choices; each one wins over Studio's resolution. */
+export type CallerPrintOptions = {
+    bedLeveling?: boolean;
+    flowCalibration?: boolean;
+    vibrationCalibration?: boolean;
+    layerInspect?: boolean;
+    /** 0 off, 1 on, 2 auto, as Studio's getValueInt. */
+    autoBedLeveling?: number;
+    autoFlowCali?: number;
+    autoOffsetCali?: number;
+    extruderCaliManualMode?: number;
+};
+export type StudioPrintOptions = {
+    printerType?: string;
+    values: {
+        bed_leveling: StudioOptionValue;
+        flow_cali: StudioOptionValue;
+        nozzle_offset_cali: StudioOptionValue;
+    };
+    sources: {
+        bed_leveling: StudioOptionSource;
+        flow_cali: StudioOptionSource;
+        nozzle_offset_cali: StudioOptionSource;
+    };
+    task_bed_leveling: boolean;
+    task_flow_cali: boolean;
+    task_vibration_cali: boolean;
+    task_layer_inspect: boolean;
+    auto_bed_leveling: number;
+    auto_flow_cali: number;
+    auto_offset_cali: number;
+    extruder_cali_manual_mode: number;
+};
+/** Where Studio keeps BambuStudio.conf; BAMBU_STUDIO_CONFIG overrides it (empty: none). */
+export declare function studioConfigPath(): string | undefined;
+/**
+ * The Send dialog options Studio saved for a printer type, and nothing else:
+ * BambuStudio.conf also holds access codes, so only that one section is kept,
+ * and a parse failure is reported without any of the file's text.
+ */
+export declare function readStudioSavedOptions(printerTypes: string[], configPath: string | undefined): Record<string, string> | undefined;
+/**
+ * What Studio's Send dialog would send for this model, with the caller's
+ * explicit choices taking precedence. usedNozzles is the number of nozzles the
+ * job uses, for dual-nozzle printers.
+ */
+export declare function resolveStudioPrintOptions(model: string, caller?: CallerPrintOptions, options?: {
+    usedNozzles?: number;
+    configPath?: string;
+}): StudioPrintOptions;
+/** The number of nozzles a job's used filaments print from, when the inspection knows. */
+export declare function usedNozzleCount(inspection: {
+    usedFilamentPositions: number[];
+    filamentNozzleIndices?: Array<number | undefined>;
+}): number | undefined;