mcp-3d-printer-server 1.2.25 → 1.2.26

package/src/slicer/bambu-cli.ts

@@ -49,6 +49,8 @@ export interface BambuSliceOptions {
   minSave?: boolean;           // --min-save
   skipModifiedGcodes?: boolean;// --skip-modified-gcodes
   slicePlate?: number;         // --slice N (0 = all plates)
+  pauseAtLayers?: number[];    // pause before each 1-based layer, through the slicer's own custom G-code
+  customGcodesFile?: string;   // internal --load-custom-gcodes file, prepared by sliceSTLWithResult
   /** Process keys written over the resolved process preset (layer_height, wall_loops, sparse_infill_density). */
   processOverrides?: Record<string, string>;
 }
@@ -597,6 +599,9 @@ export interface BambuCliInput {
  */
 export function planBambuCliInput(slicerType: BambuCliSlicerType, is3mf: boolean, options: BambuSliceOptions): BambuCliInput {
   const input = { slicerType, is3mf, meshTransformed: false };
+  if (!is3mf && options.repetitions !== undefined && options.cloneObjects) {
+    throw new Error("Use either repetitions or clone_objects for an STL, not both.");
+  }
   if (slicerType === "bambustudio") return input;
   const tilts = !!options.rotateX || !!options.rotateY;
   if (is3mf) {
@@ -608,9 +613,6 @@ export function planBambuCliInput(slicerType: BambuCliSlicerType, is3mf: boolean
     }
     return input;
   }
-  if (options.repetitions !== undefined && options.cloneObjects) {
-    throw new Error("Use either repetitions or clone_objects for an STL with OrcaSlicer, not both.");
-  }
   return { ...input, meshTransformed: options.scale !== undefined || tilts };
 }
 
@@ -689,8 +691,8 @@ export function buildBambuCliArgs(
   if (options.orient !== undefined) args.push("--orient", options.orient ? "1" : "0");
   if (options.arrange !== undefined) args.push("--arrange", options.arrange ? "1" : "0");
   if (options.repetitions !== undefined) {
-    // OrcaSlicer rejects --repetitions for one STL; it copies the loaded model with --clone-objects.
-    if (input.slicerType !== "bambustudio" && !input.is3mf) args.push("--clone-objects", String(options.repetitions));
+    // Both Bambu Studio and OrcaSlicer copy standalone STL objects with --clone-objects.
+    if (!input.is3mf) args.push("--clone-objects", String(options.repetitions));
     else args.push("--repetitions", String(options.repetitions));
   }
   if (!input.meshTransformed) {
@@ -706,6 +708,7 @@ export function buildBambuCliArgs(
     args.push("--load-defaultfila");
   }
   if (options.loadFilamentIds) args.push("--load-filament-ids", options.loadFilamentIds);
+  if (options.customGcodesFile) args.push("--load-custom-gcodes", path.resolve(options.customGcodesFile));
   return args;
 }
 

package/src/slicer/layer-pauses.ts

@@ -0,0 +1,143 @@
+import fs from "node:fs";
+import JSZip from "jszip";
+
+/**
+ * Pause-at-layer for Bambu-compatible slicer CLIs ("Add pause" in Bambu Studio
+ * and OrcaSlicer). The slicer writes the machine's own machine_pause_gcode
+ * (M400 U1 on Bambu printers) before the chosen layer, so the printer pauses
+ * by itself there and waits for Resume; no remote command is involved.
+ *
+ * The CLI takes these as --load-custom-gcodes <json> (CustomGCode::Info). It
+ * does not apply the pauses a project 3MF already carries in
+ * Metadata/custom_gcode_per_print_z.xml, so those are read here and passed the
+ * same way. A pause's print_z must be the exact top of its layer: a height
+ * between layers lands on the layer below.
+ */
+
+/** CustomGCode::Type, in the order bbs_3mf.cpp writes it as an integer. */
+const CUSTOM_GCODE_TYPES = ["ColorChange", "PausePrint", "ToolChange", "Template", "Custom", "Unknown"] as const;
+export type CustomGcodeType = (typeof CUSTOM_GCODE_TYPES)[number];
+
+export interface CustomGcodeItem {
+  type: CustomGcodeType;
+  print_z: number;
+  color: string;
+  extruder: number;
+  extra: string;
+}
+
+export interface CustomGcodeInfo {
+  mode: string;
+  gcodes: CustomGcodeItem[];
+}
+
+/** 1-based layer numbers, as Bambu Studio's and OrcaSlicer's preview slider count them. */
+export function parsePauseLayers(value: unknown): number[] | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  const raw = Array.isArray(value) ? value : String(value).split(/[\s,;]+/).filter(Boolean);
+  const layers = raw.map(entry => Number(entry));
+  for (const layer of layers) {
+    if (!Number.isInteger(layer) || layer < 2) {
+      throw new Error(`pause_at_layers takes whole layer numbers of 2 or more (the printer cannot pause before layer 1), not ${JSON.stringify(value)}.`);
+    }
+  }
+  const unique = [...new Set(layers)].sort((a, b) => a - b);
+  return unique.length ? unique : undefined;
+}
+
+function xmlAttr(tag: string, name: string): string | undefined {
+  const match = new RegExp(`\\b${name}="([^"]*)"`).exec(tag);
+  return match ? match[1].replace(/&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&") : undefined;
+}
+
+/**
+ * The custom G-codes (pauses, colour changes, ...) a project 3MF stores for
+ * one plate (1-based), as Bambu Studio and OrcaSlicer save them.
+ */
+export async function readProjectCustomGcodes(threeMfPath: string, plate = 1): Promise<CustomGcodeInfo | undefined> {
+  let zip: JSZip;
+  try {
+    zip = await JSZip.loadAsync(await fs.promises.readFile(threeMfPath));
+  } catch {
+    return undefined;
+  }
+  const file = zip.file(/^Metadata\/custom_gcode_per_print_z\.xml$/i)[0];
+  if (!file) return undefined;
+  const xml = await file.async("string");
+  for (const block of xml.match(/<plate>[\s\S]*?<\/plate>/g) ?? []) {
+    const info = /<plate_info\b[^>]*>/.exec(block)?.[0];
+    if (Number(info ? xmlAttr(info, "id") : NaN) !== plate) continue;
+    const gcodes: CustomGcodeItem[] = [];
+    for (const tag of block.match(/<layer\b[^>]*>/g) ?? []) {
+      const type = CUSTOM_GCODE_TYPES[Number(xmlAttr(tag, "type"))] ?? "Unknown";
+      const printZ = Number(xmlAttr(tag, "top_z"));
+      if (!Number.isFinite(printZ)) continue;
+      gcodes.push({
+        type,
+        print_z: printZ,
+        color: xmlAttr(tag, "color") ?? "",
+        extruder: Number(xmlAttr(tag, "extruder") ?? 1) || 1,
+        // Template and Custom keep their G-code text in "extra" (CustomGCode.hpp).
+        extra: xmlAttr(tag, "extra") ?? "",
+      });
+    }
+    const modeTag = /<mode\b[^>]*>/.exec(block)?.[0];
+    return { mode: (modeTag && xmlAttr(modeTag, "value")) || "SingleExtruder", gcodes };
+  }
+  return undefined;
+}
+
+/** The plate's G-code text inside a sliced 3MF. */
+export async function readPlateGcode(threeMfPath: string, plate = 1): Promise<string | undefined> {
+  const zip = await JSZip.loadAsync(await fs.promises.readFile(threeMfPath));
+  const exact = zip.file(`Metadata/plate_${plate}.gcode`);
+  const file = exact ?? zip.file(/^Metadata\/plate_\d+\.gcode$/)[0];
+  return file ? file.async("string") : undefined;
+}
+
+/** Each layer's top Z in order, from the slicer's "; Z_HEIGHT:" markers. */
+export function layerTops(gcode: string): number[] {
+  const tops: number[] = [];
+  for (const match of gcode.matchAll(/^; Z_HEIGHT: ([0-9.]+)\s*$/gm)) tops.push(Number(match[1]));
+  return tops;
+}
+
+/**
+ * The 1-based layers whose block holds a pause: the slicer's "; PAUSE_PRINTING"
+ * marker or the machine's pause G-code on its own line.
+ */
+export function pausedLayers(gcode: string, pauseGcode = "M400 U1"): number[] {
+  const lines = gcode.split(/\r?\n/);
+  const paused = new Set<number>();
+  let layer = 0;
+  const pauseLine = pauseGcode.trim();
+  for (const line of lines) {
+    if (line.startsWith("; Z_HEIGHT:")) { layer += 1; continue; }
+    if (layer === 0) continue;
+    const trimmed = line.trim();
+    if (trimmed === "; PAUSE_PRINTING" || (pauseLine && trimmed === pauseLine)) paused.add(layer);
+  }
+  return [...paused].sort((a, b) => a - b);
+}
+
+/** The machine_pause_gcode a sliced file was made with (its config block), else Bambu's M400 U1. */
+export function machinePauseGcode(gcode: string): string {
+  const match = /^; machine_pause_gcode = (.*)$/m.exec(gcode);
+  const value = match?.[1]?.split("\\n")[0]?.trim();
+  return value || "M400 U1";
+}
+
+/** Project custom G-codes plus a pause before each requested layer, at that layer's exact top. */
+export function customGcodesWithPauses(tops: number[], layers: number[], project?: CustomGcodeInfo): CustomGcodeInfo {
+  const total = tops.length;
+  const beyond = layers.filter(layer => layer > total);
+  if (beyond.length) {
+    throw new Error(`This print has ${total} layers, so it cannot pause before layer ${beyond.join(", ")}.`);
+  }
+  const pauses: CustomGcodeItem[] = layers.map(layer => ({ type: "PausePrint", print_z: tops[layer - 1], color: "", extruder: 1, extra: "" }));
+  const kept = (project?.gcodes ?? []).filter(item => !(item.type === "PausePrint" && pauses.some(p => Math.abs(p.print_z - item.print_z) < 1e-4)));
+  return {
+    mode: project?.mode || "SingleExtruder",
+    gcodes: [...kept, ...pauses].sort((a, b) => a.print_z - b.print_z),
+  };
+}

package/src/stl/stl-manipulator.ts

@@ -21,6 +21,7 @@ import {
 } from '../slicer/bambu-cli.js';
 import { runSlicerProcess } from '../slicer/run-slicer.js';
 import { SlicerError, asPreparationError } from '../slicer/slicer-error.js';
+import { customGcodesWithPauses, layerTops, machinePauseGcode, pausedLayers, readPlateGcode, readProjectCustomGcodes } from '../slicer/layer-pauses.js';
 
 export type { BambuSliceOptions } from '../slicer/bambu-cli.js';
 
@@ -1120,6 +1121,50 @@ export class STLManipulator extends EventEmitter {
     filamentProfile?: string,
     bambuOptions?: BambuSliceOptions,
     processOverrides?: ProcessOverrides
+  ): Promise<SliceOutput> {
+    const once = (options?: BambuSliceOptions) => this.sliceSTLOnce(stlFilePath, slicerType, slicerPath,
+      slicerProfile, progressCallback, printerPreset, filamentProfile, options, processOverrides);
+    const layers = bambuOptions?.pauseAtLayers?.length ? bambuOptions.pauseAtLayers : undefined;
+    const cli = STLManipulator.usesBambuCliPreparation(slicerType, printerPreset);
+    const plate = bambuOptions?.slicePlate && bambuOptions.slicePlate > 0 ? bambuOptions.slicePlate : 1;
+    const project = cli && /\.3mf$/i.test(stlFilePath) ? await readProjectCustomGcodes(stlFilePath, plate) : undefined;
+    if (!layers && !project?.gcodes.length) return once(bambuOptions);
+    if (layers && !cli) throw new Error(`Pausing at a layer needs the Bambu Studio or OrcaSlicer CLI, not ${slicerType}.`);
+    const customGcodesFile = path.join(this.tempDir, `custom-gcodes-${crypto.randomUUID()}.json`);
+    try {
+      let tops: number[] = [];
+      if (layers) {
+        if (progressCallback) progressCallback(10, `Finding layer heights for the pause before layer ${layers.join(", ")}`);
+        const plain = await once({ ...bambuOptions, pauseAtLayers: undefined, customGcodesFile: undefined });
+        const gcode = await readPlateGcode(plain.path, plate);
+        if (!gcode) throw new Error('The slicer wrote no plate G-code, so the pause layers cannot be placed.');
+        tops = layerTops(gcode);
+      }
+      const info = layers ? customGcodesWithPauses(tops, layers, project) : project!;
+      await fs.promises.writeFile(customGcodesFile, JSON.stringify(info));
+      const result = await once({ ...bambuOptions, customGcodesFile });
+      if (layers) {
+        const gcode = await readPlateGcode(result.path, plate);
+        const placed = gcode ? pausedLayers(gcode, machinePauseGcode(gcode)) : [];
+        const missing = layers.filter(layer => !placed.includes(layer));
+        if (!gcode || missing.length || layerTops(gcode).length !== tops.length) {
+          throw new Error(`The slicer did not place the pause before layer ${(missing.length ? missing : layers).join(", ")}. Nothing was sent to the printer.`);
+        }
+      }
+      return result;
+    } finally { await fs.promises.rm(customGcodesFile, { force: true }); }
+  }
+
+  private async sliceSTLOnce(
+    stlFilePath: string,
+    slicerType: SlicerType,
+    slicerPath: string,
+    slicerProfile?: string,
+    progressCallback?: ProgressCallback,
+    printerPreset?: string,
+    filamentProfile?: string,
+    bambuOptions?: BambuSliceOptions,
+    processOverrides?: ProcessOverrides
   ): Promise<SliceOutput> {
     const operationId = this.generateOperationId();
     this.activeOperations.set(operationId, true);

package/src/studio-print-options.ts

@@ -0,0 +1,201 @@
+/**
+ * The print options Bambu Studio's Send dialog sends, resolved the way it
+ * resolves them, so every print route sends what Bambu's own Print button
+ * would. Source: Bambu Studio v02.08.02.61 (commit 926a7192574b), the version
+ * the hidden-HMS and stage tables are pinned to:
+ *
+ * - SelectMachine.cpp:3344-3356 `set_print_config(bed_type,
+ *   bed_leveling == "on", flow_cali == "on", false, timelapse, true,
+ *   ext_change_assist, bed_leveling.getValueInt(), flow_cali.getValueInt(),
+ *   nozzle_offset_cali.getValueInt(), pa_value_switch ? 0 : 1)`. Vibration
+ *   calibration is always false and layer inspection always true; the
+ *   parameter order is PrintJob.hpp:98-116.
+ * - SelectMachine.cpp:7318-7329 `getValueInt`: off 0, on 1, auto 2.
+ * - SelectMachine.cpp:1117-1123 `update_select_layout`: update_option_opts
+ *   (which choices each option offers on this printer) runs before
+ *   load_option_vals.
+ * - SelectMachine.cpp:2993-3027 `load_option_vals`: the value saved in
+ *   BambuStudio.conf under the printer type, if the option offers it; else
+ *   "auto" if offered; else "on". Dual-nozzle printers then set nozzle offset
+ *   calibration to "auto" for a two-nozzle job and, without a filament
+ *   switcher, "off" for a one-nozzle job.
+ * - SelectMachine.cpp:2586-2615 `update_option_opts`: bed leveling offers
+ *   auto/on/off when the printer's support_bed_leveling is 2 and on/off when it
+ *   is 1; with 0 it is hidden and keeps the auto/on/off it was built with
+ *   (SelectMachine.cpp:676-691), as does flow calibration when the printer has
+ *   no PA calibration. DeviceManager.cpp:1100/4441 give P-series printers
+ *   (series_p1p: P1P, P1S) no PA calibration, so their flow calibration is
+ *   hidden and resolves to "auto". Nozzle offset calibration always offers auto.
+ * - SelectMachine.cpp:705-707: the PA value switch starts on and is not saved,
+ *   so extruder_cali_manual_mode is 0.
+ *
+ * Approximations, outside the P1P/P1S: flow calibration on other printers is
+ * shown when the printer's push status reports PA calibration (assumed here),
+ * and offers auto when support_auto_flow_calibration is true and the mapped
+ * filaments allow it (can_support_pa_auto_cali, assumed true). A filament
+ * switcher on a dual-nozzle printer is assumed absent.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export type StudioOptionValue = "off" | "on" | "auto";
+type Offers = readonly StudioOptionValue[];
+const AUTO_ON_OFF: Offers = ["auto", "on", "off"];
+const ON_OFF: Offers = ["on", "off"];
+
+/**
+ * Studio's printer types (resources/printers/<type>.json at the pinned commit:
+ * model_id/printer_type, printer_series, support_bed_leveling,
+ * support_auto_flow_calibration), keyed by this server's model names.
+ */
+const STUDIO_PRINTERS: Record<string, { types: string[]; pSeries: boolean; bedLeveling: 0 | 1 | 2; autoFlow: boolean; dualNozzle: boolean }> = {
+  p1p: { types: ["C11"], pSeries: true, bedLeveling: 1, autoFlow: false, dualNozzle: false },
+  p1s: { types: ["C12"], pSeries: true, bedLeveling: 1, autoFlow: false, dualNozzle: false },
+  x1c: { types: ["3DPrinter-X1-Carbon"], pSeries: false, bedLeveling: 1, autoFlow: false, dualNozzle: false },
+  x1: { types: ["3DPrinter-X1"], pSeries: false, bedLeveling: 1, autoFlow: false, dualNozzle: false },
+  x1e: { types: ["C13"], pSeries: false, bedLeveling: 1, autoFlow: false, dualNozzle: false },
+  a1mini: { types: ["N1"], pSeries: false, bedLeveling: 1, autoFlow: false, dualNozzle: false },
+  a1: { types: ["N2S"], pSeries: false, bedLeveling: 1, autoFlow: false, dualNozzle: false },
+  p2s: { types: ["N7"], pSeries: false, bedLeveling: 2, autoFlow: true, dualNozzle: false },
+  x2d: { types: ["N6"], pSeries: false, bedLeveling: 2, autoFlow: true, dualNozzle: true },
+  h2s: { types: ["O1S"], pSeries: false, bedLeveling: 2, autoFlow: true, dualNozzle: false },
+  h2d: { types: ["O1D"], pSeries: false, bedLeveling: 2, autoFlow: true, dualNozzle: true },
+  h2dpro: { types: ["O1E"], pSeries: false, bedLeveling: 2, autoFlow: true, dualNozzle: true },
+  h2c: { types: ["O1C", "O1C2"], pSeries: false, bedLeveling: 2, autoFlow: true, dualNozzle: true },
+};
+
+export type StudioOptionSource = "caller" | "studio-config" | "studio-default";
+
+/** Explicit caller choices; each one wins over Studio's resolution. */
+export type CallerPrintOptions = {
+  bedLeveling?: boolean;
+  flowCalibration?: boolean;
+  vibrationCalibration?: boolean;
+  layerInspect?: boolean;
+  /** 0 off, 1 on, 2 auto, as Studio's getValueInt. */
+  autoBedLeveling?: number;
+  autoFlowCali?: number;
+  autoOffsetCali?: number;
+  extruderCaliManualMode?: number;
+};
+
+export type StudioPrintOptions = {
+  printerType?: string;
+  values: { bed_leveling: StudioOptionValue; flow_cali: StudioOptionValue; nozzle_offset_cali: StudioOptionValue };
+  sources: { bed_leveling: StudioOptionSource; flow_cali: StudioOptionSource; nozzle_offset_cali: StudioOptionSource };
+  task_bed_leveling: boolean;
+  task_flow_cali: boolean;
+  task_vibration_cali: boolean;
+  task_layer_inspect: boolean;
+  auto_bed_leveling: number;
+  auto_flow_cali: number;
+  auto_offset_cali: number;
+  extruder_cali_manual_mode: number;
+};
+
+/** Where Studio keeps BambuStudio.conf; BAMBU_STUDIO_CONFIG overrides it (empty: none). */
+export function studioConfigPath(): string | undefined {
+  const override = process.env.BAMBU_STUDIO_CONFIG;
+  if (override !== undefined) return override.trim() || undefined;
+  if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Application Support", "BambuStudio", "BambuStudio.conf");
+  if (process.platform === "win32") return process.env.APPDATA ? path.join(process.env.APPDATA, "BambuStudio", "BambuStudio.conf") : undefined;
+  return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "BambuStudio", "BambuStudio.conf");
+}
+
+/**
+ * The Send dialog options Studio saved for a printer type, and nothing else:
+ * BambuStudio.conf also holds access codes, so only that one section is kept,
+ * and a parse failure is reported without any of the file's text.
+ */
+export function readStudioSavedOptions(printerTypes: string[], configPath: string | undefined): Record<string, string> | undefined {
+  if (!configPath) return undefined;
+  let text: string;
+  try {
+    const stat = fs.statSync(configPath);
+    if (!stat.isFile() || stat.size > 16 * 1024 * 1024) return undefined;
+    text = fs.readFileSync(configPath, "utf8");
+  } catch { return undefined; }
+  let config: unknown;
+  // Studio appends "# MD5 checksum <hex>" after the JSON.
+  try { config = JSON.parse(text.split("\n").filter(line => !line.trimStart().startsWith("#")).join("\n")); }
+  catch { return undefined; }
+  if (!config || typeof config !== "object") return undefined;
+  for (const type of printerTypes) {
+    const section = (config as Record<string, unknown>)[type];
+    if (!section || typeof section !== "object" || Array.isArray(section)) continue;
+    const saved: Record<string, string> = {};
+    for (const key of ["bed_leveling", "flow_cali", "nozzle_offset_cali", "timelapse"]) {
+      const value = (section as Record<string, unknown>)[key];
+      if (typeof value === "string") saved[key] = value;
+    }
+    return saved;
+  }
+  return undefined;
+}
+
+function fromInt(value: number, label: string): StudioOptionValue {
+  if (value === 0) return "off";
+  if (value === 1) return "on";
+  if (value === 2) return "auto";
+  throw new Error(`${label} must be 0 (off), 1 (on) or 2 (auto).`);
+}
+
+const toInt = (value: StudioOptionValue) => value === "off" ? 0 : value === "on" ? 1 : 2;
+
+/** load_option_vals for one option: saved if offered, else auto if offered, else on. */
+function loaded(saved: string | undefined, offers: Offers): { value: StudioOptionValue; source: StudioOptionSource } {
+  if (saved !== undefined && (offers as readonly string[]).includes(saved)) return { value: saved as StudioOptionValue, source: "studio-config" };
+  return { value: offers.includes("auto") ? "auto" : "on", source: "studio-default" };
+}
+
+/**
+ * What Studio's Send dialog would send for this model, with the caller's
+ * explicit choices taking precedence. usedNozzles is the number of nozzles the
+ * job uses, for dual-nozzle printers.
+ */
+export function resolveStudioPrintOptions(model: string, caller: CallerPrintOptions = {}, options: { usedNozzles?: number; configPath?: string } = {}): StudioPrintOptions {
+  const printer = STUDIO_PRINTERS[model];
+  const saved = printer ? readStudioSavedOptions(printer.types, "configPath" in options ? options.configPath : studioConfigPath()) ?? {} : {};
+  const printerType = printer?.types[0];
+
+  const bedOffers = !printer || printer.bedLeveling !== 1 ? AUTO_ON_OFF : ON_OFF;
+  const flowOffers = !printer || printer.pSeries || printer.autoFlow ? AUTO_ON_OFF : ON_OFF;
+  const bed = loaded(saved.bed_leveling, bedOffers);
+  const flow = loaded(saved.flow_cali, flowOffers);
+  let offset = loaded(saved.nozzle_offset_cali, AUTO_ON_OFF);
+  if (printer?.dualNozzle && options.usedNozzles !== undefined) {
+    if (options.usedNozzles >= 2) offset = { value: "auto", source: "studio-default" };
+    else if (options.usedNozzles === 1) offset = { value: "off", source: "studio-default" };
+  }
+
+  const choose = (current: { value: StudioOptionValue; source: StudioOptionSource }, auto: number | undefined, flag: boolean | undefined, label: string) =>
+    auto !== undefined ? { value: fromInt(auto, label), source: "caller" as const }
+      : flag !== undefined ? { value: flag ? "on" as const : "off" as const, source: "caller" as const }
+        : current;
+  const bedLeveling = choose(bed, caller.autoBedLeveling, caller.bedLeveling, "auto_bed_leveling");
+  const flowCali = choose(flow, caller.autoFlowCali, caller.flowCalibration, "auto_flow_cali");
+  const nozzleOffset = choose(offset, caller.autoOffsetCali, undefined, "auto_offset_cali");
+  const manualMode = caller.extruderCaliManualMode ?? 0;
+  if (!Number.isInteger(manualMode) || manualMode < -1 || manualMode > 1) throw new Error("extruder_cali_manual_mode must be -1, 0 or 1.");
+
+  return {
+    ...(printerType ? { printerType } : {}),
+    values: { bed_leveling: bedLeveling.value, flow_cali: flowCali.value, nozzle_offset_cali: nozzleOffset.value },
+    sources: { bed_leveling: bedLeveling.source, flow_cali: flowCali.source, nozzle_offset_cali: nozzleOffset.source },
+    task_bed_leveling: bedLeveling.value === "on",
+    task_flow_cali: flowCali.value === "on",
+    task_vibration_cali: caller.vibrationCalibration ?? false,
+    task_layer_inspect: caller.layerInspect ?? true,
+    auto_bed_leveling: toInt(bedLeveling.value),
+    auto_flow_cali: toInt(flowCali.value),
+    auto_offset_cali: toInt(nozzleOffset.value),
+    extruder_cali_manual_mode: manualMode,
+  };
+}
+
+/** The number of nozzles a job's used filaments print from, when the inspection knows. */
+export function usedNozzleCount(inspection: { usedFilamentPositions: number[]; filamentNozzleIndices?: Array<number | undefined> }): number | undefined {
+  const nozzles = inspection.usedFilamentPositions.map(position => inspection.filamentNozzleIndices?.[position]).filter((value): value is number => Number.isInteger(value));
+  return nozzles.length === inspection.usedFilamentPositions.length && nozzles.length ? new Set(nozzles).size : undefined;
+}