mcp-3d-printer-server 1.2.9 → 1.2.12

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

@@ -0,0 +1,18 @@
+export interface SlicerRunOptions {
+    command: string;
+    args: string[];
+    timeoutMs: number;
+    slicerType: string;
+    /** Polled while the slicer runs; returning true kills it. */
+    isCancelled?: () => boolean;
+}
+export interface SlicerRunResult {
+    stdoutTail: string;
+    stderrTail: string;
+}
+/**
+ * Run a slicer executable with a timeout and cancellation, keeping bounded
+ * stdout/stderr tails. A nonzero exit, signal, spawn failure, timeout, or
+ * cancellation rejects with a SlicerError that includes the evidence.
+ */
+export declare function runSlicerProcess(options: SlicerRunOptions): Promise<SlicerRunResult>;

package/dist/slicer/run-slicer.js

@@ -0,0 +1,102 @@
+import { spawn } from "node:child_process";
+import { SlicerError, tailText } from "./slicer-error.js";
+/** Bytes of each stream kept for diagnostics; verbose slicers are never truncated into a failure. */
+const OUTPUT_TAIL_BYTES = 64 * 1024;
+class TailBuffer {
+    constructor() {
+        this.chunks = [];
+        this.size = 0;
+    }
+    push(chunk) {
+        this.chunks.push(chunk);
+        this.size += chunk.length;
+        while (this.size > OUTPUT_TAIL_BYTES && this.chunks.length > 1) {
+            this.size -= this.chunks.shift().length;
+        }
+    }
+    text() {
+        const all = Buffer.concat(this.chunks);
+        return all.subarray(Math.max(0, all.length - OUTPUT_TAIL_BYTES)).toString("utf8");
+    }
+}
+function describeOutput(stdoutTail, stderrTail) {
+    const stdout = tailText(stdoutTail);
+    const stderr = tailText(stderrTail);
+    return [
+        stdout ? `Slicer stdout (tail):\n${stdout}` : "Slicer stdout: (empty)",
+        stderr ? `Slicer stderr (tail):\n${stderr}` : "Slicer stderr: (empty)",
+    ].join("\n");
+}
+/**
+ * Run a slicer executable with a timeout and cancellation, keeping bounded
+ * stdout/stderr tails. A nonzero exit, signal, spawn failure, timeout, or
+ * cancellation rejects with a SlicerError that includes the evidence.
+ */
+export function runSlicerProcess(options) {
+    const { command, args, timeoutMs, slicerType, isCancelled } = options;
+    return new Promise((resolve, reject) => {
+        const stdout = new TailBuffer();
+        const stderr = new TailBuffer();
+        let settled = false;
+        let timedOut = false;
+        let cancelled = false;
+        const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+        child.stdout?.on("data", (chunk) => stdout.push(chunk));
+        child.stderr?.on("data", (chunk) => stderr.push(chunk));
+        const cleanup = () => {
+            clearTimeout(timeoutHandle);
+            clearInterval(cancelHandle);
+        };
+        const settle = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            callback();
+        };
+        const timeoutHandle = setTimeout(() => {
+            timedOut = true;
+            try {
+                child.kill("SIGKILL");
+            }
+            catch { /* reported through close/error */ }
+        }, timeoutMs);
+        const cancelHandle = setInterval(() => {
+            if (isCancelled?.()) {
+                cancelled = true;
+                try {
+                    child.kill("SIGKILL");
+                }
+                catch { /* reported through close/error */ }
+            }
+        }, 500);
+        child.on("error", (error) => {
+            settle(() => reject(new SlicerError("execution", `Could not start slicer "${command}": ${error.message}. Check SLICER_PATH/slicer_path.`, { slicerType, slicerPath: command, stdoutTail: stdout.text(), stderrTail: stderr.text() })));
+        });
+        child.on("close", (code, signal) => {
+            const stdoutTail = stdout.text();
+            const stderrTail = stderr.text();
+            if (!timedOut && !cancelled && code === 0 && !signal) {
+                settle(() => resolve({ stdoutTail, stderrTail }));
+                return;
+            }
+            const reason = timedOut
+                ? `Slicer exceeded timeout ${timeoutMs}ms and was killed`
+                : cancelled
+                    ? "Slicing operation cancelled"
+                    : signal
+                        ? `Slicer was terminated by signal ${signal}`
+                        : `Slicer exited with code ${code}`;
+            settle(() => reject(new SlicerError("execution", `${reason} (${slicerType}: ${command}).\n${describeOutput(stdoutTail, stderrTail)}`, {
+                slicerType,
+                slicerPath: command,
+                exitCode: code,
+                signal: signal ?? null,
+                timedOut,
+                cancelled,
+                stdoutTail: tailText(stdoutTail),
+                stderrTail: tailText(stderrTail),
+            })));
+        });
+    });
+}

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

