bambu-printer-mcp 1.1.31 → 1.1.33

package/src/index.ts

@@ -45,7 +45,7 @@ import { analyze3MFAmsRequirements, analyze3MFPlateObjects, analyzeCollarCharm3M
 import type { ThreeMFAmsRequirements } from "./types.js";
 import { BambuImplementation, assertDirectPrintSupported } from "./printers/bambu.js";
 import { inspectPrintFile } from "./safety/print-file.js";
-import { validatePrinterState } from "./safety/printer-state.js";
+import { externalStorageState, validatePrinterState } from "./safety/printer-state.js";
 import { isDualNozzleModel } from "./safety/limits.js";
 import { withPrinterOperation, withPrintSnapshot, uniquePrintName } from "./safety/artifact.js";
 import { detectProfilesRoot } from "./slicer/profile-flatten.js";
@@ -101,6 +101,20 @@ function withEmergencyMqttTimeout<T>(send: (signal: AbortSignal) => Promise<T>):
   return Promise.race([Promise.resolve().then(() => send(controller.signal)), timeout]).finally(() => clearTimeout(timer));
 }
 
+/**
+ * Whether an X2D native print stores its job on the SD card or USB stick
+ * (true) or internal storage (eMMC). An explicit try_emmc_print wins, then
+ * BAMBU_NATIVE_TRY_EMMC_PRINT read as the helper reads it; otherwise a ready
+ * card is used, as OrcaSlicer does, so the job can be reprinted from the
+ * printer and read over FTPS.
+ */
+function nativeExternalStorage(tryEmmcPrint: boolean | undefined, raw: unknown): boolean {
+  if (tryEmmcPrint !== undefined) return !tryEmmcPrint;
+  const configured = process.env.BAMBU_NATIVE_TRY_EMMC_PRINT?.trim();
+  if (configured) return !["1", "true", "TRUE", "yes"].includes(configured);
+  return externalStorageState(raw) === "normal";
+}
+
 function requestedPrintNozzles(args: Record<string, any>): number[] | undefined {
   if (args.nozzle_diameters !== undefined && args.nozzle_diameter !== undefined) {
     throw new Error("Supply nozzle_diameters or nozzle_diameter, not both.");
@@ -1527,6 +1541,9 @@ class BambuPrinterMCPServer {
     if (!args?.three_mf_path) {
       throw new Error("Missing required parameter: three_mf_path");
     }
+    if (args?.try_emmc_print !== undefined && typeof args.try_emmc_print !== "boolean") {
+      throw new Error("try_emmc_print must be true or false.");
+    }
 
     const printModel = await this.resolveBambuModel(args?.bambu_model as string | undefined);
     const printBedType = resolveBedType(args?.bed_type as string | undefined);
@@ -1674,6 +1691,10 @@ class BambuPrinterMCPServer {
 
       assertActive();
       if (native) {
+        const externalStorage = nativeExternalStorage(args?.try_emmc_print, confirmedStatus.raw);
+        if (externalStorage && externalStorageState(confirmedStatus.raw) !== "normal") {
+          throw new Error("External storage was requested, but the printer reports no ready SD card or USB stick.");
+        }
         // Release the telemetry client before the installed plug-in opens its session.
         await this.bambu.disconnectAll();
         assertActive();
@@ -1687,11 +1708,15 @@ class BambuPrinterMCPServer {
           vibrationCalibration: params.task_vibration_cali as boolean,
           layerInspect: params.task_layer_inspect as boolean,
           timelapse: params.task_record_timelapse as boolean,
+          externalStorage,
         }, native.onUpdate, { signal: native.signal, assertActive, beforeDispatch: async () => {
           assertActive();
           const dispatchStatus = await this.bambu.getSafetyStatus(devIp, devId, password || bambuToken);
           validatePrinterState(dispatchStatus, requirements);
           this.bambu.assertBedClearance(dispatchStatus, bedClearance);
+          if (externalStorage && externalStorageState(dispatchStatus.raw) !== "normal") {
+            throw new Error("The printer's SD card or USB stick is no longer ready. Check it and start the print again.");
+          }
           assertActive();
         } });
         assertActive();
@@ -2611,7 +2636,7 @@ class BambuPrinterMCPServer {
                 use_ssl_for_ftp: { type: "boolean", description: "Whether FULU local print should use SSL for FTP (default: true)." },
                 use_ssl_for_mqtt: { type: "boolean", description: "Whether FULU local print should use SSL for MQTT (default: true)." },
                 external_change_assist: { type: "boolean", description: "Enable FULU PrintParams task_ext_change_assist for external filament change assistance." },
-                try_emmc_print: { type: "boolean", description: "Enable FULU PrintParams try_emmc_print for printers that support internal storage printing." },
+                try_emmc_print: { type: "boolean", description: "Store the job on internal storage (eMMC) instead of the SD card or USB stick. FULU bridge: default false. X2D native printing: omit to use a ready card, else eMMC." },
                 extra_options: { type: "string", description: "Raw JSON string or text for FULU PrintParams extra_options." },
                 client_job_id: { type: "number", description: "Optional client job id sent to the bridge; defaults to the current timestamp." }
               },
@@ -2987,8 +3012,9 @@ class BambuPrinterMCPServer {
                 connection_mode: {
                   type: "string",
                   enum: ["lan_mqtt_ftps", "bambu_network", "bambu_native", "bambu_connect"],
-                  description: "Print path: bambu_connect hands a printable file to the signed-in Bambu Connect app for cloud-mode review; X2D otherwise defaults to bambu_native (Bambu Studio's installed local networking plug-in and emmc tunnel); lan_mqtt_ftps is the legacy direct MQTT/FTPS path; bambu_network uses the FULU bridge."
+                  description: "Print path: bambu_connect hands a printable file to the signed-in Bambu Connect app for cloud-mode review; X2D otherwise defaults to bambu_native (Bambu Studio's installed local networking plug-in, storing the job on a ready SD card or USB stick, otherwise internal eMMC); lan_mqtt_ftps is the legacy direct MQTT/FTPS path; bambu_network uses the FULU bridge."
                 },
+                try_emmc_print: { type: "boolean", description: "X2D native printing: true stores the job on internal storage (eMMC), false on the SD card or USB stick (refused unless the printer reports one ready). Omit to use the card when ready, else eMMC; BAMBU_NATIVE_TRY_EMMC_PRINT sets a server default." },
                 connection_type: { type: "string", enum: ["cloud", "lan"], description: "BambuNetwork connection type when connection_mode is bambu_network; cloud uses restored internet printing, lan uses local bridge printing." },
                 bambu_network_method: { type: "string", enum: BAMBU_NETWORK_PRINT_METHODS, description: "FULU print method when connection_mode is bambu_network; defaults to start_print for cloud and start_local_print for lan." },
                 dev_id: { type: "string", description: "Bambu device id for FULU BambuNetwork printing; defaults to BAMBU_DEV_ID or BAMBU_SERIAL." },

package/src/safety/printer-state.ts

@@ -424,3 +424,22 @@ export function manualHeatingRequirements(status: any, model: string, nozzleDiam
   if (tray < 254) { requirements.useAMS = true; requirements.amsMapping = [tray]; }
   return requirements;
 }
+
+export type ExternalStorageState = "none" | "normal" | "abnormal" | "readonly";
+const EXTERNAL_STORAGE_STATES: readonly ExternalStorageState[] = ["none", "normal", "abnormal", "readonly"];
+
+/**
+ * The SD card or USB stick state, read as Bambu Studio does: the `sdcard`
+ * flag, then `home_flag` bits 8-9, then on firmware that reports cfg/fun/aux/stat
+ * the `aux` bits 12-13, each later source overriding the earlier one
+ * (DevStorage.cpp, DeviceManager.cpp parse_home_flag and parse_new_info).
+ */
+export function externalStorageState(raw: unknown): ExternalStorageState {
+  if (!object(raw)) return "none";
+  let state: ExternalStorageState = raw.sdcard === true ? "normal" : "none";
+  if (Number.isInteger(raw.home_flag)) state = EXTERNAL_STORAGE_STATES[(raw.home_flag >> 8) & 3];
+  if (["cfg", "fun", "aux", "stat"].every(key => key in raw) && typeof raw.aux === "string" && /^[0-9a-f]+$/i.test(raw.aux)) {
+    state = EXTERNAL_STORAGE_STATES[Number((BigInt(`0x${raw.aux}`) >> 12n) & 3n)];
+  }
+  return state;
+}

package/src/slicer/orca-profile-cache.ts

@@ -0,0 +1,379 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { profileJsonFiles } from './profile-files.js';
+
+// OrcaSlicer 14da40e3a7b82aa8fc88593c2cf880e66560028f:
+// PresetCacheFormat.{hpp,cpp}, Config.hpp, Config.cpp::save_to_json,
+// Preset.hpp::VendorProfile and Semver.hpp. Only the named v2 format is read;
+// the old ordinal-based cache must never be interpreted as this format.
+const MAX_CACHE_BYTES = 64 * 1024 * 1024;
+const MAX_ITEMS = 100_000;
+const VECTOR = 0x4000;
+// Nullable declarations in the same pinned PrintConfig.cpp; unknown nil values fail closed.
+const NULLABLE_KEYS = new Set([
+  "bridge_acceleration",
+  "bridge_speed",
+  "default_acceleration",
+  "default_jerk",
+  "default_junction_deviation",
+  "deretract_speed_extruder_change",
+  "enable_overhang_speed",
+  "extruder_max_nozzle_count",
+  "filament_adaptive_volumetric_speed",
+  "filament_cooling_before_tower",
+  "filament_deretraction_speed",
+  "filament_flow_ratio",
+  "filament_flush_temp",
+  "filament_flush_temp_fast",
+  "filament_flush_volumetric_speed",
+  "filament_ironing_flow",
+  "filament_ironing_inset",
+  "filament_ironing_spacing",
+  "filament_ironing_speed",
+  "filament_long_retractions_when_cut",
+  "filament_pre_cooling_temperature",
+  "filament_pre_cooling_temperature_nc",
+  "filament_preheat_temperature_delta",
+  "filament_ramming_travel_time",
+  "filament_ramming_travel_time_nc",
+  "filament_ramming_volumetric_speed",
+  "filament_ramming_volumetric_speed_nc",
+  "filament_retract_after_wipe",
+  "filament_retract_before_wipe",
+  "filament_retract_length_nc",
+  "filament_retract_length_toolchange",
+  "filament_retract_lift_above",
+  "filament_retract_lift_below",
+  "filament_retract_lift_enforce",
+  "filament_retract_restart_extra",
+  "filament_retract_restart_extra_toolchange",
+  "filament_retract_when_changing_layer",
+  "filament_retraction_distances_when_cut",
+  "filament_retraction_length",
+  "filament_retraction_minimum_travel",
+  "filament_retraction_speed",
+  "filament_wipe",
+  "filament_wipe_distance",
+  "filament_z_hop",
+  "filament_z_hop_types",
+  "gap_infill_speed",
+  "hotend_cooling_rate",
+  "hotend_heating_rate",
+  "infill_jerk",
+  "initial_layer_acceleration",
+  "initial_layer_infill_speed",
+  "initial_layer_jerk",
+  "initial_layer_speed",
+  "initial_layer_travel_acceleration",
+  "initial_layer_travel_jerk",
+  "initial_layer_travel_speed",
+  "inner_wall_acceleration",
+  "inner_wall_jerk",
+  "inner_wall_speed",
+  "internal_bridge_speed",
+  "internal_solid_infill_acceleration",
+  "internal_solid_infill_speed",
+  "long_retractions_when_ec",
+  "nozzle_flush_dataset",
+  "nozzle_type",
+  "nozzle_volume",
+  "outer_wall_acceleration",
+  "outer_wall_jerk",
+  "outer_wall_speed",
+  "overhang_1_4_speed",
+  "overhang_2_4_speed",
+  "overhang_3_4_speed",
+  "overhang_4_4_speed",
+  "retraction_distances_when_ec",
+  "slowdown_for_curled_perimeters",
+  "small_perimeter_speed",
+  "small_perimeter_threshold",
+  "sparse_infill_acceleration",
+  "sparse_infill_speed",
+  "support_interface_speed",
+  "support_speed",
+  "top_solid_infill_flow_ratio",
+  "top_surface_acceleration",
+  "top_surface_jerk",
+  "top_surface_speed",
+  "travel_acceleration",
+  "travel_jerk",
+  "travel_speed",
+  "travel_speed_z",
+]);
+const fail = (message: string): never => { throw new Error(`Orca profile cache: ${message}`); };
+
+class Reader {
+  offset = 0;
+  constructor(readonly bytes: Buffer) {}
+  take(size: number): Buffer {
+    if (!Number.isSafeInteger(size) || size < 0 || size > this.bytes.length - this.offset) fail('truncated or invalid length');
+    const result = this.bytes.subarray(this.offset, this.offset + size);
+    this.offset += size;
+    return result;
+  }
+  u8(): number { return this.take(1).readUInt8(); }
+  u16(): number { return this.take(2).readUInt16LE(); }
+  u32(): number { return this.take(4).readUInt32LE(); }
+  i32(): number { return this.take(4).readInt32LE(); }
+  u64(): number {
+    const value = this.take(8).readBigUInt64LE();
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) fail('length exceeds safe range');
+    return Number(value);
+  }
+  count(): number {
+    const n = this.u64();
+    if (n > MAX_ITEMS || n > this.bytes.length - this.offset) fail('collection length out of bounds');
+    return n;
+  }
+  string(): string {
+    const raw = this.take(this.u64());
+    try { return new TextDecoder('utf-8', { fatal: true }).decode(raw); }
+    catch { return fail('invalid UTF-8'); }
+  }
+  strings(): string[] { return this.array(() => this.string()); }
+  array<T>(read: () => T): T[] { return Array.from({ length: this.count() }, read); }
+  double(): number { return this.take(8).readDoubleLE(); }
+}
+
+function crc32(bytes: Buffer): number {
+  let crc = 0xffffffff;
+  for (const byte of bytes) {
+    crc ^= byte;
+    for (let bit = 0; bit < 8; bit++) crc = (crc >>> 1) ^ ((crc & 1) ? 0xedb88320 : 0);
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+interface CachedProfile { subPath: string; data: Record<string, unknown>; }
+
+/** Read raw source diffs, not merged profiles: inheritance/includes still use the shared resolver. */
+export function decodeOrcaBblCache(bytes: Buffer): CachedProfile[] {
+  if (bytes.length < 20 || bytes.length > MAX_CACHE_BYTES) fail('file size out of bounds');
+  const header = new Reader(bytes);
+  if (header.u32() !== 0x4f52435a) fail('unknown magic');
+  if (header.u32() !== 2) fail('unsupported format version');
+  if (header.u64() !== bytes.length - 20) fail('body size does not match file');
+  const expectedCrc = header.u32();
+  const body = bytes.subarray(20);
+  if (crc32(body) !== expectedCrc) fail('CRC checksum mismatch');
+  const r = new Reader(body);
+  if (r.u32() !== 2) fail('unsupported body version');
+  if (r.string() !== 'BBL') fail('expected BBL vendor');
+  const version = r.string();
+  if (!/^\d+(?:\.\d+){2,3}(?:[-+][\w.-]+)?$/.test(version)) fail('invalid vendor version');
+  const keys = r.strings();
+  const types = r.array(() => r.u16());
+  const enums = r.strings();
+  if (keys.length !== types.length || keys.length > 65535 || enums.length > 65535 || enums[0] !== '') fail('invalid option dictionary');
+  if (new Set(keys).size !== keys.length || keys.some(key => !key || ['__proto__', 'constructor', 'prototype'].includes(key))) fail('invalid option name');
+
+  // VendorMap is std::map<string, VendorProfile>, serialized by cereal in declaration order.
+  const modelsMetadata: CachedProfile[] = [];
+  const vendors = r.count();
+  let ownVendor = false;
+  let vendorProfileVersion = "";
+  for (let i = 0; i < vendors; i++) {
+    const mapKey = r.string();
+    r.string(); // display name
+    const id = r.string();
+    const profileVersion = r.string();
+    if (mapKey === 'BBL' && id === 'BBL' && profileVersion) { ownVendor = true; vendorProfileVersion = profileVersion; }
+    r.string(); r.string(); // update/changelog URLs
+    const models = r.count();
+    for (let j = 0; j < models; j++) {
+      const modelId = r.string(); const modelName = r.string();
+      r.string(); r.u8(); r.string();
+      r.strings(); r.strings(); const unsupportedBeds = r.strings();
+      r.string(); r.string(); const imageBedType = r.string();
+      for (let k = 0; k < 6; k++) r.string();
+      if (mapKey === 'BBL' && modelName) {
+        modelsMetadata.push({ subPath: `machine/__models__/${encodeURIComponent(modelId)}.json`,
+          data: { name: modelName, type: 'machine_model',
+            ...(imageBedType ? { image_bed_type: imageBedType } : {}),
+            ...(unsupportedBeds.length ? { not_support_bed_type: unsupportedBeds.join(';') } : {}) } });
+      }
+    }
+    r.strings(); r.strings(); // default filament/material sets
+  }
+  if (!ownVendor) fail('cache does not carry its BBL vendor profile');
+
+  const number = (value: number, nullable = false): string => {
+    if (nullable && Number.isNaN(value)) return 'nil';
+    if (!Number.isFinite(value)) return fail('non-finite numeric option');
+    return String(value);
+  };
+  const point = (dimension: number, separator: string): string =>
+    Array.from({ length: dimension }, () => number(r.double())).join(separator);
+  const scalar = (type: number, vector: boolean): string => {
+    switch (type) {
+      case 1: return number(r.double(), vector);
+      case 2: { const n = r.i32(); return vector && n === 2147483647 ? 'nil' : String(n); }
+      case 3: return r.string();
+      case 4: { const n = r.double(); return Number.isNaN(n) && vector ? 'nil' : `${number(n)}%`; }
+      case 5: {
+        const n = r.double(); const percent = r.u8();
+        if (percent > 1) return fail('invalid percent flag');
+        return Number.isNaN(n) && vector ? 'nil' : number(n) + (percent ? '%' : '');
+      }
+      case 6: return point(2, vector ? 'x' : ',');
+      case 7: return point(3, ',');
+      case 8: {
+        const n = r.u8();
+        if (vector && n === 255) return 'nil';
+        if (n > 1) return fail('invalid boolean option');
+        return String(n);
+      }
+      default: return fail(`unsupported option type ${type}`);
+    }
+  };
+  const option = (type: number): string | string[] => {
+    if (type === 9 || type === VECTOR + 9) {
+      const count = r.u32();
+      if (count > MAX_ITEMS || (type === 9 && count !== 1)) fail('invalid enum count');
+      const values = Array.from({ length: count }, () => {
+        const index = r.u16();
+        if (index >= enums.length) return fail('enum index out of bounds');
+        if (index !== 0) return enums[index];
+        const value = r.i32();
+        if (type === VECTOR + 9 && value === 2147483647) return 'nil';
+        return fail('unnamed enum cannot be exported safely');
+      });
+      return type === 9 ? values[0] : values;
+    }
+    if (type === VECTOR + 10) return r.array(() => r.array(() => point(2, 'x')).join(','));
+    if (type === VECTOR + 11) return r.array(() => r.array(() => String(r.i32())).join(','));
+    if (type & VECTOR) return r.array(() => scalar(type - VECTOR, true));
+    return scalar(type, false);
+  };
+  const profiles: CachedProfile[] = [...modelsMetadata];
+  const names = new Set(profiles.map(p => String(p.data.name))); const paths = new Set(profiles.map(p => p.subPath.toLowerCase()));
+  for (const kind of ['process', 'filament', 'machine']) {
+    const count = r.u32();
+    if (count > MAX_ITEMS) fail('preset count out of bounds');
+    for (let i = 0; i < count; i++) {
+      const name = r.string(); const subPath = r.string();
+      if (!name || names.has(name)) fail('duplicate/empty preset name');
+      const normalized = subPath.replace(/\\/g, '/');
+      if (!normalized.startsWith(`${kind}/`) || !normalized.endsWith('.json') || normalized.split('/').some(p => !p || p === '.' || p === '..') || normalized.includes(':') || paths.has(normalized.toLowerCase())) fail('invalid or colliding preset path');
+      names.add(name); paths.add(normalized.toLowerCase());
+      const data: Record<string, unknown> = Object.create(null);
+      const configCount = r.u32(); const seen = new Set<number>();
+      if (configCount > keys.length) fail('option count out of bounds');
+      for (let j = 0; j < configCount; j++) {
+        const key = r.u16();
+        if (key >= keys.length || seen.has(key)) fail('invalid/duplicate option index');
+        seen.add(key);
+        const value = option(types[key]);
+        if (types[key] !== VECTOR + 3 && Array.isArray(value) && value.includes('nil') && !NULLABLE_KEYS.has(keys[key])) fail(`unexpected nil for ${keys[key]}`);
+        data[keys[key]] = value;
+      }
+      const inherits = r.string(); const includes = r.strings();
+      const description = r.string(); const instantiation = r.string();
+      const settingId = r.string(); const filamentId = r.string(); const renamed = r.strings();
+      Object.assign(data, { name, type: kind, from: 'system', version: vendorProfileVersion, instantiation, inherits });
+      if (includes.length) data.include = includes;
+      if (description) data.description = description;
+      if (settingId) data.setting_id = settingId;
+      if (filamentId) data.filament_id = filamentId;
+      if (renamed.length) data.renamed_from = renamed.map(value => JSON.stringify(value)).join(';');
+      profiles.push({ subPath: normalized, data });
+    }
+  }
+  if (r.u64() !== 0) fail('vendor cache records profile parse errors');
+  if (r.offset !== body.length) fail('unexpected trailing cache data');
+  return profiles;
+}
+
+/** Expand only the selected installation's cache in the owning server's private temp directory. */
+export async function materializeOrcaProfilesRoot(profilesRoot: string, tempDir: string): Promise<string> {
+  if (profileJsonFiles(path.join(profilesRoot, 'BBL', 'machine')).length) return profilesRoot;
+  const cachePath = path.join(profilesRoot, 'BBL.opc');
+  let stat;
+  try { stat = await fs.stat(cachePath); }
+  catch (error) { if ((error as NodeJS.ErrnoException).code === 'ENOENT') return profilesRoot; throw error; }
+  if (stat.size > MAX_CACHE_BYTES) fail('file size out of bounds');
+  let cli: Buffer;
+  try { cli = await fs.readFile(path.join(profilesRoot, 'BBL', 'cli_config.json')); }
+  catch { return fail('selected installation is missing BBL/cli_config.json; update Orca or supply its exact matching profile tree'); }
+  const parsed: unknown = JSON.parse(cli.toString('utf8'));
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) fail('invalid BBL/cli_config.json');
+  const cache = await fs.readFile(cachePath);
+  const profiles = decodeOrcaBblCache(cache);
+  const digest = createHash('sha256').update(cache).update(cli).digest('hex');
+  const output = await fs.mkdtemp(path.join(tempDir, `orca-profiles-${digest.slice(0, 16)}-`));
+  try {
+    await fs.mkdir(path.join(output, 'BBL'), { recursive: true });
+    await fs.writeFile(path.join(output, 'BBL', 'cli_config.json'), cli, { flag: 'wx' });
+    await fs.writeFile(path.join(output, 'BBL.opc'), cache, { flag: 'wx' });
+    for (const profile of profiles) {
+      const file = path.join(output, 'BBL', profile.subPath);
+      await fs.mkdir(path.dirname(file), { recursive: true });
+      await fs.writeFile(file, JSON.stringify(profile.data), { flag: 'wx' });
+    }
+    return output;
+  } catch (error) {
+    await fs.rm(output, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+interface CliProfiles { settingsArg?: string; filamentPaths: string[]; }
+
+/** Orca v2 cache builds resolve User presets by loaded file identity, not just inherits. */
+export async function stageOrcaCliProfiles(
+  profilesRoot: string, tempDir: string, bundle: CliProfiles
+): Promise<CliProfiles & { extraArgs: string[]; dataDir: string }> {
+  const settings = bundle.settingsArg?.split(';') ?? [];
+  if (settings.length !== 2) fail('complete machine and process settings are required');
+  const root = await fs.mkdtemp(path.join(tempDir, 'orca-cli-'));
+  try {
+    await fs.mkdir(path.join(root, 'system'));
+    await fs.copyFile(path.join(profilesRoot, 'BBL.opc'), path.join(root, 'system', 'BBL.opc'));
+    const profiles = decodeOrcaBblCache(await fs.readFile(path.join(profilesRoot, 'BBL.opc')));
+    const parents = new Set(profiles.map(p => `${p.data.type}:${p.data.name}`));
+    const version = profiles.find(p => p.data.type === 'machine')?.data.version;
+    if (typeof version !== 'string') fail('missing vendor profile version');
+    const output: string[] = [];
+    const colours: string[] = [];
+    const extras: string[] = [];
+    for (const [index, file] of [...settings, ...bundle.filamentPaths].entries()) {
+      const kind = index === 0 ? 'machine' : index === 1 ? 'process' : 'filament';
+      const data = JSON.parse(await fs.readFile(file, 'utf8')) as Record<string, unknown>;
+      if (kind === 'filament') {
+        const colour = Array.isArray(data.filament_colour) ? data.filament_colour[0] : undefined;
+        if (typeof colour !== 'string' || !/^#[0-9a-f]{6}(?:[0-9a-f]{2})?$/i.test(colour)) fail('missing positional filament colour');
+        colours.push(colour);
+      }
+      if (kind === 'process') {
+        if (typeof data.curr_bed_type === 'string') extras.push('--curr-bed-type', data.curr_bed_type);
+        for (const key of ['wipe_tower_x', 'wipe_tower_y']) {
+          if (data[key] === undefined) continue;
+          const values = Array.isArray(data[key]) ? data[key] as unknown[] : [data[key]];
+          if (!values.length || values.some(v => !Number.isFinite(Number(v)))) fail('invalid saved tower position');
+          extras.push(`--${key.replace(/_/g, '-')}`, values.join(','));
+        }
+      }
+      // The selected machine's system identity remains the validated cache leaf.
+      // A fully resolved custom process/filament may be a standalone User root.
+      if (!parents.has(`${kind}:${data.inherits}`)) {
+        if (kind === 'machine') fail('selected machine parent is absent from the exact cache');
+        delete data.inherits;
+      }
+      const digest = createHash('sha256').update(JSON.stringify(data)).digest('hex').slice(0, 16);
+      const name = `mcp_${kind}_${index}_${digest}`;
+      Object.assign(data, { name, from: 'User', version });
+      const directory = path.join(root, 'user', 'default', kind);
+      await fs.mkdir(directory, { recursive: true });
+      const staged = path.join(directory, `${name}.json`);
+      await fs.writeFile(staged, JSON.stringify(data), { flag: 'wx' });
+      output.push(staged);
+    }
+    return { settingsArg: output.slice(0, 2).join(';'), filamentPaths: output.slice(2),
+      extraArgs: ['--datadir', root, ...extras, '--filament-colour', colours.join(';')], dataDir: root };
+  } catch (error) {
+    await fs.rm(root, { recursive: true, force: true });
+    throw error;
+  }
+}

package/src/slicer/profile-flatten.ts

@@ -836,7 +836,7 @@ export function detectProfilesRoot(slicerPath?: string, slicerType = 'bambustudi
             path.resolve(bin, '..', 'share', name, 'resources', 'profiles'),
           ]),
         ];
-    const found = candidates.find(root => existsSync(path.join(root, 'BBL', 'machine')));
+    const found = candidates.find(root => (existsSync(path.join(root, 'BBL', 'machine')) || existsSync(path.join(root, 'BBL.opc'))));
     // Do not select another installation if this executable has no profile tree.
     // flattenForCli reports the missing tree and asks for BAMBU_PROFILES_ROOT.
     return found ?? candidates[0];

package/src/stl/stl-manipulator.ts

@@ -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 { materializeOrcaProfilesRoot, stageOrcaCliProfiles } from '../slicer/orca-profile-cache.js';
 import { sliceWithOrcaApi, validateRemoteSliceOptions } from '../slicer/remote-slicer.js';
 
 const readFileAsync = promisify(fs.readFile);
@@ -291,7 +292,7 @@ export class STLManipulator extends EventEmitter {
     return value;
   }
 
-  private sanitizeProcessForOrca(processConfig: any, printerPreset?: string): any {
+  private sanitizeProcessForOrca(processConfig: any, printerPreset?: string, preserveExtrusionMode = false): any {
     const sanitized = { ...processConfig };
 
     sanitized.type = 'process';
@@ -312,7 +313,7 @@ export class STLManipulator extends EventEmitter {
       sanitized.prime_tower_brim_width = String(sanitized.prime_tower_brim_width);
     }
 
-    return this.useAbsoluteExtrusionForOrca(sanitized);
+    return preserveExtrusionMode ? sanitized : this.useAbsoluteExtrusionForOrca(sanitized);
   }
 
   /** Orca slices with absolute E distances; per-layer `G92 E0` resets would break them. */
@@ -344,7 +345,8 @@ export class STLManipulator extends EventEmitter {
     slicerProfile?: string,
     printerPreset?: string,
     bambuOptions?: BambuSliceOptions,
-    activeProfilesRoot?: string
+    activeProfilesRoot?: string,
+    preserveOrcaExtrusionMode = false
   ): Promise<BambuSettingsBundle> {
     const roots = activeProfilesRoot
       ? [path.join(activeProfilesRoot, 'BBL')]
@@ -417,7 +419,7 @@ export class STLManipulator extends EventEmitter {
         outputBase,
         slicerType === 'orcaslicer' ? 'process_orca' : 'process',
         slicerType === 'orcaslicer'
-          ? this.sanitizeProcessForOrca(mergedProcess, printerPreset)
+          ? this.sanitizeProcessForOrca(mergedProcess, printerPreset, preserveOrcaExtrusionMode)
           : mergedProcess
       );
 
@@ -460,7 +462,7 @@ export class STLManipulator extends EventEmitter {
             ? this.writeTempJson(
                 outputBase,
                 'process_default_orca',
-                this.sanitizeProcessForOrca(this.readJsonFile(defaultProcessPath), printerPreset)
+                this.sanitizeProcessForOrca(this.readJsonFile(defaultProcessPath), printerPreset, preserveOrcaExtrusionMode)
               )
             : defaultProcessPath;
       }
@@ -1608,6 +1610,7 @@ export class STLManipulator extends EventEmitter {
     let outputFilePath = path.join(this.tempDir, outputFileName);
 
     let args: string[] = [];
+    const orcaTemporaryDirectories: string[] = [];
 
     try {
       if (progressCallback) progressCallback(0, `Starting slicing with ${slicerType}...`);
@@ -1660,14 +1663,19 @@ export class STLManipulator extends EventEmitter {
             const profileSlicerType = remote ? 'orcaslicer' : slicerType;
             const bambuOutputPath = path.join(this.tempDir, outputBase + (remote ? `_${operationId}` : '') + '_sliced.3mf');
             const outputDir = path.dirname(bambuOutputPath);
-            const profilesRoot = detectProfilesRoot(remote ? undefined : slicerPath, profileSlicerType);
+            const selectedProfilesRoot = detectProfilesRoot(remote ? undefined : slicerPath, profileSlicerType);
+            const profilesRoot = !remote && profileSlicerType === 'orcaslicer'
+              ? await materializeOrcaProfilesRoot(selectedProfilesRoot, this.tempDir)
+              : selectedProfilesRoot;
+            if (profilesRoot !== selectedProfilesRoot) orcaTemporaryDirectories.push(profilesRoot);
             const rawBundle = await this.resolveBambuLikeSettingsBundle(
               outputBase,
               profileSlicerType,
               slicerProfile,
               printerPreset,
               bambuOptions,
-              profilesRoot
+              profilesRoot,
+              profileSlicerType === 'orcaslicer' && profilesRoot !== selectedProfilesRoot
             );
             // Resolve every BBL dependency before launching the slicer.
             const settingsBundle = await this.maybeFlattenBundle(
@@ -1689,7 +1697,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 (profileSlicerType === 'orcaslicer' && settingsBundle.settingsArg) {
+            if (profileSlicerType === 'orcaslicer' && settingsBundle.settingsArg && profilesRoot === selectedProfilesRoot) {
               const [machinePath, processPath] = settingsBundle.settingsArg.split(';');
               settingsBundle.settingsArg = [
                 this.writeTempJson(outputBase, 'machine_orca_resolved',
@@ -1698,7 +1706,14 @@ export class STLManipulator extends EventEmitter {
                   this.sanitizeProcessForOrca(this.readJsonFile(processPath), printerPreset)),
               ].join(';');
             }
-            const cliBundle = this.isolateMachineSettings(settingsBundle);
+            let cliBundle = this.isolateMachineSettings(settingsBundle);
+            let orcaExtraArgs: string[] = [];
+            if (!remote && profileSlicerType === 'orcaslicer' && profilesRoot !== selectedProfilesRoot) {
+              const staged = await stageOrcaCliProfiles(profilesRoot, this.tempDir, cliBundle);
+              cliBundle = { ...cliBundle, settingsArg: staged.settingsArg, filamentPaths: staged.filamentPaths };
+              orcaExtraArgs = staged.extraArgs;
+              orcaTemporaryDirectories.push(staged.dataDir);
+            }
             if (remote) {
               const [machinePath, processPath] = cliBundle.settingsArg?.split(';') ?? [];
               if (!machinePath || !processPath) throw new Error('Remote slicing requires complete prepared machine and process profiles.');
@@ -1710,6 +1725,7 @@ export class STLManipulator extends EventEmitter {
               break;
             }
             args = [
+              ...orcaExtraArgs,
               '--slice', String(bambuOptions?.slicePlate ?? 0),
               '--outputdir', outputDir,
               '--export-3mf', path.basename(bambuOutputPath),
@@ -1825,6 +1841,11 @@ export class STLManipulator extends EventEmitter {
       throw error; 
     } finally {
       this.activeOperations.delete(operationId);
+      for (const directory of orcaTemporaryDirectories.reverse()) {
+        await fs.promises.rm(directory, { recursive: true, force: true }).catch(error => {
+          console.error('Could not remove temporary Orca profiles:', error);
+        });
+      }
     }
   }