bambu-printer-mcp 1.1.28 → 1.1.29

package/dist/safety/printer-state.d.ts

@@ -7,6 +7,8 @@ export interface PrinterStateRequirements {
     nozzleDiameters: number[];
     materials?: string[];
     usedFilamentPositions?: number[];
+    /** Verified physical nozzle index for each project filament, composed from the inspected plate mappings. */
+    filamentNozzleIndices?: number[];
     amsMapping?: number[];
     useAMS?: boolean;
     requireIdle?: boolean;

package/dist/safety/printer-state.js

@@ -1,6 +1,6 @@
 import { HIDDEN_HMS } from "./hidden-hms.js";
 import { GetVersionCommand, PushAllCommand } from "bambu-node";
-import { normalizeMaterial, normalizeModel } from "./limits.js";
+import { isDualNozzleModel, normalizeMaterial, normalizeModel } from "./limits.js";
 const MAX_REPORT_AGE_MS = 15000;
 const MODEL_IDS = {
     O1C: "H2C", O1C2: "H2C", O1D: "H2D", O1E: "H2D Pro", O1S: "H2S", N6: "X2D",
@@ -282,15 +282,24 @@ function trayRange(value, label) {
         throw new Error(`Reported filament ${label} temperature is malformed.`);
     return number;
 }
-function externalTray(raw) {
+/** Dual-nozzle printers report one virtual external slot per nozzle, numbered as Bambu
+ * Studio does (VIRTUAL_TRAY_MAIN_ID 255 = right/main nozzle, VIRTUAL_TRAY_DEPUTY_ID 254 =
+ * left/deputy nozzle), so the requested tray selects its slot. Single-nozzle printers keep
+ * requiring exactly one slot 254 report, then the legacy vt_tray field. */
+function externalTray(raw, trayIndex, model) {
     const slots = raw.vir_slot;
+    const dualNozzle = isDualNozzleModel(model);
     if (Array.isArray(slots)) {
-        const selected = slots.filter((slot) => Number(slot?.id) === 254);
-        if (slots.length === 1 && selected.length === 1)
+        const selected = slots.filter((slot) => Number(slot?.id) === trayIndex);
+        if (selected.length === 1 && (dualNozzle || slots.length === 1))
             return selected[0];
+        if (dualNozzle && selected.length === 0 && slots.length > 0)
+            throw new Error(`External spool ${trayIndex} is not in the fresh per-nozzle report; cannot verify the selected material.`);
         if (slots.length > 0)
             throw new Error("External spool report is ambiguous for this nozzle; cannot verify the selected material.");
     }
+    if (dualNozzle)
+        throw new Error(`Dual-nozzle external spool ${trayIndex} requires a fresh per-nozzle vir_slot report; legacy vt_tray cannot verify the selected nozzle.`);
     return object(raw.vt_tray) ? raw.vt_tray : undefined;
 }
 function mappedTray(raw, index) {
@@ -345,7 +354,7 @@ export function validatePrinterState(status, requirements) {
         }
     }
     const nozzles = requirements.nozzleDiameters.length ? reportedNozzles(raw) : [];
-    if (requirements.nozzleDiameters.length && ["h2d", "h2dpro", "h2c", "x2d"].includes(model) &&
+    if (requirements.nozzleDiameters.length && isDualNozzleModel(model) &&
         !Array.isArray(raw.device?.nozzle?.info) && !Array.isArray(raw.nozzle_diameter)) {
         throw new Error("A scalar legacy nozzle report is ambiguous for this multi-nozzle printer; fresh per-nozzle configuration is required.");
     }
@@ -374,16 +383,33 @@ export function validatePrinterState(status, requirements) {
     if (requirements.verifyMaterials !== false && (requirements.materials !== undefined || requirements.nozzleDiameters.length)) {
         const materials = requirements.materials ?? [];
         const positions = requirements.usedFilamentPositions ?? materials.map((_, index) => index);
+        // 255 is the right/main nozzle external spool only on dual-nozzle printers.
+        const dualNozzle = isDualNozzleModel(model);
+        const maxTray = dualNozzle ? 255 : 254;
         if (!positions.length)
             throw new Error("A declared material is required for each used filament or external spool.");
         for (const position of positions) {
             const material = normalizeMaterial(materials[position]);
             if (!Number.isInteger(position) || position < 0 || !material)
                 throw new Error(`A known declared material is required for filament position ${position}.`);
-            const trayIndex = requirements.useAMS ? requirements.amsMapping?.[position] : 254;
-            if (trayIndex === undefined || !Number.isInteger(trayIndex) || trayIndex < 0 || trayIndex > 254)
+            const physicalNozzle = requirements.filamentNozzleIndices?.[position];
+            const externalForNozzle = physicalNozzle === 0 ? 255 : physicalNozzle === 1 ? 254 : undefined;
+            const trayIndex = requirements.useAMS || requirements.amsMapping !== undefined
+                ? requirements.amsMapping?.[position] : dualNozzle ? externalForNozzle : 254;
+            if (!requirements.useAMS && dualNozzle && requirements.amsMapping === undefined && externalForNozzle === undefined) {
+                throw new Error(`External spool for filament position ${position} is ambiguous; re-slice with complete filament_map and physical_extruder_map nozzle bindings or provide a verified sliced plate.`);
+            }
+            if (trayIndex === undefined || !Number.isInteger(trayIndex) || trayIndex < 0 || trayIndex > maxTray)
                 throw new Error(`Complete AMS mapping is required for filament position ${position}.`);
-            const tray = trayIndex === 254 ? externalTray(raw) : mappedTray(raw, trayIndex);
+            if (!requirements.useAMS && trayIndex < 254)
+                throw new Error("External-spool printing requires an external spool mapping; AMS trays require use_ams:true.");
+            if (dualNozzle && trayIndex >= 254) {
+                if (externalForNozzle === undefined)
+                    throw new Error(`External spool ${trayIndex} needs a verified physical nozzle binding for filament position ${position}; re-slice with complete filament_map and physical_extruder_map metadata.`);
+                if (trayIndex !== externalForNozzle)
+                    throw new Error(`External spool ${trayIndex} does not feed physical nozzle ${physicalNozzle} for filament position ${position}; use spool ${externalForNozzle}.`);
+            }
+            const tray = trayIndex >= 254 ? externalTray(raw, trayIndex, model) : mappedTray(raw, trayIndex);
             const reportedType = typeof tray?.tray_type === "string" ? tray.tray_type.trim() : "";
             if (reportedType && normalizeMaterial(reportedType) !== material)
                 throw new Error(`Reported material ${reportedType} in slot ${trayIndex} contradicts declared ${materials[position]}.`);
@@ -404,7 +430,7 @@ export function manualHeatingRequirements(status, model, nozzleDiameter, materia
     const raw = status?.raw;
     if (!object(raw))
         throw new Error("A fresh printer report is required for manual nozzle heating.");
-    if (["h2d", "h2dpro", "h2c", "x2d"].includes(normalized) || reportedNozzles(raw).some(nozzle => nozzle.index !== 0)) {
+    if (isDualNozzleModel(normalized) || reportedNozzles(raw).some(nozzle => nozzle.index !== 0)) {
         throw new Error("Manual heating cannot verify the active nozzle and loaded material on this multi-nozzle printer. Use a checked sliced print instead.");
     }
     const requirements = {

package/dist/slicer/remote-slicer.d.ts

@@ -0,0 +1,12 @@
+import type { BambuSliceOptions } from '../stl/stl-manipulator.js';
+export declare function validateRemoteSliceOptions(options?: BambuSliceOptions): number;
+/** Upload only locally prepared profiles, then inspect the exact downloaded 3MF. */
+export declare function sliceWithOrcaApi(input: {
+    inputPath: string;
+    machinePath: string;
+    processPath: string;
+    filamentPaths: string[];
+    outputPath: string;
+    options?: BambuSliceOptions;
+    isCancelled: () => boolean;
+}): Promise<string>;

package/dist/slicer/remote-slicer.js

@@ -0,0 +1,240 @@
+/** AFKFelix/orca-slicer-api contract at a9a28f0a7b0c6f51b9be158509e9e9677532b868. */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { inspectPrintFile } from '../safety/print-file.js';
+import { normalizeMaterial, normalizeModel } from '../safety/limits.js';
+const MAX_BYTES = 100000000;
+const SUPPORTED_OPTIONS = new Set([
+    'arrange', 'orient', 'loadFilaments', 'filamentColours', 'bedType',
+    'nozzleType', 'nozzleVolumeType', 'slicePlate',
+]);
+function configuration() {
+    let url;
+    try {
+        url = new URL(process.env.SLICER_API_URL ?? '');
+    }
+    catch {
+        throw new Error('Remote slicing requires a valid trusted SLICER_API_URL.');
+    }
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
+        throw new Error('SLICER_API_URL must use HTTP(S) without embedded credentials, query or fragment.');
+    }
+    const mode = process.env.SLICER_API_MODE || 'sync';
+    if (!['sync', 'async'].includes(mode))
+        throw new Error('SLICER_API_MODE must be sync or async.');
+    const timeout = Number(process.env.SLICER_API_TIMEOUT_MS ?? 600000);
+    if (!Number.isInteger(timeout) || timeout < 1 || timeout > 3600000) {
+        throw new Error('SLICER_API_TIMEOUT_MS must be an integer from 1 to 3600000.');
+    }
+    const headers = {};
+    const token = process.env.SLICER_API_TOKEN;
+    if (token) {
+        const header = process.env.SLICER_API_TOKEN_HEADER || 'Authorization';
+        if (!/^[a-zA-Z0-9!#$%&'*+.^_`|~-]+$/.test(header) ||
+            ['host', 'content-type', 'content-length', 'connection', 'transfer-encoding'].includes(header.toLowerCase()) ||
+            /[^\x20-\x7e]/.test(token)) {
+            throw new Error('Invalid remote slicing authentication configuration.');
+        }
+        headers[header] = header.toLowerCase() === 'authorization' ? `Bearer ${token}` : token;
+    }
+    return { base: url.href.replace(/\/+$/, ''), headers, mode, timeout };
+}
+export function validateRemoteSliceOptions(options = {}) {
+    for (const [key, value] of Object.entries(options)) {
+        if (value !== undefined && !SUPPORTED_OPTIONS.has(key)) {
+            throw new Error(`Remote slicing option ${key} is unsupported by orca-slicer-api; use a local backend for this workflow.`);
+        }
+    }
+    // Upstream evaluates multipart values by truthiness, so the string "false"
+    // becomes true. Never silently turn an explicit false into an enabled flag.
+    if (options.arrange === false || options.orient === false) {
+        throw new Error('Remote arrange=false and orient=false are unsupported by the upstream multipart API.');
+    }
+    const plate = options.slicePlate ?? 1;
+    if (!Number.isInteger(plate) || plate < 1)
+        throw new Error('Remote slicing requires one positive plate number; slicing all plates is unsupported.');
+    return plate;
+}
+/** The remote API forwards this display name to Orca's --curr-bed-type. */
+function remoteBedType(value) {
+    const names = {
+        textured_plate: 'Textured PEI Plate', textured_pei_plate: 'Textured PEI Plate',
+        cool_plate: 'Cool Plate', engineering_plate: 'Engineering Plate',
+        hot_plate: 'High Temp Plate', high_temp_plate: 'High Temp Plate',
+    };
+    const key = typeof value === 'string' ? value.trim().toLowerCase().replace(/[\s-]+/g, '_') : '';
+    if (typeof names[key] !== 'string')
+        throw new Error('Unsupported remote bed type; use textured_plate, cool_plate, engineering_plate, or hot_plate.');
+    return names[key];
+}
+async function readResponse(response, limit) {
+    const size = Number(response.headers.get('content-length'));
+    if (size > limit) {
+        await response.body?.cancel();
+        throw new Error('Remote slicing response exceeds the size limit.');
+    }
+    if (!response.body)
+        throw new Error('Remote slicing returned an empty response.');
+    const reader = response.body.getReader();
+    const chunks = [];
+    let length = 0;
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            length += value.byteLength;
+            if (length > limit)
+                throw new Error('Remote slicing response exceeds the size limit.');
+            chunks.push(value);
+        }
+    }
+    finally {
+        await reader.cancel();
+    }
+    return Buffer.concat(chunks);
+}
+async function readJob(response) {
+    try {
+        const job = JSON.parse((await readResponse(response, 65536)).toString('utf8'));
+        if (job && typeof job === 'object' && !Array.isArray(job))
+            return job;
+    }
+    catch { /* Do not echo an untrusted response, which may contain credentials. */ }
+    throw new Error('Remote slicing returned invalid job metadata.');
+}
+/** Upload only locally prepared profiles, then inspect the exact downloaded 3MF. */
+export async function sliceWithOrcaApi(input) {
+    const options = input.options ?? {};
+    const plate = validateRemoteSliceOptions(options);
+    if (input.filamentPaths.length !== 1 || (options.filamentColours && options.filamentColours.length !== 1)) {
+        throw new Error('orca-slicer-api supports exactly one filament slot; multi-slot projects require a local slicer.');
+    }
+    const config = configuration();
+    const machine = JSON.parse(await fs.readFile(input.machinePath, 'utf8'));
+    const filament = JSON.parse(await fs.readFile(input.filamentPaths[0], 'utf8'));
+    const processProfile = JSON.parse(await fs.readFile(input.processPath, 'utf8'));
+    const bedType = remoteBedType(options.bedType ?? processProfile.curr_bed_type ?? 'textured_plate');
+    const model = normalizeModel(machine.printer_model);
+    const nozzles = Array.isArray(machine.nozzle_diameter) ? machine.nozzle_diameter.map(Number) : [];
+    const materialValues = Array.isArray(filament.filament_type) ? filament.filament_type : [];
+    const materials = materialValues.map(normalizeMaterial);
+    if (!model || !nozzles.length || nozzles.some((n) => ![0.2, 0.4, 0.6, 0.8].includes(n)) ||
+        materials.length !== 1 || !materials[0]) {
+        throw new Error('Remote slicing requires explicit model, nozzle and single-material metadata in the prepared profiles.');
+    }
+    const controller = new AbortController();
+    let timedOut = false;
+    const deadline = setTimeout(() => { timedOut = true; controller.abort(); }, config.timeout);
+    const cancelCheck = setInterval(() => { if (input.isCancelled())
+        controller.abort(); }, 100);
+    let requestId;
+    let terminalJob = false;
+    let wroteOutput = false;
+    const request = async (route, init = {}) => {
+        if (input.isCancelled())
+            controller.abort();
+        // Do not pass multipart data to fetch after cancellation: undici may start
+        // its body producer before checking the signal and close it mid-enqueue.
+        controller.signal.throwIfAborted();
+        let response;
+        try {
+            response = await fetch(config.base + route, { ...init, headers: config.headers, signal: controller.signal, redirect: 'manual' });
+        }
+        catch {
+            throw new Error('Remote slicing HTTP request failed; check the trusted service configuration.');
+        }
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new Error(`Remote slicing HTTP ${response.status}.`);
+        }
+        return response;
+    };
+    try {
+        const ext = path.extname(input.inputPath).toLowerCase();
+        if (!['.stl', '.3mf'].includes(ext))
+            throw new Error('Remote slicing supports only STL or 3MF input.');
+        const bytes = await fs.readFile(input.inputPath);
+        if (bytes.length > MAX_BYTES)
+            throw new Error('Remote slicing input exceeds the 100 MB upstream limit.');
+        const form = new FormData();
+        form.set('file', new Blob([new Uint8Array(bytes)], { type: ext === '.3mf' ? 'model/3mf' : 'model/stl' }), `model${ext}`);
+        for (const [field, filePath, type] of [
+            ['printerProfile', input.machinePath, 'machine'],
+            ['presetProfile', input.processPath, 'process'],
+            ['filamentProfile', input.filamentPaths[0], 'filament'],
+        ]) {
+            const profile = JSON.parse(await fs.readFile(filePath, 'utf8'));
+            // The remote validator requires these metadata fields even for standalone
+            // user profiles. They do not change the resolved machine/process settings.
+            const data = { ...profile, type, from: profile.from || 'User' };
+            form.set(field, new Blob([JSON.stringify(data)], { type: 'application/json' }), `${field}.json`);
+        }
+        form.set('exportType', '3mf');
+        form.set('plate', String(plate));
+        form.set('bedType', bedType);
+        form.set('resolveProfileInheritance', 'false');
+        if (options.arrange === true)
+            form.set('arrange', 'true');
+        if (options.orient === true)
+            form.set('orient', 'true');
+        let response = await request(config.mode === 'async' ? '/slice-async' : '/slice', { method: 'POST', body: form });
+        if (config.mode === 'async') {
+            const submitted = await readJob(response);
+            if (typeof submitted.requestId !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(submitted.requestId)) {
+                throw new Error('Remote slicing returned an invalid request ID.');
+            }
+            requestId = submitted.requestId;
+            for (;;) {
+                // Construct the documented same-service paths. Returned URLs cannot
+                // redirect authenticated requests to an arbitrary origin or route.
+                const job = await readJob(await request(`/slice-async/${requestId}`));
+                if (job.status === 'completed' || job.status === 'failed') {
+                    terminalJob = true;
+                    if (job.status === 'failed')
+                        throw new Error('Remote slicing job failed; inspect the service logs.');
+                    break;
+                }
+                if (job.status !== 'pending' && job.status !== 'processing')
+                    throw new Error('Remote slicing returned an unknown job state.');
+                await delay(500, undefined, { signal: controller.signal });
+            }
+            response = await request(`/slice-async/${requestId}/result`);
+        }
+        const result = await readResponse(response, MAX_BYTES);
+        await fs.writeFile(input.outputPath, result, { flag: 'wx', mode: 0o600 });
+        wroteOutput = true;
+        const inspection = await inspectPrintFile(input.outputPath, {
+            model, nozzleDiameters: nozzles, plateIndex: plate - 1, bedType,
+        });
+        if (JSON.stringify(inspection.materials) !== JSON.stringify(materials)) {
+            throw new Error('Remote sliced file materials contradict the prepared filament profile.');
+        }
+        if (input.isCancelled())
+            throw new Error('Remote slicing cancelled.');
+        return input.outputPath;
+    }
+    catch (error) {
+        if (wroteOutput)
+            await fs.rm(input.outputPath, { force: true });
+        if (controller.signal.aborted) {
+            throw new Error(`Remote slicing ${timedOut ? 'timed out' : 'cancelled'}; the remote job may continue. No retry was sent.`);
+        }
+        throw error;
+    }
+    finally {
+        // DELETE only removes finished jobs; upstream has no active-job cancellation.
+        // Cleanup never retries submission or masks a valid result / original error.
+        if (requestId && terminalJob && !controller.signal.aborted) {
+            try {
+                await (await request(`/slice-async/${requestId}`, { method: 'DELETE' })).body?.cancel();
+            }
+            catch {
+                console.error('Remote slicing finished-job cleanup failed; service retention applies.');
+            }
+        }
+        clearTimeout(deadline);
+        clearInterval(cancelCheck);
+    }
+}

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

@@ -22,7 +22,7 @@ export type TransformationParams = {
     relative?: boolean;
     selectionBounds?: THREE.Box3;
 };
-export declare const SLICER_TYPES: readonly ["bambustudio", "orcaslicer", "orcaslicer-bambulab", "prusaslicer", "cura", "slic3r"];
+export declare const SLICER_TYPES: readonly ["bambustudio", "orcaslicer", "orcaslicer-bambulab", "orca-slicer-api", "prusaslicer", "cura", "slic3r"];
 export type SlicerType = typeof SLICER_TYPES[number];
 export declare function normalizeSlicerType(rawSlicerType: string): SlicerType;
 export declare function isBambuCompatibleSlicer(slicerType: SlicerType): boolean;

package/dist/stl/stl-manipulator.js

@@ -11,6 +11,7 @@ import * as crypto from 'crypto';
 import { execFile } from 'child_process';
 import { flattenForCli, detectProfilesRoot, resolveBblMachineProfile } from '../slicer/profile-flatten.js';
 import { profileJsonFiles } from '../slicer/profile-files.js';
+import { sliceWithOrcaApi, validateRemoteSliceOptions } from '../slicer/remote-slicer.js';
 const readFileAsync = promisify(fs.readFile);
 const writeFileAsync = promisify(fs.writeFile);
 const BAMBU_PROFILE_ROOTS = [
@@ -27,6 +28,7 @@ export const SLICER_TYPES = [
     'bambustudio',
     'orcaslicer',
     'orcaslicer-bambulab',
+    'orca-slicer-api',
     'prusaslicer',
     'cura',
     'slic3r',
@@ -48,6 +50,8 @@ const SLICER_TYPE_ALIASES = {
     orcastudio: 'orcaslicer-bambulab',
     'orcaslicer-bmcu': 'orcaslicer-bambulab',
     'orca-bmcu': 'orcaslicer-bambulab',
+    'orca-slicer-api': 'orca-slicer-api',
+    'orcaslicer-api': 'orca-slicer-api',
     prusaslicer: 'prusaslicer',
     'prusa-slicer': 'prusaslicer',
     cura: 'cura',
@@ -65,7 +69,8 @@ export function normalizeSlicerType(rawSlicerType) {
 export function isBambuCompatibleSlicer(slicerType) {
     return (slicerType === 'bambustudio' ||
         slicerType === 'orcaslicer' ||
-        slicerType === 'orcaslicer-bambulab');
+        slicerType === 'orcaslicer-bambulab' ||
+        slicerType === 'orca-slicer-api');
 }
 function isPathLikeExecutable(slicerPath) {
     return (path.isAbsolute(slicerPath) ||
@@ -1225,7 +1230,7 @@ export class STLManipulator extends EventEmitter {
     async sliceSTL(stlFilePath, slicerType, slicerPath, slicerProfile, progressCallback, printerPreset, bambuOptions) {
         const operationId = this.generateOperationId();
         this.activeOperations.set(operationId, true);
-        if (isPathLikeExecutable(slicerPath) && !fs.existsSync(slicerPath)) {
+        if (slicerType !== 'orca-slicer-api' && isPathLikeExecutable(slicerPath) && !fs.existsSync(slicerPath)) {
             throw new Error(`Slicer executable not found at: ${slicerPath}`);
         }
         if (slicerProfile && !fs.existsSync(slicerProfile)) {
@@ -1267,6 +1272,7 @@ export class STLManipulator extends EventEmitter {
                 case 'bambustudio':
                 case 'orcaslicer':
                 case 'orcaslicer-bambulab':
+                case 'orca-slicer-api':
                     // Bambu-compatible CLI: slice and export as 3MF with embedded gcode.
                     // FULU's OrcaSlicer-bambulab fork keeps this Bambu-style path.
                     // For 3MF input: slice in place and export sliced 3MF
@@ -1274,10 +1280,19 @@ export class STLManipulator extends EventEmitter {
                     {
                         const is3mf = stlFilePath.toLowerCase().endsWith('.3mf');
                         const outputBase = path.basename(stlFilePath, is3mf ? '.3mf' : '.stl');
-                        const bambuOutputPath = path.join(this.tempDir, outputBase + '_sliced.3mf');
+                        const remote = slicerType === 'orca-slicer-api';
+                        if (remote) {
+                            validateRemoteSliceOptions(bambuOptions);
+                            if (!process.env.BAMBU_PROFILES_ROOT)
+                                throw new Error('Remote slicing requires BAMBU_PROFILES_ROOT pointing to the matching Orca profile tree (a read-only mount is sufficient).');
+                            if (slicerProfile && !fs.existsSync(slicerProfile))
+                                throw new Error('Remote slicing process profile does not exist.');
+                        }
+                        const profileSlicerType = remote ? 'orcaslicer' : slicerType;
+                        const bambuOutputPath = path.join(this.tempDir, outputBase + (remote ? `_${operationId}` : '') + '_sliced.3mf');
                         const outputDir = path.dirname(bambuOutputPath);
-                        const profilesRoot = detectProfilesRoot(slicerPath, slicerType);
-                        const rawBundle = await this.resolveBambuLikeSettingsBundle(outputBase, slicerType, slicerProfile, printerPreset, bambuOptions, profilesRoot);
+                        const profilesRoot = detectProfilesRoot(remote ? undefined : slicerPath, profileSlicerType);
+                        const rawBundle = await this.resolveBambuLikeSettingsBundle(outputBase, profileSlicerType, slicerProfile, printerPreset, bambuOptions, profilesRoot);
                         // Resolve every BBL dependency before launching the slicer.
                         const settingsBundle = await this.maybeFlattenBundle(await this.expandProjectFilaments(stlFilePath, rawBundle), bambuOptions, profilesRoot);
                         // The machine preset assumes the stock hotend; record the installed one so
@@ -1297,7 +1312,7 @@ export class STLManipulator extends EventEmitter {
                         // absolute-extrusion normalization after resolving those ancestors.
                         // The machine owns the extrusion mode and layer G-code once process
                         // files lose machine keys, so normalize it there as well.
-                        if (slicerType === 'orcaslicer' && settingsBundle.settingsArg) {
+                        if (profileSlicerType === 'orcaslicer' && settingsBundle.settingsArg) {
                             const [machinePath, processPath] = settingsBundle.settingsArg.split(';');
                             settingsBundle.settingsArg = [
                                 this.writeTempJson(outputBase, 'machine_orca_resolved', this.useAbsoluteExtrusionForOrca(this.readJsonFile(machinePath))),
@@ -1305,6 +1320,17 @@ export class STLManipulator extends EventEmitter {
                             ].join(';');
                         }
                         const cliBundle = this.isolateMachineSettings(settingsBundle);
+                        if (remote) {
+                            const [machinePath, processPath] = cliBundle.settingsArg?.split(';') ?? [];
+                            if (!machinePath || !processPath)
+                                throw new Error('Remote slicing requires complete prepared machine and process profiles.');
+                            outputFilePath = await sliceWithOrcaApi({
+                                inputPath: stlFilePath, machinePath, processPath,
+                                filamentPaths: cliBundle.filamentPaths, outputPath: bambuOutputPath,
+                                options: bambuOptions, isCancelled: () => !this.activeOperations.get(operationId),
+                            });
+                            break;
+                        }
                         args = [
                             '--slice', String(bambuOptions?.slicePlate ?? 0),
                             '--outputdir', outputDir,
@@ -1360,45 +1386,47 @@ export class STLManipulator extends EventEmitter {
                 default:
                     throw new Error(`Unsupported slicer type: ${slicerType}`);
             }
-            if (progressCallback)
-                progressCallback(20, `Executing slicer: ${slicerPath} ${args.join(' ')}`);
-            console.error(`Executing: ${slicerPath} ${args.join(' ')}`);
-            // Execute the slicer
-            await new Promise((resolve, reject) => {
-                const process = execFile(slicerPath, args, (error, stdout, stderr) => {
-                    if (error) {
-                        console.error(`Slicer Error: ${error.message}`);
-                        console.error(`Slicer Stderr: ${stderr}`);
-                        reject(new Error(`Slicer failed: ${error.message}. Stderr: ${stderr}`));
-                    }
-                    else {
-                        console.error(`Slicer Stdout: ${stdout}`);
-                        if (stderr) {
-                            console.warn(`Slicer Stderr: ${stderr}`); // Log stderr even on success
+            if (slicerType !== 'orca-slicer-api') {
+                if (progressCallback)
+                    progressCallback(20, `Executing slicer: ${slicerPath} ${args.join(' ')}`);
+                console.error(`Executing: ${slicerPath} ${args.join(' ')}`);
+                // Execute the slicer
+                await new Promise((resolve, reject) => {
+                    const process = execFile(slicerPath, args, (error, stdout, stderr) => {
+                        if (error) {
+                            console.error(`Slicer Error: ${error.message}`);
+                            console.error(`Slicer Stderr: ${stderr}`);
+                            reject(new Error(`Slicer failed: ${error.message}. Stderr: ${stderr}`));
                         }
-                        resolve();
-                    }
-                });
-                // Optional: Add listeners for stdout/stderr for real-time progress if slicer provides it
-                // process.stdout?.on('data', (data) => { console.error(`Slicer stdout: ${data}`); });
-                // process.stderr?.on('data', (data) => { console.error(`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
-                            reject(new Error("Slicing operation cancelled"));
+                        else {
+                            console.error(`Slicer Stdout: ${stdout}`);
+                            if (stderr) {
+                                console.warn(`Slicer Stderr: ${stderr}`); // Log stderr even on success
+                            }
+                            resolve();
                         }
-                        catch (killError) {
-                            console.error("Error attempting to kill slicer process:", killError);
-                            reject(new Error("Slicing operation cancelled, but failed to kill process."));
+                    });
+                    // Optional: Add listeners for stdout/stderr for real-time progress if slicer provides it
+                    // process.stdout?.on('data', (data) => { console.error(`Slicer stdout: ${data}`); });
+                    // process.stderr?.on('data', (data) => { console.error(`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
+                                reject(new Error("Slicing operation cancelled"));
+                            }
+                            catch (killError) {
+                                console.error("Error attempting to kill slicer process:", killError);
+                                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
-            });
+                    }, 500);
+                    process.on('exit', () => clearInterval(checkCancel));
+                    process.on('error', () => clearInterval(checkCancel)); // Ensure interval cleared on process error too
+                });
+            }
             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");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bambu-printer-mcp",
-  "version": "1.1.28",
+  "version": "1.1.29",
   "description": "MCP server for Bambu Lab 3D printers with STL manipulation, slicing, and print management",
   "main": "dist/index.js",
   "repository": {

package/src/ams-mapping.ts

@@ -1,4 +1,15 @@
-export function normalizeBridgeAmsTrayValue(value: unknown, label: string): number {
+/** Tray-value options. `dualNozzle` admits 255, the right/main nozzle external spool that
+ * dual-nozzle printers report beside the left/deputy external spool 254 (Bambu Studio
+ * VIRTUAL_TRAY_MAIN_ID / VIRTUAL_TRAY_DEPUTY_ID). Single-nozzle printers keep 254 only. */
+export interface AmsTrayValueOptions { dualNozzle?: boolean }
+
+export function describeAmsTrayRange(options: AmsTrayValueOptions = {}): string {
+  return options.dualNozzle
+    ? "[-1, 15] (absolute tray), 128-253 (AMS-HT), 254 (left/deputy external) or 255 (right/main external)"
+    : "[-1, 15] (absolute tray) or 128-254 (HT/external)";
+}
+
+export function normalizeBridgeAmsTrayValue(value: unknown, label: string, options: AmsTrayValueOptions = {}): number {
   let numeric: number;
   if (typeof value === "number") {
     numeric = value;
@@ -12,10 +23,10 @@ export function normalizeBridgeAmsTrayValue(value: unknown, label: string): numb
     !Number.isInteger(numeric) ||
     numeric < -1 ||
     (numeric > 15 && numeric < 128) ||
-    numeric > 254
+    numeric > (options.dualNozzle ? 255 : 254)
   ) {
     throw new Error(
-      `${label} must be an integer in [-1, 15] (absolute tray) or 128-254 (HT/external); got ${JSON.stringify(value)}`
+      `${label} must be an integer in ${describeAmsTrayRange(options)}; got ${JSON.stringify(value)}`
     );
   }
 
@@ -27,7 +38,7 @@ function isNumericMappingKey(key: string): boolean {
   return Number.isInteger(numeric) && numeric >= 0;
 }
 
-export function normalizeAmsMappingObject(mapping: Record<string, unknown>, label = "ams_mapping"): number[] {
+export function normalizeAmsMappingObject(mapping: Record<string, unknown>, label = "ams_mapping", options: AmsTrayValueOptions = {}): number[] {
   return Object.entries(mapping)
     .sort(([leftKey], [rightKey]) => {
       const leftNumeric = isNumericMappingKey(leftKey);
@@ -37,7 +48,7 @@ export function normalizeAmsMappingObject(mapping: Record<string, unknown>, labe
       if (rightNumeric) return 1;
       return 0;
     })
-    .map(([key, value]) => normalizeBridgeAmsTrayValue(value, `${label}[${key}]`));
+    .map(([key, value]) => normalizeBridgeAmsTrayValue(value, `${label}[${key}]`, options));
 }
 
 export function hasAmsMappingInput(value: unknown): boolean {
@@ -45,3 +56,25 @@ export function hasAmsMappingInput(value: unknown): boolean {
   if (value && typeof value === "object") return Object.keys(value as Record<string, unknown>).length > 0;
   return value !== undefined && value !== null;
 }
+
+/** Flat wire entries use -1 for dual-nozzle virtual trays; ams_mapping2 identifies their spool. */
+export function bridgeAmsMappingValue(value: number, dualNozzle = false): number {
+  return dualNozzle && (value === 254 || value === 255) ? -1 : value;
+}
+
+/** Select an external spool only from a verified physical nozzle on dual-nozzle printers. */
+export function externalTrayForNozzle(nozzle: number | undefined, dualNozzle = false): number {
+  if (!dualNozzle) return 254;
+  if (nozzle === 0) return 255;
+  if (nozzle === 1) return 254;
+  throw new Error("External-spool printing requires inspected filament_map and physical_extruder_map nozzle bindings.");
+}
+
+/** Virtual trays use slot zero on dual-nozzle printers; retain the historical single-nozzle form. */
+export function bridgeAmsMapping2Entry(value: number, dualNozzle = false): { ams_id: number; slot_id: number } {
+  if (value < 0) return { ams_id: 255, slot_id: 255 };
+  if (value === 255) return dualNozzle ? { ams_id: 255, slot_id: 0 } : { ams_id: 255, slot_id: 255 };
+  if (value === 254) return { ams_id: 254, slot_id: dualNozzle ? 0 : 254 };
+  if (value >= 128) return { ams_id: 128, slot_id: value - 128 };
+  return { ams_id: Math.floor(value / 4), slot_id: value % 4 };
+}