mcp-3d-printer-server 1.2.24 → 1.2.26

package/dist/printers/creality.d.ts

@@ -1,5 +1,5 @@
 import type { AxiosInstance } from "axios";
-import { GenericPrinterImplementation, type GenericPrinterState, type SnapshotCandidate } from "./generic-base.js";
+import { GenericPrinterImplementation, type GenericPrinterState, type SnapshotCandidate, type CameraCandidate } from "./generic-base.js";
 import type { ConfirmHardware } from "../safety/confirmation.js";
 import type { CounterpartProgress, FilamentSlot, PrinterIdentity } from "../counterpart/contract.js";
 /**
@@ -27,6 +27,7 @@ export declare class CrealityImplementation extends GenericPrinterImplementation
     reportsLayers(host: string): Promise<boolean>;
     supportsPauseResume(host: string): Promise<boolean>;
     snapshotCandidates(host: string): Promise<SnapshotCandidate[]>;
+    cameraCandidates(host: string): Promise<CameraCandidate[]>;
     counterpartFilaments(host: string, port: string, apiKey: string): Promise<FilamentSlot[]>;
     counterpartIdentity(host: string): Promise<PrinterIdentity>;
     /** Pause and resume only through a detected Moonraker; the device API has no verified route. */

package/dist/printers/creality.js

@@ -65,6 +65,10 @@ export class CrealityImplementation extends GenericPrinterImplementation {
         const moonraker = await this.moonrakerPort(host);
         return moonraker ? this.moonraker.snapshotCandidates(host, moonraker, "") : [];
     }
