mcp-3d-printer-server 1.2.9 → 1.2.11

package/dist/stl/stl-manipulator.js

@@ -7,7 +7,11 @@ import path from 'path';
 import { promisify } from 'util';
 import { EventEmitter } from 'events';
 import * as crypto from 'crypto';
-import { execFile } from 'child_process';
+import { detectProfilesRoot } from '../slicer/profile-flatten.js';
+import { BambuCliProfilePreparer, assertSlicedProjectOutput, buildBambuCliArgs, } from '../slicer/bambu-cli.js';
+import { runSlicerProcess } from '../slicer/run-slicer.js';
+import { SlicerError, asPreparationError } from '../slicer/slicer-error.js';
+import { scanGcodeThermal } from '../safety/gcode-thermal.js';
 const readFileAsync = promisify(fs.readFile);
 const writeFileAsync = promisify(fs.writeFile);
 const DEFAULT_SLICER_TIMEOUT_MS = 10 * 60 * 1000;
@@ -27,6 +31,16 @@ export class STLManipulator extends EventEmitter {
     generateOperationId() {
         return crypto.randomUUID();
     }
+    /**
+     * Each operation writes into its own folder. Outputs named only after the
+     * input (for example bracket_extended.stl) would otherwise let two
+     * concurrent requests replace each other's file before it is used or printed.
+     */
+    operationOutputPath(operationId, fileName) {
+        const directory = path.join(this.tempDir, `${operationId}-out`);
+        fs.mkdirSync(directory, { recursive: true });
+        return path.join(directory, fileName);
+    }
     validateSlicerExecutable(slicerPath) {
         if (!slicerPath.trim()) {
             throw new Error("Slicer executable path is required.");
@@ -84,28 +98,6 @@ export class STLManipulator extends EventEmitter {
         }
         return path.join(outputDir, plateOutputs[0]);
     }
-    resolveBambuMachinePresetPath(slicerPath, printerPreset) {
-        if (fs.existsSync(printerPreset)) {
-            return printerPreset;
-        }
-        const presetFile = printerPreset.endsWith(".json") ? printerPreset : `${printerPreset}.json`;
-        const candidateDirs = [];
-        const macAppMarker = `${path.sep}Contents${path.sep}MacOS${path.sep}`;
-        const macAppIndex = slicerPath.indexOf(macAppMarker);
-        if (macAppIndex >= 0) {
-            candidateDirs.push(path.join(slicerPath.slice(0, macAppIndex + `${path.sep}Contents`.length), "Resources", "profiles", "BBL", "machine"));
-        }
-        const executableDir = path.dirname(slicerPath);
-        candidateDirs.push(path.join(executableDir, "..", "Resources", "profiles", "BBL", "machine"), path.join(executableDir, "..", "share", "OrcaSlicer", "resources", "profiles", "BBL", "machine"), path.join(executableDir, "..", "resources", "profiles", "BBL", "machine"), path.join(executableDir, "resources", "profiles", "BBL", "machine"));
-        for (const candidateDir of candidateDirs) {
-            const candidate = path.resolve(candidateDir, presetFile);
-            if (fs.existsSync(candidate)) {
-                return candidate;
-            }
-        }
-        throw new Error(`Could not find Bambu machine preset "${presetFile}" near slicer executable ${slicerPath}. ` +
-            "Pass slicer_profile with an explicit machine/process settings file, or use a slicer bundle that includes Resources/profiles/BBL/machine.");
-    }
     resolveSlicerTimeoutMs() {
         const rawTimeout = process.env.SLICER_TIMEOUT_MS?.trim();
         if (!rawTimeout) {
@@ -240,7 +232,7 @@ export class STLManipulator extends EventEmitter {
             }
             // Generate output file path
             const outputFileName = path.basename(stlFilePath, '.stl') + '_scaled.stl';
-            const outputFilePath = path.join(this.tempDir, outputFileName);
+            const outputFilePath = this.operationOutputPath(operationId, outputFileName);
             // Save the modified STL
             await this.saveSTL(geometry, outputFilePath, progressCallback);
             this.emit('operationComplete', {
@@ -298,7 +290,7 @@ export class STLManipulator extends EventEmitter {
             }
             // Generate output file path
             const outputFileName = path.basename(stlFilePath, '.stl') + '_rotated.stl';
-            const outputFilePath = path.join(this.tempDir, outputFileName);
+            const outputFilePath = this.operationOutputPath(operationId, outputFileName);
             // Save the modified STL
             await this.saveSTL(geometry, outputFilePath, progressCallback);
             this.emit('operationComplete', {
@@ -347,7 +339,7 @@ export class STLManipulator extends EventEmitter {
             }
             // Generate output file path
             const outputFileName = path.basename(stlFilePath, '.stl') + '_translated.stl';
-            const outputFilePath = path.join(this.tempDir, outputFileName);
+            const outputFilePath = this.operationOutputPath(operationId, outputFileName);
             // Save the modified STL
             await this.saveSTL(geometry, outputFilePath, progressCallback);
             this.emit('operationComplete', {
@@ -488,7 +480,7 @@ export class STLManipulator extends EventEmitter {
                 progressCallback(90, "Saving visualization...");
             // Write the SVG to file
             const outputFileName = path.basename(stlFilePath, '.stl') + '_visualization.svg';
-            const outputFilePath = path.join(this.tempDir, outputFileName);
+            const outputFilePath = this.operationOutputPath(operationId, outputFileName);
             await writeFileAsync(outputFilePath, svgContent);
             if (progressCallback)
                 progressCallback(100, "Visualization saved successfully");
@@ -630,7 +622,7 @@ export class STLManipulator extends EventEmitter {
             }
             // Generate output file path
             const outputFileName = path.basename(stlFilePath, '.stl') + '_modified.stl';
-            const outputFilePath = path.join(this.tempDir, outputFileName);
+            const outputFilePath = this.operationOutputPath(operationId, outputFileName);
             // Save the modified STL
             await this.saveSTL(geometry, outputFilePath, progressCallback);
             this.emit('operationComplete', {
@@ -666,7 +658,7 @@ export class STLManipulator extends EventEmitter {
         try {
             if (progressCallback)
                 progressCallback(0, "Starting base extension operation...");
-            console.log(`Extending base of ${stlFilePath} by ${extensionInches} inches`);
+            console.error(`Extending base of ${stlFilePath} by ${extensionInches} inches`);
             // Load the STL file
             const { geometry, boundingBox } = await this.loadSTL(stlFilePath, progressCallback);
             if (!this.activeOperations.get(operationId)) {
@@ -674,19 +666,19 @@ export class STLManipulator extends EventEmitter {
             }
             if (progressCallback)
                 progressCallback(60, "Creating extended base geometry...");
-            // Find the minimum Y value (assuming Y is up, which is common in 3D printing)
-            const minY = boundingBox.min.y;
+            // STL files and slicers are Z-up: the base goes under the model.
+            const minZ = boundingBox.min.z;
             // Convert inches to millimeters (STL files typically use mm)
             const extensionMm = extensionInches * 25.4;
-            // Create a transformation matrix to move the mesh up by the extension amount
-            const matrix = new THREE.Matrix4().makeTranslation(0, extensionMm, 0);
+            // Raise the model by the extension amount
+            const matrix = new THREE.Matrix4().makeTranslation(0, 0, extensionMm);
             geometry.applyMatrix4(matrix);
-            // Create a box geometry for the base extension
+            // A box spanning the model's X/Y footprint fills the new space below it
             const baseWidth = boundingBox.max.x - boundingBox.min.x;
-            const baseDepth = boundingBox.max.z - boundingBox.min.z;
-            const baseGeometry = new THREE.BoxGeometry(baseWidth, extensionMm, baseDepth);
+            const baseDepth = boundingBox.max.y - boundingBox.min.y;
+            const baseGeometry = new THREE.BoxGeometry(baseWidth, baseDepth, extensionMm);
             // Position the base geometry
-            const baseMatrix = new THREE.Matrix4().makeTranslation((boundingBox.min.x + boundingBox.max.x) / 2, minY + extensionMm / 2, (boundingBox.min.z + boundingBox.max.z) / 2);
+            const baseMatrix = new THREE.Matrix4().makeTranslation((boundingBox.min.x + boundingBox.max.x) / 2, (boundingBox.min.y + boundingBox.max.y) / 2, minZ + extensionMm / 2);
             baseGeometry.applyMatrix4(baseMatrix);
             if (!this.activeOperations.get(operationId)) {
                 throw new Error("Operation cancelled");
@@ -706,7 +698,7 @@ export class STLManipulator extends EventEmitter {
             const baseStl = exporter.parse(baseMesh);
             // Generate output file path
             const outputFileName = path.basename(stlFilePath, '.stl') + '_extended.stl';
-            const outputFilePath = path.join(this.tempDir, outputFileName);
+            const outputFilePath = this.operationOutputPath(operationId, outputFileName);
             if (progressCallback)
                 progressCallback(90, "Saving extended STL...");
             // Write the combined STL data to file
@@ -719,7 +711,7 @@ export class STLManipulator extends EventEmitter {
                 success: true,
                 output: outputFilePath
             });
-            console.log(`Modified STL saved to ${outputFilePath}`);
+            console.error(`Modified STL saved to ${outputFilePath}`);
             return outputFilePath;
         }
         catch (error) {
@@ -735,188 +727,184 @@ export class STLManipulator extends EventEmitter {
             this.activeOperations.delete(operationId);
         }
     }
+    /**
+     * Bambu-compatible CLI slicing applies when the slicer is BambuStudio or
+     * FULU OrcaSlicer-bambulab, or when generic OrcaSlicer is given an explicit
+     * Bambu machine preset. Generic OrcaSlicer without a preset keeps its
+     * user-supplied machine/process profile path.
+     */
+    static usesBambuCliPreparation(slicerType, printerPreset) {
+        return (slicerType === 'bambustudio' ||
+            slicerType === 'orcaslicer-bambulab' ||
+            (slicerType === 'orcaslicer' && Boolean(printerPreset)));
+    }
     /**
      * Slice an STL or 3MF file using the specified slicer
      * @param stlFilePath Path to the input STL or 3MF file
      * @param slicerType Type of slicer (prusaslicer, cura, slic3r, orcaslicer, orcaslicer-bambulab, bambustudio)
      * @param slicerPath Path to the slicer executable
-     * @param slicerProfile Optional path to the slicer profile/config file
+     * @param slicerProfile Optional slicer profile/config file. For Bambu-compatible
+     *   CLI slicing this is a process profile; the machine comes from printerPreset.
      * @param progressCallback Optional callback for progress updates
+     * @param printerPreset Bambu machine preset name, e.g. "Bambu Lab P1S 0.4 nozzle"
+     * @param filamentProfile Optional filament profile path(s), ';'-separated
+     * @param bambuOptions Optional Bambu-compatible CLI options (added last for compatibility)
      * @returns Path to the generated G-code or sliced 3MF file
      */
-    async sliceSTL(stlFilePath, slicerType, slicerPath, slicerProfile, progressCallback, printerPreset, filamentProfile) {
+    async sliceSTL(stlFilePath, slicerType, slicerPath, slicerProfile, progressCallback, printerPreset, filamentProfile, bambuOptions) {
         const operationId = this.generateOperationId();
         this.activeOperations.set(operationId, true);
-        this.validateSlicerExecutable(slicerPath);
-        const orcaProfiles = this.parseOrcaProfileArgs(slicerProfile, filamentProfile);
-        if (slicerType === 'orcaslicer') {
-            this.warnForMissingProfiles(orcaProfiles.settingsProfiles, 'Slicer profile');
-            this.warnForMissingProfiles(orcaProfiles.filamentProfiles, 'Filament profile');
-        }
-        else if (slicerProfile && !fs.existsSync(slicerProfile)) {
-            console.warn(`Slicer profile specified but not found: ${slicerProfile}. Slicer might use defaults.`);
-            // Allow proceeding without profile, slicer might handle it
-        }
-        if (slicerType !== 'orcaslicer' && filamentProfile && !fs.existsSync(filamentProfile)) {
-            console.warn(`Filament profile specified but not found: ${filamentProfile}. Slicer might use defaults.`);
-        }
-        const outputFileName = path.basename(stlFilePath, '.stl') + '.gcode';
-        let outputFilePath = path.join(this.tempDir, outputFileName);
+        const bambuCli = STLManipulator.usesBambuCliPreparation(slicerType, printerPreset);
         let orcaOutputDir;
-        let args = [];
+        let bambuOutputDir;
         try {
+            try {
+                this.validateSlicerExecutable(slicerPath);
+            }
+            catch (error) {
+                throw asPreparationError(error, { slicerType, slicerPath });
+            }
+            if (!fs.existsSync(stlFilePath)) {
+                throw new SlicerError('preparation', `Input model not found: ${stlFilePath}`, { slicerType, slicerPath });
+            }
+            const orcaProfiles = this.parseOrcaProfileArgs(slicerProfile, filamentProfile);
+            if (!bambuCli) {
+                if (slicerType === 'orcaslicer') {
+                    this.warnForMissingProfiles(orcaProfiles.settingsProfiles, 'Slicer profile');
+                    this.warnForMissingProfiles(orcaProfiles.filamentProfiles, 'Filament profile');
+                }
+                else if (slicerProfile && !fs.existsSync(slicerProfile)) {
+                    console.warn(`Slicer profile specified but not found: ${slicerProfile}. Slicer might use defaults.`);
+                }
+            }
+            const outputFileName = path.basename(stlFilePath, '.stl') + '.gcode';
+            let outputFilePath = this.operationOutputPath(operationId, outputFileName);
+            let args = [];
+            let bambuExport;
             if (progressCallback)
                 progressCallback(0, `Starting slicing with ${slicerType}...`);
-            switch (slicerType) {
-                case 'prusaslicer':
-                case 'slic3r': // PrusaSlicer and Slic3r share similar CLI args
-                    args = [
-                        '--slice',
-                        '--output', outputFilePath,
-                        '--load', slicerProfile || '', // Pass profile path
-                        stlFilePath
-                    ];
-                    // Remove empty profile arg if not provided
-                    args = args.filter(arg => arg !== '');
-                    break;
-                case 'orcaslicer': // Add OrcaSlicer case
-                    orcaOutputDir = path.join(this.tempDir, `${operationId}-orca-output`);
-                    fs.mkdirSync(orcaOutputDir, { recursive: true });
-                    args = [
-                        '--slice', '0',
-                        '--outputdir', orcaOutputDir,
-                    ];
-                    this.appendOrcaProfileArgs(args, orcaProfiles);
-                    args.push(stlFilePath);
-                    break;
-                case 'cura':
-                    // CuraEngine CLI args are different, often requiring -s for settings
-                    // Example: curaengine slice -v -j cura_settings.json -s layer_height=0.2 -o output.gcode -l input.stl
-                    // This requires parsing the profile or passing individual settings.
-                    // Keeping it simple for now, assuming profile contains necessary info.
-                    args = [
-                        'slice',
-                        '-l', stlFilePath,
-                        '-o', outputFilePath
-                    ];
-                    if (slicerProfile) {
-                        args.push('-j', slicerProfile); // Load settings from profile definition file
+            if (bambuCli) {
+                // Bambu-compatible CLI: resolve the exact machine preset and every
+                // profile dependency, then slice and export a 3MF with plate G-code.
+                const cliType = slicerType;
+                const is3mf = stlFilePath.toLowerCase().endsWith('.3mf');
+                const outputBase = path.basename(stlFilePath, is3mf ? '.3mf' : '.stl');
+                const exportName = `${outputBase}_sliced.3mf`;
+                try {
+                    if (orcaProfiles.settingsProfiles.length > 1) {
+                        throw new Error(`slicer_profile (or SLICER_PROFILE) lists ${orcaProfiles.settingsProfiles.length} settings files, but Bambu-compatible CLI slicing ` +
+                            'takes one process profile. Set slicer_profile/SLICER_PROFILE to a process profile only (or leave it empty for the ' +
+                            "preset's default process); the machine preset comes from bambu_model/BAMBU_MODEL and nozzle_diameter/NOZZLE_DIAMETER. " +
+                            'Pass filaments with filament_profile/load_filaments. For a non-Bambu printer, use slicer_type orcaslicer without bambu_model ' +
+                            'to keep the machine;process|filament format.');
                     }
-                    break;
-                case 'orcaslicer-bambulab':
-                case 'bambustudio':
-                    // Bambu project slicers: slice and export as 3MF with embedded gcode.
-                    // orcaslicer-bambulab is the FULU fork that restores BambuNetwork support.
-                    // For 3MF input: slice in place and export sliced 3MF
-                    // For STL input: slice and export as 3MF
-                    {
-                        const is3mf = stlFilePath.toLowerCase().endsWith('.3mf');
-                        const outputBase = path.basename(stlFilePath, is3mf ? '.3mf' : '.stl');
-                        const bambuOutputPath = path.join(this.tempDir, outputBase + '_sliced.3mf');
+                    const options = { ...bambuOptions };
+                    if (orcaProfiles.filamentProfiles.length > 0) {
+                        const legacyFilaments = orcaProfiles.filamentProfiles.join(';');
+                        if (options.loadFilaments && this.splitProfileList(options.loadFilaments).join(';') !== legacyFilaments) {
+                            throw new Error('Provide either load_filaments or filament_profile, not conflicting values.');
+                        }
+                        options.loadFilaments = legacyFilaments;
+                    }
+                    const profilesRoot = detectProfilesRoot(slicerPath, cliType);
+                    const preparer = new BambuCliProfilePreparer(path.join(this.tempDir, 'slicer-profiles'));
+                    const bundle = await preparer.prepare(stlFilePath, outputBase, cliType, profilesRoot, printerPreset, orcaProfiles.settingsProfiles[0], options);
+                    bambuOutputDir = fs.mkdtempSync(path.join(this.tempDir, `${operationId}-bambu-output-`));
+                    args = [...buildBambuCliArgs(bundle, bambuOutputDir, exportName, options), stlFilePath];
+                    bambuExport = {
+                        producedPath: path.join(bambuOutputDir, exportName),
+                        // One folder per operation: concurrent slices of same-named inputs
+                        // must never replace each other's result before it is printed.
+                        finalPath: this.operationOutputPath(operationId, exportName),
+                    };
+                    outputFilePath = bambuExport.finalPath;
+                }
+                catch (error) {
+                    throw asPreparationError(error, { slicerType, slicerPath });
+                }
+            }
+            else {
+                switch (slicerType) {
+                    case 'prusaslicer':
+                    case 'slic3r': // PrusaSlicer and Slic3r share similar CLI args
                         args = [
-                            '--slice', '0', // Slice all plates
-                            '--export-3mf', bambuOutputPath,
+                            '--slice',
+                            '--output', outputFilePath,
+                            '--load', slicerProfile || '', // Pass profile path
+                            stlFilePath
+                        ];
+                        // Remove empty profile arg if not provided
+                        args = args.filter(arg => arg !== '');
+                        break;
+                    case 'orcaslicer':
+                        orcaOutputDir = path.join(this.tempDir, `${operationId}-orca-output`);
+                        fs.mkdirSync(orcaOutputDir, { recursive: true });
+                        args = [
+                            '--slice', '0',
+                            '--outputdir', orcaOutputDir,
+                        ];
+                        this.appendOrcaProfileArgs(args, orcaProfiles);
+                        args.push(stlFilePath);
+                        break;
+                    case 'cura':
+                        // CuraEngine CLI args are different, often requiring -s for settings
+                        // Example: curaengine slice -v -j cura_settings.json -s layer_height=0.2 -o output.gcode -l input.stl
+                        args = [
+                            'slice',
+                            '-l', stlFilePath,
+                            '-o', outputFilePath
                         ];
-                        // FULU Orca/Bambu Studio load machine presets as JSON settings files.
-                        if (printerPreset && !slicerProfile) {
-                            args.push('--load-settings', this.resolveBambuMachinePresetPath(slicerPath, printerPreset));
-                        }
                         if (slicerProfile) {
-                            args.push('--load-settings', slicerProfile);
-                        }
-                        if (filamentProfile) {
-                            args.push('--load-filaments', filamentProfile);
+                            args.push('-j', slicerProfile); // Load settings from profile definition file
                         }
-                        args.push(stlFilePath);
-                        // Override outputFilePath for bambustudio since it produces 3MF, not gcode
-                        outputFilePath = bambuOutputPath;
-                    }
-                    break;
-                default:
-                    throw new Error(`Unsupported slicer type: ${slicerType}`);
+                        break;
+                    default:
+                        throw new SlicerError('preparation', `Unsupported slicer type: ${slicerType}`, { slicerType, slicerPath });
+                }
             }
+            // Never mistake a previous run's file for this run's result (or overwrite the input).
+            if (path.resolve(outputFilePath) === path.resolve(stlFilePath)) {
+                throw new SlicerError('preparation', `Slicer output would overwrite the input file: ${stlFilePath}`, { slicerType, slicerPath });
+            }
+            if (fs.existsSync(outputFilePath))
+                fs.rmSync(outputFilePath, { force: true });
             if (progressCallback)
                 progressCallback(20, `Executing slicer: ${slicerPath} ${args.join(' ')}`);
-            console.log(`Executing: ${slicerPath} ${args.join(' ')}`);
-            // Execute the slicer
-            await new Promise((resolve, reject) => {
-                const timeoutMs = this.resolveSlicerTimeoutMs();
-                let settled = false;
-                let slicerProcessKilledByTimeout = false;
-                let timeoutHandle;
-                const settle = (callback) => {
-                    if (settled) {
-                        return;
-                    }
-                    settled = true;
-                    if (timeoutHandle) {
-                        clearTimeout(timeoutHandle);
-                    }
-                    callback();
-                };
-                const process = execFile(slicerPath, args, (error, stdout, stderr) => {
-                    if (error) {
-                        console.error(`Slicer Error: ${error.message}`);
-                        console.error(`Slicer Stderr: ${stderr}`);
-                        const timeoutMessage = slicerProcessKilledByTimeout
-                            ? ` Slicer exceeded timeout ${timeoutMs}ms.`
-                            : "";
-                        settle(() => reject(new Error(`Slicer failed: ${error.message}.${timeoutMessage} Stderr: ${stderr}`)));
-                    }
-                    else {
-                        console.log(`Slicer Stdout: ${stdout}`);
-                        if (stderr) {
-                            console.warn(`Slicer Stderr: ${stderr}`); // Log stderr even on success
-                        }
-                        settle(() => resolve());
-                    }
-                });
-                timeoutHandle = setTimeout(() => {
-                    slicerProcessKilledByTimeout = true;
-                    try {
-                        process.kill("SIGKILL");
-                    }
-                    catch (killError) {
-                        console.error("Error attempting to kill timed-out slicer process:", killError);
-                    }
-                    settle(() => reject(new Error(`Slicer exceeded timeout ${timeoutMs}ms.`)));
-                }, timeoutMs);
-                // Optional: Add listeners for stdout/stderr for real-time progress if slicer provides it
-                // process.stdout?.on('data', (data) => { console.log(`Slicer stdout: ${data}`); });
-                // process.stderr?.on('data', (data) => { console.log(`Slicer stderr: ${data}`); });
-                // Check for cancellation periodically
-                const checkCancel = setInterval(() => {
-                    if (!this.activeOperations.get(operationId)) {
-                        clearInterval(checkCancel);
-                        try {
-                            process.kill(); // Attempt to kill the slicer process
-                            settle(() => reject(new Error("Slicing operation cancelled")));
-                        }
-                        catch (killError) {
-                            console.error("Error attempting to kill slicer process:", killError);
-                            settle(() => reject(new Error("Slicing operation cancelled, but failed to kill process.")));
-                        }
-                    }
-                }, 500);
-                process.on('exit', () => clearInterval(checkCancel));
-                process.on('error', () => clearInterval(checkCancel)); // Ensure interval cleared on process error too
+            console.error(`Executing: ${slicerPath} ${args.join(' ')}`);
+            await runSlicerProcess({
+                command: slicerPath,
+                args,
+                timeoutMs: this.resolveSlicerTimeoutMs(),
+                slicerType,
+                isCancelled: () => !this.activeOperations.get(operationId),
             });
             if (!this.activeOperations.get(operationId)) {
-                // This check might be redundant if the promise rejected on kill, but good safety
-                throw new Error("Slicing operation cancelled after process finished");
+                throw new SlicerError('execution', 'Slicing operation cancelled after process finished', { slicerType, slicerPath });
             }
-            if (slicerType === 'orcaslicer') {
-                if (!orcaOutputDir) {
-                    throw new Error("Internal error: OrcaSlicer output directory was not initialized.");
+            try {
+                if (bambuExport) {
+                    if (!fs.existsSync(bambuExport.producedPath)) {
+                        throw new Error(`Slicer exited successfully but did not write ${bambuExport.producedPath}.`);
+                    }
+                    await assertSlicedProjectOutput(bambuExport.producedPath);
+                    fs.mkdirSync(path.dirname(bambuExport.finalPath), { recursive: true });
+                    fs.renameSync(bambuExport.producedPath, bambuExport.finalPath);
+                }
+                else if (slicerType === 'orcaslicer') {
+                    if (!orcaOutputDir) {
+                        throw new Error("Internal error: OrcaSlicer output directory was not initialized.");
+                    }
+                    const orcaGcodePath = this.resolveOrcaGcodeOutput(orcaOutputDir);
+                    fs.renameSync(orcaGcodePath, outputFilePath);
                 }
-                const orcaGcodePath = this.resolveOrcaGcodeOutput(orcaOutputDir);
-                if (fs.existsSync(outputFilePath)) {
-                    fs.unlinkSync(outputFilePath);
+                if (!fs.existsSync(outputFilePath)) {
+                    throw new Error(`Slicer finished but output file not found: ${outputFilePath}`);
                 }
-                fs.renameSync(orcaGcodePath, outputFilePath);
             }
-            if (!fs.existsSync(outputFilePath)) {
-                throw new Error(`Slicer finished but output file not found: ${outputFilePath}`);
+            catch (error) {
+                if (error instanceof SlicerError)
+                    throw error;
+                throw new SlicerError('output', error instanceof Error ? error.message : String(error), { slicerType, slicerPath });
             }
             if (progressCallback)
                 progressCallback(100, "Slicing completed successfully");
@@ -929,7 +917,7 @@ export class STLManipulator extends EventEmitter {
             return outputFilePath;
         }
         catch (error) {
-            console.error(`Slicing failed for ${stlFilePath}:`, error);
+            console.error(`Slicing failed for ${stlFilePath}:`, error instanceof Error ? error.message : error);
             this.emit('operationError', {
                 operationId,
                 type: 'slice',
@@ -938,8 +926,10 @@ export class STLManipulator extends EventEmitter {
             throw error;
         }
         finally {
-            if (orcaOutputDir && fs.existsSync(orcaOutputDir)) {
-                fs.rmSync(orcaOutputDir, { recursive: true, force: true });
+            for (const dir of [orcaOutputDir, bambuOutputDir]) {
+                if (dir && fs.existsSync(dir)) {
+                    fs.rmSync(dir, { recursive: true, force: true });
+                }
             }
             this.activeOperations.delete(operationId);
         }
@@ -965,45 +955,37 @@ export class STLManipulator extends EventEmitter {
                 progressCallback(20, "Reading G-code file...");
             // Read the G-code file
             const gcode = await readFileAsync(gcodePath, 'utf8');
-            const lines = gcode.split('\n');
             if (!this.activeOperations.get(operationId)) {
                 throw new Error("Operation cancelled");
             }
             if (progressCallback)
                 progressCallback(50, "Analyzing temperature commands...");
-            // Extract temperature settings from G-code
-            const actual = {};
-            const allTemperatures = { extruder: [], bed: [] };
-            for (const line of lines) {
-                // Look for extruder temperature (M104 or M109)
-                const extruderMatch = line.match(/M10[49] S(\d+)/);
-                if (extruderMatch) {
-                    const temp = parseInt(extruderMatch[1], 10);
-                    allTemperatures.extruder.push(temp);
-                    // Keep the first temperature for compatibility with original function
-                    if (!actual.extruder) {
-                        actual.extruder = temp;
-                    }
-                }
-                // Look for bed temperature (M140 or M190)
-                const bedMatch = line.match(/M1[49]0 S(\d+)/);
-                if (bedMatch) {
-                    const temp = parseInt(bedMatch[1], 10);
-                    allTemperatures.bed.push(temp);
-                    // Keep the first temperature for compatibility with original function
-                    if (!actual.bed) {
-                        actual.bed = temp;
-                    }
-                }
-            }
+            // Extract every heater target with the shared print-safety scanner: S and
+            // R forms, tool-addressed commands, RepRapFirmware G10/M568 and Klipper
+            // SET_HEATER_TEMPERATURE. Unparseable thermal syntax fails closed.
+            const scan = scanGcodeThermal(gcode);
+            const allTemperatures = {
+                extruder: scan.targets.filter((target) => target.heater === "nozzle").map((target) => target.value),
+                bed: scan.targets.filter((target) => target.heater === "bed").map((target) => target.value),
+            };
+            // First positive target, kept for compatibility with the original report.
+            const actual = {
+                extruder: allTemperatures.extruder.find((value) => value > 0),
+                bed: allTemperatures.bed.find((value) => value > 0),
+            };
+            const peak = {
+                extruder: allTemperatures.extruder.length ? Math.max(...allTemperatures.extruder) : undefined,
+                bed: allTemperatures.bed.length ? Math.max(...allTemperatures.bed) : undefined,
+            };
             if (progressCallback)
                 progressCallback(80, "Comparing temperatures...");
-            // Compare actual with expected
+            // An expected temperature matches only when it is the job's highest
+            // target, so a later or R-form higher target is always a mismatch.
             let match = true;
-            if (expected.extruder !== undefined && actual.extruder !== expected.extruder) {
+            if (expected.extruder !== undefined && peak.extruder !== expected.extruder) {
                 match = false;
             }
-            if (expected.bed !== undefined && actual.bed !== expected.bed) {
+            if (expected.bed !== undefined && peak.bed !== expected.bed) {
                 match = false;
             }
             if (progressCallback)
@@ -1012,9 +994,9 @@ export class STLManipulator extends EventEmitter {
                 operationId,
                 type: 'confirmTemperatures',
                 success: true,
-                result: { match, actual, expected, allTemperatures }
+                result: { match, actual, peak, expected, allTemperatures }
             });
-            return { match, actual, expected, allTemperatures };
+            return { match, actual, peak, expected, allTemperatures };
         }
         catch (error) {
             console.error("Error confirming temperatures:", error);
@@ -1047,13 +1029,13 @@ export class STLManipulator extends EventEmitter {
             const originalVertexCount = geometry.attributes.position.count;
             const mergedGeometry = BufferGeometryUtils.mergeVertices(geometry, tolerance);
             const newVertexCount = mergedGeometry.attributes.position.count;
-            console.log(`Merged vertices: ${originalVertexCount} -> ${newVertexCount} (Tolerance: ${tolerance}mm)`);
+            console.error(`Merged vertices: ${originalVertexCount} -> ${newVertexCount} (Tolerance: ${tolerance}mm)`);
             if (progressCallback)
                 progressCallback(70, `Vertices merged: ${originalVertexCount} -> ${newVertexCount}`);
             if (!this.activeOperations.get(operationId))
                 throw new Error("Operation cancelled");
             const outputFileName = path.basename(stlFilePath, '.stl') + '_merged.stl';
-            const outputFilePath = path.join(this.tempDir, outputFileName);
+            const outputFilePath = this.operationOutputPath(operationId, outputFileName);
             await this.saveSTL(mergedGeometry, outputFilePath, progressCallback); // 80-100% progress
             this.emit('operationComplete', { operationId, type: 'mergeVertices', success: true, output: outputFilePath, verticesRemoved: originalVertexCount - newVertexCount });
             return outputFilePath;
@@ -1085,7 +1067,7 @@ export class STLManipulator extends EventEmitter {
             if (center.lengthSq() < 0.0001) { // Already centered (or very close)
                 if (progressCallback)
                     progressCallback(100, "Model is already centered.");
-                console.log("Model already centered. No changes made.");
+                console.error("Model already centered. No changes made.");
                 this.emit('operationComplete', { operationId, type: 'centerModel', success: true, output: stlFilePath, message: "Model already centered." });
                 return stlFilePath; // Return original path
             }
@@ -1097,7 +1079,7 @@ export class STLManipulator extends EventEmitter {
             if (!this.activeOperations.get(operationId))
                 throw new Error("Operation cancelled");
             const outputFileName = path.basename(stlFilePath, '.stl') + '_centered.stl';
-            const outputFilePath = path.join(this.tempDir, outputFileName);
+            const outputFilePath = this.operationOutputPath(operationId, outputFileName);
             await this.saveSTL(geometry, outputFilePath, progressCallback); // 80-100% progress
             this.emit('operationComplete', { operationId, type: 'centerModel', success: true, output: outputFilePath });
             return outputFilePath;
@@ -1226,7 +1208,7 @@ export class STLManipulator extends EventEmitter {
             if (!this.activeOperations.get(operationId))
                 throw new Error("Operation cancelled");
             const outputFileName = path.basename(stlFilePath, '.stl') + '_flat.stl';
-            const outputFilePath = path.join(this.tempDir, outputFileName);
+            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;