bambu-printer-mcp 1.0.5 → 1.1.2

package/src/stl/stl-manipulator.ts

@@ -3,14 +3,26 @@ import { STLLoader } from 'three/examples/jsm/loaders/STLLoader.js';
 import { STLExporter } from 'three/examples/jsm/exporters/STLExporter.js';
 import * as BufferGeometryUtils from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 import fs from 'fs';
+import os from 'os';
 import path from 'path';
 import { promisify } from 'util';
 import { EventEmitter } from 'events';
 import * as crypto from 'crypto';
 import { execFile } from 'child_process';
+import { flattenForCli, detectProfilesRoot } from '../slicer/profile-flatten.js';
 
 const readFileAsync = promisify(fs.readFile);
 const writeFileAsync = promisify(fs.writeFile);
+const BAMBU_PROFILE_ROOTS = [
+  '/Applications/BambuStudio.app/Contents/Resources/profiles/BBL',
+  '/Applications/OrcaSlicer.app/Contents/Resources/profiles/BBL',
+];
+const BAMBU_CLI_BED_TYPES: Record<string, string> = {
+  textured_plate: 'Textured PEI Plate',
+  cool_plate: 'Cool Plate',
+  engineering_plate: 'Engineering Plate',
+  hot_plate: 'High Temp Plate',
+};
 
 // Define types for progress tracking
 export type ProgressCallback = (progress: number, message?: string) => void;
@@ -40,7 +52,106 @@ export type TransformationParams = {
   selectionBounds?: THREE.Box3;
 };
 
