mcp-3d-printer-server 1.2.20 → 1.2.22

package/dist/printers/repetier.d.ts

@@ -1,4 +1,5 @@
-import { GenericPrinterImplementation, type GenericPrinterState } from "./generic-base.js";
+import { GenericPrinterImplementation, type GenericPrinterState, type SnapshotCandidate } from "./generic-base.js";
+import type { CounterpartProgress, PrinterIdentity } from "../counterpart/contract.js";
 /**
  * Note: Repetier-Server documents printer commands at /printer/api/<slug>;
  * this adapter's slug-less routes are unverified. Remote starts are refused
@@ -7,6 +8,21 @@ import { GenericPrinterImplementation, type GenericPrinterState } from "./generi
 export declare class RepetierImplementation extends GenericPrinterImplementation {
     protected readonly printerLabel = "Repetier";
     protected readonly uploadStartsPrint = true;
+    /**
+     * The printer the counterpart tools address: REPETIER_SLUG when set,
+     * otherwise the only printer listPrinter reports.
+     * REST form: /printer/api/<slug>?a=<command>&data=<json>&apikey=<key>
+     * (https://www.repetier-server.com/manuals/programming/API/index.html).
+     */
+    private selectPrinter;
+    private printerUrl;
+    counterpartProgress(host: string, port: string, apiKey: string): Promise<CounterpartProgress>;
+    counterpartIdentity(host: string, port: string, apiKey: string): Promise<PrinterIdentity>;
+    /** getPrinterConfig webcams[].staticUrl (older servers: a single webcam object). */
+    snapshotCandidates(host: string, port: string, apiKey: string): Promise<SnapshotCandidate[]>;
+    /** Pause sends the @pause host command; resume is the documented continueJob. */
+    protected rawPauseJob(host: string, port: string, apiKey: string): Promise<any>;
+    protected rawResumeJob(host: string, port: string, apiKey: string): Promise<any>;
     getStatus(host: string, port: string, apiKey: string): Promise<any>;
     getFiles(host: string, port: string, apiKey: string): Promise<any>;
     getFile(host: string, port: string, apiKey: string, filename: string): Promise<any>;

package/dist/printers/repetier.js

@@ -1,6 +1,8 @@
 import fs from "fs";
 import FormData from "form-data";
 import { GenericPrinterImplementation } from "./generic-base.js";