@@ -0,0 +1,27 @@
+/**
+ * Slicer failures carry their own phase and actionable suggestion so the MCP
+ * error handler never falls back to printer-connectivity advice for a local
+ * profile or slicer problem.
+ */
+export type SlicerFailurePhase = "preparation" | "execution" | "output";
+export interface SlicerFailureDetails {
+    slicerType?: string;
+    slicerPath?: string;
+    exitCode?: number | null;
+    signal?: string | null;
+    timedOut?: boolean;
+    cancelled?: boolean;
+    stdoutTail?: string;
+    stderrTail?: string;
+}
+export declare function slicerSuggestion(phase: SlicerFailurePhase, slicerType?: string): string;
+export declare class SlicerError extends Error {
+    readonly phase: SlicerFailurePhase;
+    readonly suggestion: string;
+    readonly details: SlicerFailureDetails;
+    constructor(phase: SlicerFailurePhase, message: string, details?: SlicerFailureDetails);
+}
+/** Keep the last lines of slicer output; the actionable line is usually at the end. */
+export declare function tailText(text: string, maxLines?: number, maxChars?: number): string;
+/** Wrap a preparation failure (profile lookup, flattening, arguments) without losing its message. */
+export declare function asPreparationError(error: unknown, details: SlicerFailureDetails): SlicerError;

package/dist/slicer/slicer-error.js

@@ -0,0 +1,53 @@
+/**
+ * Slicer failures carry their own phase and actionable suggestion so the MCP
+ * error handler never falls back to printer-connectivity advice for a local
+ * profile or slicer problem.
+ */
+const BAMBU_COMPATIBLE = new Set(["bambustudio", "orcaslicer", "orcaslicer-bambulab"]);
+export function slicerSuggestion(phase, slicerType) {
+    const bambu = slicerType !== undefined && BAMBU_COMPATIBLE.has(slicerType);
+    switch (phase) {
+        case "preparation":
+            return bambu
+                ? "Slicer profile preparation failed before the slicer ran. Check that bambu_model and nozzle_diameter " +
+                    "match an installed machine preset in the selected slicer's BBL profile tree (set BAMBU_PROFILES_ROOT " +
+                    "for non-standard installs), that slicer_profile/filament paths exist and are valid JSON, and that " +
+                    "BAMBU_SLICER_PROFILE_DIRS points at directories containing any custom parents. Otherwise slice in the " +
+                    "GUI and print the exported .gcode.3mf."
+                : "Slicer setup failed before the slicer ran. Check slicer_path, slicer_profile, and filament_profile.";
+        case "execution":
+            return "The slicer process failed. Read the exit code and slicer output above: fix the reported profile, " +
+                "model, or flag problem (or raise SLICER_TIMEOUT_MS for a timeout), or slice in the GUI and print the " +
+                "exported file. Nothing was uploaded or printed.";
+        case "output":
+            return "The slicer exited without producing a printable result. Check the slicer output above, confirm the " +
+                "model fits the selected printer's plate, or slice in the GUI and export the sliced plate. Nothing was " +
+                "uploaded or printed.";
+    }
+}
+export class SlicerError extends Error {
+    constructor(phase, message, details = {}) {
+        super(message);
+        this.name = "SlicerError";
+        this.phase = phase;
+        this.details = details;
+        this.suggestion = slicerSuggestion(phase, details.slicerType);
+    }
+}
+/** Keep the last lines of slicer output; the actionable line is usually at the end. */
+export function tailText(text, maxLines = 25, maxChars = 4000) {
+    const trimmed = text.replace(/\s+$/, "");
+    if (!trimmed)
+        return "";
+    let tail = trimmed.split(/\r?\n/).slice(-maxLines).join("\n");
+    if (tail.length > maxChars)
+        tail = `...${tail.slice(-maxChars)}`;
+    return tail;
+}
+/** Wrap a preparation failure (profile lookup, flattening, arguments) without losing its message. */
+export function asPreparationError(error, details) {
+    if (error instanceof SlicerError)
+        return error;
+    const message = error instanceof Error ? error.message : String(error);
+    return new SlicerError("preparation", `Slicer preparation failed: ${message}`, details);
+}

