@aubron/ankerts 0.1.0

package/dist/index.js

@@ -0,0 +1,2514 @@
+// src/client.ts
+import { readFile } from "fs/promises";
+import { basename } from "path";
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir, platform } from "os";
+import { dirname, join } from "path";
+var MQTT_HOSTS = {
+  us: "make-mqtt.ankermake.com",
+  eu: "make-mqtt-eu.ankermake.com"
+};
+var API_HOSTS = {
+  us: "make-app.ankermake.com",
+  eu: "make-app-eu.ankermake.com"
+};
+var REDACTED = "<redacted>";
+var mqttUsername = (acct) => `eufy_${acct.user_id}`;
+var mqttPassword = (acct) => acct.email;
+function mqttHostFor(acct, printer) {
+  return printer.mqtt_host ?? MQTT_HOSTS[acct.region];
+}
+function configDir() {
+  const override = process.env.ANKER_CONFIG_DIR;
+  if (override) return override;
+  const home = homedir();
+  switch (platform()) {
+    case "darwin":
+      return join(home, "Library", "Application Support", "ankerts");
+    case "win32":
+      return join(process.env.APPDATA ?? join(home, "AppData", "Roaming"), "ankerts");
+    default:
+      return join(process.env.XDG_CONFIG_HOME ?? join(home, ".config"), "ankerts");
+  }
+}
+var emptyConfig = () => ({ account: null, printers: [] });
+var ConfigStore = class {
+  constructor(path = join(configDir(), "config.json")) {
+    this.path = path;
+  }
+  path;
+  exists() {
+    return existsSync(this.path);
+  }
+  load() {
+    if (!existsSync(this.path)) return emptyConfig();
+    const parsed = JSON.parse(readFileSync(this.path, "utf8"));
+    return {
+      account: parsed.account ?? null,
+      printers: parsed.printers ?? [],
+      ...parsed.selected ? { selected: parsed.selected } : {}
+    };
+  }
+  save(config) {
+    mkdirSync(dirname(this.path), { recursive: true });
+    writeFileSync(this.path, `${JSON.stringify(config, null, 2)}
+`);
+  }
+  /** Mutate-and-persist helper. */
+  update(fn) {
+    const config = this.load();
+    fn(config);
+    this.save(config);
+    return config;
+  }
+};
+function redactConfig(config, reveal = false) {
+  if (reveal) return config;
+  return {
+    account: config.account ? { ...config.account, auth_token: config.account.auth_token ? REDACTED : "" } : null,
+    printers: config.printers.map((p) => ({
+      ...p,
+      mqtt_key: p.mqtt_key ? REDACTED : "",
+      p2p_key: p.p2p_key ? REDACTED : ""
+    })),
+    ...config.selected ? { selected: config.selected } : {}
+  };
+}
+function findPrinter(config, ref) {
+  const { printers } = config;
+  if (typeof ref === "number" || /^\d+$/.test(String(ref))) {
+    const idx = Number(ref);
+    return printers[idx] ?? null;
+  }
+  const r = String(ref);
+  return printers.find((p) => p.duid === r || p.sn === r || p.id === r || p.name === r) ?? null;
+}
+
+// src/crypto.ts
+import { createCipheriv, createDecipheriv, createECDH, createHash, randomBytes } from "crypto";
+var unhex = (s) => Buffer.from(s, "hex");
+var b64e = (b) => b.toString("base64");
+var MQTT_AES_IV = Buffer.from("3DPrintAnkerMake", "ascii");
+function pkcs7Pad(data, blockSize = 16) {
+  const padLen = blockSize - data.length % blockSize;
+  return Buffer.concat([data, Buffer.alloc(padLen, padLen)]);
+}
+function pkcs7Unpad(data) {
+  if (data.length === 0) return data;
+  const padLen = data[data.length - 1];
+  if (padLen < 1 || padLen > 16 || padLen > data.length) {
+    throw new Error("invalid PKCS#7 padding");
+  }
+  return data.subarray(0, data.length - padLen);
+}
+function aesCbcAlgo(key) {
+  switch (key.length) {
+    case 16:
+      return "aes-128-cbc";
+    case 24:
+      return "aes-192-cbc";
+    case 32:
+      return "aes-256-cbc";
+    default:
+      throw new Error(`unsupported AES key length: ${key.length} bytes`);
+  }
+}
+function aesCbcEncrypt(msg, key, iv) {
+  const cipher = createCipheriv(aesCbcAlgo(key), key, iv);
+  cipher.setAutoPadding(false);
+  return Buffer.concat([cipher.update(pkcs7Pad(msg)), cipher.final()]);
+}
+function aesCbcDecrypt(cmsg, key, iv) {
+  const decipher = createDecipheriv(aesCbcAlgo(key), key, iv);
+  decipher.setAutoPadding(false);
+  return pkcs7Unpad(Buffer.concat([decipher.update(cmsg), decipher.final()]));
+}
+var mqttAesEncrypt = (msg, key, iv = MQTT_AES_IV) => aesCbcEncrypt(msg, key, iv);
+var mqttAesDecrypt = (cmsg, key, iv = MQTT_AES_IV) => aesCbcDecrypt(cmsg, key, iv);
+function xorBytes(data) {
+  let s = 0;
+  for (const x of data) s ^= x;
+  return s;
+}
+function mqttChecksumAdd(msg) {
+  return Buffer.concat([msg, Buffer.from([xorBytes(msg)])]);
+}
+function mqttChecksumRemove(payload) {
+  if (xorBytes(payload) !== 0) {
+    throw new Error("malformed MQTT message: checksum mismatch");
+  }
+  return payload.subarray(0, payload.length - 1);
+}
+var ANKER_EC_PUBKEY = Buffer.from(
+  "04c5c00c4f8d1197cc7c3167c52bf7acb054d722f0ef08dcd7e0883236e0d72a3868d9750cb47fa4619248f3d83f0f662671dadc6e2d31c2f41db0161651c7c076",
+  "hex"
+);
+function ecdhEncryptLoginPassword(password) {
+  const ecdh = createECDH("prime256v1");
+  ecdh.generateKeys();
+  const key = ecdh.computeSecret(ANKER_EC_PUBKEY);
+  const iv = key.subarray(0, 16);
+  const ciphertext = aesCbcEncrypt(Buffer.from(password, "utf8"), key, iv);
+  return {
+    publicKey: ecdh.getPublicKey("hex", "uncompressed"),
+    encryptedPassword: b64e(ciphertext)
+  };
+}
+var LOGIN_CACHE_KEY = unhex("1b55f97793d58864571e1055838cac97");
+var md5Hex = (data) => createHash("md5").update(data).digest("hex");
+function ppcsCrc16(data) {
+  let crc = 0;
+  for (const byte of data) {
+    crc ^= byte << 8;
+    for (let i = 0; i < 8; i++) {
+      crc = crc & 32768 ? (crc << 1 ^ 4129) & 65535 : crc << 1 & 65535;
+    }
+  }
+  const out = Buffer.alloc(2);
+  out.writeUInt16LE(crc, 0);
+  return out;
+}
+var PPPP_SEED = "EUPRAKM";
+var PPPP_SHUFFLE = [
+  [149, 229, 97, 151, 131, 13, 167, 241],
+  [211, 5, 149, 139, 223, 19, 109, 239],
+  [7, 97, 13, 109, 127, 103, 23, 43],
+  [193, 181, 19, 11, 223, 139, 73, 59],
+  [127, 7, 211, 2, 109, 47, 19, 197],
+  [109, 61, 251, 13, 11, 41, 233, 79],
+  [137, 47, 227, 233, 13, 131, 109, 229],
+  [7, 83, 139, 37, 149, 71, 31, 41]
+];
+function curseStep(a, b, c, d, q, shuffle) {
+  return [
+    shuffle[b + q % a & 7][q + c % d & 7],
+    shuffle[c + q % b & 7][q + d % a & 7],
+    shuffle[d + q % c & 7][q + a % b & 7],
+    shuffle[a + q % d & 7][q + b % c & 7]
+  ];
+}
+function curseInit(key, shuffle) {
+  let [a, b, c, d] = [1, 3, 5, 7];
+  for (const ch of key) {
+    [a, b, c, d] = curseStep(a, b, c, d, ch.charCodeAt(0), shuffle);
+  }
+  return [a, b, c, d];
+}
+function cryptoCurse(input, key, shuffle) {
+  let [a, b, c, d] = curseInit(key, shuffle);
+  const output = new Array(input.length + 4).fill(0);
+  for (let p = 0; p < input.length; p++) {
+    const x = output[p] = input[p] ^ (a ^ b ^ c ^ d);
+    [a, b, c, d] = curseStep(a, b, c, d, x, shuffle);
+  }
+  for (let p = input.length; p < input.length + 4; p++) {
+    const x = output[p] = a ^ b ^ c ^ d ^ 67;
+    [a, b, c, d] = curseStep(a, b, c, d, x, shuffle);
+  }
+  return output;
+}
+function cryptoCurseString(input) {
+  return Buffer.from(cryptoCurse(input, PPPP_SEED, PPPP_SHUFFLE));
+}
+var PPPP_SIMPLE_SEED = Buffer.from("SSD@cs2-network.", "ascii");
+var PPPP_SIMPLE_SHUFFLE = [
+  124,
+  156,
+  232,
+  74,
+  19,
+  222,
+  220,
+  178,
+  47,
+  33,
+  35,
+  228,
+  48,
+  123,
+  61,
+  140,
+  188,
+  11,
+  39,
+  12,
+  60,
+  247,
+  154,
+  231,
+  8,
+  113,
+  150,
+  0,
+  151,
+  133,
+  239,
+  193,
+  31,
+  196,
+  219,
+  161,
+  194,
+  235,
+  217,
+  1,
+  250,
+  186,
+  59,
+  5,
+  184,
+  21,
+  135,
+  131,
+  40,
+  114,
+  209,
+  139,
+  90,
+  214,
+  218,
+  147,
+  88,
+  254,
+  170,
+  204,
+  110,
+  27,
+  240,
+  163,
+  136,
+  171,
+  67,
+  192,
+  13,
+  181,
+  69,
+  56,
+  79,
+  80,
+  34,
+  102,
+  32,
+  127,
+  7,
+  91,
+  20,
+  152,
+  29,
+  155,
+  167,
+  42,
+  185,
+  168,
+  203,
+  241,
+  252,
+  73,
+  71,
+  6,
+  62,
+  177,
+  14,
+  4,
+  58,
+  148,
+  94,
+  238,
+  84,
+  17,
+  52,
+  221,
+  77,
+  249,
+  236,
+  199,
+  201,
+  227,
+  120,
+  26,
+  111,
+  112,
+  107,
+  164,
+  189,
+  169,
+  93,
+  213,
+  248,
+  229,
+  187,
+  38,
+  175,
+  66,
+  55,
+  216,
+  225,
+  2,
+  10,
+  174,
+  95,
+  28,
+  197,
+  115,
+  9,
+  78,
+  105,
+  36,
+  144,
+  109,
+  18,
+  179,
+  25,
+  173,
+  116,
+  138,
+  41,
+  64,
+  245,
+  45,
+  190,
+  165,
+  89,
+  224,
+  244,
+  121,
+  210,
+  75,
+  206,
+  137,
+  130,
+  72,
+  132,
+  37,
+  198,
+  145,
+  43,
+  162,
+  251,
+  143,
+  233,
+  166,
+  176,
+  158,
+  63,
+  101,
+  246,
+  3,
+  49,
+  46,
+  172,
+  15,
+  149,
+  44,
+  92,
+  237,
+  57,
+  183,
+  51,
+  108,
+  86,
+  126,
+  180,
+  160,
+  253,
+  122,
+  129,
+  83,
+  81,
+  134,
+  141,
+  159,
+  119,
+  255,
+  106,
+  128,
+  223,
+  226,
+  191,
+  16,
+  215,
+  117,
+  100,
+  87,
+  118,
+  243,
+  85,
+  205,
+  208,
+  200,
+  24,
+  230,
+  54,
+  65,
+  98,
+  207,
+  153,
+  242,
+  50,
+  76,
+  103,
+  96,
+  97,
+  146,
+  202,
+  211,
+  234,
+  99,
+  125,
+  22,
+  182,
+  142,
+  212,
+  104,
+  53,
+  195,
+  82,
+  157,
+  70,
+  68,
+  30,
+  23
+];
+function simpleHash(seed) {
+  const hash = [0, 0, 0, 0];
+  for (const byte of seed) {
+    hash[0] = (hash[0] ^ byte) & 255;
+    hash[1] = hash[1] + Math.floor(byte / 3) & 255;
+    hash[2] = hash[2] - byte & 255;
+    hash[3] = hash[3] + byte & 255;
+  }
+  return hash.reverse();
+}
+function simpleLookup(hash, b) {
+  const index = hash[b & 3] + b & 4294967295;
+  return PPPP_SIMPLE_SHUFFLE[(index % PPPP_SIMPLE_SHUFFLE.length + PPPP_SIMPLE_SHUFFLE.length) % PPPP_SIMPLE_SHUFFLE.length];
+}
+function simpleDecrypt(input, seed = PPPP_SIMPLE_SEED) {
+  const hash = simpleHash(seed);
+  const output = Buffer.alloc(input.length);
+  if (input.length === 0) return output;
+  output[0] = input[0] ^ simpleLookup(hash, 0);
+  for (let i = 1; i < input.length; i++) {
+    output[i] = input[i] ^ simpleLookup(hash, input[i - 1]);
+  }
+  return output;
+}
+var PPPP_INITSTRING_SHUFFLE = [
+  73,
+  89,
+  67,
+  61,
+  181,
+  191,
+  109,
+  163,
+  71,
+  83,
+  79,
+  97,
+  101,
+  227,
+  113,
+  233,
+  103,
+  127,
+  2,
+  3,
+  11,
+  173,
+  179,
+  137,
+  43,
+  47,
+  53,
+  193,
+  107,
+  139,
+  149,
+  151,
+  17,
+  229,
+  167,
+  13,
+  239,
+  241,
+  5,
+  7,
+  131,
+  251,
+  157,
+  59,
+  197,
+  199,
+  19,
+  23,
+  29,
+  31,
+  37,
+  41,
+  211,
+  223
+];
+function ppppDecodeInitstringRaw(input) {
+  const olen = input.length >> 1;
+  const output = new Array(olen).fill(0);
+  for (let q = 0; q < olen; q++) {
+    let xor = 57 ^ PPPP_INITSTRING_SHUFFLE[q % 54];
+    for (let p = 0; p <= q; p++) xor ^= output[p];
+    const l = input[q * 2 + 1] - 65;
+    const h = input[q * 2 + 0] - 65;
+    output[q] = (xor ^ l + (h << 4)) & 255;
+  }
+  return Buffer.from(output);
+}
+function ppppDecodeInitstring(input) {
+  const res = ppppDecodeInitstringRaw(Buffer.from(input, "ascii"));
+  return res.toString("utf8").replace(/,+$/, "").split(",");
+}
+
+// src/errors.ts
+var AnkerError = class extends Error {
+  exitCode = 1;
+  code;
+  transport;
+  retriable;
+  hint;
+  input;
+  constructor(opts) {
+    super(opts.message, opts.cause !== void 0 ? { cause: opts.cause } : void 0);
+    this.name = new.target.name;
+    this.code = opts.code;
+    this.transport = opts.transport;
+    this.retriable = opts.retriable ?? false;
+    this.hint = opts.hint;
+    this.input = opts.input;
+  }
+  /** Attach/merge the failing input (the CLI echoes this back). */
+  withInput(input) {
+    this.input = { ...this.input, ...input };
+    return this;
+  }
+  /** The structured body for JSON output and stderr. */
+  body() {
+    return {
+      code: this.code,
+      message: this.message,
+      ...this.transport ? { transport: this.transport } : {},
+      retriable: this.retriable,
+      ...this.hint ? { hint: this.hint } : {},
+      ...this.input ? { input: this.input } : {}
+    };
+  }
+  toJSON() {
+    return { error: this.body() };
+  }
+};
+var UsageError = class extends AnkerError {
+  exitCode = 2;
+  constructor(opts) {
+    super({ code: "usage", retriable: false, ...opts });
+  }
+};
+var AuthError = class extends AnkerError {
+  exitCode = 3;
+  constructor(opts) {
+    super({ code: "auth_required", transport: "https", retriable: false, ...opts });
+  }
+};
+var PrinterNotFoundError = class extends AnkerError {
+  exitCode = 4;
+  constructor(opts) {
+    super({ code: "printer_not_found", retriable: false, ...opts });
+  }
+};
+var TimeoutError = class extends AnkerError {
+  exitCode = 5;
+  constructor(opts) {
+    super({ code: "timeout", retriable: true, ...opts });
+  }
+};
+var TransportUnavailableError = class extends AnkerError {
+  exitCode = 6;
+  constructor(opts) {
+    super({ code: "transport_unavailable", retriable: false, ...opts });
+  }
+};
+var PrinterRejectedError = class extends AnkerError {
+  exitCode = 7;
+  constructor(opts) {
+    super({ code: "printer_rejected", retriable: false, ...opts });
+  }
+};
+function toAnkerError(err) {
+  if (err instanceof AnkerError) return err;
+  if (err instanceof Error) {
+    return new AnkerError({ code: "internal_error", message: err.message, cause: err });
+  }
+  return new AnkerError({ code: "internal_error", message: String(err) });
+}
+
+// src/protocol/commands.ts
+var MqttCommandType = /* @__PURE__ */ ((MqttCommandType2) => {
+  MqttCommandType2[MqttCommandType2["EVENT_NOTIFY"] = 1e3] = "EVENT_NOTIFY";
+  MqttCommandType2[MqttCommandType2["PRINT_SCHEDULE"] = 1001] = "PRINT_SCHEDULE";
+  MqttCommandType2[MqttCommandType2["FIRMWARE_VERSION"] = 1002] = "FIRMWARE_VERSION";
+  MqttCommandType2[MqttCommandType2["NOZZLE_TEMP"] = 1003] = "NOZZLE_TEMP";
+  MqttCommandType2[MqttCommandType2["HOTBED_TEMP"] = 1004] = "HOTBED_TEMP";
+  MqttCommandType2[MqttCommandType2["FAN_SPEED"] = 1005] = "FAN_SPEED";
+  MqttCommandType2[MqttCommandType2["PRINT_SPEED"] = 1006] = "PRINT_SPEED";
+  MqttCommandType2[MqttCommandType2["AUTO_LEVELING"] = 1007] = "AUTO_LEVELING";
+  MqttCommandType2[MqttCommandType2["PRINT_CONTROL"] = 1008] = "PRINT_CONTROL";
+  MqttCommandType2[MqttCommandType2["FILE_LIST_REQUEST"] = 1009] = "FILE_LIST_REQUEST";
+  MqttCommandType2[MqttCommandType2["APP_QUERY_STATUS"] = 1027] = "APP_QUERY_STATUS";
+  MqttCommandType2[MqttCommandType2["ONLINE_NOTIFY"] = 1028] = "ONLINE_NOTIFY";
+  MqttCommandType2[MqttCommandType2["RECOVER_FACTORY"] = 1029] = "RECOVER_FACTORY";
+  MqttCommandType2[MqttCommandType2["BREAK_POINT"] = 1039] = "BREAK_POINT";
+  MqttCommandType2[MqttCommandType2["MODEL_LAYER"] = 1052] = "MODEL_LAYER";
+  MqttCommandType2[MqttCommandType2["GCODE_COMMAND"] = 1043] = "GCODE_COMMAND";
+  return MqttCommandType2;
+})(MqttCommandType || {});
+var NoticeType = /* @__PURE__ */ ((NoticeType2) => {
+  NoticeType2[NoticeType2["EVENT_NOTIFY"] = 1e3] = "EVENT_NOTIFY";
+  NoticeType2[NoticeType2["PRINT_SCHEDULE"] = 1001] = "PRINT_SCHEDULE";
+  NoticeType2[NoticeType2["NOZZLE_TEMP"] = 1003] = "NOZZLE_TEMP";
+  NoticeType2[NoticeType2["HOTBED_TEMP"] = 1004] = "HOTBED_TEMP";
+  NoticeType2[NoticeType2["PRINT_SPEED"] = 1006] = "PRINT_SPEED";
+  NoticeType2[NoticeType2["MODEL_LAYER"] = 1052] = "MODEL_LAYER";
+  return NoticeType2;
+})(NoticeType || {});
+var PrintControl = /* @__PURE__ */ ((PrintControl2) => {
+  PrintControl2[PrintControl2["PAUSE"] = 2] = "PAUSE";
+  PrintControl2[PrintControl2["RESUME"] = 3] = "RESUME";
+  PrintControl2[PrintControl2["STOP"] = 4] = "STOP";
+  return PrintControl2;
+})(PrintControl || {});
+
+// src/protocol/transcoder.ts
+function parseDurationToSeconds(text) {
+  let total = 0;
+  let any = false;
+  for (const [, value, unit] of text.matchAll(/(\d+(?:\.\d+)?)\s*([dhms])/gi)) {
+    const n = Number(value);
+    if (Number.isNaN(n)) continue;
+    any = true;
+    total += n * { d: 86400, h: 3600, m: 60, s: 1 }[unit.toLowerCase()];
+  }
+  return any ? Math.round(total) : void 0;
+}
+function detectSlicer(gcode) {
+  const head = gcode.slice(0, 4096).toLowerCase();
+  if (/;time:\s*\d/.test(head) || head.includes("ankermake") || head.includes("eufymake")) {
+    return "ankermake";
+  }
+  if (head.includes("orcaslicer") || head.includes("orca_slicer")) return "orca";
+  if (head.includes("prusaslicer")) return "prusa";
+  if (/estimated printing time/.test(head)) return "orca";
+  return "unknown";
+}
+function hasAnkerTimeHeader(gcode) {
+  return /^;TIME:\s*\d+/m.test(gcode);
+}
+function findNumber(gcode, re) {
+  const m = re.exec(gcode);
+  if (!m) return void 0;
+  const n = Number(m[1]);
+  return Number.isNaN(n) ? void 0 : n;
+}
+function transcodeMetadata(gcode) {
+  if (hasAnkerTimeHeader(gcode)) {
+    return { content: gcode, changed: false, injected: {} };
+  }
+  const injected = {};
+  const headerLines = [];
+  const timeMatch = /;\s*estimated printing time \(normal mode\)\s*=\s*(.+)/i.exec(gcode);
+  if (timeMatch) {
+    const seconds = parseDurationToSeconds(timeMatch[1]);
+    if (seconds !== void 0) {
+      injected.timeSeconds = seconds;
+      headerLines.push(`;TIME:${seconds}s`);
+    }
+  }
+  const mm = findNumber(gcode, /;\s*filament used \[mm\]\s*=\s*([\d.]+)/i);
+  if (mm !== void 0) {
+    injected.filamentMm = mm;
+    headerLines.push(`;Filament used: ${mm}mm`);
+  }
+  const grams = findNumber(gcode, /;\s*total filament used \[g\]\s*=\s*([\d.]+)/i);
+  if (grams !== void 0) {
+    injected.filamentGrams = grams;
+    headerLines.push(`;Filament weight: ${grams}g`);
+  }
+  if (headerLines.length === 0) {
+    return { content: gcode, changed: false, injected };
+  }
+  const content = `${headerLines.join("\n")}
+${gcode}`;
+  return { content, changed: true, injected };
+}
+
+// src/transport/mqtt.ts
+import mqtt from "mqtt";
+
+// src/protocol/gcode.ts
+var GCODE_WINDOW_BYTES = 512;
+var RINGBUF_RE = /\+ringbuf:\s*\d+,\s*\d+,\s*\d+/;
+var ESC = String.fromCharCode(27);
+var CSI = String.fromCharCode(155);
+var ANSI_RE = new RegExp(
+  `[${ESC}${CSI}][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PR-TZcf-ntqry=><~]`,
+  "g"
+);
+function stripAnsi(text) {
+  return text.replace(ANSI_RE, "");
+}
+function reassembleRaw(chunks) {
+  return stripAnsi(chunks.join("")).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function splitLines(raw) {
+  return raw.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+}
+function gcodeHasTerminalOk(raw) {
+  const lines = splitLines(raw).filter((l) => !/^\+/.test(l));
+  const last = lines[lines.length - 1];
+  return last !== void 0 && (/^ok\b/i.test(last) || last.toLowerCase() === "ok");
+}
+function hasUnknownCommand(lines) {
+  return lines.some((l) => /echo:\s*Unknown command/i.test(l));
+}
+var REPORT_RE = /^([GM]\d+)\b\s*(.*)$/;
+function parseKeyColonTokens(line, out) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*:/.test(line)) return false;
+  const parts = line.split(/\s+(?=[A-Z][A-Z0-9_]*:)/);
+  let matched = false;
+  for (const part of parts) {
+    const idx = part.indexOf(":");
+    if (idx <= 0) continue;
+    const key = part.slice(0, idx).trim();
+    const value = part.slice(idx + 1).trim();
+    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+      out[key] = value;
+      matched = true;
+    }
+  }
+  return matched;
+}
+function parseGcodeResult(command, chunks, meta) {
+  const raw = reassembleRaw(chunks);
+  const lines = splitLines(raw);
+  const fields = {};
+  const reports = {};
+  const truncated = RINGBUF_RE.test(raw) || chunks.join("").length >= GCODE_WINDOW_BYTES;
+  for (const line of lines) {
+    const body = line.replace(/^echo:\s*/i, "").trim();
+    const report = REPORT_RE.exec(body);
+    if (report && !body.includes("=")) {
+      reports[report[1]] = report[2].trim();
+      continue;
+    }
+    if (body.includes("=") && !/^[A-Za-z_][A-Za-z0-9_]*:/.test(body)) {
+      const eq = body.indexOf("=");
+      const key = body.slice(0, eq).trim();
+      const value = body.slice(eq + 1).trim();
+      if (key) {
+        fields[key] = value;
+        continue;
+      }
+    }
+    parseKeyColonTokens(body, fields);
+  }
+  return {
+    command,
+    raw,
+    lines,
+    ok: gcodeHasTerminalOk(raw),
+    recognized: !hasUnknownCommand(lines),
+    fields,
+    reports,
+    durationMs: meta.durationMs,
+    timedOut: meta.timedOut,
+    truncated,
+    frames: chunks.length
+  };
+}
+
+// src/protocol/status.ts
+var centiToC = (v) => Math.round(v / 100 * 100) / 100;
+var num = (v) => typeof v === "number" ? v : typeof v === "string" && v.trim() !== "" ? Number(v) : void 0;
+var SANE_ETA_SECONDS = 60 * 60 * 24 * 30;
+function isEtaReliable(schedule) {
+  const totalTime = num(schedule.totalTime);
+  const time = num(schedule.time);
+  const left = num(schedule.startLeftTime);
+  if (totalTime === void 0 || totalTime <= 0) return false;
+  if (time !== void 0 && time > totalTime) return false;
+  if (left !== void 0 && (left < 0 || left > SANE_ETA_SECONDS)) return false;
+  return true;
+}
+function deriveState(schedule, progressPct, eventState) {
+  if (eventState === 0) return progressPct >= 100 ? "complete" : "idle";
+  if (eventState === 1) return progressPct >= 100 ? "complete" : "printing";
+  if (eventState === 2) return "paused";
+  const hint = schedule?.state;
+  if (typeof hint === "string") {
+    const h = hint.toLowerCase();
+    if (["idle", "printing", "paused", "complete", "failed", "cancelled"].includes(h)) {
+      return h;
+    }
+  }
+  if (!schedule || !schedule.name) return "idle";
+  if (progressPct >= 100) return "complete";
+  return "printing";
+}
+function normalizeStatus(notices, opts = {}) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const n of notices) {
+    if (typeof n.commandType === "number") latest.set(n.commandType, n);
+  }
+  const nozzleN = latest.get(1003 /* NOZZLE_TEMP */);
+  const bedN = latest.get(1004 /* HOTBED_TEMP */);
+  const layerN = latest.get(1052 /* MODEL_LAYER */);
+  const speedN = latest.get(1006 /* PRINT_SPEED */);
+  const schedule = latest.get(1001 /* PRINT_SCHEDULE */);
+  const eventN = latest.get(1e3 /* EVENT_NOTIFY */);
+  const eventState = num(eventN?.subType) === 1 ? num(eventN?.value) : void 0;
+  const raw = {};
+  for (const [type, payload] of latest) raw[String(type)] = payload;
+  const status = {
+    nozzle: {
+      current: centiToC(num(nozzleN?.currentTemp) ?? 0),
+      target: centiToC(num(nozzleN?.targetTemp) ?? 0)
+    },
+    bed: {
+      current: centiToC(num(bedN?.currentTemp) ?? 0),
+      target: centiToC(num(bedN?.targetTemp) ?? 0)
+    },
+    raw
+  };
+  if (schedule) {
+    const progressPct = Math.round((num(schedule.progress) ?? 0) / 100 * 100) / 100;
+    const reliable = opts.etaReliableOverride ?? isEtaReliable(schedule);
+    const left = num(schedule.startLeftTime);
+    status.job = {
+      name: typeof schedule.name === "string" ? schedule.name : "",
+      state: deriveState(schedule, progressPct, eventState),
+      progressPct,
+      layer: num(layerN?.real_print_layer) ?? 0,
+      totalLayers: num(layerN?.total_layer) ?? 0,
+      etaReliable: reliable,
+      ...reliable && left !== void 0 ? { etaSeconds: left } : {},
+      ...num(schedule.filamentUsed) !== void 0 ? { filamentUsed: num(schedule.filamentUsed) } : {},
+      ...typeof schedule.filamentUnit === "string" ? { filamentUnit: schedule.filamentUnit } : {},
+      ...num(speedN?.value) !== void 0 ? { speedMmS: num(speedN?.value) } : {},
+      ...num(schedule.realSpeed) !== void 0 ? { speedFactorPct: num(schedule.realSpeed) } : {}
+    };
+  }
+  return status;
+}
+
+// src/transport/certs.ts
+var ANKERMAKE_MQTT_CA = `-----BEGIN CERTIFICATE-----
+MIIDwTCCAqmgAwIBAgIJAKrbZvWARI3BMA0GCSqGSIb3DQEBCwUAMHUxCzAJBgNV
+BAYTAkNOMREwDwYDVQQIDAhTaGVuemhlbjERMA8GA1UEBwwIU2hlbnpoZW4xEjAQ
+BgNVBAoMCWFua2VybWFrZTESMBAGA1UECwwJYW5rZXJtYWtlMRgwFgYDVQQDDA8q
+LmFua2VybWFrZS5jb20wIBcNMjIwNjE3MDMwNzU5WhgPMjEyMjA1MjQwMzA3NTla
+MHUxCzAJBgNVBAYTAkNOMREwDwYDVQQIDAhTaGVuemhlbjERMA8GA1UEBwwIU2hl
+bnpoZW4xEjAQBgNVBAoMCWFua2VybWFrZTESMBAGA1UECwwJYW5rZXJtYWtlMRgw
+FgYDVQQDDA8qLmFua2VybWFrZS5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw
+ggEKAoIBAQC8JWJzdVJFqrarK5oMCF8nI5QZ2nebs9df6CQHuSZCOmGCav5sDDFt
+5IGhQ6G44++YNexC10kwxy10fOzIT6cZWnQrYQPBfS0y7G+yu/GPe9vXMWwkIcWv
+hg8xAO+/m5C/QAj4BOVTXVl5spuBGX644P3eErV+tUDwb1U2K6mMzmaJ7SZqkmiw
+QKfTK1KxH7oczcxjDtdbNdtpa1Rm3IUCCI2eAOQTlDHlKGGM2T+e6qQRCUQYqkiY
+jG+3ugTzHMe6FMzOB1EjG0bZDemQwgUdBJexLgxrJe4jsVcuP75DfrV0NL/Drrmt
+uJax3V4tu5Yx1RQCWqGTNPOahpS+qD+NAgMBAAGjUjBQMA4GA1UdDwEB/wQEAwID
+iDATBgNVHSUEDDAKBggrBgEFBQcDATApBgNVHREEIjAggg1hbmtlcm1ha2UuY29t
+gg8qLmFua2VybWFrZS5jb20wDQYJKoZIhvcNAQELBQADggEBALF/VDyZ21IdFejE
+awLriK+Xo78k1yqf2YKWYSDMEJPXXHfbkHZTU0IL+K9kToN19sObuWPA1oE2iyKp
+h4nKVDjy56Ntgt5lXeSTN08jlD0PzuuGfzPVxMrky8sp14pFT+Kw2HOEMLU6Hxj0
+WjpprKRbl1oI8JoksYNzCSelIItokA8CI3/p1j5FyWxok99sVvNUfjG9iaV74Nuh
+kY/1nm0T0aMPZKpcS0xS0JwA0tsySdDJP5t1KgmDa5D0hIhXuAJWGwUvg15vSyme
+bk3IO48Nh8QOG8PwGebPus1nnvKCbG6+iJaWp/PqSqNCzx/Nht+Tfi413dIc3exF
+LX0ZR20=
+-----END CERTIFICATE-----`;
+
+// src/binary.ts
+var BufReader = class {
+  constructor(buf) {
+    this.buf = buf;
+  }
+  buf;
+  offset = 0;
+  get remaining() {
+    return this.buf.length - this.offset;
+  }
+  take(n) {
+    if (this.offset + n > this.buf.length) {
+      throw new RangeError(`buffer underrun: need ${n}, have ${this.remaining}`);
+    }
+    const slice = this.buf.subarray(this.offset, this.offset + n);
+    this.offset += n;
+    return slice;
+  }
+  u8() {
+    return this.take(1).readUInt8(0);
+  }
+  u16be() {
+    return this.take(2).readUInt16BE(0);
+  }
+  u16le() {
+    return this.take(2).readUInt16LE(0);
+  }
+  u32be() {
+    return this.take(4).readUInt32BE(0);
+  }
+  u32le() {
+    return this.take(4).readUInt32LE(0);
+  }
+  i32be() {
+    return this.take(4).readInt32BE(0);
+  }
+  i32le() {
+    return this.take(4).readInt32LE(0);
+  }
+  bytes(n) {
+    return Buffer.from(this.take(n));
+  }
+  tail() {
+    return this.bytes(this.remaining);
+  }
+  /** Read `n` zero bytes, asserting they are all zero. */
+  zeroes(n) {
+    const b = this.take(n);
+    for (const x of b) if (x !== 0) throw new Error("expected zero padding");
+    return Buffer.from(b);
+  }
+  /** Read `expected.length` bytes and assert they match (a magic signature). */
+  magic(expected) {
+    const b = this.take(expected.length);
+    if (!b.equals(expected)) {
+      throw new Error(`bad magic: expected ${expected.toString("hex")}, got ${b.toString("hex")}`);
+    }
+    return Buffer.from(b);
+  }
+  /** Fixed-width, NUL-terminated string field of `size` bytes (last byte NUL). */
+  string(size) {
+    const b = this.take(size);
+    if (b[size - 1] !== 0) throw new Error("expected NUL-terminated fixed string");
+    let end = size - 1;
+    for (let i = 0; i < size; i++) {
+      if (b[i] === 0) {
+        end = i;
+        break;
+      }
+    }
+    return b.subarray(0, end).toString("utf8");
+  }
+  /** IPv4 address stored as 4 little-endian bytes (reversed dotted quad). */
+  ipv4() {
+    const b = this.take(4);
+    return `${b[3]}.${b[2]}.${b[1]}.${b[0]}`;
+  }
+};
+var BufWriter = class {
+  chunks = [];
+  u8(v) {
+    const b = Buffer.alloc(1);
+    b.writeUInt8(v & 255, 0);
+    this.chunks.push(b);
+    return this;
+  }
+  u16be(v) {
+    const b = Buffer.alloc(2);
+    b.writeUInt16BE(v & 65535, 0);
+    this.chunks.push(b);
+    return this;
+  }
+  u16le(v) {
+    const b = Buffer.alloc(2);
+    b.writeUInt16LE(v & 65535, 0);
+    this.chunks.push(b);
+    return this;
+  }
+  u32be(v) {
+    const b = Buffer.alloc(4);
+    b.writeUInt32BE(v >>> 0, 0);
+    this.chunks.push(b);
+    return this;
+  }
+  u32le(v) {
+    const b = Buffer.alloc(4);
+    b.writeUInt32LE(v >>> 0, 0);
+    this.chunks.push(b);
+    return this;
+  }
+  i32be(v) {
+    const b = Buffer.alloc(4);
+    b.writeInt32BE(v | 0, 0);
+    this.chunks.push(b);
+    return this;
+  }
+  i32le(v) {
+    const b = Buffer.alloc(4);
+    b.writeInt32LE(v | 0, 0);
+    this.chunks.push(b);
+    return this;
+  }
+  bytes(b) {
+    this.chunks.push(Buffer.from(b));
+    return this;
+  }
+  zeroes(n) {
+    this.chunks.push(Buffer.alloc(n));
+    return this;
+  }
+  /** Write a fixed-width string, NUL-padded to `size` bytes. */
+  string(s, size) {
+    const b = Buffer.alloc(size);
+    Buffer.from(s, "utf8").copy(b, 0, 0, Math.min(size - 1, Buffer.byteLength(s, "utf8")));
+    this.chunks.push(b);
+    return this;
+  }
+  ipv4(addr) {
+    const parts = addr.split(".").map((x) => parseInt(x, 10) & 255);
+    if (parts.length !== 4) throw new Error(`invalid IPv4 address: ${addr}`);
+    this.chunks.push(Buffer.from([parts[3], parts[2], parts[1], parts[0]]));
+    return this;
+  }
+  build() {
+    return Buffer.concat(this.chunks);
+  }
+};
+
+// src/transport/mqttframe.ts
+var SIGNATURE = Buffer.from("MA", "ascii");
+var M7_F = 70;
+var BODY_LEN = { 1: 24, 2: 64 };
+function packMqttMessage(opts) {
+  const data = mqttAesEncrypt(Buffer.from(JSON.stringify(opts.payload), "utf8"), opts.key);
+  const bodyLen = 64;
+  const size = bodyLen + data.length + 1;
+  const header = new BufWriter().bytes(SIGNATURE).u16le(size).u8(5).u8(1).u8(2).u8(5).u8(M7_F).u8(opts.packetType ?? 192 /* Single */).u16le(opts.packetNum ?? 0).u32le(opts.time ?? 0).string(opts.guid, 37).zeroes(11).build();
+  return mqttChecksumAdd(Buffer.concat([header.subarray(0, bodyLen), data]));
+}
+function parseMqttMessage(payload, key) {
+  const stripped = mqttChecksumRemove(payload);
+  const m5 = stripped[6];
+  const bodyLen = m5 !== void 0 ? BODY_LEN[m5] : void 0;
+  if (bodyLen === void 0) {
+    throw new Error(`unsupported MQTT message format (m5=${m5})`);
+  }
+  const body = stripped.subarray(0, bodyLen);
+  const data = mqttAesDecrypt(stripped.subarray(bodyLen), key);
+  const r = new BufReader(body);
+  r.magic(SIGNATURE);
+  r.u16le();
+  r.u8();
+  r.u8();
+  r.u8();
+  r.u8();
+  r.u8();
+  const packetType = r.u8();
+  const packetNum = r.u16le();
+  let time = 0;
+  let deviceGuid = "none";
+  if (m5 === 2) {
+    time = r.u32le();
+    deviceGuid = r.string(37);
+  }
+  return { packetType, packetNum, time, deviceGuid, payload: JSON.parse(data.toString("utf8")) };
+}
+
+// src/transport/mqtt.ts
+var COMMAND_REPLY = (sn) => `/phone/maker/${sn}/command/reply`;
+var QUERY_REPLY = (sn) => `/phone/maker/${sn}/query/reply`;
+var NOTICE = (sn) => `/phone/maker/${sn}/notice`;
+var COMMAND_TOPIC = (sn) => `/device/maker/${sn}/command`;
+var QUERY_TOPIC = (sn) => `/device/maker/${sn}/query`;
+function randomGuid() {
+  const h = (n) => Math.floor(Math.random() * 16 ** n).toString(16).padStart(n, "0");
+  return `${h(8)}-${h(4)}-4${h(3)}-${h(4)}-${h(8)}${h(4)}`;
+}
+var AnkerMqttClient = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.guid = opts.guid ?? randomGuid();
+    this.log = opts.log ?? (() => {
+    });
+  }
+  opts;
+  client;
+  guid;
+  log;
+  noticeHandlers = /* @__PURE__ */ new Set();
+  replyHandlers = /* @__PURE__ */ new Set();
+  latestNotices = /* @__PURE__ */ new Map();
+  gcodeLock = Promise.resolve();
+  get connected() {
+    return this.client?.connected ?? false;
+  }
+  async connect(timeoutMs = 3e4) {
+    const { host, port = 8789, username, password, sn } = this.opts;
+    this.log(`mqtt: connecting to ${host}:${port} as ${username}`);
+    const client = await mqtt.connectAsync(`mqtts://${host}:${port}`, {
+      username,
+      password,
+      ca: this.opts.ca ?? ANKERMAKE_MQTT_CA,
+      rejectUnauthorized: !this.opts.insecure,
+      connectTimeout: timeoutMs,
+      reconnectPeriod: 0
+    });
+    this.client = client;
+    client.on("message", (topic, payload) => this.onMessage(topic, payload));
+    await client.subscribeAsync([COMMAND_REPLY(sn), QUERY_REPLY(sn), NOTICE(sn)]);
+    this.log("mqtt: connected and subscribed");
+  }
+  async disconnect() {
+    await this.client?.endAsync();
+    this.client = void 0;
+  }
+  onMessage(_topic, payload) {
+    let msg;
+    try {
+      msg = parseMqttMessage(payload, this.opts.key);
+    } catch (err) {
+      this.log(`mqtt: failed to decode message: ${err.message}`);
+      return;
+    }
+    const objects = Array.isArray(msg.payload) ? msg.payload : [msg.payload];
+    for (const obj of objects) {
+      if (obj && typeof obj === "object") {
+        const notice = obj;
+        if (typeof notice.commandType === "number")
+          this.latestNotices.set(notice.commandType, notice);
+        for (const h of this.replyHandlers) h(notice);
+        for (const h of this.noticeHandlers) h(notice);
+      }
+    }
+  }
+  publish(topic, payload) {
+    if (!this.client) throw new Error("MQTT client not connected");
+    const packed = packMqttMessage({ guid: this.guid, payload, key: this.opts.key });
+    this.client.publish(topic, packed);
+  }
+  /** Subscribe to streaming notices. Returns an unsubscribe function. */
+  onNotice(handler) {
+    this.noticeHandlers.add(handler);
+    return () => this.noticeHandlers.delete(handler);
+  }
+  /** Publish a raw command payload (escape hatch for un-modeled commands). */
+  command(payload) {
+    this.publish(COMMAND_TOPIC(this.opts.sn), payload);
+  }
+  /** Publish a raw query payload. */
+  query(payload) {
+    this.publish(QUERY_TOPIC(this.opts.sn), payload);
+  }
+  /**
+   * Send a single gcode command and return the parsed response (§6). The result
+   * carries `truncated` when the firmware's snapshot was partial. Serialized:
+   * only one gcode is in flight at a time.
+   */
+  async gcode(command, opts = {}) {
+    const run = this.gcodeLock.then(() => this.gcodeOnce(command, opts));
+    this.gcodeLock = run.catch(() => void 0);
+    return run;
+  }
+  gcodeOnce(command, opts) {
+    const { timeoutMs = 1e4, quietMs = 600, wait = true } = opts;
+    const started = Date.now();
+    const payload = {
+      commandType: 1043 /* GCODE_COMMAND */,
+      cmdData: command,
+      cmdLen: Buffer.byteLength(command, "utf8")
+    };
+    if (!wait) {
+      this.command(payload);
+      return Promise.resolve(
+        parseGcodeResult(command, [], { durationMs: Date.now() - started, timedOut: false })
+      );
+    }
+    return new Promise((resolve) => {
+      const chunks = [];
+      let lastFrameAt = Date.now();
+      let settled = false;
+      const finish = (timedOut) => {
+        if (settled) return;
+        settled = true;
+        clearInterval(ticker);
+        this.replyHandlers.delete(collector);
+        resolve(parseGcodeResult(command, chunks, { durationMs: Date.now() - started, timedOut }));
+      };
+      const collector = (obj) => {
+        if (obj.commandType !== 1043 /* GCODE_COMMAND */) return;
+        const chunk = obj.resData;
+        if (typeof chunk === "string") {
+          chunks.push(chunk);
+          lastFrameAt = Date.now();
+        }
+      };
+      this.replyHandlers.add(collector);
+      this.command(payload);
+      const okGraceMs = Math.min(quietMs, 250);
+      const ticker = setInterval(
+        () => {
+          const now = Date.now();
+          const idle = now - lastFrameAt;
+          if (now - started >= timeoutMs) {
+            finish(true);
+          } else if (chunks.length > 0) {
+            const trailingOk = gcodeHasTerminalOk(reassembleRaw(chunks));
+            if (trailingOk && idle >= okGraceMs)
+              finish(false);
+            else if (idle >= quietMs) finish(false);
+          }
+        },
+        Math.max(25, Math.floor(okGraceMs / 2))
+      );
+    });
+  }
+  /**
+   * Snapshot current printer status by normalizing the latest notice of each
+   * type. Optionally nudges the printer with an APP_QUERY_STATUS query and waits
+   * briefly for fresh telemetry.
+   */
+  async getStatus(opts = {}) {
+    const { refresh = true, waitMs = 1200 } = opts;
+    if (refresh && this.client) {
+      this.query({ commandType: 1027 /* APP_QUERY_STATUS */ });
+      await new Promise((r) => setTimeout(r, waitMs));
+    }
+    return normalizeStatus([...this.latestNotices.values()]);
+  }
+  /** Throw a structured timeout error (used by waiters). */
+  static timeout(message, hint) {
+    throw new TimeoutError({ message, transport: "mqtt", hint });
+  }
+};
+
+// src/transport/https.ts
+var US_REGIONS = /* @__PURE__ */ new Set(["US", "CA", "MX", "BR", "AR", "CU", "BS", "AU", "NZ"]);
+function guessRegion(countryCode) {
+  return US_REGIONS.has(countryCode.toUpperCase()) ? "us" : "eu";
+}
+var LOGIN_HEADERS = {
+  App_name: "anker_make",
+  App_version: "",
+  Model_type: "PC",
+  Os_type: "windows",
+  Os_version: "10sp1"
+};
+function num2(v) {
+  return typeof v === "number" ? v : void 0;
+}
+function str(v, fallback = "") {
+  return typeof v === "string" ? v : fallback;
+}
+var AnkerHttpApi = class {
+  constructor(region, authToken) {
+    this.region = region;
+    this.authToken = authToken;
+  }
+  region;
+  authToken;
+  base() {
+    return `https://${API_HOSTS[this.region]}`;
+  }
+  async request(scope, path, body, auth = false) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...LOGIN_HEADERS
+    };
+    if (auth) {
+      if (!this.authToken) throw new AuthError({ message: "Missing auth token" });
+      headers["X-Auth-Token"] = this.authToken;
+    }
+    let resp;
+    try {
+      resp = await fetch(`${this.base()}${scope}${path}`, {
+        method: body ? "POST" : "GET",
+        headers,
+        ...body ? { body: JSON.stringify(body) } : {}
+      });
+    } catch (cause) {
+      throw new AuthError({
+        code: "https_unreachable",
+        message: `Could not reach Anker cloud API (${API_HOSTS[this.region]})`,
+        retriable: true,
+        hint: "Check your internet connection and try again.",
+        cause
+      });
+    }
+    if (!resp.ok) {
+      throw new AuthError({
+        code: "https_error",
+        message: `API request failed: ${resp.status} ${resp.statusText}`,
+        retriable: resp.status >= 500
+      });
+    }
+    const jsn = await resp.json();
+    if (num2(jsn.code) !== 0) {
+      throw this.apiError(jsn);
+    }
+    return jsn.data ?? {};
+  }
+  /** Translate a non-zero API response into a structured error (captcha-aware). */
+  apiError(jsn) {
+    const data = jsn.data ?? {};
+    const message = str(jsn.msg, "API error");
+    if (typeof data.captcha_id === "string") {
+      return new AuthError({
+        code: "captcha_required",
+        message: "Login requires solving a captcha challenge",
+        hint: "Re-run login with `--captcha-answer <text>` (and the captcha_id below). The captcha image URL is in `input`.",
+        input: {
+          captcha_id: data.captcha_id,
+          ...typeof data.item === "string" ? { captcha_image: data.item } : {}
+        }
+      });
+    }
+    return new AuthError({
+      code: "login_rejected",
+      message,
+      input: { api_code: num2(jsn.code) }
+    });
+  }
+  // --- /v2/passport/login ---
+  async login(opts) {
+    const { publicKey, encryptedPassword } = ecdhEncryptLoginPassword(opts.password);
+    const body = {
+      client_secret_info: { public_key: publicKey },
+      email: opts.email,
+      password: encryptedPassword
+    };
+    if (opts.captchaId) body.captcha_id = opts.captchaId;
+    if (opts.captchaAnswer) body.answer = opts.captchaAnswer;
+    const data = await this.request("/v2/passport/login", "", body);
+    const authToken = str(data.auth_token);
+    if (!authToken) {
+      throw new AuthError({ code: "login_failed", message: "Login returned no auth token" });
+    }
+    return {
+      auth_token: authToken,
+      user_id: str(data.user_id),
+      email: str(data.email, opts.email),
+      region: this.region,
+      ab_code: str(data.ab_code) || void 0
+    };
+  }
+  // --- /v1/passport/profile ---
+  async profile() {
+    const data = await this.request("/v1/passport", "/profile", void 0, true);
+    const country = data.country?.code;
+    return {
+      user_id: str(data.user_id),
+      email: str(data.email),
+      country: str(country)
+    };
+  }
+  // --- /v1/app/query_fdm_list ---
+  async queryFdmList() {
+    const data = await this.request("/v1/app", "/query_fdm_list", {}, true);
+    return Array.isArray(data) ? data : data.data ?? [];
+  }
+  // --- /v1/app/equipment/get_dsk_keys ---
+  async getDskKeys(stationSns) {
+    const data = await this.request(
+      "/v1/app",
+      "/equipment/get_dsk_keys",
+      { invalid_dsks: {}, station_sns: stationSns },
+      true
+    );
+    const out = {};
+    for (const dsk of data.dsk_keys ?? []) {
+      const sn = str(dsk.station_sn);
+      if (sn) out[sn] = str(dsk.dsk_key);
+    }
+    return out;
+  }
+};
+function toPrinter(pr, dskKeys) {
+  const sn = str(pr.station_sn);
+  return {
+    id: str(pr.station_id),
+    sn,
+    name: str(pr.station_name),
+    model: str(pr.station_model),
+    duid: str(pr.p2p_did),
+    ip_addr: str(pr.ip_addr),
+    wifi_mac: str(pr.wifi_mac),
+    mqtt_key: str(pr.secret_key),
+    p2p_key: dskKeys[sn] ?? "",
+    api_hosts: pr.app_conn ? ppppDecodeInitstring(str(pr.app_conn)) : [],
+    p2p_hosts: pr.p2p_conn ? ppppDecodeInitstring(str(pr.p2p_conn)) : []
+  };
+}
+async function loginAndBuildConfig(opts) {
+  const region = guessRegion(opts.country);
+  const api = new AnkerHttpApi(region);
+  const login = await api.login(opts);
+  const authed = new AnkerHttpApi(region, login.auth_token);
+  const profile = await authed.profile();
+  const printersRaw = await authed.queryFdmList();
+  const sns = printersRaw.map((p) => str(p.station_sn)).filter(Boolean);
+  const dskKeys = sns.length ? await authed.getDskKeys(sns) : {};
+  const printers = printersRaw.map((p) => toPrinter(p, dskKeys)).sort((a, b) => Number(a.id) - Number(b.id));
+  return {
+    account: {
+      user_id: profile.user_id || login.user_id,
+      auth_token: login.auth_token,
+      email: profile.email || login.email,
+      region,
+      country: profile.country || opts.country.toUpperCase()
+    },
+    printers
+  };
+}
+
+// src/transport/pppp/client.ts
+import { createSocket } from "dgram";
+
+// src/transport/pppp/packets.ts
+var MSG_MAGIC = 241;
+var FileTransferReply = /* @__PURE__ */ ((FileTransferReply2) => {
+  FileTransferReply2[FileTransferReply2["OK"] = 0] = "OK";
+  FileTransferReply2[FileTransferReply2["ERR_TIMEOUT"] = 252] = "ERR_TIMEOUT";
+  FileTransferReply2[FileTransferReply2["ERR_FRAME_TYPE"] = 253] = "ERR_FRAME_TYPE";
+  FileTransferReply2[FileTransferReply2["ERR_WRONG_MD5"] = 254] = "ERR_WRONG_MD5";
+  FileTransferReply2[FileTransferReply2["ERR_BUSY"] = 255] = "ERR_BUSY";
+  return FileTransferReply2;
+})(FileTransferReply || {});
+function parseDuidString(s) {
+  const [prefix, serial, check] = s.split("-");
+  return { prefix: prefix ?? "", serial: Number(serial ?? 0), check: check ?? "" };
+}
+function duidToString(d) {
+  return `${d.prefix}-${String(d.serial).padStart(6, "0")}-${d.check}`;
+}
+function writeDuid(w, d) {
+  w.string(d.prefix, 8).u32be(d.serial).string(d.check, 6).zeroes(2);
+}
+function readDuid(r) {
+  const prefix = r.string(8);
+  const serial = r.u32be();
+  const check = r.string(6);
+  r.zeroes(2);
+  return { prefix, serial, check };
+}
+function writeHost(w, h) {
+  w.zeroes(1).u8(h.afam).u16le(h.port).ipv4(h.addr).zeroes(8);
+}
+function wrapMessage(type, body) {
+  return new BufWriter().u8(MSG_MAGIC).u8(type).u16be(body.length).bytes(body).build();
+}
+function parseMessage(buf) {
+  const r = new BufReader(buf);
+  const magic = r.u8();
+  if (magic !== MSG_MAGIC) throw new Error(`bad PPPP magic: 0x${magic.toString(16)}`);
+  const type = r.u8();
+  const size = r.u16be();
+  const body = r.bytes(size);
+  const out = { type, body };
+  switch (type) {
+    case 65 /* PUNCH_PKT */:
+    case 66 /* P2P_RDY */: {
+      out.duid = readDuid(new BufReader(body));
+      break;
+    }
+    case 208 /* DRW */: {
+      const b = new BufReader(body);
+      b.magic(Buffer.from([209]));
+      out.chan = b.u8();
+      out.index = b.u16be();
+      out.data = b.tail();
+      break;
+    }
+    case 209 /* DRW_ACK */: {
+      const b = new BufReader(body);
+      b.magic(Buffer.from([209]));
+      out.chan = b.u8();
+      const count = b.u16be();
+      out.acks = Array.from({ length: count }, () => b.u16be());
+      break;
+    }
+    case 249 /* REPORT_SESSION_READY */: {
+      try {
+        out.duid = readDuid(new BufReader(simpleDecrypt(body)));
+      } catch {
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return out;
+}
+var pktLanSearch = () => wrapMessage(48 /* LAN_SEARCH */, Buffer.alloc(0));
+var pktClose = () => wrapMessage(240 /* CLOSE */, Buffer.alloc(0));
+var pktAliveAck = () => wrapMessage(225 /* ALIVE_ACK */, Buffer.alloc(0));
+function pktP2pRdy(duid) {
+  const w = new BufWriter();
+  writeDuid(w, duid);
+  return wrapMessage(66 /* P2P_RDY */, w.build());
+}
+function pktP2pRdyAck(duid, host) {
+  const w = new BufWriter();
+  writeDuid(w, duid);
+  writeHost(w, host);
+  w.zeroes(8);
+  return wrapMessage(67 /* P2P_RDY_ACK */, w.build());
+}
+function pktHelloAck(host) {
+  const w = new BufWriter();
+  writeHost(w, host);
+  return wrapMessage(1 /* HELLO_ACK */, w.build());
+}
+function pktDevLgnAckCrc() {
+  return wrapMessage(19 /* DEV_LGN_ACK_CRC */, cryptoCurseString(Buffer.alloc(4)));
+}
+function pktDrw(chan, index, data) {
+  const body = new BufWriter().u8(209).u8(chan).u16be(index).bytes(data).build();
+  return wrapMessage(208 /* DRW */, body);
+}
+function pktDrwAck(chan, acks) {
+  const w = new BufWriter().u8(209).u8(chan).u16be(acks.length);
+  for (const a of acks) w.u16be(a);
+  return wrapMessage(209 /* DRW_ACK */, w.build());
+}
+function packXzyh(opts) {
+  const { cmd, data, chan = 0, signCode = 0, devType = 0 } = opts;
+  return new BufWriter().bytes(Buffer.from("XZYH", "ascii")).u16le(cmd).u32le(data.length).u8(0).u8(0).u8(chan).u8(signCode).u8(0).u8(devType).bytes(data).build();
+}
+var AABB_SIG = Buffer.from([170, 187]);
+function packAabbHeader(h) {
+  return new BufWriter().bytes(AABB_SIG).u8(h.frametype).u8(h.sn).u32le(h.pos).u32le(h.len).build();
+}
+function packAabb(frametype, data, opts = {}) {
+  const header = packAabbHeader({
+    frametype,
+    sn: opts.sn ?? 0,
+    pos: opts.pos ?? 0,
+    len: data.length
+  });
+  const crc = ppcsCrc16(Buffer.concat([header.subarray(2), data]));
+  return Buffer.concat([header, data, crc]);
+}
+function parseAabbWithCrc(buf) {
+  const head = buf.subarray(0, 12);
+  const r = new BufReader(head);
+  r.magic(AABB_SIG);
+  const frametype = r.u8();
+  const sn = r.u8();
+  const pos = r.u32le();
+  const len = r.u32le();
+  const data = buf.subarray(12, 12 + len);
+  const crc1 = buf.subarray(12 + len, 12 + len + 2);
+  const crc2 = ppcsCrc16(Buffer.concat([head.subarray(2), data]));
+  if (!crc1.equals(crc2)) throw new Error("AABB CRC mismatch");
+  return { header: { frametype, sn, pos, len }, data: Buffer.from(data) };
+}
+function sanitizeFilename(name) {
+  const base = name.split(/[\\/]/).pop() ?? name;
+  const cleaned = [...base].map((c) => /[A-Za-z0-9._-]/.test(c) ? c : "_").join("");
+  return cleaned.replace(/^\.+/, "").replace(/\.\./g, ".");
+}
+function packFileUploadInfo(f) {
+  const type = f.type ?? 0;
+  const str2 = `${type},${f.name},${f.size},${f.md5},${f.userName},${f.userId},${f.machineId}`;
+  return Buffer.concat([Buffer.from(str2, "utf8"), Buffer.from([0])]);
+}
+
+// src/transport/pppp/channel.ts
+var U16 = 65535;
+var trunc = (n) => n & U16;
+function cyclicLt(a, b, wrap = 256) {
+  a = trunc(a);
+  b = trunc(b);
+  if ((a ^ b) & 32768) return trunc(a - wrap) < trunc(b - wrap);
+  return a < b;
+}
+function cyclicGt(a, b, wrap = 256) {
+  a = trunc(a);
+  b = trunc(b);
+  if ((a ^ b) & 32768) return trunc(a - wrap) > trunc(b - wrap);
+  return a > b;
+}
+var cyclicGte = (a, b, wrap = 256) => !cyclicLt(a, b, wrap);
+var CHUNK = 1024;
+var Channel = class {
+  constructor(index, timeoutMs = 500, maxInFlight = 64) {
+    this.index = index;
+    this.timeoutMs = timeoutMs;
+    this.maxInFlight = maxInFlight;
+  }
+  index;
+  timeoutMs;
+  maxInFlight;
+  txCtr = 0;
+  txAck = 0;
+  backlog = [];
+  txqueue = /* @__PURE__ */ new Map();
+  acks = /* @__PURE__ */ new Set();
+  ackWaiters = [];
+  rxCtr = 0;
+  rxqueue = /* @__PURE__ */ new Map();
+  rxBuf = Buffer.alloc(0);
+  rxWaiters = [];
+  // --- transmit side ---
+  /** Queue `payload` for reliable delivery; returns its sequence range. */
+  write(payload) {
+    const start = this.txCtr;
+    let rest = payload;
+    do {
+      const data = rest.subarray(0, CHUNK);
+      rest = rest.subarray(CHUNK);
+      this.backlog.push({ ctr: this.txCtr, data });
+      this.txCtr = trunc(this.txCtr + 1);
+    } while (rest.length > 0);
+    return { start, done: this.txCtr };
+  }
+  /** Resolve once every chunk up to (but excluding) `done` has been ACKed. */
+  ackUpTo(done) {
+    if (cyclicGte(this.txAck, done)) return Promise.resolve();
+    return new Promise((resolve) => this.ackWaiters.push({ ctr: done, resolve }));
+  }
+  /** Apply received ACKs, advancing `txAck` and releasing waiters. */
+  rxAck(acks) {
+    for (const a of acks) {
+      this.txqueue.delete(a);
+      if (cyclicGte(a, this.txAck)) this.acks.add(a);
+    }
+    while (this.acks.has(this.txAck)) {
+      this.acks.delete(this.txAck);
+      this.txAck = trunc(this.txAck + 1);
+    }
+    for (let i = this.ackWaiters.length - 1; i >= 0; i--) {
+      if (cyclicGte(this.txAck, this.ackWaiters[i].ctr)) {
+        this.ackWaiters.splice(i, 1)[0].resolve();
+      }
+    }
+  }
+  /** Produce DRW packets to (re)transmit; called on each poll tick. */
+  poll(now) {
+    while (this.backlog.length && this.txqueue.size < this.maxInFlight) {
+      const item = this.backlog.shift();
+      this.txqueue.set(item.ctr, { deadline: now, data: item.data });
+    }
+    const out = [];
+    for (const [ctr, entry] of this.txqueue) {
+      if (entry.deadline <= now) {
+        out.push(pktDrw(this.index, ctr, entry.data));
+        entry.deadline = now + this.timeoutMs;
+      }
+    }
+    return out;
+  }
+  /** True once all queued writes have been fully ACKed. */
+  get drained() {
+    return this.backlog.length === 0 && this.txqueue.size === 0;
+  }
+  // --- receive side ---
+  /** Ingest a received DRW chunk, reordering into the contiguous stream. */
+  rxDrw(index, data) {
+    if (cyclicGt(this.rxCtr, index)) return;
+    this.rxqueue.set(trunc(index), data);
+    let advanced = false;
+    while (this.rxqueue.has(this.rxCtr)) {
+      const chunk = this.rxqueue.get(this.rxCtr);
+      this.rxqueue.delete(this.rxCtr);
+      this.rxCtr = trunc(this.rxCtr + 1);
+      this.rxBuf = Buffer.concat([this.rxBuf, chunk]);
+      advanced = true;
+    }
+    if (advanced) {
+      for (const w of this.rxWaiters.splice(0)) w();
+    }
+  }
+  waitForData(timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const timer = timeoutMs !== void 0 ? setTimeout(() => {
+        const i = this.rxWaiters.indexOf(onData);
+        if (i >= 0) this.rxWaiters.splice(i, 1);
+        reject(new Error("channel read timeout"));
+      }, timeoutMs) : void 0;
+      const onData = () => {
+        if (timer) clearTimeout(timer);
+        resolve();
+      };
+      this.rxWaiters.push(onData);
+    });
+  }
+  /** Read exactly `n` bytes from the reassembled stream (awaiting more). */
+  async read(n, timeoutMs) {
+    while (this.rxBuf.length < n) {
+      await this.waitForData(timeoutMs);
+    }
+    const out = this.rxBuf.subarray(0, n);
+    this.rxBuf = this.rxBuf.subarray(n);
+    return Buffer.from(out);
+  }
+};
+
+// src/transport/pppp/client.ts
+var PPPP_LAN_PORT = 32108;
+var PpppState = /* @__PURE__ */ ((PpppState2) => {
+  PpppState2[PpppState2["Idle"] = 1] = "Idle";
+  PpppState2[PpppState2["Connecting"] = 2] = "Connecting";
+  PpppState2[PpppState2["Connected"] = 3] = "Connected";
+  PpppState2[PpppState2["Disconnected"] = 4] = "Disconnected";
+  return PpppState2;
+})(PpppState || {});
+function discoverLan(opts = {}) {
+  const { timeoutMs = 1e3, bindAddr, log = () => {
+  } } = opts;
+  return new Promise((resolve, reject) => {
+    const sock = createSocket({ type: "udp4", reuseAddr: true });
+    const found = /* @__PURE__ */ new Map();
+    const done = () => {
+      try {
+        sock.close();
+      } catch {
+      }
+      resolve([...found].map(([duid, ip]) => ({ duid, ip })));
+    };
+    sock.on("error", (err) => {
+      try {
+        sock.close();
+      } catch {
+      }
+      reject(err);
+    });
+    sock.on("message", (data, rinfo) => {
+      try {
+        const msg = parseMessage(data);
+        if (msg.type === 65 /* PUNCH_PKT */ && msg.duid) {
+          found.set(duidToString(msg.duid), rinfo.address);
+        }
+      } catch {
+      }
+    });
+    sock.bind(bindAddr ? { address: bindAddr, port: 0 } : { port: 0 }, () => {
+      sock.setBroadcast(true);
+      log(`pppp: broadcasting LAN_SEARCH (timeout ${timeoutMs}ms)`);
+      sock.send(pktLanSearch(), PPPP_LAN_PORT, "255.255.255.255");
+      setTimeout(done, timeoutMs);
+    });
+  });
+}
+var AnkerPpppClient = class {
+  sock;
+  addr;
+  duid;
+  chans = Array.from({ length: 8 }, (_, i) => new Channel(i));
+  pollTimer;
+  log;
+  state = 1 /* Idle */;
+  connectResolve;
+  connectReject;
+  constructor(opts) {
+    this.duid = parseDuidString(opts.duid);
+    this.addr = { host: opts.host, port: opts.port ?? PPPP_LAN_PORT };
+    this.log = opts.log ?? (() => {
+    });
+  }
+  get host() {
+    return { afam: 2, port: this.addr.port, addr: this.addr.host };
+  }
+  send(buf) {
+    this.sock?.send(buf, this.addr.port, this.addr.host);
+  }
+  /** Connect over the LAN via the punch/ready handshake. */
+  connect(timeoutMs = 1e4) {
+    this.sock = createSocket("udp4");
+    this.sock.on("message", (data, rinfo) => {
+      this.addr = { host: rinfo.address, port: rinfo.port };
+      this.process(data);
+    });
+    this.sock.on("error", (err) => this.failConnect(err));
+    this.state = 2 /* Connecting */;
+    const ready = new Promise((resolve, reject) => {
+      this.connectResolve = resolve;
+      this.connectReject = reject;
+    });
+    this.send(pktLanSearch());
+    this.pollTimer = setInterval(() => this.pollChannels(), 20);
+    const timer = setTimeout(() => {
+      if (this.state !== 3 /* Connected */) {
+        this.failConnect(
+          new TimeoutError({
+            message: `PPPP handshake to ${this.addr.host} timed out`,
+            transport: "pppp",
+            hint: "The printer may be off-LAN or asleep. Re-run `ankerts discover --store` and retry."
+          })
+        );
+      }
+    }, timeoutMs);
+    return ready.finally(() => clearTimeout(timer));
+  }
+  failConnect(err) {
+    this.state = 4 /* Disconnected */;
+    this.stop();
+    this.connectReject?.(err);
+    this.connectReject = void 0;
+    this.connectResolve = void 0;
+  }
+  pollChannels() {
+    const now = Date.now();
+    for (const ch of this.chans) {
+      for (const pkt of ch.poll(now)) this.send(pkt);
+    }
+  }
+  process(data) {
+    let msg;
+    try {
+      msg = parseMessage(data);
+    } catch {
+      return;
+    }
+    switch (msg.type) {
+      case 240 /* CLOSE */:
+        this.failConnect(new Error("PPPP connection closed by device"));
+        break;
+      case 224 /* ALIVE */:
+        this.send(pktAliveAck());
+        break;
+      case 208 /* DRW */:
+        if (msg.chan !== void 0 && msg.index !== void 0 && msg.data) {
+          this.send(pktDrwAck(msg.chan, [msg.index]));
+          this.chans[msg.chan]?.rxDrw(msg.index, msg.data);
+        }
+        break;
+      case 209 /* DRW_ACK */:
+        if (msg.chan !== void 0 && msg.acks) this.chans[msg.chan]?.rxAck(msg.acks);
+        break;
+      case 18 /* DEV_LGN_CRC */:
+        this.send(pktDevLgnAckCrc());
+        break;
+      case 0 /* HELLO */:
+        this.send(pktHelloAck(this.host));
+        break;
+      case 66 /* P2P_RDY */:
+        this.send(pktP2pRdyAck(this.duid, this.host));
+        this.state = 3 /* Connected */;
+        this.connectResolve?.();
+        this.connectResolve = void 0;
+        this.connectReject = void 0;
+        this.log("pppp: connected");
+        break;
+      case 65 /* PUNCH_PKT */:
+        if (this.state === 2 /* Connecting */) {
+          this.send(pktClose());
+          this.send(pktP2pRdy(this.duid));
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  stop() {
+    if (this.pollTimer) clearInterval(this.pollTimer);
+    this.pollTimer = void 0;
+    if (this.sock) {
+      try {
+        if (this.state === 3 /* Connected */) this.send(pktClose());
+        this.sock.close();
+      } catch {
+      }
+      this.sock = void 0;
+    }
+  }
+  /** Send one channel-1 AABB request and await the printer's reply byte. */
+  async aabbRequest(frametype, data, opts = {}) {
+    const ch = this.chans[1];
+    const { done } = ch.write(packAabb(frametype, data, { pos: opts.pos ?? 0 }));
+    await ch.ackUpTo(done);
+    const replyTimeout = opts.replyTimeoutMs ?? 3e4;
+    const head = await ch.read(12, replyTimeout);
+    const len = head.readUInt32LE(8);
+    const rest = await ch.read(len + 2, replyTimeout);
+    const { data: payload } = parseAabbWithCrc(Buffer.concat([head, rest]));
+    const reply = payload[0] ?? 255 /* ERR_BUSY */;
+    if (reply !== 0 /* OK */) {
+      throw new PrinterRejectedError({
+        code: "upload_rejected",
+        message: `Printer rejected file transfer: ${FileTransferReply[reply] ?? reply}`,
+        transport: "pppp"
+      });
+    }
+    return reply;
+  }
+  /**
+   * Upload a gcode file and (by default) start the print. Mirrors the reference
+   * web service: XZYH(P2P_SEND_FILE) → AABB BEGIN (metadata) → AABB DATA chunks
+   * → AABB END (starts printing).
+   */
+  async uploadFile(filename, data, opts = {}) {
+    if (this.state !== 3 /* Connected */) {
+      throw new TransportUnavailableError({
+        message: "PPPP not connected \u2014 cannot upload",
+        transport: "pppp",
+        hint: "Run discovery and connect to the printer on the LAN first."
+      });
+    }
+    const name = sanitizeFilename(filename);
+    const md5 = md5Hex(data);
+    const fui = packFileUploadInfo({
+      name,
+      size: data.length,
+      md5,
+      userName: opts.userName ?? "ankerts",
+      userId: opts.userId ?? "-",
+      machineId: opts.machineId ?? "-"
+    });
+    const token = Buffer.from(
+      globalThis.crypto.randomUUID().replace(/-/g, "").slice(0, 16),
+      "utf8"
+    );
+    const ch0 = this.chans[0];
+    const { done: tokenDone } = ch0.write(packXzyh({ cmd: 15e3 /* P2P_SEND_FILE */, data: token }));
+    await ch0.ackUpTo(tokenDone);
+    this.log(`pppp: uploading ${data.length} bytes as ${name}`);
+    await this.aabbRequest(0 /* BEGIN */, Buffer.concat([fui, Buffer.from([0])]));
+    const blockSize = 1024 * 32;
+    let sent = 0;
+    for (let pos = 0; pos < data.length; pos += blockSize) {
+      const chunk = data.subarray(pos, pos + blockSize);
+      await this.aabbRequest(1 /* DATA */, chunk, { pos });
+      sent += chunk.length;
+      opts.onProgress?.({ sent, total: data.length, pct: sent / data.length * 100 });
+    }
+    const started = opts.start !== false;
+    if (started) {
+      await this.aabbRequest(2 /* END */, Buffer.alloc(0));
+    }
+    return { name, size: data.length, md5, started };
+  }
+};
+
+// src/wait.ts
+var TEMP_STABLE_DELTA = 2;
+function parseWaitCondition(input) {
+  const s = input.trim();
+  const cmp = /^(nozzle|bed|progress|layer)\s*>=\s*(-?\d+(?:\.\d+)?)$/.exec(s);
+  if (cmp) {
+    const value = Number(cmp[2]);
+    switch (cmp[1]) {
+      case "nozzle":
+        return { kind: "nozzle", atLeast: value };
+      case "bed":
+        return { kind: "bed", atLeast: value };
+      case "progress":
+        return { kind: "progress", atLeast: value };
+      case "layer":
+        return { kind: "layer", atLeast: value };
+    }
+  }
+  switch (s) {
+    case "connected":
+    case "lan":
+    case "temp-stable":
+    case "printing":
+    case "idle":
+    case "complete":
+    case "failed":
+    case "cancelled":
+    case "runout":
+      return { kind: s };
+    default:
+      throw new Error(
+        `unknown wait condition: "${input}" (try connected|lan|nozzle>=C|bed>=C|temp-stable|printing|idle|progress>=pct|layer>=n|complete|failed|cancelled|runout)`
+      );
+  }
+}
+function describeWaitCondition(cond) {
+  switch (cond.kind) {
+    case "nozzle":
+      return `nozzle>=${cond.atLeast}`;
+    case "bed":
+      return `bed>=${cond.atLeast}`;
+    case "progress":
+      return `progress>=${cond.atLeast}`;
+    case "layer":
+      return `layer>=${cond.atLeast}`;
+    default:
+      return cond.kind;
+  }
+}
+function conditionHolds(cond, status) {
+  const job = status.job;
+  switch (cond.kind) {
+    case "connected":
+    case "lan":
+      return null;
+    case "nozzle":
+      return status.nozzle.current >= cond.atLeast;
+    case "bed":
+      return status.bed.current >= cond.atLeast;
+    case "temp-stable": {
+      const nozzleOk = status.nozzle.target > 0 && Math.abs(status.nozzle.current - status.nozzle.target) <= TEMP_STABLE_DELTA;
+      const bedOk = status.bed.target <= 0 || Math.abs(status.bed.current - status.bed.target) <= TEMP_STABLE_DELTA;
+      return nozzleOk && bedOk;
+    }
+    case "printing":
+      return job?.state === "printing";
+    case "idle":
+      return !job || job.state === "idle" || job.state === "complete";
+    case "progress":
+      return (job?.progressPct ?? -1) >= cond.atLeast;
+    case "layer":
+      return (job?.layer ?? -1) >= cond.atLeast;
+    case "complete":
+      return job?.state === "complete";
+    case "failed":
+      return job?.state === "failed";
+    case "cancelled":
+      return job?.state === "cancelled";
+    case "runout":
+      return job?.state === "failed" || JSON.stringify(status.raw).toLowerCase().includes("runout");
+  }
+}
+
+// src/client.ts
+function defaultTimeoutFor(command) {
+  const code = /^\s*([GM]\d+)/i.exec(command)?.[1]?.toUpperCase();
+  switch (code) {
+    case "M109":
+    // heat-and-wait hotend
+    case "M190":
+    // heat-and-wait bed
+    case "M303":
+    // PID autotune
+    case "G29":
+      return 6e5;
+    // minutes
+    case "G28":
+    // homing
+    case "M400":
+      return 12e4;
+    default:
+      return 1e4;
+  }
+}
+var AnkerClient = class _AnkerClient {
+  config;
+  store;
+  log;
+  insecure;
+  printerRef;
+  mqtt;
+  constructor(config, opts = {}) {
+    this.config = config;
+    this.store = opts.store;
+    this.log = opts.log ?? (() => {
+    });
+    this.insecure = opts.insecure ?? false;
+    this.printerRef = opts.printer;
+  }
+  // --- construction / auth (HTTPS) ---
+  static async login(opts) {
+    const config = await loginAndBuildConfig(opts);
+    const store = new ConfigStore();
+    if (opts.save) store.save(config);
+    return new _AnkerClient(config, { store });
+  }
+  static fromStoredConfig(path, opts = {}) {
+    const store = opts.store ?? new ConfigStore(path);
+    return new _AnkerClient(store.load(), { ...opts, store });
+  }
+  getConfig() {
+    return this.config;
+  }
+  // --- account / selection ---
+  listPrinters() {
+    return this.config.printers;
+  }
+  selectPrinter(ref) {
+    const printer = findPrinter(this.config, ref);
+    if (!printer) throw this.notFound(ref);
+    this.printerRef = printer.duid;
+    this.config.selected = printer.duid;
+    this.store?.update((c) => {
+      c.selected = printer.duid;
+    });
+    return printer;
+  }
+  /** The currently selected printer (explicit ref → stored default → first). */
+  currentPrinter() {
+    if (this.config.printers.length === 0) {
+      throw new PrinterNotFoundError({
+        message: "No printers configured",
+        hint: "Run `ankerts login --save` to populate the account's printer list."
+      });
+    }
+    const ref = this.printerRef ?? this.config.selected;
+    if (ref !== void 0) {
+      const p = findPrinter(this.config, ref);
+      if (!p) throw this.notFound(ref);
+      return p;
+    }
+    return this.config.printers[0];
+  }
+  notFound(ref) {
+    return new PrinterNotFoundError({
+      message: `Printer "${ref}" not found on the account`,
+      hint: "List printers with `ankerts printer list`.",
+      input: { printer: ref }
+    });
+  }
+  account() {
+    if (!this.config.account) {
+      throw new PrinterNotFoundError({
+        code: "not_logged_in",
+        message: "Not logged in",
+        transport: "https",
+        hint: "Run `ankerts login --email \u2026 --password \u2026 --country \u2026 --save`."
+      });
+    }
+    return this.config.account;
+  }
+  // --- MQTT lifecycle ---
+  async ensureMqtt() {
+    if (this.mqtt?.connected) return this.mqtt;
+    const account = this.account();
+    const printer = this.currentPrinter();
+    this.mqtt = new AnkerMqttClient({
+      sn: printer.sn,
+      key: unhex(printer.mqtt_key),
+      host: mqttHostFor(account, printer),
+      username: mqttUsername(account),
+      password: mqttPassword(account),
+      insecure: this.insecure,
+      log: this.log
+    });
+    await this.mqtt.connect();
+    return this.mqtt;
+  }
+  /** Close any open transports. */
+  async close() {
+    await this.mqtt?.disconnect();
+    this.mqtt = void 0;
+  }
+  // --- telemetry / status (MQTT) ---
+  async getStatus() {
+    const mqtt2 = await this.ensureMqtt();
+    return mqtt2.getStatus();
+  }
+  async subscribeEvents(handler) {
+    const mqtt2 = await this.ensureMqtt();
+    return mqtt2.onNotice(handler);
+  }
+  // --- gcode (MQTT, §6) ---
+  async gcode(command, opts = {}) {
+    const mqtt2 = await this.ensureMqtt();
+    const timeoutMs = opts.timeoutMs ?? defaultTimeoutFor(command);
+    const result = await mqtt2.gcode(command, { timeoutMs, quietMs: opts.quietMs, wait: opts.wait });
+    if (opts.waitMotion && opts.wait !== false) {
+      const motion = await mqtt2.gcode("M400", { timeoutMs: defaultTimeoutFor("M400") });
+      return {
+        ...result,
+        raw: `${result.raw}
+${motion.raw}`,
+        lines: [...result.lines, ...motion.lines],
+        ok: motion.ok,
+        timedOut: result.timedOut || motion.timedOut,
+        frames: result.frames + motion.frames,
+        durationMs: result.durationMs + motion.durationMs
+      };
+    }
+    return result;
+  }
+  /** Run many commands, yielding each result as it completes (NDJSON-friendly). */
+  async *gcodeBatch(commands, opts = {}) {
+    for (const command of commands) {
+      if (command.trim() === "") continue;
+      yield await this.gcode(command, opts);
+    }
+  }
+  // --- state helpers ---
+  async snapshotState() {
+    const result = await this.gcode("M503", { timeoutMs: 15e3 });
+    const reports = result.reports;
+    const pid = reports.M301?.match(/P([\d.]+)\s+I([\d.]+)\s+D([\d.]+)/);
+    const settings = { result, reports };
+    if (reports.M900) {
+      const k = reports.M900.match(/K([\d.]+)/);
+      if (k) settings.linearAdvanceK = Number(k[1]);
+    }
+    if (pid) settings.hotendPid = { p: Number(pid[1]), i: Number(pid[2]), d: Number(pid[3]) };
+    if (reports.M92) settings.steps = reports.M92;
+    const z = reports.M851?.match(/Z(-?[\d.]+)/);
+    if (z) settings.probeZOffset = Number(z[1]);
+    return settings;
+  }
+  async restoreState() {
+    return this.gcode("M501", { timeoutMs: 15e3 });
+  }
+  // --- job control (MQTT) ---
+  //
+  // PRINT_CONTROL (0x03f0) with the `value` codes in PrintControl, reverse-
+  // engineered and confirmed live against an M5 (2026-06-07): cancel drops the
+  // job to idle with heaters off; pause/resume toggle the print.
+  async cancelJob() {
+    (await this.ensureMqtt()).command({
+      commandType: 1008 /* PRINT_CONTROL */,
+      value: 4 /* STOP */
+    });
+  }
+  async pauseJob() {
+    (await this.ensureMqtt()).command({
+      commandType: 1008 /* PRINT_CONTROL */,
+      value: 2 /* PAUSE */
+    });
+  }
+  async resumeJob() {
+    (await this.ensureMqtt()).command({
+      commandType: 1008 /* PRINT_CONTROL */,
+      value: 3 /* RESUME */
+    });
+  }
+  // --- discovery + jobs (PPPP, LAN) ---
+  async discoverLan(opts = {}) {
+    const { retries = 3, timeoutMs = 1e3, store = false } = opts;
+    let found = [];
+    for (let attempt = 1; attempt <= retries; attempt++) {
+      this.log(`pppp: LAN discovery attempt ${attempt}/${retries}`);
+      found = await discoverLan({ timeoutMs, log: this.log });
+      if (found.length > 0) break;
+    }
+    if (store && found.length > 0) {
+      this.config = this.persistDiscoveredIps(found);
+    }
+    return found;
+  }
+  persistDiscoveredIps(found) {
+    const apply = (c) => {
+      for (const f of found) {
+        const p = c.printers.find((x) => x.duid === f.duid);
+        if (p) p.ip_addr = f.ip;
+      }
+    };
+    if (this.store) return this.store.update(apply);
+    apply(this.config);
+    return this.config;
+  }
+  /**
+   * Upload a gcode file over the LAN and (by default) start the print. Auto-runs
+   * discovery if the printer's IP is unknown; if it's still unreachable, throws
+   * {@link TransportUnavailableError} (exit 6) naming the transport and the fix.
+   */
+  async uploadAndPrint(file, opts = {}) {
+    let printer = this.currentPrinter();
+    const filename = opts.filename ?? (typeof file === "string" ? basename(file) : "print.gcode");
+    let data;
+    if (typeof file === "string") {
+      try {
+        data = await readFile(file);
+      } catch (cause) {
+        throw new UsageError({
+          code: "file_not_found",
+          message: `Cannot read gcode file: ${file}`,
+          hint: "Check the path. Provide a sliced .gcode file to upload.",
+          input: { file },
+          cause
+        });
+      }
+    } else {
+      data = file;
+    }
+    if (opts.fixMetadata !== false) {
+      const transcoded = transcodeMetadata(data.toString("utf8"));
+      if (transcoded.changed) {
+        this.log(`transcoder: injected Anker metadata (${JSON.stringify(transcoded.injected)})`);
+        data = Buffer.from(transcoded.content, "utf8");
+      }
+    }
+    if (!printer.ip_addr) {
+      this.log("pppp: no stored IP \u2014 running discovery");
+      await this.discoverLan({ store: true });
+      printer = this.currentPrinter();
+    }
+    if (!printer.ip_addr) {
+      throw new TransportUnavailableError({
+        code: "lan_printer_unreachable",
+        message: `Printer ${printer.duid} not found on the local network`,
+        transport: "pppp",
+        hint: "File upload is LAN-only (PPPP). Run `ankerts discover --store` while on the same LAN as the printer, then retry.",
+        input: { file: filename }
+      });
+    }
+    const pppp = new AnkerPpppClient({ duid: printer.duid, host: printer.ip_addr, log: this.log });
+    try {
+      await pppp.connect();
+      const account = this.config.account;
+      const res = await pppp.uploadFile(filename, data, {
+        start: opts.start,
+        userName: account?.email ?? "ankerts",
+        userId: account?.user_id ?? "-",
+        onProgress: opts.onProgress
+      });
+      return { ...res, transport: "lan", duid: printer.duid, ip: printer.ip_addr };
+    } finally {
+      pppp.stop();
+    }
+  }
+  // --- waiting (§6A) ---
+  /**
+   * Block until `cond` holds, resolving the current status. Re-attachable: it
+   * re-derives state from fresh snapshots, so a re-issued wait still resolves.
+   * Rejects with a retriable {@link TimeoutError} (exit 5) on timeout.
+   */
+  async waitFor(cond, opts = {}) {
+    const { pollMs = 2e3, timeoutMs = 6e5, onTick } = opts;
+    const deadline = Date.now() + timeoutMs;
+    if (cond.kind === "connected") {
+      await this.ensureMqtt();
+      return this.getStatus();
+    }
+    if (cond.kind === "lan") {
+      const found = await this.discoverLan({ store: true, retries: Math.ceil(timeoutMs / 1e3) });
+      if (found.length === 0) {
+        throw new TimeoutError({
+          message: "Printer not found on the local network within the timeout",
+          transport: "pppp",
+          hint: "Ensure you are on the same LAN as the printer and it is powered on."
+        });
+      }
+      return this.getStatus();
+    }
+    for (; ; ) {
+      const status = await this.getStatus();
+      onTick?.(status);
+      if (conditionHolds(cond, status) === true) return status;
+      if (Date.now() >= deadline) {
+        throw new TimeoutError({
+          message: `Condition "${cond.kind}" not met within ${timeoutMs}ms`,
+          transport: "mqtt",
+          hint: "Waits are re-attachable \u2014 re-run the same `printer wait` to continue.",
+          input: { condition: cond.kind }
+        });
+      }
+      await new Promise((r) => setTimeout(r, pollMs));
+    }
+  }
+};
+
+// src/protocol/safety.ts
+var VOLATILE_SETTERS = /* @__PURE__ */ new Set([
+  "M92",
+  // steps/mm
+  "M201",
+  // max acceleration
+  "M203",
+  // max feedrate
+  "M204",
+  // accel for print/retract/travel
+  "M301",
+  // hotend PID
+  "M304",
+  // bed PID
+  "M851",
+  // probe Z offset
+  "M900",
+  // linear advance K
+  "M906",
+  // stepper current (TMC)
+  "M913"
+  // hybrid threshold (TMC)
+]);
+function gcodeCode(command) {
+  const m = /^\s*([GM]\d+)/i.exec(command);
+  return m ? m[1].toUpperCase() : null;
+}
+function inspectGcode(command) {
+  const code = gcodeCode(command);
+  const base = {
+    code,
+    mutatesState: false,
+    volatile: false,
+    persists: false,
+    note: ""
+  };
+  if (!code) return base;
+  switch (code) {
+    case "M500":
+      return {
+        ...base,
+        mutatesState: true,
+        persists: true,
+        note: "M500 writes current settings to EEPROM \u2014 the change persists across power cycles."
+      };
+    case "M501":
+      return {
+        ...base,
+        mutatesState: true,
+        note: "M501 reloads settings from EEPROM, discarding volatile (RAM) changes."
+      };
+    case "M502":
+      return {
+        ...base,
+        mutatesState: true,
+        volatile: true,
+        note: "M502 resets settings to firmware defaults in RAM (not saved until M500)."
+      };
+    default:
+      if (VOLATILE_SETTERS.has(code)) {
+        return {
+          ...base,
+          mutatesState: true,
+          volatile: true,
+          note: `${code} changes a machine setting in volatile RAM \u2014 it persists until power-cycle and can contaminate the next print. M500 persists it; M501 reverts to the EEPROM value.`
+        };
+      }
+      return base;
+  }
+}
+export {
+  API_HOSTS,
+  AnkerClient,
+  AnkerError,
+  AnkerHttpApi,
+  AnkerMqttClient,
+  AnkerPpppClient,
+  AuthError,
+  ConfigStore,
+  MQTT_HOSTS,
+  MqttCommandType,
+  NoticeType,
+  PPPP_LAN_PORT,
+  PpppState,
+  PrintControl,
+  PrinterNotFoundError,
+  PrinterRejectedError,
+  REDACTED,
+  TimeoutError,
+  TransportUnavailableError,
+  UsageError,
+  conditionHolds,
+  configDir,
+  defaultTimeoutFor,
+  describeWaitCondition,
+  detectSlicer,
+  discoverLan,
+  findPrinter,
+  gcodeCode,
+  gcodeHasTerminalOk,
+  guessRegion,
+  hasAnkerTimeHeader,
+  inspectGcode,
+  isEtaReliable,
+  loginAndBuildConfig,
+  mqttHostFor,
+  mqttPassword,
+  mqttUsername,
+  normalizeStatus,
+  parseDurationToSeconds,
+  parseGcodeResult,
+  parseWaitCondition,
+  reassembleRaw,
+  redactConfig,
+  splitLines,
+  stripAnsi,
+  toAnkerError,
+  transcodeMetadata
+};
+//# sourceMappingURL=index.js.map