+import { nonEmptyText } from "../counterpart/contract.js";
+import { mapRepetier } from "../counterpart/progress.js";
 /**
  * Note: Repetier-Server documents printer commands at /printer/api/<slug>;
  * this adapter's slug-less routes are unverified. Remote starts are refused
@@ -13,6 +15,59 @@ export class RepetierImplementation extends GenericPrinterImplementation {
         // The upload form's print=1 flag uploads and starts the same bytes.
         this.uploadStartsPrint = true;
     }
+    /**
+     * The printer the counterpart tools address: REPETIER_SLUG when set,
+     * otherwise the only printer listPrinter reports.
+     * REST form: /printer/api/<slug>?a=<command>&data=<json>&apikey=<key>
+     * (https://www.repetier-server.com/manuals/programming/API/index.html).
+     */
+    async selectPrinter(host, port, apiKey) {
+        const wanted = process.env.REPETIER_SLUG?.trim();
+        const route = wanted ? encodeURIComponent(wanted) : "";
+        const data = (await this.apiClient.get(`http://${host}:${port}/printer/api/${route}?a=listPrinter&apikey=${encodeURIComponent(apiKey)}`)).data;
+        const printers = Array.isArray(data) ? data : Array.isArray(data?.data) ? data.data : [];
+        if (wanted) {
+            const entry = printers.find((printer) => printer?.slug === wanted);
+            if (!entry)
+                throw new Error(`Repetier lists no printer with slug "${wanted}" (REPETIER_SLUG).`);
+            return { slug: wanted, entry };
+        }
+        if (printers.length !== 1 || typeof printers[0]?.slug !== "string") {
+            throw new Error(`Repetier reports ${printers.length} printers; set REPETIER_SLUG to the printer's slug.`);
+        }
+        return { slug: printers[0].slug, entry: printers[0] };
+    }
+    printerUrl(host, port, apiKey, slug, action, data) {
+        const query = `a=${action}${data === undefined ? "" : `&data=${encodeURIComponent(JSON.stringify(data))}`}&apikey=${encodeURIComponent(apiKey)}`;
+        return `http://${host}:${port}/printer/api/${encodeURIComponent(slug)}?${query}`;
+    }
+    async counterpartProgress(host, port, apiKey) {
+        const { entry } = await this.selectPrinter(host, port, apiKey);
+        return mapRepetier(entry, new Date().toISOString());
+    }
+    async counterpartIdentity(host, port, apiKey) {
+        const { entry, slug } = await this.selectPrinter(host, port, apiKey);
+        return { name: nonEmptyText(entry?.name) ?? slug };
+    }
+    /** getPrinterConfig webcams[].staticUrl (older servers: a single webcam object). */
+    async snapshotCandidates(host, port, apiKey) {
+        const { slug } = await this.selectPrinter(host, port, apiKey);
+        const config = (await this.apiClient.get(this.printerUrl(host, port, apiKey, slug, "getPrinterConfig"))).data;
+        const webcams = Array.isArray(config?.webcams) ? config.webcams : config?.webcam ? [config.webcam] : [];
+        return webcams
+            .map((webcam) => nonEmptyText(webcam?.staticUrl))
+            .filter((url) => url !== undefined)
+            .map((url) => ({ url, source: "repetier-webcam", configured: true }));
+    }
+    /** Pause sends the @pause host command; resume is the documented continueJob. */
+    async rawPauseJob(host, port, apiKey) {
+        const { slug } = await this.selectPrinter(host, port, apiKey);
+        return (await this.apiClient.get(this.printerUrl(host, port, apiKey, slug, "send", { cmd: "@pause" }))).data;
+    }
+    async rawResumeJob(host, port, apiKey) {
+        const { slug } = await this.selectPrinter(host, port, apiKey);
+        return (await this.apiClient.get(this.printerUrl(host, port, apiKey, slug, "continueJob"))).data;
+    }
     async getStatus(host, port, apiKey) {
         const url = `http://${host}:${port}/printer/api/?a=getPrinterInfo&apikey=${apiKey}`;
         const response = await this.apiClient.get(url);

package/dist/slicer/bambu-cli.d.ts

@@ -35,6 +35,8 @@ export interface BambuSliceOptions {
     minSave?: boolean;
     skipModifiedGcodes?: boolean;
     slicePlate?: number;
+    /** Process keys written over the resolved process preset (layer_height, wall_loops, sparse_infill_density). */
+    processOverrides?: Record<string, string>;
 }
 export interface BambuSettingsBundle {
     settingsArg?: string;

package/dist/slicer/bambu-cli.js

@@ -431,6 +431,17 @@ export class BambuCliProfilePreparer {
                 this.writeTempJson(outputBase, "process_orca_resolved", this.sanitizeProcessForOrca(this.readJsonFile(processPath), printerPreset)),
             ].join(";");
         }
+        // Print-sheet quality/strength choices win over the preset and any template.
+        if (options.processOverrides && Object.keys(options.processOverrides).length && bundle.settingsArg) {
+            const [machinePath, processPath, ...rest] = bundle.settingsArg.split(";");
+            if (processPath) {
+                bundle.settingsArg = [
+                    machinePath,
+                    this.writeTempJson(outputBase, "process_overrides", { ...this.readJsonFile(processPath), ...options.processOverrides }),
+                    ...rest,
+                ].join(";");
+            }
+        }
         return this.isolateMachineSettings(bundle);
     }
     /**

package/dist/slicer/filament-profiles.d.ts

@@ -0,0 +1,25 @@
+export interface FilamentProfileContext {
+    /** The canonical slicer type slice_stl uses without a slicer_type argument. */
+    slicerType: string;
+    slicerPath?: string;
+    /** SLICER_PROFILE: Orca "machine.json;process.json[|filament.json]", or PrusaSlicer's exported config. */
+    slicerProfile?: string;
+    /** What slice_stl loads when no filament is passed, in slot order. */
+    configuredFilaments?: string[];
+    /** Tests replace the searched directories. */
+    roots?: {
+        system: string[];
+        user: string[];
+    };
+}
+export declare function resolveFilamentProfile(material: string | undefined, context: FilamentProfileContext): Promise<string | undefined>;
+/**
+ * A generic OrcaSlicer filament preset with its `inherits` chain merged in,
+ * parent first, for --load-filaments: the CLI does not resolve inheritance,
+ * so a bundled preset such as "Generic PETG @System" would otherwise slice
+ * without its own temperatures. Undefined when the file inherits nothing, or
+ * when a parent is not installed (the file is then passed as it is).
+ */
+export declare function flattenOrcaFilament(file: string, context: Pick<FilamentProfileContext, "slicerPath" | "roots">): Promise<Record<string, unknown> | undefined>;
+/** Tests only: forget cached profile indexes. */
+export declare function clearFilamentProfileCache(): void;