-// BambuStudio CLI flags exposed via the slice_stl tool
+export const SLICER_TYPES = [
+  'bambustudio',
+  'orcaslicer',
+  'orcaslicer-bambulab',
+  'prusaslicer',
+  'cura',
+  'slic3r',
+] as const;
+
+export type SlicerType = typeof SLICER_TYPES[number];
+
+const SLICER_TYPE_ALIASES: Record<string, SlicerType> = {
+  bambustudio: 'bambustudio',
+  'bambu-studio': 'bambustudio',
+  bblstudio: 'bambustudio',
+  orcaslicer: 'orcaslicer',
+  'orca-slicer': 'orcaslicer',
+  orca: 'orcaslicer',
+  'orcaslicer-bambulab': 'orcaslicer-bambulab',
+  'orca-slicer-bambulab': 'orcaslicer-bambulab',
+  'orca-bambulab': 'orcaslicer-bambulab',
+  'fulu-orca': 'orcaslicer-bambulab',
+  'fulu-orcaslicer': 'orcaslicer-bambulab',
+  'fulu-orca-slicer': 'orcaslicer-bambulab',
+  'orca-studio': 'orcaslicer-bambulab',
+  orcastudio: 'orcaslicer-bambulab',
+  'orcaslicer-bmcu': 'orcaslicer-bambulab',
+  'orca-bmcu': 'orcaslicer-bambulab',
+  prusaslicer: 'prusaslicer',
+  'prusa-slicer': 'prusaslicer',
+  cura: 'cura',
+  curaengine: 'cura',
+  slic3r: 'slic3r',
+};
+
+export function normalizeSlicerType(rawSlicerType: string): SlicerType {
+  const key = rawSlicerType.trim().toLowerCase().replace(/_/g, '-');
+  const normalized = SLICER_TYPE_ALIASES[key];
+
+  if (!normalized) {
+    throw new Error(
+      `Unsupported slicer_type: "${rawSlicerType}". Valid values: ${SLICER_TYPES.join(', ')}`
+    );
+  }
+
+  return normalized;
+}
+
+export function isBambuCompatibleSlicer(slicerType: SlicerType): boolean {
+  return (
+    slicerType === 'bambustudio' ||
+    slicerType === 'orcaslicer' ||
+    slicerType === 'orcaslicer-bambulab'
+  );
+}
+
+function isPathLikeExecutable(slicerPath: string): boolean {
+  return (
+    path.isAbsolute(slicerPath) ||
+    slicerPath.startsWith("./") ||
+    slicerPath.startsWith("../") ||
+    slicerPath.includes("/") ||
+    slicerPath.includes("\\") ||
+    /^[A-Za-z]:/.test(slicerPath)
+  );
+}
+
+function configuredBambuProfileDirs(): string[] {
+  const override = process.env.BAMBU_SLICER_PROFILE_DIRS;
+  if (override !== undefined) {
+    return override.split(path.delimiter).filter(Boolean);
+  }
+
+  const home = os.homedir();
+  const macAppSupport = path.join(home, 'Library', 'Application Support');
+  const linuxConfig = path.join(home, '.config');
+  const appData = process.env.APPDATA;
+  const localAppData = process.env.LOCALAPPDATA;
+  const appNames = [
+    'BambuStudio',
+    'Bambu Studio',
+    'OrcaSlicer',
+    'Orca Slicer',
+    'OrcaStudio',
+    'Orca Studio',
+  ];
+
+  const roots = [
+    macAppSupport,
+    linuxConfig,
+    ...(appData ? [appData] : []),
+    ...(localAppData ? [localAppData] : []),
+  ];
+
+  return roots.flatMap((root) =>
+    appNames.map((appName) => path.join(root, appName, 'system', 'BBL'))
+  );
+}
+
+// Bambu-compatible slicer CLI flags exposed via the slice_stl tool
 export interface BambuSliceOptions {
   uptodate?: boolean;          // --uptodate: update 3MF configs to latest presets
   repetitions?: number;        // --repetitions N: print N copies
@@ -51,6 +162,7 @@ export interface BambuSliceOptions {
   skipObjects?: string;        // --skip-objects "3,5,10": skip specific objects
   loadFilaments?: string;      // --load-filaments "f1.json;f2.json": filament profiles
   loadFilamentIds?: string;    // --load-filament-ids "1,2,3,1": filament-to-object mapping
+  bedType?: string;            // Bambu bed type, e.g. textured_plate or cool_plate
   enableTimelapse?: boolean;   // --enable-timelapse: timelapse-aware slicing
   allowMixTemp?: boolean;      // --allow-mix-temp: allow mixed-temp filaments
   scale?: number;              // --scale factor: uniform scale
@@ -82,6 +194,340 @@ export class STLManipulator extends EventEmitter {
     return crypto.randomUUID();
   }
 
+  private getAvailableProfileRoots(): string[] {
+    return [...BAMBU_PROFILE_ROOTS, ...configuredBambuProfileDirs()].filter((root) => fs.existsSync(root));
+  }
+
+  private findProfileFile(
+    category: 'machine' | 'process' | 'filament',
+    profileName?: string
+  ): string | undefined {
+    if (!profileName) {
+      return undefined;
+    }
+
+    for (const root of this.getAvailableProfileRoots()) {
+      const candidate = path.join(root, category, `${profileName}.json`);
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+
+    return undefined;
+  }
+
+  private buildFilamentIdIndex(): Map<string, string> {
+    const index = new Map<string, string>();
+
+    for (const root of this.getAvailableProfileRoots()) {
+      const filamentDir = path.join(root, 'filament');
+      if (!fs.existsSync(filamentDir)) {
+        continue;
+      }
+
+      for (const entry of fs.readdirSync(filamentDir)) {
+        if (!entry.endsWith('.json')) {
+          continue;
+        }
+
+        const filePath = path.join(filamentDir, entry);
+        try {
+          const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+          const filamentId = typeof parsed?.filament_id === 'string' ? parsed.filament_id.trim() : '';
+          if (filamentId && !index.has(filamentId)) {
+            index.set(filamentId, filePath);
+          }
+        } catch {
+          // Ignore malformed JSON.
+        }
+      }
+    }
+
+    return index;
+  }
+
+  private readJsonFile(filePath: string): any {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  }
+
+  private stripAbsoluteExtruderResets(value: unknown): unknown {
+    if (typeof value === 'string') {
+      return value
+        .split(/\r?\n/)
+        .filter((line) => line.trim().toUpperCase() !== 'G92 E0')
+        .join('\n');
+    }
+
+    if (Array.isArray(value)) {
+      return value.filter((line) => String(line).trim().toUpperCase() !== 'G92 E0');
+    }
+
+    return value;
+  }
+
+  private sanitizeProcessForOrca(processConfig: any, printerPreset?: string): any {
+    const sanitized = { ...processConfig };
+
+    sanitized.type = 'process';
+    if (!sanitized.from || sanitized.from === 'project') {
+      sanitized.from = 'User';
+    }
+
+    if (printerPreset) {
+      sanitized.compatible_printers = [printerPreset];
+    }
+
+    if (
+      sanitized.prime_tower_brim_width !== undefined &&
+      Number(sanitized.prime_tower_brim_width) < 0
+    ) {
+      sanitized.prime_tower_brim_width = '0';
+    } else if (sanitized.prime_tower_brim_width !== undefined) {
+      sanitized.prime_tower_brim_width = String(sanitized.prime_tower_brim_width);
+    }
+
+    sanitized.use_relative_e_distances = '0';
+    sanitized.before_layer_change_gcode = this.stripAbsoluteExtruderResets(
+      sanitized.before_layer_change_gcode
+    );
+    sanitized.layer_gcode = this.stripAbsoluteExtruderResets(sanitized.layer_gcode);
+    sanitized.layer_change_gcode = this.stripAbsoluteExtruderResets(
+      sanitized.layer_change_gcode
+    );
+
+    return sanitized;
+  }
+
+  private writeTempJson(outputBase: string, suffix: string, value: any): string {
+    const outPath = path.join(this.tempDir, `${outputBase}_${suffix}.json`);
+    fs.writeFileSync(outPath, JSON.stringify(value, null, 2));
+    return outPath;
+  }
+
+  private resolveBambuLikeSettingsBundle(
+    outputBase: string,
+    slicerType: 'orcaslicer' | 'orcaslicer-bambulab' | 'bambustudio',
+    slicerProfile?: string,
+    printerPreset?: string,
+    bambuOptions?: BambuSliceOptions
+  ): { settingsArg?: string; filamentPaths: string[] } {
+    const machinePath = this.findProfileFile('machine', printerPreset);
+    const machineConfig = machinePath ? this.readJsonFile(machinePath) : null;
+    const hasSlicerProfile = !!slicerProfile && fs.existsSync(slicerProfile);
+    const filamentPaths: string[] = [];
+
+    let processPath: string | undefined;
+    let parsedProfile: any = null;
+
+    if (hasSlicerProfile) {
+      try {
+        parsedProfile = this.readJsonFile(slicerProfile!);
+      } catch {
+        parsedProfile = null;
+      }
+    }
+
+    if (parsedProfile && typeof parsedProfile === 'object') {
+      const inheritedProcessName =
+        (typeof parsedProfile.inherits === 'string' && parsedProfile.inherits) ||
+        (typeof parsedProfile.print_settings_id === 'string' &&
+        parsedProfile.print_settings_id !== parsedProfile.name
+          ? parsedProfile.print_settings_id
+          : undefined) ||
+        (typeof parsedProfile.default_print_profile === 'string'
+          ? parsedProfile.default_print_profile
+          : undefined) ||
+        (typeof machineConfig?.default_print_profile === 'string'
+          ? machineConfig.default_print_profile
+          : undefined);
+
+      const inheritedProcessPath = this.findProfileFile('process', inheritedProcessName);
+      const inheritedProcess =
+        inheritedProcessPath && fs.existsSync(inheritedProcessPath)
+          ? this.readJsonFile(inheritedProcessPath)
+          : {};
+
+      const mergedProcess = {
+        ...inheritedProcess,
+        ...parsedProfile,
+        type: 'process',
+      };
+
+      processPath = this.writeTempJson(
+        outputBase,
+        slicerType === 'orcaslicer' ? 'process_orca' : 'process',
+        slicerType === 'orcaslicer'
+          ? this.sanitizeProcessForOrca(mergedProcess, printerPreset)
+          : mergedProcess
+      );
+
+      const defaultFilamentProfiles = Array.isArray(parsedProfile.default_filament_profile)
+        ? parsedProfile.default_filament_profile
+        : [];
+      for (const profileName of defaultFilamentProfiles) {
+        const filamentPath = this.findProfileFile('filament', String(profileName));
+        if (filamentPath) {
+          filamentPaths.push(filamentPath);
+        }
+      }
+
+      if (filamentPaths.length === 0 && Array.isArray(parsedProfile.filament_ids)) {
+        const filamentIdIndex = this.buildFilamentIdIndex();
+        for (const filamentId of parsedProfile.filament_ids) {
+          const filamentPath = filamentIdIndex.get(String(filamentId));
+          if (filamentPath) {
+            filamentPaths.push(filamentPath);
+          }
+        }
+      }
+    } else if (hasSlicerProfile) {
+      processPath = slicerProfile;
+    }
+
+    if (!processPath) {
+      const defaultProcessName =
+        typeof machineConfig?.default_print_profile === 'string'
+          ? machineConfig.default_print_profile
+          : undefined;
+      const defaultProcessPath = this.findProfileFile('process', defaultProcessName);
+      if (defaultProcessPath) {
+        processPath =
+          slicerType === 'orcaslicer'
+            ? this.writeTempJson(
+                outputBase,
+                'process_default_orca',
+                this.sanitizeProcessForOrca(this.readJsonFile(defaultProcessPath), printerPreset)
+              )
+            : defaultProcessPath;
+      }
+    }
+
+    if (
+      !bambuOptions?.loadFilaments &&
+      filamentPaths.length === 0 &&
+      Array.isArray(machineConfig?.default_filament_profile)
+    ) {
+      for (const profileName of machineConfig.default_filament_profile) {
+        const filamentPath = this.findProfileFile('filament', String(profileName));
+        if (filamentPath) {
+          filamentPaths.push(filamentPath);
+        }
+      }
+    }
+
+    if (bambuOptions?.loadFilaments) {
+      filamentPaths.length = 0;
+      for (const filamentPath of bambuOptions.loadFilaments.split(';')) {
+        const trimmed = filamentPath.trim();
+        if (trimmed) {
+          filamentPaths.push(trimmed);
+        }
+      }
+    }
+
+    const settingsParts = [machinePath, processPath].filter(
+      (entry): entry is string => Boolean(entry)
+    );
+
+    return {
+      settingsArg: settingsParts.length > 0 ? settingsParts.join(';') : undefined,
+      filamentPaths: Array.from(new Set(filamentPaths)),
+    };
+  }
+
+  /**
+   * Optionally rewrite a Bambu-like settings bundle so the paths point at
+   * fully-flattened temp configs instead of the BBL-shipped leaf JSONs.
+   *
+   * BambuStudio's CLI does not resolve the `inherits` chain when loading
+   * profiles via --load-settings / --load-filaments, which causes a
+   * cluster of upstream bugs (see https://github.com/bambulab/BambuStudio/issues/9636
+   * and #9968). Our flattener (src/slicer/profile-flatten.ts) reproduces
+   * what the GUI does at slice time so the CLI accepts the configs.
+   *
+   * Opt-in via `BAMBU_CLI_FLATTEN=true`. When the env var is unset or
+   * not "true"/"1", returns the bundle unchanged so behavior is
+   * backward-compatible. When enabled, only BBL-shipped leaves get
+   * flattened; user-provided custom configs pass through untouched.
+   */
+  private async maybeFlattenBundle(
+    bundle: { settingsArg?: string; filamentPaths: string[] },
+    bambuOptions?: BambuSliceOptions,
+    activeSlicerPath?: string
+  ): Promise<{ settingsArg?: string; filamentPaths: string[] }> {
+    const flag = process.env.BAMBU_CLI_FLATTEN;
+    if (flag !== 'true' && flag !== '1') return bundle;
+    if (!bundle.settingsArg) return bundle;
+
+    // settingsArg is "machine.json;process.json".
+    const parts = bundle.settingsArg.split(';').filter(Boolean);
+    if (parts.length < 2) return bundle;
+    const [machinePath, processPath] = parts;
+
+    // Pull leaf names from each JSON's `name` field. If any is missing or
+    // looks non-BBL (e.g. a user-saved custom config), bail out and
+    // return the original bundle untouched.
+    const machineLeaf = this.readLeafName(machinePath);
+    const processLeaf = this.readLeafName(processPath);
+    const filamentLeaves = bundle.filamentPaths
+      .map((p) => this.readLeafName(p))
+      .filter((n): n is string => Boolean(n));
+
+    if (!machineLeaf || !processLeaf || filamentLeaves.length === 0) {
+      console.log(
+        '[cli-flatten] skipping: could not derive BBL leaf names from bundle paths'
+      );
+      return bundle;
+    }
+
+    const bedType = this.resolveBambuStudioBedType(bambuOptions?.bedType);
+
+    try {
+      const profilesRoot = detectProfilesRoot(activeSlicerPath || process.env.SLICER_PATH);
+      const flat = await flattenForCli({
+        machineLeaf,
+        processLeaf,
+        filamentLeaves,
+        profilesRoot,
+        tempDir: this.tempDir,
+        bedType,
+      });
+      console.log(
+        `[cli-flatten] applied for ${machineLeaf} (cliOverlay=${flat.meta.cliOverlayApplied})`
+      );
+      return {
+        settingsArg: `${flat.machinePath};${flat.processPath}`,
+        filamentPaths: flat.filamentPaths,
+      };
+    } catch (err: any) {
+      console.error(
+        `[cli-flatten] failed, falling back to unflattened bundle: ${err?.message ?? err}`
+      );
+      return bundle;
+    }
+  }
+
+  private resolveBambuStudioBedType(bedType?: string): string | undefined {
+    if (!bedType) return undefined;
+    const normalized = bedType.trim().toLowerCase();
+    if (normalized === 'supertack_plate') {
+      throw new Error(
+        'BambuStudio CLI SuperTack bed type is not verified; use a pre-sliced 3MF or choose textured_plate, cool_plate, engineering_plate, or hot_plate.'
+      );
+    }
+    return BAMBU_CLI_BED_TYPES[normalized] || bedType;
+  }
+
+  /** Read a profile JSON's top-level `name` field, or null if unreadable. */
+  private readLeafName(filePath: string): string | null {
+    try {
+      const data = this.readJsonFile(filePath);
+      return typeof data?.name === 'string' && data.name.length > 0 ? data.name : null;
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * Load STL file and return geometry and bounding box
    */
@@ -993,7 +1439,7 @@ export class STLManipulator extends EventEmitter {
    */
   async sliceSTL(
     stlFilePath: string,
-    slicerType: 'prusaslicer' | 'cura' | 'slic3r' | 'orcaslicer' | 'bambustudio',
+    slicerType: SlicerType,
     slicerPath: string,
     slicerProfile?: string,
     progressCallback?: ProgressCallback,
@@ -1003,7 +1449,7 @@ export class STLManipulator extends EventEmitter {
     const operationId = this.generateOperationId();
     this.activeOperations.set(operationId, true);
 
-    if (!fs.existsSync(slicerPath)) {
+    if (isPathLikeExecutable(slicerPath) && !fs.existsSync(slicerPath)) {
       throw new Error(`Slicer executable not found at: ${slicerPath}`);
     }
     if (slicerProfile && !fs.existsSync(slicerProfile)) {
@@ -1032,25 +1478,6 @@ export class STLManipulator extends EventEmitter {
           args = args.filter(arg => arg !== ''); 
           break;
 
-        case 'orcaslicer': // Add OrcaSlicer case
-           args = [
-               // OrcaSlicer might use --load-settings like Bambu, or --load like Prusa
-               // Assuming --load-settings based on discussion, adjust if needed.
-               // Also assuming profile path points to the main .ini or .json config.
-               '--load-settings', slicerProfile || '',
-               '--output', outputFilePath, // Assuming --output works like PrusaSlicer
-               stlFilePath
-           ];
-           // Alternative if --output doesn't specify filename:
-           // args = [
-           //    '--load-settings', slicerProfile || '',
-           //    '--outputdir', this.tempDir,
-           //    stlFilePath
-           // ];
-           // Remove empty profile arg if not provided
-           args = args.filter(arg => arg !== '');
-           break;
-
         case 'cura':
           // CuraEngine CLI args are different, often requiring -s for settings
           // Example: curaengine slice -v -j cura_settings.json -s layer_height=0.2 -o output.gcode -l input.stl
@@ -1067,32 +1494,41 @@ export class STLManipulator extends EventEmitter {
           break;
 
         case 'bambustudio':
-          // Bambu Studio CLI: slice and export as 3MF with embedded gcode
+        case 'orcaslicer':
+        case 'orcaslicer-bambulab':
+          // Bambu-compatible CLI: slice and export as 3MF with embedded gcode.
+          // FULU's OrcaSlicer-bambulab fork keeps this Bambu-style path.
           // For 3MF input: slice in place and export sliced 3MF
           // For STL input: slice and export as 3MF
           {
             const is3mf = stlFilePath.toLowerCase().endsWith('.3mf');
             const outputBase = path.basename(stlFilePath, is3mf ? '.3mf' : '.stl');
             const bambuOutputPath = path.join(this.tempDir, outputBase + '_sliced.3mf');
+            const outputDir = path.dirname(bambuOutputPath);
+            const rawBundle = this.resolveBambuLikeSettingsBundle(
+              outputBase,
+              slicerType,
+              slicerProfile,
+              printerPreset,
+              bambuOptions
+            );
+            // Opt-in flatten step: walks the BBL `inherits` chain so the
+            // CLI accepts what we hand it. See maybeFlattenBundle docstring.
+            const settingsBundle =
+              slicerType === 'bambustudio'
+                ? await this.maybeFlattenBundle(rawBundle, bambuOptions, slicerPath)
+                : rawBundle;
             args = [
               '--slice', String(bambuOptions?.slicePlate ?? 0),
-              '--export-3mf', bambuOutputPath,
+              '--outputdir', outputDir,
+              '--export-3mf', path.basename(bambuOutputPath),
             ];
-            if (slicerProfile) {
-              args.push('--load-settings', slicerProfile);
+            if (settingsBundle.settingsArg) {
+              args.push('--load-settings', settingsBundle.settingsArg);
             }
             // Always allow newer-version 3MF files (the CLI rejects them by default)
             args.push('--allow-newer-file');
 
-            // If a printer preset name is given AND no explicit profile was provided,
-            // write a minimal settings JSON containing the printer_settings_id so
-            // BambuStudio resolves the correct machine profile from its built-in presets.
-            if (printerPreset && !slicerProfile) {
-              const presetJson = path.join(this.tempDir, '_printer_preset.json');
-              fs.writeFileSync(presetJson, JSON.stringify({ printer_settings_id: printerPreset }));
-              args.push('--load-settings', presetJson);
-            }
-
             // BambuSliceOptions flags
             if (bambuOptions?.uptodate) args.push('--uptodate');
             if (bambuOptions?.ensureOnBed) args.push('--ensure-on-bed');
@@ -1109,7 +1545,10 @@ export class STLManipulator extends EventEmitter {
             if (bambuOptions?.rotateY !== undefined) args.push('--rotate-y', String(bambuOptions.rotateY));
             if (bambuOptions?.cloneObjects) args.push('--clone-objects', bambuOptions.cloneObjects);
             if (bambuOptions?.skipObjects) args.push('--skip-objects', bambuOptions.skipObjects);
-            if (bambuOptions?.loadFilaments) args.push('--load-filaments', bambuOptions.loadFilaments);
+            if (settingsBundle.filamentPaths.length > 0) {
+              args.push('--load-filaments', settingsBundle.filamentPaths.join(';'));
+              args.push('--load-defaultfila');
+            }
             if (bambuOptions?.loadFilamentIds) args.push('--load-filament-ids', bambuOptions.loadFilamentIds);
 
             args.push(stlFilePath);

package/src/types.ts

@@ -56,3 +56,44 @@ export interface ThreeMFData {
     build: { items: ThreeMFBuildItem[] };
     slicerConfig?: Partial<BambuSlicerConfig>;
 }
+
+export interface CollarCharmRole {
+    role: 'inner' | 'outer';
+    objectIndex: number;
+    name: string;
+    area: number;
+    filamentPosition: number;
+}
+
+export interface CollarCharmAnalysis {
+    plateIndex: number;
+    usedFilamentPositions: number[];
+    amsSlots: number[];
+    roles: CollarCharmRole[];
+}
+
+export interface ThreeMFFilamentRequirement {
+    filamentPosition: number;
+    filamentId: number;
+    tray_info_idx: string | null;
+    type: string | null;
+    color: string | null;
+}
+
+export interface ThreeMFAmsRequirements {
+    plateIndex: number;
+    usedFilamentPositions: number[];
+    filaments: ThreeMFFilamentRequirement[];
+}
+
+export interface ThreeMFPlateObject {
+    id: number;
+    name: string;
+    area: number | null;
+    bbox: unknown;
+}
+
+export interface ThreeMFPlateObjects {
+    plateIndex: number;
+    objects: ThreeMFPlateObject[];
+}