package/dist/slicer/templates.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Local slicing-template registry (ported from bambu-printer-mcp).
+ *
+ * A template is a saved .3mf project whose embedded slicer settings are
+ * reused as the process profile, or a .json/.config process profile. Machine
+ * presets still come from the selected bambu_model/nozzle; a template never
+ * replaces the machine safety gate.
+ */
+export type TemplateSourceType = "3mf" | "json" | "config";
+export interface TemplateEntry {
+    name: string;
+    path: string;
+    source_type: TemplateSourceType;
+    relative_path: string;
+}
+export declare function defaultTemplateDir(): string;
+export declare function sanitizeTemplateName(templateName: string): string;
+export declare function scanTemplateRegistry(templateDir: string): TemplateEntry[];
+export declare function listTemplateRegistry(templateDir?: string): {
+    template_dir: string;
+    templates: TemplateEntry[];
+};
+export declare function resolveTemplatePath(templateName: string | undefined, templateDir?: string, sourceTypes?: TemplateSourceType[]): string | undefined;
+export declare function saveTemplate(sourcePath: string, templateName?: string, templateDir?: string): {
+    saved: boolean;
+    template_name: string;
+    source_path: string;
+    destination_path: string;
+    template_dir: string;
+    resolved_path: string | undefined;
+};
+/** Extract the embedded slicer settings from a Bambu/Orca project 3MF. */
+export declare function extractBambuTemplateSettings(filePath: string, outputDir: string): Promise<string>;
+/** A template/profile path becomes the process profile passed to sliceSTL. */
+export declare function resolveTemplateSlicerProfilePath(templatePath: string, tempDir: string): Promise<string>;
+export declare function parseLooseSlicerConfig(content: string): Record<string, any>;
+export declare function summarizeSliceSettings(config: Record<string, any>): {
+    printer_settings_id: string | null;
+    printer_model: string | null;
+    default_print_profile: string | null;
+    default_filament_profile: any[];
+    filament_settings_id: any[];
+    filament_type: any[];
+    inherits: string | null;
+    print_settings_id: string | null;
+    compatible_printers: any[];
+    nozzle_diameter: any[];
+    layer_height: number | null;
+    first_layer_height: number | null;
+    sparse_infill_density: string | null;
+    sparse_infill_pattern: string | null;
+    wall_loops: number | null;
+    top_shell_layers: number | null;
+    bottom_shell_layers: number | null;
+    brim_width: number | null;
+    support_enabled: boolean | null;
+    support_type: string | null;
+    bed_type: string | null;
+    nozzle_temperature: any[];
+};
+/** Inspect settings in a template 3MF or a profile file without slicing. */
+export declare function inspectSliceSettings(sourcePath: string, tempDir: string): Promise<{
+    source_path: string;
+    source_type: string;
+    extracted_settings_path: string;
+    object_count: number;
+    build_item_count: number;
+    metadata_keys: string[];
+    summary: {
+        printer_settings_id: string | null;
+        printer_model: string | null;
+        default_print_profile: string | null;
+        default_filament_profile: any[];
+        filament_settings_id: any[];
+        filament_type: any[];
+        inherits: string | null;
+        print_settings_id: string | null;
+        compatible_printers: any[];
+        nozzle_diameter: any[];
+        layer_height: number | null;
+        first_layer_height: number | null;
+        sparse_infill_density: string | null;
+        sparse_infill_pattern: string | null;
+        wall_loops: number | null;
+        top_shell_layers: number | null;
+        bottom_shell_layers: number | null;
+        brim_width: number | null;
+        support_enabled: boolean | null;
+        support_type: string | null;
+        bed_type: string | null;
+        nozzle_temperature: any[];
+    };
+    raw_key_count: number;
+} | {
+    source_path: string;
+    source_type: string;
+    extracted_settings_path: string;
+    summary: {
+        printer_settings_id: string | null;
+        printer_model: string | null;
+        default_print_profile: string | null;
+        default_filament_profile: any[];
+        filament_settings_id: any[];
+        filament_type: any[];
+        inherits: string | null;
+        print_settings_id: string | null;
+        compatible_printers: any[];
+        nozzle_diameter: any[];
+        layer_height: number | null;
+        first_layer_height: number | null;
+        sparse_infill_density: string | null;
+        sparse_infill_pattern: string | null;
+        wall_loops: number | null;
+        top_shell_layers: number | null;
+        bottom_shell_layers: number | null;
+        brim_width: number | null;
+        support_enabled: boolean | null;
+        support_type: string | null;
+        bed_type: string | null;
+        nozzle_temperature: any[];
+    };
+    raw_key_count: number;
+    object_count?: undefined;
+    build_item_count?: undefined;
+    metadata_keys?: undefined;
+}>;