+    async cameraCandidates(host) {
+        const moonraker = await this.moonrakerPort(host);
+        return moonraker ? this.moonraker.cameraCandidates(host, moonraker, "") : [];
+    }
     async counterpartFilaments(host, port, apiKey) {
         const moonraker = await this.moonrakerPort(host);
         return moonraker ? this.moonraker.counterpartFilaments(host, moonraker, "") : super.counterpartFilaments(host, port, apiKey);
@@ -104,7 +108,7 @@ export class CrealityImplementation extends GenericPrinterImplementation {
         if (IDLE_STATES.has(state))
             return { state, ready: true };
         if (FINISHED_STATES.has(state))
-            return { state, ready: true, finishedJob: JSON.stringify([state]) };
+            return { state, ready: true };
         return { state, ready: false, reason: `state is ${state}` };
     }
     async getStatus(host, port, apiKey) {

package/dist/printers/generic-base.d.ts

@@ -11,6 +11,12 @@ export interface SnapshotCandidate {
     /** True when the firmware's own settings name this URL; false for a conventional fallback. */
     configured: boolean;
 }
+export interface CameraCandidate extends SnapshotCandidate {
+    transport: "http-mjpeg" | "http-snapshot";
+    /** Snapshot belonging to this same camera, never an unrelated later candidate. */
+    snapshotUrl?: string;
+    unsupportedStream?: boolean;
+}
 /** Normalized adapter state used by the print and heating preflight. */
 export interface GenericPrinterState {
     /** Adapter-reported state text. */
@@ -19,8 +25,6 @@ export interface GenericPrinterState {
     ready: boolean;
     /** Why the printer is not ready. */
     reason?: string;
-    /** Set when the printer explicitly reports a finished or cancelled job that may still be on the bed. */
-    finishedJob?: string;
 }
 export interface HeaterComponent {
     heater: Heater;
@@ -49,6 +53,8 @@ export declare abstract class GenericPrinterImplementation extends PrinterImplem
     counterpartIdentity(_host: string, _port: string, _apiKey: string): Promise<PrinterIdentity>;
     /** Snapshot URLs from the firmware's own settings, in preference order. */
     snapshotCandidates(_host: string, _port: string, _apiKey: string): Promise<SnapshotCandidate[]>;
+    /** Existing snapshot discovery is the fallback for cameras without an MJPEG URL. */
+    cameraCandidates(host: string, port: string, apiKey: string): Promise<CameraCandidate[]>;
     /** The single extruder slot; adapters with a spool manager override this. */
     counterpartFilaments(_host: string, _port: string, _apiKey: string): Promise<FilamentSlot[]>;
     /** Whether progress reports carry layer numbers on this firmware. */
@@ -66,9 +72,9 @@ export declare abstract class GenericPrinterImplementation extends PrinterImplem
      * Resume reheats and moves the printer, so it is gated like a print start:
      * only the job this server instance inspected and started, only while the
      * printer freshly reports that job paused, with its bytes re-read and
-     * compared where the firmware can download them, and after human
-     * confirmation (unless the server opted out). A stop or heater-off request
-     * in the meantime cancels it.
+     * compared where the firmware can download them. Only when the bytes cannot
+     * be re-read does a person confirm (MCP elicitation). A stop or heater-off
+     * request in the meantime cancels it.
      */
     resumeJob(host: string, port: string, apiKey: string): Promise<{
         status: string;
@@ -110,5 +116,4 @@ export declare abstract class GenericPrinterImplementation extends PrinterImplem
     private withNamedSnapshot;
     private assertReady;
     private printChecked;
-    private printPrompt;
 }

package/dist/printers/generic-base.js

@@ -47,6 +47,10 @@ export class GenericPrinterImplementation extends PrinterImplementation {
     async snapshotCandidates(_host, _port, _apiKey) {
         return [];
     }
+    /** Existing snapshot discovery is the fallback for cameras without an MJPEG URL. */
+    async cameraCandidates(host, port, apiKey) {
+        return (await this.snapshotCandidates(host, port, apiKey)).map(candidate => ({ ...candidate, transport: "http-snapshot" }));
+    }
     /** The single extruder slot; adapters with a spool manager override this. */
     async counterpartFilaments(_host, _port, _apiKey) {
         return [{ id: "ext", source: "unknown" }];
@@ -70,9 +74,9 @@ export class GenericPrinterImplementation extends PrinterImplementation {
      * Resume reheats and moves the printer, so it is gated like a print start:
      * only the job this server instance inspected and started, only while the
      * printer freshly reports that job paused, with its bytes re-read and
-     * compared where the firmware can download them, and after human
-     * confirmation (unless the server opted out). A stop or heater-off request
-     * in the meantime cancels it.
+     * compared where the firmware can download them. Only when the bytes cannot
+     * be re-read does a person confirm (MCP elicitation). A stop or heater-off
+     * request in the meantime cancels it.
      */
     async resumeJob(host, port, apiKey) {
         if (!(await this.supportsPauseResume(host, port, apiKey)) || !this.rawResumeJob) {
@@ -98,17 +102,20 @@ export class GenericPrinterImplementation extends PrinterImplementation {
                 bytesVerified = true;
             }
             assertActive();
-            await requireHumanConfirmation(this.confirm, `Resume ${checked.name} on ${this.printerLabel} (${host}:${port})? It reheats to its targets (peak nozzle ${checked.peaks.nozzle}°C, ` +
-                `bed ${checked.peaks.bed}°C, chamber ${checked.peaks.chamber}°C) and moves. Materials: ${checked.materials.length ? checked.materials.join(", ") : "none declared"}. ` +
-                `File SHA-256: ${checked.sha256}${bytesVerified ? " (re-read from the printer)" : " (this firmware cannot re-read the file; matched by name)"}. ` +
-                "Confirm the nozzle path is clear and the filament is still loaded.", "generic");
-            assertActive();
-            // Someone may have resumed or stopped it at the printer while the prompt was open.
+            if (!bytesVerified) {
+                // This firmware cannot hand the file back, so only a person can tell it is still the inspected job.
+                await requireHumanConfirmation(this.confirm, `Resume ${checked.name} on ${this.printerLabel} (${host}:${port})? This firmware cannot re-read the file, so it is matched by name only. ` +
+                    `It reheats to its targets (peak nozzle ${checked.peaks.nozzle}°C, bed ${checked.peaks.bed}°C, chamber ${checked.peaks.chamber}°C) and moves. ` +
+                    `Materials: ${checked.materials.length ? checked.materials.join(", ") : "none declared"}. Inspected file SHA-256: ${checked.sha256}. ` +
+                    "Confirm the paused job is that file, the nozzle path is clear and the filament is still loaded.");
+                assertActive();
+            }
+            // Someone may have resumed or stopped it at the printer meanwhile (for example while a prompt was open).
             await this.assertPausedJob(host, port, apiKey, checked.name);
-            // A progress read during the prompt may have retired this record (the job ended, and a new one
-            // could now be paused under the same name); only the record that was confirmed may be resumed.
+            // A progress read meanwhile may have retired this record (the job ended, and a new one
+            // could now be paused under the same name); only the record that was checked may be resumed.
             if (this.checkedJobs.get(key) !== checked) {
-                throw new Error(`Print safety: ${checked.name} ended on ${this.printerLabel} while the confirmation was open; nothing was sent.`);
+                throw new Error(`Print safety: ${checked.name} ended on ${this.printerLabel} during the resume checks; nothing was sent.`);
             }
             assertActive();
             await this.rawResumeJob(host, port, apiKey);
@@ -186,8 +193,6 @@ export class GenericPrinterImplementation extends PrinterImplementation {
         validateGenericTemperature(target.heater, value, material ? [material] : undefined);
         return withPrinterOperation(host, key, async (assertActive) => {
             this.assertReady(await this.readPrinterState(host, port, apiKey), "heat");
-            await requireHumanConfirmation(this.confirm, `Heat ${target.heater} on ${this.printerLabel} (${host}:${port}) to ${value}°C?` +
-                (material && target.heater === "nozzle" ? ` Declared material: ${material}. Confirm the loaded filament matches.` : ""), "generic");
             assertActive();
             this.assertReady(await this.readPrinterState(host, port, apiKey), "heat");
             assertActive();
@@ -275,10 +280,9 @@ export class GenericPrinterImplementation extends PrinterImplementation {
         assertExpectedPeaks(options.expectedPeaks, { nozzle: inspection.peaks.nozzle, bed: inspection.peaks.bed });
         const initial = await this.readPrinterState(host, port, apiKey);
         this.assertReady(initial, "print");
-        await requireHumanConfirmation(this.confirm, this.printPrompt(host, port, remoteName, inspection, initial), "generic");
         assertActive();
-        const confirmed = await this.readPrinterState(host, port, apiKey);
-        this.assertReady(confirmed, "print");
+        const rechecked = await this.readPrinterState(host, port, apiKey);
+        this.assertReady(rechecked, "print");
         assertActive();
         const summary = {
             status: "success",
@@ -318,12 +322,4 @@ export class GenericPrinterImplementation extends PrinterImplementation {
         this.checkedJobs.set(this.operationKey(host, port), checkedJob(remoteName, inspection));
         return { ...summary, upload, response };
     }
-    printPrompt(host, port, remoteName, inspection, state) {
-        const materials = inspection.materials.length ? inspection.materials.join(", ") : "none declared (no positive nozzle target)";
-        return (`Start a checked print of ${remoteName} on ${this.printerLabel} (${host}:${port})? ` +
-            `Materials: ${materials} (${inspection.materialSource}). Peak targets: nozzle ${inspection.peaks.nozzle}°C, bed ${inspection.peaks.bed}°C, chamber ${inspection.peaks.chamber}°C ` +
-            `(server ceilings ${inspection.ceilings.nozzle}/${inspection.ceilings.bed}/${inspection.ceilings.chamber}°C). File SHA-256: ${inspection.sha256}. ` +
-            "Confirm the loaded filament matches." +
-            "");
-    }
 }

package/dist/printers/klipper.d.ts

@@ -1,4 +1,4 @@
-import { GenericPrinterImplementation, type GenericPrinterState, type SnapshotCandidate } from "./generic-base.js";
+import { GenericPrinterImplementation, type GenericPrinterState, type SnapshotCandidate, type CameraCandidate } from "./generic-base.js";
 import type { CounterpartProgress, FilamentSlot, PrinterIdentity } from "../counterpart/contract.js";
 export declare const MACRO_TIMEOUT_MS = 60000;
 export declare class KlipperImplementation extends GenericPrinterImplementation {
@@ -18,6 +18,7 @@ export declare class KlipperImplementation extends GenericPrinterImplementation
      * path relative to the host. https://moonraker.readthedocs.io/en/latest/external_api/webcams/
      */
     snapshotCandidates(host: string, port: string, apiKey: string): Promise<SnapshotCandidate[]>;
+    cameraCandidates(host: string, port: string, apiKey: string): Promise<CameraCandidate[]>;
     /**
      * Spoolman through Moonraker: GET /server/spoolman/spool_id, then the proxy
      * for /v1/spool/<id>. https://moonraker.readthedocs.io/en/latest/external_api/integrations/

package/dist/printers/klipper.js

@@ -62,11 +62,18 @@ export class KlipperImplementation extends GenericPrinterImplementation {
      * path relative to the host. https://moonraker.readthedocs.io/en/latest/external_api/webcams/
      */
     async snapshotCandidates(host, port, apiKey) {
+        return (await this.cameraCandidates(host, port, apiKey)).filter(candidate => candidate.transport === "http-snapshot");
+    }
+    async cameraCandidates(host, port, apiKey) {
         const data = (await this.apiClient.get(`http://${host}:${port}/server/webcams/list`, this.authHeaders(apiKey))).data;
         const webcams = Array.isArray(data?.result?.webcams) ? data.result.webcams : [];
         return webcams
-            .filter((webcam) => webcam?.enabled !== false && nonEmptyText(webcam?.snapshot_url))
-            .map((webcam) => ({ url: String(webcam.snapshot_url).trim(), source: "moonraker-webcam", configured: true }));
+            .filter((webcam) => webcam?.enabled !== false)
+            .flatMap((webcam) => [
+            ...(nonEmptyText(webcam?.stream_url)
+                ? [{ url: String(webcam.stream_url).trim(), snapshotUrl: nonEmptyText(webcam?.snapshot_url), unsupportedStream: /webrtc|hls/i.test(String(webcam?.service ?? "")), transport: "http-mjpeg" }] : []),
+            ...(nonEmptyText(webcam?.snapshot_url) ? [{ url: String(webcam.snapshot_url).trim(), transport: "http-snapshot" }] : []),
+        ].map(candidate => ({ ...candidate, source: "moonraker-webcam", configured: true })));
     }
     /**
      * Spoolman through Moonraker: GET /server/spoolman/spool_id, then the proxy
@@ -159,11 +166,7 @@ export class KlipperImplementation extends GenericPrinterImplementation {
         if (!["standby", "complete", "cancelled"].includes(job)) {
             return { state, ready: false, reason: `print_stats.state is ${job}` };
         }
-        return {
-            state,
-            ready: true,
-            finishedJob: job === "standby" ? undefined : JSON.stringify([job, status?.print_stats?.filename ?? null]),
-        };
+        return { state, ready: true };
     }
     async downloadRemoteFile(host, port, apiKey, filename, destination) {
         await this.downloadToFile(`http://${host}:${port}/server/files/gcodes/${encodePath(filename)}`, apiKey ? { "X-Api-Key": apiKey } : {}, destination);

package/dist/printers/octoprint.d.ts

@@ -1,4 +1,4 @@
-import { GenericPrinterImplementation, type GenericPrinterState, type HeaterComponent, type SnapshotCandidate } from "./generic-base.js";
+import { GenericPrinterImplementation, type GenericPrinterState, type HeaterComponent, type SnapshotCandidate, type CameraCandidate } from "./generic-base.js";
 import type { CounterpartProgress, PrinterIdentity } from "../counterpart/contract.js";
 export declare class OctoPrintImplementation extends GenericPrinterImplementation {
     protected readonly printerLabel = "OctoPrint";
@@ -19,6 +19,7 @@ export declare class OctoPrintImplementation extends GenericPrinterImplementatio
      * src/octoprint/plugins/classicwebcam/__init__.py; checked on 1.8.7 and 1.11.2.
      */
     snapshotCandidates(host: string, port: string, apiKey: string): Promise<SnapshotCandidate[]>;
+    cameraCandidates(host: string, port: string, apiKey: string): Promise<CameraCandidate[]>;
     counterpartIdentity(host: string, port: string, apiKey: string): Promise<PrinterIdentity>;
     /** POST /api/job {command:"pause", action:"pause"|"resume"}; 204 on success, 409 without an active job. */
     protected rawPauseJob(host: string, port: string, apiKey: string): Promise<any>;

package/dist/printers/octoprint.js

@@ -54,21 +54,28 @@ export class OctoPrintImplementation extends GenericPrinterImplementation {
      * src/octoprint/plugins/classicwebcam/__init__.py; checked on 1.8.7 and 1.11.2.
      */
     async snapshotCandidates(host, port, apiKey) {
+        return (await this.cameraCandidates(host, port, apiKey)).filter(candidate => candidate.transport === "http-snapshot");
+    }
+    async cameraCandidates(host, port, apiKey) {
         const settings = (await this.apiClient.get(`http://${host}:${port}/api/settings`, { headers: { "X-Api-Key": apiKey } })).data;
         const candidates = [];
         if (settings?.webcam?.webcamEnabled !== false) {
+            // The settings API maps webcam.stream to streamUrl. Classic Webcam on
+            // 1.9+ exposes its own stream field; only configured URLs are used.
             const configured = [
-                settings?.plugins?.classicwebcam?.snapshot,
-                settings?.webcam?.snapshotUrl,
-                ...(Array.isArray(settings?.webcam?.webcams) ? settings.webcam.webcams.map((webcam) => webcam?.compat?.snapshot) : []),
+                settings?.plugins?.classicwebcam,
+                { stream: settings?.webcam?.streamUrl, snapshot: settings?.webcam?.snapshotUrl },
+                ...(Array.isArray(settings?.webcam?.webcams) ? settings.webcam.webcams.map((webcam) => webcam?.compat) : []),
             ];
-            for (const url of configured) {
-                const text = nonEmptyText(url);
-                if (text)
-                    candidates.push({ url: text, source: "octoprint-settings", configured: true });
+            for (const camera of configured) {
+                const stream = nonEmptyText(camera?.stream), snapshot = nonEmptyText(camera?.snapshot);
+                if (stream)
+                    candidates.push({ url: stream, snapshotUrl: snapshot, source: "octoprint-settings", configured: true, transport: "http-mjpeg" });
+                if (snapshot)
+                    candidates.push({ url: snapshot, source: "octoprint-settings", configured: true, transport: "http-snapshot" });
             }
         }
-        candidates.push({ url: `http://${host}/webcam/?action=snapshot`, source: "octoprint-fallback", configured: false });
+        candidates.push({ url: `http://${host}/webcam/?action=snapshot`, source: "octoprint-fallback", configured: false, transport: "http-snapshot" });
         return candidates;
     }
     async counterpartIdentity(host, port, apiKey) {

package/dist/printers/printer-factory.d.ts

@@ -10,7 +10,7 @@ export type GuardedPrinterImplementation = PrinterImplementation & {
 export declare class PrinterFactory {
     private implementations;
     private apiClient;
-    /** confirm is the human (MCP elicitation) confirmation used before prints and positive heating. */
+    /** confirm is the human (MCP elicitation) confirmation for physical checks software cannot make, such as resuming a job that cannot be re-read. */
     constructor(confirm?: ConfirmHardware);
     getImplementation(type: string): GuardedPrinterImplementation;
     disconnectAll(): Promise<void>;

package/dist/printers/printer-factory.js

@@ -2,12 +2,12 @@ import { OctoPrintImplementation } from "./octoprint.js";
 import { KlipperImplementation } from "./klipper.js";
 import { DuetImplementation } from "./duet.js";
 import { RepetierImplementation } from "./repetier.js";
-import { BambuImplementation } from "./bambu.js";
+import { BambuImplementation, defaultResumeStateDir } from "./bambu.js";
 import { PrusaImplementation } from "./prusa.js";
 import { CrealityImplementation } from "./creality.js";
 import axios from "axios";
 export class PrinterFactory {
-    /** confirm is the human (MCP elicitation) confirmation used before prints and positive heating. */
+    /** confirm is the human (MCP elicitation) confirmation for physical checks software cannot make, such as resuming a job that cannot be re-read. */
     constructor(confirm) {
         this.implementations = new Map();
         this.apiClient = axios.create({ timeout: 10000 });
@@ -15,7 +15,7 @@ export class PrinterFactory {
         this.implementations.set("klipper", new KlipperImplementation(this.apiClient, confirm));
         this.implementations.set("duet", new DuetImplementation(this.apiClient, confirm));
         this.implementations.set("repetier", new RepetierImplementation(this.apiClient, confirm));
-        this.implementations.set("bambu", new BambuImplementation(this.apiClient, confirm));
+        this.implementations.set("bambu", new BambuImplementation(this.apiClient, confirm, { resumeStateDir: defaultResumeStateDir() }));
         this.implementations.set("prusa", new PrusaImplementation(this.apiClient, confirm));
         this.implementations.set("creality", new CrealityImplementation(this.apiClient, confirm));
     }

package/dist/printers/prusa.js

@@ -201,7 +201,6 @@ export class PrusaImplementation extends GenericPrinterImplementation {
                 state,
                 ready,
                 reason: ready ? undefined : `printer.state is ${state}`,
-                finishedJob: ready && (state === "FINISHED" || state === "STOPPED") ? JSON.stringify([state, data?.job?.id ?? null]) : undefined,
             };
         }
         const flags = data?.state?.flags;

package/dist/safety/confirmation.d.ts

@@ -1,22 +1,17 @@
-/** Human confirmation for physical printer mutations (print start, positive heating). */
-export type ConfirmHardware = (message: string) => Promise<boolean>;
-export type ConfirmationScope = "bambu" | "generic";
 /**
- * Ordinary print/heat prompts are on by default. Only an explicit "0" opts out.
- * PRINT_REQUIRE_CONFIRMATION applies to every printer type; the older
- * BAMBU_REQUIRE_CONFIRMATION applies to Bambu printers only. If any variable
- * relevant to the scope is set to another value, confirmation stays required.
+ * Human confirmation through MCP elicitation. Ordinary print starts, positive
+ * heating and resumes of a re-read job do not ask: the client's own action is
+ * the approval. Only a check that software cannot make asks a person, such as
+ * resuming a job whose file the printer cannot hand back for re-reading.
  */
-export declare function confirmationOptOut(scope: ConfirmationScope): boolean;
+export type ConfirmHardware = (message: string) => Promise<boolean>;
 /**
- * How long a human has to answer a confirmation prompt. The MCP SDK's default
- * request timeout (60 s) is too short for someone walking to the printer.
+ * How long a person has to answer a prompt from the server (a resume of a job
+ * that could not be re-read, or the Bambu printer-model prompt). The MCP SDK's
+ * default request timeout (60 s) is too short for someone walking to the printer.
  */
 export declare function confirmationTimeoutMs(): number;
 export declare function confirmationTimedOut(timeoutMs: number): string;
-export declare const CONFIRMATION_UNAVAILABLE: string;
-/**
- * physicalCheck marks confirmations that software cannot replace (for example
- * clearing hardware errors). Those are required even when prompts are opted out.
- */
-export declare function requireHumanConfirmation(confirm: ConfirmHardware | undefined, message: string, scope: ConfirmationScope, physicalCheck?: boolean): Promise<void>;
+export declare const CONFIRMATION_UNAVAILABLE = "This step needs a person to confirm a check at the printer, which requires an MCP client with elicitation support. No command was sent.";
+/** Ask a person to accept a physical check that software cannot replace. */
+export declare function requireHumanConfirmation(confirm: ConfirmHardware | undefined, message: string): Promise<void>;

package/dist/safety/confirmation.js

@@ -1,21 +1,7 @@
 /**
- * Ordinary print/heat prompts are on by default. Only an explicit "0" opts out.
- * PRINT_REQUIRE_CONFIRMATION applies to every printer type; the older
- * BAMBU_REQUIRE_CONFIRMATION applies to Bambu printers only. If any variable
- * relevant to the scope is set to another value, confirmation stays required.
- */
-export function confirmationOptOut(scope) {
-    const names = scope === "bambu"
-        ? ["BAMBU_REQUIRE_CONFIRMATION", "PRINT_REQUIRE_CONFIRMATION"]
-        : ["PRINT_REQUIRE_CONFIRMATION"];
-    const values = names
-        .map((name) => process.env[name]?.trim())
-        .filter((value) => value !== undefined && value !== "");
-    return values.length > 0 && values.every((value) => value === "0");
-}
-/**
- * How long a human has to answer a confirmation prompt. The MCP SDK's default
- * request timeout (60 s) is too short for someone walking to the printer.
+ * How long a person has to answer a prompt from the server (a resume of a job
+ * that could not be re-read, or the Bambu printer-model prompt). The MCP SDK's
+ * default request timeout (60 s) is too short for someone walking to the printer.
  */
 export function confirmationTimeoutMs() {
     const raw = process.env.PRINT_CONFIRMATION_TIMEOUT_MS?.trim();
@@ -27,23 +13,13 @@ export function confirmationTimedOut(timeoutMs) {
     return `No confirmation was received within ${minutes >= 1 ? `${Number(minutes.toFixed(1))} minute(s)` : `${timeoutMs / 1000} seconds`}; ` +
         "nothing was sent to the printer. Ask again when you are at the printer, or raise PRINT_CONFIRMATION_TIMEOUT_MS.";
 }
-export const CONFIRMATION_UNAVAILABLE = "Human hardware confirmation requires an MCP client with elicitation support. For deliberately headless operation, " +
-    "PRINT_REQUIRE_CONFIRMATION=0 (or BAMBU_REQUIRE_CONFIRMATION=0 for Bambu printers) disables ordinary print/heat prompts. No command was sent.";
-/**
- * physicalCheck marks confirmations that software cannot replace (for example
- * clearing hardware errors). Those are required even when prompts are opted out.
- */
-export async function requireHumanConfirmation(confirm, message, scope, physicalCheck = false) {
-    if (!physicalCheck && confirmationOptOut(scope))
-        return;
+export const CONFIRMATION_UNAVAILABLE = "This step needs a person to confirm a check at the printer, which requires an MCP client with elicitation support. No command was sent.";
+/** Ask a person to accept a physical check that software cannot replace. */
+export async function requireHumanConfirmation(confirm, message) {
     if (!confirm)
         throw new Error(CONFIRMATION_UNAVAILABLE);
     if (!(await confirm(message))) {
-        throw new Error("Hardware safety confirmation was declined or cancelled in the MCP client. No command was sent. " + (physicalCheck
-            ? "This confirmation covers a physical check at the printer and always needs a person to accept it."
-            : "Some clients decline prompts automatically, for example in a non-interactive permission mode. A deliberately headless " +
-                `setup that approves jobs another way can set ${scope === "bambu"
-                    ? "PRINT_REQUIRE_CONFIRMATION=0 (or BAMBU_REQUIRE_CONFIRMATION=0)"
-                    : "PRINT_REQUIRE_CONFIRMATION=0"} to skip ordinary print and heating prompts.`));
+        throw new Error("Hardware safety confirmation was declined or cancelled in the MCP client. No command was sent. " +
+            "This confirmation covers a physical check at the printer and always needs a person to accept it.");
     }
 }

package/dist/safety/hidden-hms.d.ts

@@ -0,0 +1,32 @@
+export declare const HIDDEN_HMS_SOURCE: {
+    readonly studioTag: "v02.08.02.61";
+    readonly studioCommit: "926a7192574bcb9b3a732e1ec59a46d79cb45466";
+    /** Per table: Bambu's device_hms version and the SHA-256 of the English file used. */
+    readonly tables: {
+        readonly "093": {
+            readonly version: 202508191204;
+            readonly sha256: "7801fd6c355854b62ecb62ee32727b4e5dcca908841dbcfd5e5de45b3dfd1c25";
+        };
+        readonly "094": {
+            readonly version: 202503231214;
+            readonly sha256: "047c15e2140738ec08258b74536e6cb996cddf0c586c5c39e2318e54125a9e76";
+        };
+        readonly "20P": {
+            readonly version: 202511162200;
+            readonly sha256: "e4f067d027b9bcbb9bbf6cb90f41f11130cf4d83dffd3dee101db7826dc808c3";
+        };
+        readonly "22E": {
+            readonly version: 202510142200;
+            readonly sha256: "87426021aea2bd4e8d721e46e1c86808fd7c6fc06f52baf6d952ead9e8d14d1e";
+        };
+        readonly "239": {
+            readonly version: 202506171403;
+            readonly sha256: "c1d23d5302756d57df5cb9bc795d95fc54ef1db7565dca1f04b69a024886426a";
+        };
+        readonly "31B": {
+            readonly version: 202511162200;
+            readonly sha256: "dcf63657bff5451f0715ea3c032efe482279bc8cbc28cb9b8ae51c7354826574";
+        };
+    };
+};
+export declare const HIDDEN_HMS: Readonly<Record<string, readonly string[]>>;