package/dist/slicer/filament-profiles.js

@@ -0,0 +1,249 @@
+/**
+ * The installed slicer filament profile for a material, as a path slice_stl's
+ * load_filaments accepts (get_printer_filaments slots[].profile).
+ *
+ * The existing resolvers do not fit: bambu-printer-mcp's inventory resolver
+ * and bambu-cli.ts look up Bambu (BBL) profiles by an AMS tray_info_idx, which
+ * other printers do not report. Here the key is the spool's material, matched
+ * exactly against each profile's filament_type, in the slicer slice_stl uses
+ * by default:
+ * - OrcaSlicer: the app's bundled profiles/<Vendor>/filament, the copies under
+ *   OrcaSlicer/system, and the user's OrcaSlicer/user/<id>/filament presets.
+ *   filament_type and compatible_printers are read through `inherits`.
+ * - PrusaSlicer and Slic3r: the data directory's filament/*.ini presets.
+ *   Vendor bundle INIs hold many presets in one file and cannot be --load-ed.
+ * Profiles whose compatible_printers names other printers are excluded; ones
+ * that name the configured printer (SLICER_PROFILE's machine) come first,
+ * then universal ones. Any failure resolves to undefined: a missing profile
+ * never fails get_printer_filaments.
+ */
+import { existsSync, promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { detectProfilesRoot } from "./profile-flatten.js";
+import { parseLooseSlicerConfig } from "./templates.js";
+const ORCA = new Set(["orcaslicer"]);
+const PRUSA = new Set(["prusaslicer", "slic3r"]);
+const MAX_FILES = 20000;
+const MAX_BYTES = 2 * 1024 * 1024;
+const MAX_DEPTH = 5;
+const INDEX_TTL_MS = 60000;
+const indexes = new Map();
+/** Per-user application data directories, in the order the slicers use them. */
+function appDataDirs() {
+    const home = os.homedir();
+    return [
+        path.join(home, "Library", "Application Support"),
+        path.join(home, ".config"),
+        ...(process.env.APPDATA ? [process.env.APPDATA] : []),
+    ];
+}
+function defaultRoots(context) {
+    if (ORCA.has(context.slicerType)) {
+        const system = [detectProfilesRoot(context.slicerPath, "orcaslicer"), ...appDataDirs().map((dir) => path.join(dir, "OrcaSlicer", "system"))];
+        const user = appDataDirs().map((dir) => path.join(dir, "OrcaSlicer", "user"));
+        return { system, user };
+    }
+    const home = os.homedir();
+    const name = context.slicerType === "slic3r" ? "Slic3r" : "PrusaSlicer";
+    const user = [
+        ...appDataDirs().map((dir) => path.join(dir, name)),
+        ...(name === "PrusaSlicer" ? [path.join(home, ".PrusaSlicer"), path.join(home, ".var", "app", "com.prusa3d.PrusaSlicer", "config", "PrusaSlicer")] : [path.join(home, ".Slic3r")]),
+    ];
+    return { system: [], user };
+}
+async function listFiles(dir, extension, depth, budget) {
+    if (depth > MAX_DEPTH || budget.left <= 0)
+        return [];
+    const items = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+    const files = [];
+    for (const item of items.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (budget.left <= 0)
+            break;
+        const full = path.join(dir, item.name);
+        if (item.isDirectory())
+            files.push(...await listFiles(full, extension, depth + 1, budget));
+        else if (item.isFile() && item.name.toLowerCase().endsWith(extension)) {
+            files.push(full);
+            budget.left -= 1;
+        }
+    }
+    return files;
+}
+async function readConfig(file) {
+    try {
+        const stat = await fs.stat(file);
+        if (!stat.isFile() || stat.size > MAX_BYTES)
+            return undefined;
+        const parsed = parseLooseSlicerConfig(await fs.readFile(file, "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function buildIndex(context, roots) {
+    const budget = { left: MAX_FILES };
+    const files = [];
+    if (ORCA.has(context.slicerType)) {
+        // <root>/<Vendor>/filament/** for system trees; <user>/<id>/filament/** for presets.
+        for (const [list, user] of [[roots.system, false], [roots.user, true]]) {
+            for (const root of list) {
+                const groups = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+                for (const group of groups.filter((item) => item.isDirectory()).sort((a, b) => a.name.localeCompare(b.name))) {
+                    for (const file of await listFiles(path.join(root, group.name, "filament"), ".json", 0, budget))
+                        files.push({ file, user });
+                }
+            }
+        }
+    }
+    else {
+        for (const root of roots.user) {
+            for (const file of await listFiles(path.join(root, "filament"), ".ini", MAX_DEPTH, budget))
+                files.push({ file, user: true });
+        }
+    }
+    const entries = [];
+    const byName = new Map();
+    for (const { file, user } of files) {
+        const config = await readConfig(file);
+        if (!config)
+            continue;
+        const name = typeof config.name === "string" && config.name.trim() ? config.name.trim() : path.basename(file, path.extname(file));
+        const entry = { file, name, config, user };
+        entries.push(entry);
+        // System names first: `inherits` points at system presets.
+        if (!byName.has(name))
+            byName.set(name, entry);
+    }
+    return { entries, byName };
+}
+function profileIndex(context) {
+    const roots = context.roots ?? defaultRoots(context);
+    const key = JSON.stringify([context.slicerType, roots]);
+    const cached = indexes.get(key);
+    if (cached && Date.now() - cached.at < INDEX_TTL_MS)
+        return cached.index;
+    const index = buildIndex(context, roots);
+    indexes.set(key, { at: Date.now(), index });
+    // A failed build is not cached.
+    index.catch(() => indexes.delete(key));
+    return index;
+}
+/** A key's value on the profile or the nearest preset it inherits from. */
+function inherited(index, entry, key) {
+    const seen = new Set();
+    let current = entry;
+    for (let depth = 0; current && depth < 12 && !seen.has(current); depth += 1) {
+        seen.add(current);
+        if (current.config[key] !== undefined)
+            return current.config[key];
+        const parent = current.config.inherits;
+        current = typeof parent === "string" && parent.trim() ? index.byName.get(parent.trim()) : undefined;
+    }
+    return undefined;
+}
+function textValues(value) {
+    if (Array.isArray(value))
+        return value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+    if (typeof value !== "string" || !value.trim())
+        return [];
+    // PrusaSlicer lists are "a";"b"; Orca's are JSON arrays.
+    const quoted = [...value.matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((match) => match[1].trim()).filter(Boolean);
+    return quoted.length ? quoted : value.split(";").map((item) => item.trim()).filter(Boolean);
+}
+/** The configured printer's preset names, from SLICER_PROFILE. */
+async function printerNames(context) {
+    const names = new Set();
+    const settings = (context.slicerProfile ?? "").split("|", 1)[0].split(";").map((item) => item.trim()).filter(Boolean);
+    for (const file of settings) {
+        const config = await readConfig(file);
+        if (!config)
+            continue;
+        const isMachine = config.type === "machine" || config.printer_settings_id !== undefined || config.printer_model !== undefined;
+        if (!isMachine)
+            continue;
+        for (const key of ["name", "inherits", "printer_settings_id"]) {
+            for (const value of textValues(config[key]))
+                names.add(value);
+        }
+    }
+    return names;
+}
+export async function resolveFilamentProfile(material, context) {
+    try {
+        const wanted = material?.trim().toUpperCase();
+        if (!wanted) {
+            // No reported material: the profile slice_stl loads by default, when it exists.
+            const configured = context.configuredFilaments?.map((item) => item.trim()).find(Boolean);
+            return configured && existsSync(configured) ? path.resolve(configured) : undefined;
+        }
+        if (!ORCA.has(context.slicerType) && !PRUSA.has(context.slicerType))
+            return undefined;
+        const [index, printers] = await Promise.all([profileIndex(context), printerNames(context)]);
+        const candidates = [];
+        for (const entry of index.entries) {
+            if (String(entry.config.instantiation ?? "true").toLowerCase() === "false" || /@base$/i.test(entry.name))
+                continue;
+            if (!textValues(inherited(index, entry, "filament_type")).some((type) => type.toUpperCase() === wanted))
+                continue;
+            const compatible = textValues(inherited(index, entry, "compatible_printers"));
+            const condition = inherited(index, entry, "compatible_printers_condition");
+            let rank;
+            if (compatible.length) {
+                if (!compatible.some((name) => printers.has(name)))
+                    continue;
+                rank = 0;
+            }
+            else {
+                // A condition this server cannot evaluate ranks below a profile for every printer.
+                rank = typeof condition === "string" && condition.trim() ? 2 : 1;
+            }
+            candidates.push({ entry, rank });
+        }
+        candidates.sort((a, b) => a.rank - b.rank || Number(b.entry.user) - Number(a.entry.user) || a.entry.file.localeCompare(b.entry.file));
+        const best = candidates[0]?.entry.file;
+        return best ? path.resolve(best) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * A generic OrcaSlicer filament preset with its `inherits` chain merged in,
+ * parent first, for --load-filaments: the CLI does not resolve inheritance,
+ * so a bundled preset such as "Generic PETG @System" would otherwise slice
+ * without its own temperatures. Undefined when the file inherits nothing, or
+ * when a parent is not installed (the file is then passed as it is).
+ */
+export async function flattenOrcaFilament(file, context) {
+    const leaf = await readConfig(file);
+    const parentName = leaf?.inherits;
+    if (!leaf || typeof parentName !== "string" || !parentName.trim())
+        return undefined;
+    const index = await profileIndex({ slicerType: "orcaslicer", ...context });
+    const chain = [leaf];
+    const seen = new Set();
+    for (let name = parentName.trim(); name;) {
+        const parent = index.byName.get(name);
+        if (!parent || seen.has(name) || chain.length > 12)
+            return undefined;
+        seen.add(name);
+        chain.push(parent.config);
+        name = typeof parent.config.inherits === "string" ? parent.config.inherits.trim() : "";
+    }
+    const merged = Object.assign({}, ...chain.reverse());
+    const name = typeof leaf.name === "string" && leaf.name.trim() ? leaf.name.trim() : path.basename(file, path.extname(file));
+    // As the Bambu CLI flattener does: a user-owned, self-contained preset.
+    merged.name = name;
+    merged.inherits = "";
+    merged.from = "User";
+    merged.filament_settings_id = [name];
+    delete merged.instantiation;
+    delete merged.setting_id;
+    return merged;
+}
+/** Tests only: forget cached profile indexes. */
+export function clearFilamentProfileCache() {
+    indexes.clear();
+}

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

@@ -2,6 +2,19 @@ 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';
+/** Print-sheet slicing overrides (PRD §8.4), applied on top of the selected profile. */
+export interface ProcessOverrides {
+    /** mm */
+    layerHeight?: number;
+    /** wall (perimeter) count */
+    wallLoops?: number;
+    /** e.g. "15%" */
+    sparseInfillDensity?: string;
+}
+/** Orca/Bambu Studio process keys; profile JSON values are strings. */
+export declare function orcaProcessOverrides(overrides: ProcessOverrides | undefined): Record<string, string>;
+/** PrusaSlicer/Slic3r command-line options, which override the loaded config. */
+export declare function prusaSlicerOverrideArgs(overrides: ProcessOverrides | undefined): string[];
 export type ProgressCallback = (progress: number, message?: string) => void;
 export type OperationResult = {
     success: boolean;
@@ -43,6 +56,13 @@ export declare class STLManipulator extends EventEmitter {
     private splitProfileList;
     private parseOrcaProfileArgs;
     private warnForMissingProfiles;
+    /**
+     * Generic OrcaSlicer: write the overrides over a copy of the process profile
+     * (the settings file whose type is "process", else the last of two or more).
+     */
+    private withOrcaProcessOverrides;
+    /** Bundled and user Orca filament presets inherit their settings; the CLI needs them merged in. */
+    private withFlattenedOrcaFilaments;
     private appendOrcaProfileArgs;
     private resolveOrcaGcodeOutput;
     private resolveSlicerTimeoutMs;
@@ -133,7 +153,7 @@ export declare class STLManipulator extends EventEmitter {
      * @param bambuOptions Optional Bambu-compatible CLI options (added last for compatibility)
      * @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): Promise<string>;
+    sliceSTL(stlFilePath: string, slicerType: SlicerType, slicerPath: string, slicerProfile?: string, progressCallback?: ProgressCallback, printerPreset?: string, filamentProfile?: string, bambuOptions?: BambuSliceOptions, processOverrides?: ProcessOverrides): Promise<string>;
     /**
      * Enhanced version of confirmTemperatures with better error handling
      * @param gcodePath Path to the G-code file

package/dist/stl/stl-manipulator.js

@@ -8,9 +8,32 @@ import { promisify } from 'util';
 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 { runSlicerProcess } from '../slicer/run-slicer.js';
 import { SlicerError, asPreparationError } from '../slicer/slicer-error.js';
+/** Orca/Bambu Studio process keys; profile JSON values are strings. */
+export function orcaProcessOverrides(overrides) {
+    const keys = {};
+    if (overrides?.layerHeight !== undefined)
+        keys.layer_height = String(overrides.layerHeight);
+    if (overrides?.wallLoops !== undefined)
+        keys.wall_loops = String(overrides.wallLoops);
+    if (overrides?.sparseInfillDensity !== undefined)
+        keys.sparse_infill_density = overrides.sparseInfillDensity;
+    return keys;
+}
+/** PrusaSlicer/Slic3r command-line options, which override the loaded config. */
+export function prusaSlicerOverrideArgs(overrides) {
+    const args = [];
+    if (overrides?.layerHeight !== undefined)
+        args.push('--layer-height', String(overrides.layerHeight));
+    if (overrides?.wallLoops !== undefined)
+        args.push('--perimeters', String(overrides.wallLoops));
+    if (overrides?.sparseInfillDensity !== undefined)
+        args.push('--fill-density', overrides.sparseInfillDensity);
+    return args;
+}
 import { scanGcodeThermal } from '../safety/gcode-thermal.js';
 const readFileAsync = promisify(fs.readFile);
 const writeFileAsync = promisify(fs.writeFile);
@@ -73,6 +96,47 @@ export class STLManipulator extends EventEmitter {
             }
         }
     }
+    /**
+     * Generic OrcaSlicer: write the overrides over a copy of the process profile
+     * (the settings file whose type is "process", else the last of two or more).
+     */
+    withOrcaProcessOverrides(profiles, overrides, outputDir) {
+        const keys = orcaProcessOverrides(overrides);
+        if (!Object.keys(keys).length)
+            return profiles;
+        const parsed = profiles.settingsProfiles.map((profile) => {
+            try {
+                return JSON.parse(fs.readFileSync(profile, 'utf8'));
+            }
+            catch {
+                return undefined;
+            }
+        });
+        let index = parsed.findIndex((profile) => profile?.type === 'process');
+        if (index < 0 && profiles.settingsProfiles.length >= 2)
+            index = profiles.settingsProfiles.length - 1;
+        if (index < 0 || !parsed[index] || typeof parsed[index] !== 'object') {
+            throw new SlicerError('preparation', 'layer_height, wall_loops and sparse_infill_density need a readable process profile for generic OrcaSlicer. ' +
+                "Pass slicer_profile as 'machine.json;process.json', or slice with bambu_model.", { slicerType: 'orcaslicer' });
+        }
+        const merged = path.join(outputDir, `process-overrides-${path.basename(profiles.settingsProfiles[index])}`);
+        fs.writeFileSync(merged, JSON.stringify({ ...parsed[index], ...keys }, null, 2));
+        const settingsProfiles = [...profiles.settingsProfiles];
+        settingsProfiles[index] = merged;
+        return { ...profiles, settingsProfiles };
+    }
+    /** Bundled and user Orca filament presets inherit their settings; the CLI needs them merged in. */
+    async withFlattenedOrcaFilaments(profiles, slicerPath, outputDir) {
+        const filamentProfiles = await Promise.all(profiles.filamentProfiles.map(async (profile, index) => {
+            const flat = await flattenOrcaFilament(profile, { slicerPath }).catch(() => undefined);
+            if (!flat)
+                return profile;
+            const merged = path.join(outputDir, `filament-${index + 1}-${path.basename(profile)}`);
+            fs.writeFileSync(merged, JSON.stringify(flat, null, 2));
+            return merged;
+        }));
+        return { ...profiles, filamentProfiles };
+    }
     appendOrcaProfileArgs(args, profiles) {
         for (const profile of profiles.settingsProfiles) {
             args.push('--load-settings', profile);
@@ -775,7 +839,7 @@ export class STLManipulator extends EventEmitter {
      * @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, bambuOptions) {
+    async sliceSTL(stlFilePath, slicerType, slicerPath, slicerProfile, progressCallback, printerPreset, filamentProfile, bambuOptions, processOverrides) {
         const operationId = this.generateOperationId();
         this.activeOperations.set(operationId, true);
         const bambuCli = STLManipulator.usesBambuCliPreparation(slicerType, printerPreset);
@@ -823,6 +887,9 @@ export class STLManipulator extends EventEmitter {
                             'to keep the machine;process|filament format.');
                     }
                     const options = { ...bambuOptions };
+                    const overrideKeys = orcaProcessOverrides(processOverrides);
+                    if (Object.keys(overrideKeys).length)
+                        options.processOverrides = overrideKeys;
                     if (orcaProfiles.filamentProfiles.length > 0) {
                         const legacyFilaments = orcaProfiles.filamentProfiles.join(';');
                         if (options.loadFilaments && this.splitProfileList(options.loadFilaments).join(';') !== legacyFilaments) {
@@ -853,16 +920,26 @@ export class STLManipulator extends EventEmitter {
             else {
                 switch (slicerType) {
                     case 'prusaslicer':
-                    case 'slic3r': // PrusaSlicer and Slic3r share similar CLI args
+                    case 'slic3r': { // PrusaSlicer and Slic3r share similar CLI args
+                        // A filament preset (.ini from the slicer's filament folder) is loaded after the main
+                        // config: --load may repeat, and later files override earlier ones.
+                        const filaments = this.splitProfileList(filamentProfile);
+                        if (filaments.length > 1) {
+                            throw new SlicerError('preparation', `${slicerType} takes one filament preset; filament_profile/FILAMENT_PROFILE lists ${filaments.length}.`, { slicerType, slicerPath });
+                        }
+                        if (filaments.length && !/\.ini$/i.test(filaments[0])) {
+                            throw new SlicerError('preparation', `${slicerType} loads filament presets as .ini files (its filament folder, or File > Export > Export Config); ${path.basename(filaments[0])} is not one.`, { slicerType, slicerPath });
+                        }
                         args = [
                             '--slice',
                             '--output', outputFilePath,
-                            '--load', slicerProfile || '', // Pass profile path
+                            ...(slicerProfile ? ['--load', slicerProfile] : []),
+                            ...filaments.flatMap((filament) => ['--load', filament]),
+                            ...prusaSlicerOverrideArgs(processOverrides),
                             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 });
@@ -870,10 +947,13 @@ export class STLManipulator extends EventEmitter {
                             '--slice', '0',
                             '--outputdir', orcaOutputDir,
                         ];
-                        this.appendOrcaProfileArgs(args, orcaProfiles);
+                        this.appendOrcaProfileArgs(args, await this.withFlattenedOrcaFilaments(this.withOrcaProcessOverrides(orcaProfiles, processOverrides, orcaOutputDir), slicerPath, orcaOutputDir));
                         args.push(stlFilePath);
                         break;
                     case 'cura':
+                        if (Object.keys(orcaProcessOverrides(processOverrides)).length) {
+                            throw new SlicerError('preparation', 'layer_height, wall_loops and sparse_infill_density are not mapped for Cura; set them in the Cura definition passed as slicer_profile.', { slicerType, slicerPath });
+                        }
                         // 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 = [

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "mcp-3d-printer-server",
     "mcpName": "io.github.DMontgomery40/mcp-3d-printer-server",
-    "version": "1.2.20",
+    "version": "1.2.22",
     "description": "MCP server for connecting Claude with 3D printer management systems",
     "main": "dist/index.js",
     "repository": "https://github.com/DMontgomery40/mcp-3D-printer-server",
@@ -65,7 +65,12 @@
         "src/blender-mcp-bridge.ts",
         "CHANGELOG.md",
         "CONTRIBUTORS.md",
-        "server.json"
+        "server.json",
+        "dist/counterpart",
+        "src/counterpart",
+        "dist/fusion-mcp-bridge.js",
+        "dist/fusion-mcp-bridge.d.ts",
+        "src/fusion-mcp-bridge.ts"
     ],
     "keywords": [
         "mcp",

package/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/DMontgomery40/mcp-3D-printer-server",
     "source": "github"
   },
-  "version": "1.2.20",
+  "version": "1.2.22",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "mcp-3d-printer-server",
-      "version": "1.2.20",
+      "version": "1.2.22",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"

package/src/blender-mcp-bridge.ts

@@ -26,7 +26,7 @@ type StlMetadata = { bytes: number; triangles: number; bounding_box: BoundingBox
 
 class BlenderError extends Error {}
 
-function editDeadline(timeout: number, signal?: AbortSignal): EditDeadline {
+export function editDeadline(timeout: number, signal?: AbortSignal): EditDeadline {
   const deadline = performance.now() + timeout;
   const check = () => {
     if (signal?.aborted) throw new BlenderError("Blender edit cancelled. If execution started, inspect Blender before retrying.");
@@ -35,7 +35,7 @@ function editDeadline(timeout: number, signal?: AbortSignal): EditDeadline {
   return { check, remaining: () => { check(); return Math.max(1, Math.ceil(deadline - performance.now())); } };
 }
 
-class ClosingStdioTransport extends StdioClientTransport {
+export class ClosingStdioTransport extends StdioClientTransport {
   private closing?: Promise<void>;
 
   override close(): Promise<void> {
@@ -120,7 +120,7 @@ function boundingBox(min: number[], max: number[]): BoundingBox {
   };
 }
 
-async function regularStl(filePath: string, deadline: EditDeadline): Promise<StlMetadata> {
+export async function regularStl(filePath: string, deadline: EditDeadline): Promise<StlMetadata> {
   deadline.check();
   const stat = await fs.lstat(filePath).catch(() => { throw new BlenderError("STL file does not exist or is not readable."); });
   deadline.check();