package/dist/slicer/templates.js

@@ -0,0 +1,255 @@
+/**
+ * Local slicing-template registry (ported from bambu-printer-mcp).
+ *
+ * A template is a saved .3mf project whose embedded slicer settings are
+ * reused as the process profile, or a .json/.config process profile. Machine
+ * presets still come from the selected bambu_model/nozzle; a template never
+ * replaces the machine safety gate.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import JSZip from "jszip";
+import { parse3MF } from "../3mf_parser.js";
+export function defaultTemplateDir() {
+    return process.env.BAMBU_TEMPLATE_DIR?.trim() ||
+        path.join(process.env.HOME || os.homedir(), "Sync", "bambu", "templates");
+}
+function resolveTemplateDir(templateDir) {
+    return templateDir && templateDir.trim().length > 0 ? templateDir : defaultTemplateDir();
+}
+export function sanitizeTemplateName(templateName) {
+    const sanitized = templateName
+        .trim()
+        .replace(/\\/g, "/")
+        .replace(/^\/+|\/+$/g, "")
+        .replace(/\s+/g, "_")
+        .replace(/[^A-Za-z0-9/_-]/g, "_");
+    // Nested names are allowed; parent-directory segments are not.
+    if (!sanitized || sanitized.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) {
+        throw new Error(`Invalid template name "${templateName}".`);
+    }
+    return sanitized;
+}
+export function scanTemplateRegistry(templateDir) {
+    if (!fs.existsSync(templateDir))
+        return [];
+    const allowedExtensions = new Set([".3mf", ".json", ".config"]);
+    const entries = [];
+    const stack = [templateDir];
+    while (stack.length > 0) {
+        const currentDir = stack.pop();
+        for (const entry of fs.readdirSync(currentDir, { withFileTypes: true })) {
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+                continue;
+            }
+            const extension = path.extname(entry.name).toLowerCase();
+            if (!entry.isFile() || !allowedExtensions.has(extension))
+                continue;
+            const relativePath = path.relative(templateDir, fullPath);
+            const templateName = relativePath
+                .replace(/\\/g, "/")
+                .replace(/(\.gcode)?\.3mf$/i, "")
+                .replace(/\.(json|config)$/i, "");
+            entries.push({
+                name: templateName,
+                path: fullPath,
+                source_type: extension === ".3mf" ? "3mf" : extension === ".json" ? "json" : "config",
+                relative_path: relativePath,
+            });
+        }
+    }
+    return entries.sort((a, b) => a.name.localeCompare(b.name));
+}
+export function listTemplateRegistry(templateDir) {
+    const resolved = resolveTemplateDir(templateDir);
+    return { template_dir: resolved, templates: scanTemplateRegistry(resolved) };
+}
+export function resolveTemplatePath(templateName, templateDir, sourceTypes) {
+    if (!templateName || templateName.trim().length === 0)
+        return undefined;
+    const registry = listTemplateRegistry(templateDir);
+    const normalizedName = sanitizeTemplateName(templateName).toLowerCase();
+    const requestedName = templateName.trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "").toLowerCase();
+    const nameMatches = registry.templates.filter((entry) => entry.name.toLowerCase() === requestedName ||
+        entry.name.replace(/\s+/g, "_").replace(/[^A-Za-z0-9/_-]/g, "_").toLowerCase() === normalizedName);
+    const searchTypes = sourceTypes && sourceTypes.length > 0 ? sourceTypes : ["3mf", "json", "config"];
+    const match = searchTypes
+        .map((sourceType) => nameMatches.find((entry) => entry.source_type === sourceType))
+        .find((entry) => Boolean(entry));
+    if (!match) {
+        const typeHint = sourceTypes && sourceTypes.length > 0 ? ` with source type ${sourceTypes.join("/")}` : "";
+        const availableTypes = nameMatches.length > 0
+            ? ` Available source types: ${Array.from(new Set(nameMatches.map((entry) => entry.source_type))).join(", ")}.`
+            : "";
+        throw new Error(`Template "${templateName}"${typeHint} not found in ${registry.template_dir}.${availableTypes}`);
+    }
+    return match.path;
+}
+export function saveTemplate(sourcePath, templateName, templateDir) {
+    if (!fs.existsSync(sourcePath) || !fs.statSync(sourcePath).isFile()) {
+        throw new Error(`Template source not found: ${sourcePath}`);
+    }
+    const resolvedTemplateDir = resolveTemplateDir(templateDir);
+    const sourceBaseName = path.basename(sourcePath);
+    const extension = path.extname(sourceBaseName).toLowerCase();
+    if (![".3mf", ".json", ".config"].includes(extension)) {
+        throw new Error("Templates must be .3mf, .json, or .config files.");
+    }
+    const baseName = templateName && templateName.trim().length > 0
+        ? sanitizeTemplateName(templateName)
+        : sanitizeTemplateName(sourceBaseName.replace(/(\.gcode)?\.3mf$/i, "").replace(/\.(json|config)$/i, ""));
+    const destinationPath = path.join(resolvedTemplateDir, `${baseName}${extension}`);
+    const relative = path.relative(resolvedTemplateDir, destinationPath);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error(`Template name "${templateName}" escapes the template directory.`);
+    }
+    fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+    fs.copyFileSync(sourcePath, destinationPath);
+    const sourceType = extension === ".3mf" ? "3mf" : extension === ".json" ? "json" : "config";
+    return {
+        saved: true,
+        template_name: baseName,
+        source_path: sourcePath,
+        destination_path: destinationPath,
+        template_dir: resolvedTemplateDir,
+        resolved_path: resolveTemplatePath(baseName, resolvedTemplateDir, [sourceType]),
+    };
+}
+/** Extract the embedded slicer settings from a Bambu/Orca project 3MF. */
+export async function extractBambuTemplateSettings(filePath, outputDir) {
+    const zip = await JSZip.loadAsync(await fs.promises.readFile(filePath));
+    const potentialFiles = [
+        "Metadata/project_settings.config",
+        "Metadata/Slic3r_PE.config",
+        "Metadata/model_settings.config",
+        "Metadata/slice_info.config",
+    ];
+    for (const name of potentialFiles) {
+        const file = zip.file(name);
+        if (!file)
+            continue;
+        const content = await file.async("string");
+        await fs.promises.mkdir(outputDir, { recursive: true });
+        const stem = path.basename(filePath).replace(/[^A-Za-z0-9._-]+/g, "_").slice(0, 64);
+        const outputPath = path.join(outputDir, `${stem}_${name.replace(/\//g, "_")}`);
+        await fs.promises.writeFile(outputPath, content, "utf8");
+        return outputPath;
+    }
+    throw new Error(`No slicer settings config found in template 3MF: ${filePath}`);
+}
+/** A template/profile path becomes the process profile passed to sliceSTL. */
+export async function resolveTemplateSlicerProfilePath(templatePath, tempDir) {
+    const extension = path.extname(templatePath).toLowerCase();
+    if (extension === ".3mf")
+        return extractBambuTemplateSettings(templatePath, tempDir);
+    if (extension === ".json" || extension === ".config")
+        return templatePath;
+    throw new Error(`Template profile must be a .3mf, .json, or .config file: ${templatePath}`);
+}
+export function parseLooseSlicerConfig(content) {
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        const config = {};
+        for (const line of content.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith(";"))
+                continue;
+            const separatorIndex = trimmed.indexOf("=");
+            if (separatorIndex === -1)
+                continue;
+            const key = trimmed.slice(0, separatorIndex).trim();
+            const value = trimmed.slice(separatorIndex + 1).trim();
+            if (key)
+                config[key] = value;
+        }
+        return config;
+    }
+}
+const numberOrNull = (value) => (value !== undefined && value !== null ? Number(value) : null);
+export function summarizeSliceSettings(config) {
+    const stringList = (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
+    return {
+        printer_settings_id: typeof config.printer_settings_id === "string" ? config.printer_settings_id : null,
+        printer_model: typeof config.printer_model === "string" ? config.printer_model : null,
+        default_print_profile: typeof config.default_print_profile === "string" ? config.default_print_profile : null,
+        default_filament_profile: Array.isArray(config.default_filament_profile)
+            ? config.default_filament_profile
+            : typeof config.default_filament_profile === "string"
+                ? [config.default_filament_profile]
+                : [],
+        filament_settings_id: stringList(config.filament_settings_id),
+        filament_type: stringList(config.filament_type),
+        inherits: typeof config.inherits === "string" ? config.inherits : null,
+        print_settings_id: typeof config.print_settings_id === "string" ? config.print_settings_id : null,
+        compatible_printers: stringList(config.compatible_printers),
+        nozzle_diameter: Array.isArray(config.nozzle_diameter)
+            ? config.nozzle_diameter
+            : config.nozzle_diameter !== undefined
+                ? [config.nozzle_diameter]
+                : [],
+        layer_height: numberOrNull(config.layer_height),
+        first_layer_height: config.initial_layer_print_height !== undefined && config.initial_layer_print_height !== null
+            ? Number(config.initial_layer_print_height)
+            : numberOrNull(config.first_layer_height),
+        sparse_infill_density: config.sparse_infill_density !== undefined && config.sparse_infill_density !== null
+            ? String(config.sparse_infill_density)
+            : null,
+        sparse_infill_pattern: typeof config.sparse_infill_pattern === "string" ? config.sparse_infill_pattern : null,
+        wall_loops: numberOrNull(config.wall_loops),
+        top_shell_layers: numberOrNull(config.top_shell_layers),
+        bottom_shell_layers: numberOrNull(config.bottom_shell_layers),
+        brim_width: numberOrNull(config.brim_width),
+        support_enabled: config.enable_support !== undefined
+            ? String(config.enable_support) === "1" || String(config.enable_support).toLowerCase() === "true"
+            : config.support_enabled !== undefined
+                ? Boolean(config.support_enabled)
+                : null,
+        support_type: typeof config.support_type === "string" ? config.support_type : null,
+        bed_type: typeof config.curr_bed_type === "string"
+            ? config.curr_bed_type
+            : typeof config.bed_type === "string"
+                ? config.bed_type
+                : null,
+        nozzle_temperature: Array.isArray(config.nozzle_temperature)
+            ? config.nozzle_temperature
+            : config.nozzle_temperature !== undefined
+                ? [config.nozzle_temperature]
+                : [],
+    };
+}
+/** Inspect settings in a template 3MF or a profile file without slicing. */
+export async function inspectSliceSettings(sourcePath, tempDir) {
+    if (!fs.existsSync(sourcePath)) {
+        throw new Error(`Slice settings source not found: ${sourcePath}`);
+    }
+    const extension = path.extname(sourcePath).toLowerCase();
+    const settingsDir = path.join(tempDir, "slice-settings");
+    if (extension === ".3mf") {
+        const parsed = await parse3MF(sourcePath);
+        const extractedSettingsPath = await extractBambuTemplateSettings(sourcePath, settingsDir);
+        const config = (parsed.slicerConfig || {});
+        return {
+            source_path: sourcePath,
+            source_type: "3mf",
+            extracted_settings_path: extractedSettingsPath,
+            object_count: parsed.objects.length,
+            build_item_count: parsed.build.items.length,
+            metadata_keys: Object.keys(parsed.metadata),
+            summary: summarizeSliceSettings(config),
+            raw_key_count: Object.keys(config).length,
+        };
+    }
+    const config = parseLooseSlicerConfig(fs.readFileSync(sourcePath, "utf8"));
+    return {
+        source_path: sourcePath,
+        source_type: extension === ".json" ? "json" : extension === ".config" ? "config" : "text",
+        extracted_settings_path: sourcePath,
+        summary: summarizeSliceSettings(config),
+        raw_key_count: Object.keys(config).length,
+    };
+}

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

@@ -1,5 +1,7 @@
 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';
 export type ProgressCallback = (progress: number, message?: string) => void;
 export type OperationResult = {
     success: boolean;
@@ -31,13 +33,18 @@ export declare class STLManipulator extends EventEmitter {
      * Generate a unique operation ID
      */
     private generateOperationId;
+    /**
+     * 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.
+     */
+    private operationOutputPath;
     private validateSlicerExecutable;
     private splitProfileList;
     private parseOrcaProfileArgs;
     private warnForMissingProfiles;
     private appendOrcaProfileArgs;
     private resolveOrcaGcodeOutput;
-    private resolveBambuMachinePresetPath;
     private resolveSlicerTimeoutMs;
     /**
      * Load STL file and return geometry and bounding box
@@ -98,16 +105,27 @@ export declare class STLManipulator extends EventEmitter {
      * @returns Path to the modified STL file
      */
     extendBase(stlFilePath: string, extensionInches: number, progressCallback?: ProgressCallback): Promise<string>;
+    /**
+     * 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: SlicerType, printerPreset?: string): boolean;
     /**
      * 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
      */
-    sliceSTL(stlFilePath: string, slicerType: SlicerType, slicerPath: string, slicerProfile?: string, progressCallback?: ProgressCallback, printerPreset?: string, filamentProfile?: string): Promise<string>;
+    sliceSTL(stlFilePath: string, slicerType: SlicerType, slicerPath: string, slicerProfile?: string, progressCallback?: ProgressCallback, printerPreset?: string, filamentProfile?: string, bambuOptions?: BambuSliceOptions): Promise<string>;
     /**
      * Enhanced version of confirmTemperatures with better error handling
      * @param gcodePath Path to the G-code file
@@ -124,6 +142,10 @@ export declare class STLManipulator extends EventEmitter {
             extruder?: number;
             bed?: number;
         };
+        peak: {
+            extruder?: number;
+            bed?: number;
+        };
         expected: {
             extruder?: number;
             bed?: number;