@tbsoft-gmbh/signature-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,3900 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/node-gyp-build/node-gyp-build.js
+var require_node_gyp_build = __commonJS({
+  "node_modules/node-gyp-build/node-gyp-build.js"(exports2, module2) {
+    "use strict";
+    var fs3 = require("fs");
+    var path2 = require("path");
+    var os = require("os");
+    var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
+    var vars = process.config && process.config.variables || {};
+    var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
+    var abi = process.versions.modules;
+    var runtime = isElectron() ? "electron" : isNwjs() ? "node-webkit" : "node";
+    var arch = process.env.npm_config_arch || os.arch();
+    var platform = process.env.npm_config_platform || os.platform();
+    var libc = process.env.LIBC || (isAlpine(platform) ? "musl" : "glibc");
+    var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
+    var uv = (process.versions.uv || "").split(".")[0];
+    module2.exports = load;
+    function load(dir) {
+      return runtimeRequire(load.resolve(dir));
+    }
+    load.resolve = load.path = function(dir) {
+      dir = path2.resolve(dir || ".");
+      try {
+        var name = runtimeRequire(path2.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
+        if (process.env[name + "_PREBUILD"]) dir = process.env[name + "_PREBUILD"];
+      } catch (err) {
+      }
+      if (!prebuildsOnly) {
+        var release = getFirst(path2.join(dir, "build/Release"), matchBuild);
+        if (release) return release;
+        var debug = getFirst(path2.join(dir, "build/Debug"), matchBuild);
+        if (debug) return debug;
+      }
+      var prebuild = resolve(dir);
+      if (prebuild) return prebuild;
+      var nearby = resolve(path2.dirname(process.execPath));
+      if (nearby) return nearby;
+      var target = [
+        "platform=" + platform,
+        "arch=" + arch,
+        "runtime=" + runtime,
+        "abi=" + abi,
+        "uv=" + uv,
+        armv ? "armv=" + armv : "",
+        "libc=" + libc,
+        "node=" + process.versions.node,
+        process.versions.electron ? "electron=" + process.versions.electron : "",
+        typeof __webpack_require__ === "function" ? "webpack=true" : ""
+        // eslint-disable-line
+      ].filter(Boolean).join(" ");
+      throw new Error("No native build was found for " + target + "\n    loaded from: " + dir + "\n");
+      function resolve(dir2) {
+        var tuples = readdirSync(path2.join(dir2, "prebuilds")).map(parseTuple);
+        var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
+        if (!tuple) return;
+        var prebuilds = path2.join(dir2, "prebuilds", tuple.name);
+        var parsed = readdirSync(prebuilds).map(parseTags);
+        var candidates = parsed.filter(matchTags(runtime, abi));
+        var winner = candidates.sort(compareTags(runtime))[0];
+        if (winner) return path2.join(prebuilds, winner.file);
+      }
+    };
+    function readdirSync(dir) {
+      try {
+        return fs3.readdirSync(dir);
+      } catch (err) {
+        return [];
+      }
+    }
+    function getFirst(dir, filter) {
+      var files = readdirSync(dir).filter(filter);
+      return files[0] && path2.join(dir, files[0]);
+    }
+    function matchBuild(name) {
+      return /\.node$/.test(name);
+    }
+    function parseTuple(name) {
+      var arr = name.split("-");
+      if (arr.length !== 2) return;
+      var platform2 = arr[0];
+      var architectures = arr[1].split("+");
+      if (!platform2) return;
+      if (!architectures.length) return;
+      if (!architectures.every(Boolean)) return;
+      return { name, platform: platform2, architectures };
+    }
+    function matchTuple(platform2, arch2) {
+      return function(tuple) {
+        if (tuple == null) return false;
+        if (tuple.platform !== platform2) return false;
+        return tuple.architectures.includes(arch2);
+      };
+    }
+    function compareTuples(a, b) {
+      return a.architectures.length - b.architectures.length;
+    }
+    function parseTags(file) {
+      var arr = file.split(".");
+      var extension = arr.pop();
+      var tags = { file, specificity: 0 };
+      if (extension !== "node") return;
+      for (var i = 0; i < arr.length; i++) {
+        var tag = arr[i];
+        if (tag === "node" || tag === "electron" || tag === "node-webkit") {
+          tags.runtime = tag;
+        } else if (tag === "napi") {
+          tags.napi = true;
+        } else if (tag.slice(0, 3) === "abi") {
+          tags.abi = tag.slice(3);
+        } else if (tag.slice(0, 2) === "uv") {
+          tags.uv = tag.slice(2);
+        } else if (tag.slice(0, 4) === "armv") {
+          tags.armv = tag.slice(4);
+        } else if (tag === "glibc" || tag === "musl") {
+          tags.libc = tag;
+        } else {
+          continue;
+        }
+        tags.specificity++;
+      }
+      return tags;
+    }
+    function matchTags(runtime2, abi2) {
+      return function(tags) {
+        if (tags == null) return false;
+        if (tags.runtime && tags.runtime !== runtime2 && !runtimeAgnostic(tags)) return false;
+        if (tags.abi && tags.abi !== abi2 && !tags.napi) return false;
+        if (tags.uv && tags.uv !== uv) return false;
+        if (tags.armv && tags.armv !== armv) return false;
+        if (tags.libc && tags.libc !== libc) return false;
+        return true;
+      };
+    }
+    function runtimeAgnostic(tags) {
+      return tags.runtime === "node" && tags.napi;
+    }
+    function compareTags(runtime2) {
+      return function(a, b) {
+        if (a.runtime !== b.runtime) {
+          return a.runtime === runtime2 ? -1 : 1;
+        } else if (a.abi !== b.abi) {
+          return a.abi ? -1 : 1;
+        } else if (a.specificity !== b.specificity) {
+          return a.specificity > b.specificity ? -1 : 1;
+        } else {
+          return 0;
+        }
+      };
+    }
+    function isNwjs() {
+      return !!(process.versions && process.versions.nw);
+    }
+    function isElectron() {
+      if (process.versions && process.versions.electron) return true;
+      if (process.env.ELECTRON_RUN_AS_NODE) return true;
+      return typeof window !== "undefined" && window.process && window.process.type === "renderer";
+    }
+    function isAlpine(platform2) {
+      return platform2 === "linux" && fs3.existsSync("/etc/alpine-release");
+    }
+    load.parseTags = parseTags;
+    load.matchTags = matchTags;
+    load.compareTags = compareTags;
+    load.parseTuple = parseTuple;
+    load.matchTuple = matchTuple;
+    load.compareTuples = compareTuples;
+  }
+});
+
+// node_modules/node-gyp-build/index.js
+var require_node_gyp_build2 = __commonJS({
+  "node_modules/node-gyp-build/index.js"(exports2, module2) {
+    "use strict";
+    var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
+    if (typeof runtimeRequire.addon === "function") {
+      module2.exports = runtimeRequire.addon.bind(runtimeRequire);
+    } else {
+      module2.exports = require_node_gyp_build();
+    }
+  }
+});
+
+// node_modules/usb/dist/usb/bindings.js
+var require_bindings = __commonJS({
+  "node_modules/usb/dist/usb/bindings.js"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var path_1 = require("path");
+    var usb = require_node_gyp_build2()(process.env.NODE_USB_PATH || (0, path_1.join)(__dirname, "..", ".."));
+    module2.exports = usb;
+  }
+});
+
+// node_modules/usb/dist/usb/endpoint.js
+var require_endpoint = __commonJS({
+  "node_modules/usb/dist/usb/endpoint.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.OutEndpoint = exports2.InEndpoint = exports2.Endpoint = void 0;
+    var events_1 = require("events");
+    var bindings_1 = require_bindings();
+    var util_1 = require("util");
+    var isBuffer = (obj) => obj && obj instanceof Buffer;
+    var Endpoint = class extends events_1.EventEmitter {
+      constructor(device, descriptor) {
+        super();
+        this.device = device;
+        this.timeout = 0;
+        this.descriptor = descriptor;
+        this.address = descriptor.bEndpointAddress;
+        this.transferType = descriptor.bmAttributes & 3;
+      }
+      /** Clear the halt/stall condition for this endpoint. */
+      clearHalt(callback) {
+        return this.device.__clearHalt(this.address, callback);
+      }
+      /**
+       * Create a new `Transfer` object for this endpoint.
+       *
+       * The passed callback will be called when the transfer is submitted and finishes. Its arguments are the error (if any), the submitted buffer, and the amount of data actually written (for
+       * OUT transfers) or read (for IN transfers).
+       *
+       * @param timeout Timeout for the transfer (0 means unlimited).
+       * @param callback Transfer completion callback.
+       */
+      makeTransfer(timeout, callback) {
+        return new bindings_1.Transfer(this.device, this.address, this.transferType, timeout, callback);
+      }
+    };
+    exports2.Endpoint = Endpoint;
+    var InEndpoint = class extends Endpoint {
+      constructor(device, descriptor) {
+        super(device, descriptor);
+        this.direction = "in";
+        this.pollTransfers = [];
+        this.pollTransferSize = 0;
+        this.pollPending = 0;
+        this.pollActive = false;
+        this.transferAsync = (0, util_1.promisify)(this.transfer).bind(this);
+      }
+      /**
+       * Perform a transfer to read data from the endpoint.
+       *
+       * If length is greater than maxPacketSize, libusb will automatically split the transfer in multiple packets, and you will receive one callback with all data once all packets are complete.
+       *
+       * `this` in the callback is the InEndpoint object.
+       *
+       * The device must be open to use this method.
+       * @param length
+       * @param callback
+       */
+      transfer(length, callback) {
+        const buffer = Buffer.alloc(length);
+        const cb = (error, _buffer, actualLength) => {
+          callback.call(this, error, buffer.slice(0, actualLength));
+        };
+        try {
+          this.makeTransfer(this.timeout, cb).submit(buffer);
+        } catch (e) {
+          process.nextTick(() => callback.call(this, e));
+        }
+        return this;
+      }
+      /**
+       * Start polling the endpoint.
+       *
+       * The library will keep `nTransfers` transfers of size `transferSize` pending in the kernel at all times to ensure continuous data flow.
+       * This is handled by the libusb event thread, so it continues even if the Node v8 thread is busy. The `data` and `error` events are emitted as transfers complete.
+       *
+       * The device must be open to use this method.
+       * @param nTransfers
+       * @param transferSize
+       * @param callback
+       */
+      startPoll(nTransfers, transferSize, callback) {
+        const transferDone = (error, transfer, buffer, actualLength) => {
+          if (!error) {
+            this.emit("data", buffer.slice(0, actualLength));
+          } else if (error.errno !== bindings_1.LIBUSB_TRANSFER_CANCELLED) {
+            if (this.pollActive) {
+              this.emit("error", error);
+              this.stopPoll();
+            }
+          }
+          if (this.pollActive) {
+            startTransfer(transfer);
+          } else {
+            this.pollPending--;
+            if (this.pollPending === 0) {
+              this.pollTransfers = [];
+              this.pollActive = false;
+              this.emit("end");
+              if (callback) {
+                const cancelled = (error === null || error === void 0 ? void 0 : error.errno) === bindings_1.LIBUSB_TRANSFER_CANCELLED;
+                callback(cancelled ? void 0 : error, buffer, actualLength, cancelled);
+              }
+            }
+          }
+        };
+        const startTransfer = (transfer) => {
+          try {
+            transfer.submit(Buffer.alloc(this.pollTransferSize), (error, buffer, actualLength) => {
+              transferDone(error, transfer, buffer, actualLength);
+            });
+          } catch (e) {
+            this.emit("error", e);
+            this.stopPoll();
+          }
+        };
+        this.pollTransfers = this.startPollTransfers(nTransfers, transferSize, function(error, buffer, actualLength) {
+          transferDone(error, this, buffer, actualLength);
+        });
+        this.pollTransfers.forEach(startTransfer);
+        this.pollPending = this.pollTransfers.length;
+        return this.pollTransfers;
+      }
+      startPollTransfers(nTransfers = 3, transferSize = this.descriptor.wMaxPacketSize, callback) {
+        if (this.pollActive) {
+          throw new Error("Polling already active");
+        }
+        this.pollTransferSize = transferSize;
+        this.pollActive = true;
+        this.pollPending = 0;
+        const transfers = [];
+        for (let i = 0; i < nTransfers; i++) {
+          const transfer = this.makeTransfer(0, callback);
+          transfers[i] = transfer;
+        }
+        return transfers;
+      }
+      /**
+       * Stop polling.
+       *
+       * Further data may still be received. The `end` event is emitted and the callback is called once all transfers have completed or canceled.
+       *
+       * The device must be open to use this method.
+       * @param callback
+       */
+      stopPoll(callback) {
+        if (!this.pollActive) {
+          throw new Error("Polling is not active.");
+        }
+        for (let i = 0; i < this.pollTransfers.length; i++) {
+          try {
+            this.pollTransfers[i].cancel();
+          } catch (error) {
+            this.emit("error", error);
+          }
+        }
+        this.pollActive = false;
+        if (callback)
+          this.once("end", callback);
+      }
+    };
+    exports2.InEndpoint = InEndpoint;
+    var OutEndpoint = class extends Endpoint {
+      constructor(device, descriptor) {
+        super(device, descriptor);
+        this.direction = "out";
+        this.transferAsync = (0, util_1.promisify)(this.transfer).bind(this);
+      }
+      /**
+       * Perform a transfer to write `data` to the endpoint.
+       *
+       * If length is greater than maxPacketSize, libusb will automatically split the transfer in multiple packets, and you will receive one callback once all packets are complete.
+       *
+       * `this` in the callback is the OutEndpoint object.
+       *
+       * The device must be open to use this method.
+       * @param buffer
+       * @param callback
+       */
+      transfer(buffer, callback) {
+        if (!buffer) {
+          buffer = Buffer.alloc(0);
+        } else if (!isBuffer(buffer)) {
+          buffer = Buffer.from(buffer);
+        }
+        const cb = (error, _buffer, actual) => {
+          if (callback) {
+            callback.call(this, error, actual || 0);
+          }
+        };
+        try {
+          this.makeTransfer(this.timeout, cb).submit(buffer);
+        } catch (e) {
+          process.nextTick(() => cb(e));
+        }
+        return this;
+      }
+      transferWithZLP(buffer, callback) {
+        if (buffer.length % this.descriptor.wMaxPacketSize === 0) {
+          this.transfer(buffer);
+          this.transfer(Buffer.alloc(0), callback);
+        } else {
+          this.transfer(buffer, callback);
+        }
+      }
+    };
+    exports2.OutEndpoint = OutEndpoint;
+  }
+});
+
+// node_modules/usb/dist/usb/interface.js
+var require_interface = __commonJS({
+  "node_modules/usb/dist/usb/interface.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.Interface = void 0;
+    var bindings_1 = require_bindings();
+    var endpoint_1 = require_endpoint();
+    var util_1 = require("util");
+    var Interface = class {
+      constructor(device, id) {
+        this.device = device;
+        this.id = id;
+        this.altSetting = 0;
+        this.refresh();
+        this.releaseAsync = (0, util_1.promisify)(this.release).bind(this);
+        this.setAltSettingAsync = (0, util_1.promisify)(this.setAltSetting).bind(this);
+      }
+      refresh() {
+        if (!this.device.configDescriptor) {
+          return;
+        }
+        this.descriptor = this.device.configDescriptor.interfaces[this.id][this.altSetting];
+        this.interfaceNumber = this.descriptor.bInterfaceNumber;
+        this.endpoints = [];
+        const len = this.descriptor.endpoints.length;
+        for (let i = 0; i < len; i++) {
+          const desc = this.descriptor.endpoints[i];
+          const c = desc.bEndpointAddress & bindings_1.LIBUSB_ENDPOINT_IN ? endpoint_1.InEndpoint : endpoint_1.OutEndpoint;
+          this.endpoints[i] = new c(this.device, desc);
+        }
+      }
+      /**
+       * Claims the interface. This method must be called before using any endpoints of this interface.
+       *
+       * The device must be open to use this method.
+       */
+      claim() {
+        this.device.__claimInterface(this.id);
+      }
+      release(closeEndpointsOrCallback, callback) {
+        let closeEndpoints = false;
+        if (typeof closeEndpointsOrCallback === "boolean") {
+          closeEndpoints = closeEndpointsOrCallback;
+        } else {
+          callback = closeEndpointsOrCallback;
+        }
+        const next = () => {
+          this.device.__releaseInterface(this.id, (error) => {
+            if (!error) {
+              this.altSetting = 0;
+              this.refresh();
+            }
+            if (callback) {
+              callback.call(this, error);
+            }
+          });
+        };
+        if (!closeEndpoints || this.endpoints.length === 0) {
+          next();
+        } else {
+          let n = this.endpoints.length;
+          this.endpoints.forEach((ep) => {
+            if (ep.direction === "in" && ep.pollActive) {
+              ep.once("end", () => {
+                if (--n === 0) {
+                  next();
+                }
+              });
+              ep.stopPoll();
+            } else {
+              if (--n === 0) {
+                next();
+              }
+            }
+          });
+        }
+      }
+      /**
+       * Returns `false` if a kernel driver is not active; `true` if active.
+       *
+       * The device must be open to use this method.
+       */
+      isKernelDriverActive() {
+        return this.device.__isKernelDriverActive(this.id);
+      }
+      /**
+       * Detaches the kernel driver from the interface.
+       *
+       * The device must be open to use this method.
+       */
+      detachKernelDriver() {
+        return this.device.__detachKernelDriver(this.id);
+      }
+      /**
+       * Re-attaches the kernel driver for the interface.
+       *
+       * The device must be open to use this method.
+       */
+      attachKernelDriver() {
+        return this.device.__attachKernelDriver(this.id);
+      }
+      /**
+       * Sets the alternate setting. It updates the `interface.endpoints` array to reflect the endpoints found in the alternate setting.
+       *
+       * The device must be open to use this method.
+       * @param altSetting
+       * @param callback
+       */
+      setAltSetting(altSetting, callback) {
+        this.device.__setInterface(this.id, altSetting, (error) => {
+          if (!error) {
+            this.altSetting = altSetting;
+            this.refresh();
+          }
+          if (callback) {
+            callback.call(this, error);
+          }
+        });
+      }
+      /**
+       * Return the InEndpoint or OutEndpoint with the specified address.
+       *
+       * The device must be open to use this method.
+       * @param addr
+       */
+      endpoint(addr) {
+        return this.endpoints.find((item) => item.address === addr);
+      }
+    };
+    exports2.Interface = Interface;
+  }
+});
+
+// node_modules/usb/dist/usb/capability.js
+var require_capability = __commonJS({
+  "node_modules/usb/dist/usb/capability.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.Capability = void 0;
+    var Capability = class {
+      constructor(device, id) {
+        this.device = device;
+        this.id = id;
+        if (!device._bosDescriptor) {
+          throw new Error("bosDescriptor not found");
+        }
+        this.descriptor = device._bosDescriptor.capabilities[this.id];
+        this.type = this.descriptor.bDevCapabilityType;
+        this.data = this.descriptor.dev_capability_data;
+      }
+    };
+    exports2.Capability = Capability;
+  }
+});
+
+// node_modules/usb/dist/usb/device.js
+var require_device = __commonJS({
+  "node_modules/usb/dist/usb/device.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ExtendedDevice = void 0;
+    var usb = require_bindings();
+    var interface_1 = require_interface();
+    var capability_1 = require_capability();
+    var isBuffer = (obj) => !!obj && obj instanceof Uint8Array;
+    var DEFAULT_TIMEOUT = 1e3;
+    var ExtendedDevice = class {
+      constructor() {
+        this._timeout = DEFAULT_TIMEOUT;
+      }
+      /**
+       * Timeout in milliseconds to use for control transfers.
+       */
+      get timeout() {
+        return this._timeout || DEFAULT_TIMEOUT;
+      }
+      set timeout(value) {
+        this._timeout = value;
+      }
+      /**
+       * Object with properties for the fields of the active configuration descriptor.
+       */
+      get configDescriptor() {
+        try {
+          return this.__getConfigDescriptor();
+        } catch (e) {
+          const errno = e.errno;
+          if (errno === usb.LIBUSB_ERROR_NOT_FOUND || errno === usb.LIBUSB_ERROR_NO_DEVICE) {
+            return void 0;
+          }
+          throw e;
+        }
+      }
+      /**
+       * Contains all config descriptors of the device (same structure as .configDescriptor above)
+       */
+      get allConfigDescriptors() {
+        try {
+          return this.__getAllConfigDescriptors();
+        } catch (e) {
+          const errno = e.errno;
+          if (errno === usb.LIBUSB_ERROR_NOT_FOUND || errno === usb.LIBUSB_ERROR_NO_DEVICE) {
+            return [];
+          }
+          throw e;
+        }
+      }
+      /**
+       * Contains the parent of the device, such as a hub. If there is no parent this property is set to `null`.
+       */
+      get parent() {
+        return this.__getParent();
+      }
+      /**
+       * Open the device.
+       * @param defaultConfig
+       */
+      open(defaultConfig = true) {
+        this.__open();
+        this.interfaces = [];
+        if (defaultConfig === false) {
+          return;
+        }
+        const len = this.configDescriptor ? this.configDescriptor.interfaces.length : 0;
+        for (let i = 0; i < len; i++) {
+          this.interfaces[i] = new interface_1.Interface(this, i);
+        }
+      }
+      /**
+       * Close the device.
+       *
+       * The device must be open to use this method.
+       */
+      close() {
+        this.__close();
+        this.interfaces = void 0;
+      }
+      /**
+       * Set the device configuration to something other than the default (0). To use this, first call `.open(false)` (which tells it not to auto configure),
+       * then before claiming an interface, call this method.
+       *
+       * The device must be open to use this method.
+       * @param desired
+       * @param callback
+       */
+      setConfiguration(desired, callback) {
+        this.__setConfiguration(desired, (error) => {
+          if (!error) {
+            this.interfaces = [];
+            const len = this.configDescriptor ? this.configDescriptor.interfaces.length : 0;
+            for (let i = 0; i < len; i++) {
+              this.interfaces[i] = new interface_1.Interface(this, i);
+            }
+          }
+          if (callback) {
+            callback.call(this, error);
+          }
+        });
+      }
+      /**
+       * Enable/disable libusb's automatic kernel driver detachment
+       * When this is enabled libusb will automatically detach the kernel driver on an interface when claiming the interface, and attach it when releasing the interface
+       *
+       * The device must be open to use this method.
+       */
+      setAutoDetachKernelDriver(enable) {
+        return this.__setAutoDetachKernelDriver(enable ? 1 : 0);
+      }
+      /**
+       * Perform a control transfer with `libusb_control_transfer`.
+       *
+       * Parameter `data_or_length` can be an integer length for an IN transfer, or a `Buffer` for an OUT transfer. The type must match the direction specified in the MSB of bmRequestType.
+       *
+       * The `data` parameter of the callback is actual transferred for OUT transfers, or will be passed a Buffer for IN transfers.
+       *
+       * The device must be open to use this method.
+       * @param bmRequestType
+       * @param bRequest
+       * @param wValue
+       * @param wIndex
+       * @param data_or_length
+       * @param callback
+       */
+      controlTransfer(bmRequestType, bRequest, wValue, wIndex, data_or_length, callback) {
+        const isIn = !!(bmRequestType & usb.LIBUSB_ENDPOINT_IN);
+        const wLength = isIn ? data_or_length : data_or_length.length;
+        if (isIn) {
+          if (wLength < 0) {
+            throw new TypeError("Expected size number for IN transfer (based on bmRequestType)");
+          }
+        } else {
+          if (!isBuffer(data_or_length)) {
+            throw new TypeError("Expected buffer for OUT transfer (based on bmRequestType)");
+          }
+        }
+        const buf = Buffer.alloc(wLength + usb.LIBUSB_CONTROL_SETUP_SIZE);
+        buf.writeUInt8(bmRequestType, 0);
+        buf.writeUInt8(bRequest, 1);
+        buf.writeUInt16LE(wValue, 2);
+        buf.writeUInt16LE(wIndex, 4);
+        buf.writeUInt16LE(wLength, 6);
+        if (!isIn) {
+          buf.set(data_or_length, usb.LIBUSB_CONTROL_SETUP_SIZE);
+        }
+        const transfer = new usb.Transfer(this, 0, usb.LIBUSB_TRANSFER_TYPE_CONTROL, this.timeout, (error, buf2, actual) => {
+          if (callback) {
+            if (isIn) {
+              callback.call(this, error, buf2.slice(usb.LIBUSB_CONTROL_SETUP_SIZE, usb.LIBUSB_CONTROL_SETUP_SIZE + actual));
+            } else {
+              callback.call(this, error, actual);
+            }
+          }
+        });
+        try {
+          transfer.submit(buf);
+        } catch (e) {
+          if (callback) {
+            process.nextTick(() => callback.call(this, e, void 0));
+          }
+        }
+        return this;
+      }
+      /**
+       * Return the interface with the specified interface number.
+       *
+       * The device must be open to use this method.
+       * @param addr
+       */
+      interface(addr) {
+        if (!this.interfaces) {
+          throw new Error("Device must be open before searching for interfaces");
+        }
+        addr = addr || 0;
+        for (let i = 0; i < this.interfaces.length; i++) {
+          if (this.interfaces[i].interfaceNumber === addr) {
+            return this.interfaces[i];
+          }
+        }
+        throw new Error(`Interface not found for address: ${addr}`);
+      }
+      /**
+       * Perform a control transfer to retrieve a string descriptor
+       *
+       * The device must be open to use this method.
+       * @param desc_index
+       * @param callback
+       */
+      getStringDescriptor(desc_index, callback) {
+        if (desc_index === 0) {
+          callback();
+          return;
+        }
+        const langid = 1033;
+        const length = 255;
+        this.controlTransfer(usb.LIBUSB_ENDPOINT_IN, usb.LIBUSB_REQUEST_GET_DESCRIPTOR, usb.LIBUSB_DT_STRING << 8 | desc_index, langid, length, (error, buffer) => {
+          if (error) {
+            return callback(error);
+          }
+          callback(void 0, isBuffer(buffer) ? buffer.toString("utf16le", 2) : void 0);
+        });
+      }
+      /**
+       * Perform a control transfer to retrieve an object with properties for the fields of the Binary Object Store descriptor.
+       *
+       * The device must be open to use this method.
+       * @param callback
+       */
+      getBosDescriptor(callback) {
+        if (this._bosDescriptor) {
+          return callback(void 0, this._bosDescriptor);
+        }
+        if (this.deviceDescriptor.bcdUSB < 513) {
+          return callback(void 0, void 0);
+        }
+        this.controlTransfer(usb.LIBUSB_ENDPOINT_IN, usb.LIBUSB_REQUEST_GET_DESCRIPTOR, usb.LIBUSB_DT_BOS << 8, 0, usb.LIBUSB_DT_BOS_SIZE, (error, buffer) => {
+          if (error) {
+            if (error.errno === usb.LIBUSB_TRANSFER_STALL)
+              return callback(void 0, void 0);
+            return callback(error, void 0);
+          }
+          if (!isBuffer(buffer)) {
+            return callback(void 0, void 0);
+          }
+          const totalLength = buffer.readUInt16LE(2);
+          this.controlTransfer(usb.LIBUSB_ENDPOINT_IN, usb.LIBUSB_REQUEST_GET_DESCRIPTOR, usb.LIBUSB_DT_BOS << 8, 0, totalLength, (error2, buffer2) => {
+            if (error2) {
+              if (error2.errno === usb.LIBUSB_TRANSFER_STALL)
+                return callback(void 0, void 0);
+              return callback(error2, void 0);
+            }
+            if (!isBuffer(buffer2)) {
+              return callback(void 0, void 0);
+            }
+            const descriptor = {
+              bLength: buffer2.readUInt8(0),
+              bDescriptorType: buffer2.readUInt8(1),
+              wTotalLength: buffer2.readUInt16LE(2),
+              bNumDeviceCaps: buffer2.readUInt8(4),
+              capabilities: []
+            };
+            let i = usb.LIBUSB_DT_BOS_SIZE;
+            while (i < descriptor.wTotalLength) {
+              const capability = {
+                bLength: buffer2.readUInt8(i + 0),
+                bDescriptorType: buffer2.readUInt8(i + 1),
+                bDevCapabilityType: buffer2.readUInt8(i + 2),
+                dev_capability_data: buffer2.slice(i + 3, i + buffer2.readUInt8(i + 0))
+              };
+              descriptor.capabilities.push(capability);
+              i += capability.bLength;
+            }
+            this._bosDescriptor = descriptor;
+            callback(void 0, this._bosDescriptor);
+          });
+        });
+      }
+      /**
+       * Retrieve a list of Capability objects for the Binary Object Store capabilities of the device.
+       *
+       * The device must be open to use this method.
+       * @param callback
+       */
+      getCapabilities(callback) {
+        const capabilities = [];
+        this.getBosDescriptor((error, descriptor) => {
+          if (error)
+            return callback(error, void 0);
+          const len = descriptor ? descriptor.capabilities.length : 0;
+          for (let i = 0; i < len; i++) {
+            capabilities.push(new capability_1.Capability(this, i));
+          }
+          callback(void 0, capabilities);
+        });
+      }
+    };
+    exports2.ExtendedDevice = ExtendedDevice;
+  }
+});
+
+// node_modules/usb/dist/usb/index.js
+var require_usb = __commonJS({
+  "node_modules/usb/dist/usb/index.js"(exports2, module2) {
+    "use strict";
+    var events_1 = require("events");
+    var device_1 = require_device();
+    var usb = require_bindings();
+    if (usb.INIT_ERROR) {
+      console.warn("Failed to initialize libusb.");
+    }
+    Object.setPrototypeOf(usb, events_1.EventEmitter.prototype);
+    Object.defineProperty(usb, "pollHotplug", {
+      value: false,
+      writable: true
+    });
+    Object.defineProperty(usb, "pollHotplugDelay", {
+      value: 500,
+      writable: true
+    });
+    if (usb.Device) {
+      Object.getOwnPropertyNames(device_1.ExtendedDevice.prototype).forEach((name) => {
+        Object.defineProperty(usb.Device.prototype, name, Object.getOwnPropertyDescriptor(device_1.ExtendedDevice.prototype, name) || /* @__PURE__ */ Object.create(null));
+      });
+    }
+    var hotPlugDevices = /* @__PURE__ */ new Set();
+    var emitHotplugEvents = () => {
+      const devices = new Set(usb.getDeviceList());
+      for (const device of devices) {
+        if (!hotPlugDevices.has(device)) {
+          usb.emit("attach", device);
+        }
+      }
+      for (const device of hotPlugDevices) {
+        if (!devices.has(device)) {
+          usb.emit("detach", device);
+        }
+      }
+      hotPlugDevices = devices;
+    };
+    var pollingHotplug = false;
+    var pollHotplug = (start = false) => {
+      if (start) {
+        pollingHotplug = true;
+      } else if (!pollingHotplug) {
+        return;
+      } else {
+        emitHotplugEvents();
+      }
+      setTimeout(() => pollHotplug(), usb.pollHotplugDelay);
+    };
+    var devicesChanged = () => setTimeout(() => emitHotplugEvents(), usb.pollHotplugDelay);
+    var hotplugSupported = 0;
+    var startHotplug = () => {
+      hotplugSupported = usb.pollHotplug ? 0 : usb._supportedHotplugEvents();
+      if (hotplugSupported !== 1) {
+        hotPlugDevices = new Set(usb.getDeviceList());
+      }
+      if (hotplugSupported) {
+        usb._enableHotplugEvents();
+        if (hotplugSupported === 2) {
+          usb.on("attachIds", devicesChanged);
+          usb.on("detachIds", devicesChanged);
+        }
+      } else {
+        pollHotplug(true);
+      }
+    };
+    var stopHotplug = () => {
+      if (hotplugSupported) {
+        usb._disableHotplugEvents();
+        if (hotplugSupported === 2) {
+          usb.off("attachIds", devicesChanged);
+          usb.off("detachIds", devicesChanged);
+        }
+      } else {
+        pollingHotplug = false;
+      }
+    };
+    usb.on("newListener", (event) => {
+      if (event !== "attach" && event !== "detach") {
+        return;
+      }
+      const listenerCount = usb.listenerCount("attach") + usb.listenerCount("detach");
+      if (listenerCount === 0) {
+        startHotplug();
+      }
+    });
+    usb.on("removeListener", (event) => {
+      if (event !== "attach" && event !== "detach") {
+        return;
+      }
+      const listenerCount = usb.listenerCount("attach") + usb.listenerCount("detach");
+      if (listenerCount === 0) {
+        stopHotplug();
+      }
+    });
+    module2.exports = usb;
+  }
+});
+
+// node_modules/usb/dist/webusb/webusb-device.js
+var require_webusb_device = __commonJS({
+  "node_modules/usb/dist/webusb/webusb-device.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.WebUSBDevice = void 0;
+    var usb = require_usb();
+    var util_1 = require("util");
+    var os_1 = require("os");
+    var LIBUSB_TRANSFER_TYPE_MASK = 3;
+    var ENDPOINT_NUMBER_MASK = 127;
+    var CLEAR_FEATURE = 1;
+    var ENDPOINT_HALT = 0;
+    var WebUSBDevice = class _WebUSBDevice {
+      static async createInstance(device, autoDetachKernelDriver = true) {
+        const instance = new _WebUSBDevice(device, autoDetachKernelDriver);
+        await instance.initialize();
+        return instance;
+      }
+      constructor(device, autoDetachKernelDriver) {
+        this.device = device;
+        this.autoDetachKernelDriver = autoDetachKernelDriver;
+        this.manufacturerName = null;
+        this.productName = null;
+        this.serialNumber = null;
+        this.configurations = [];
+        const usbVersion = this.decodeVersion(device.deviceDescriptor.bcdUSB);
+        this.usbVersionMajor = usbVersion.major;
+        this.usbVersionMinor = usbVersion.minor;
+        this.usbVersionSubminor = usbVersion.sub;
+        this.deviceClass = device.deviceDescriptor.bDeviceClass;
+        this.deviceSubclass = device.deviceDescriptor.bDeviceSubClass;
+        this.deviceProtocol = device.deviceDescriptor.bDeviceProtocol;
+        this.vendorId = device.deviceDescriptor.idVendor;
+        this.productId = device.deviceDescriptor.idProduct;
+        const deviceVersion = this.decodeVersion(device.deviceDescriptor.bcdDevice);
+        this.deviceVersionMajor = deviceVersion.major;
+        this.deviceVersionMinor = deviceVersion.minor;
+        this.deviceVersionSubminor = deviceVersion.sub;
+        this.controlTransferAsync = (0, util_1.promisify)(this.device.controlTransfer).bind(this.device);
+        this.setConfigurationAsync = (0, util_1.promisify)(this.device.setConfiguration).bind(this.device);
+        this.resetAsync = (0, util_1.promisify)(this.device.reset).bind(this.device);
+        this.getStringDescriptorAsync = (0, util_1.promisify)(this.device.getStringDescriptor).bind(this.device);
+      }
+      get configuration() {
+        if (!this.device.configDescriptor) {
+          return null;
+        }
+        const currentConfiguration = this.device.configDescriptor.bConfigurationValue;
+        return this.configurations.find((configuration) => configuration.configurationValue === currentConfiguration) || null;
+      }
+      get opened() {
+        return !!this.device.interfaces;
+      }
+      async open() {
+        try {
+          if (this.opened) {
+            return;
+          }
+          this.device.open();
+          if ((0, os_1.platform)() !== "win32") {
+            this.device.setAutoDetachKernelDriver(this.autoDetachKernelDriver);
+          }
+        } catch (error) {
+          throw new Error(`open error: ${error}`);
+        }
+      }
+      async close() {
+        try {
+          if (!this.opened) {
+            return;
+          }
+          try {
+            if (this.configuration) {
+              for (const iface of this.configuration.interfaces) {
+                await this._releaseInterface(iface.interfaceNumber);
+                this.configuration.interfaces[this.configuration.interfaces.indexOf(iface)] = {
+                  interfaceNumber: iface.interfaceNumber,
+                  alternate: iface.alternate,
+                  alternates: iface.alternates,
+                  claimed: false
+                };
+              }
+            }
+          } catch (_error) {
+          }
+          this.device.close();
+        } catch (error) {
+          throw new Error(`close error: ${error}`);
+        }
+      }
+      async selectConfiguration(configurationValue) {
+        if (!this.opened || !this.device.configDescriptor) {
+          throw new Error("selectConfiguration error: invalid state");
+        }
+        if (this.device.configDescriptor.bConfigurationValue === configurationValue) {
+          return;
+        }
+        const config = this.configurations.find((configuration) => configuration.configurationValue === configurationValue);
+        if (!config) {
+          throw new Error("selectConfiguration error: configuration not found");
+        }
+        try {
+          await this.setConfigurationAsync(configurationValue);
+        } catch (error) {
+          throw new Error(`selectConfiguration error: ${error}`);
+        }
+      }
+      async claimInterface(interfaceNumber) {
+        if (!this.opened) {
+          throw new Error("claimInterface error: invalid state");
+        }
+        if (!this.configuration) {
+          throw new Error("claimInterface error: interface not found");
+        }
+        const iface = this.configuration.interfaces.find((usbInterface) => usbInterface.interfaceNumber === interfaceNumber);
+        if (!iface) {
+          throw new Error("claimInterface error: interface not found");
+        }
+        if (iface.claimed) {
+          return;
+        }
+        try {
+          this.device.interface(interfaceNumber).claim();
+          this.configuration.interfaces[this.configuration.interfaces.indexOf(iface)] = {
+            interfaceNumber,
+            alternate: iface.alternate,
+            alternates: iface.alternates,
+            claimed: true
+          };
+        } catch (error) {
+          throw new Error(`claimInterface error: ${error}`);
+        }
+      }
+      async releaseInterface(interfaceNumber) {
+        await this._releaseInterface(interfaceNumber);
+        if (this.configuration) {
+          const iface = this.configuration.interfaces.find((usbInterface) => usbInterface.interfaceNumber === interfaceNumber);
+          if (iface) {
+            this.configuration.interfaces[this.configuration.interfaces.indexOf(iface)] = {
+              interfaceNumber,
+              alternate: iface.alternate,
+              alternates: iface.alternates,
+              claimed: false
+            };
+          }
+        }
+      }
+      async selectAlternateInterface(interfaceNumber, alternateSetting) {
+        if (!this.opened) {
+          throw new Error("selectAlternateInterface error: invalid state");
+        }
+        if (!this.configuration) {
+          throw new Error("selectAlternateInterface error: interface not found");
+        }
+        const iface = this.configuration.interfaces.find((usbInterface) => usbInterface.interfaceNumber === interfaceNumber);
+        if (!iface) {
+          throw new Error("selectAlternateInterface error: interface not found");
+        }
+        if (!iface.claimed) {
+          throw new Error("selectAlternateInterface error: invalid state");
+        }
+        try {
+          const iface2 = this.device.interface(interfaceNumber);
+          await iface2.setAltSettingAsync(alternateSetting);
+        } catch (error) {
+          throw new Error(`selectAlternateInterface error: ${error}`);
+        }
+      }
+      async controlTransferIn(setup, length) {
+        try {
+          this.checkDeviceOpen();
+          const type = this.controlTransferParamsToType(setup, usb.LIBUSB_ENDPOINT_IN);
+          const result = await this.controlTransferAsync(type, setup.request, setup.value, setup.index, length);
+          return {
+            data: result ? new DataView(new Uint8Array(result).buffer) : void 0,
+            status: "ok"
+          };
+        } catch (error) {
+          if (error.errno === usb.LIBUSB_TRANSFER_STALL) {
+            return {
+              status: "stall"
+            };
+          }
+          if (error.errno === usb.LIBUSB_TRANSFER_OVERFLOW) {
+            return {
+              status: "babble"
+            };
+          }
+          throw new Error(`controlTransferIn error: ${error}`);
+        }
+      }
+      async controlTransferOut(setup, data) {
+        try {
+          this.checkDeviceOpen();
+          const type = this.controlTransferParamsToType(setup, usb.LIBUSB_ENDPOINT_OUT);
+          const buffer = data ? Buffer.from(data) : Buffer.alloc(0);
+          const bytesWritten = await this.controlTransferAsync(type, setup.request, setup.value, setup.index, buffer);
+          return {
+            bytesWritten,
+            status: "ok"
+          };
+        } catch (error) {
+          if (error.errno === usb.LIBUSB_TRANSFER_STALL) {
+            return {
+              bytesWritten: 0,
+              status: "stall"
+            };
+          }
+          throw new Error(`controlTransferOut error: ${error}`);
+        }
+      }
+      async clearHalt(direction, endpointNumber) {
+        try {
+          const wIndex = endpointNumber | (direction === "in" ? usb.LIBUSB_ENDPOINT_IN : usb.LIBUSB_ENDPOINT_OUT);
+          await this.controlTransferAsync(usb.LIBUSB_RECIPIENT_ENDPOINT, CLEAR_FEATURE, ENDPOINT_HALT, wIndex, Buffer.from(new Uint8Array()));
+        } catch (error) {
+          throw new Error(`clearHalt error: ${error}`);
+        }
+      }
+      async transferIn(endpointNumber, length) {
+        try {
+          this.checkDeviceOpen();
+          const endpoint = this.getEndpoint(endpointNumber | usb.LIBUSB_ENDPOINT_IN);
+          const result = await endpoint.transferAsync(length);
+          return {
+            data: result ? new DataView(new Uint8Array(result).buffer) : void 0,
+            status: "ok"
+          };
+        } catch (error) {
+          if (error.errno === usb.LIBUSB_TRANSFER_STALL) {
+            return {
+              status: "stall"
+            };
+          }
+          if (error.errno === usb.LIBUSB_TRANSFER_OVERFLOW) {
+            return {
+              status: "babble"
+            };
+          }
+          throw new Error(`transferIn error: ${error}`);
+        }
+      }
+      async transferOut(endpointNumber, data) {
+        try {
+          this.checkDeviceOpen();
+          const endpoint = this.getEndpoint(endpointNumber | usb.LIBUSB_ENDPOINT_OUT);
+          const buffer = Buffer.from(data);
+          const bytesWritten = await endpoint.transferAsync(buffer);
+          return {
+            bytesWritten,
+            status: "ok"
+          };
+        } catch (error) {
+          if (error.errno === usb.LIBUSB_TRANSFER_STALL) {
+            return {
+              bytesWritten: 0,
+              status: "stall"
+            };
+          }
+          throw new Error(`transferOut error: ${error}`);
+        }
+      }
+      async reset() {
+        try {
+          await this.resetAsync();
+        } catch (error) {
+          throw new Error(`reset error: ${error}`);
+        }
+      }
+      async isochronousTransferIn(_endpointNumber, _packetLengths) {
+        throw new Error("isochronousTransferIn error: method not implemented");
+      }
+      async isochronousTransferOut(_endpointNumber, _data, _packetLengths) {
+        throw new Error("isochronousTransferOut error: method not implemented");
+      }
+      async forget() {
+        throw new Error("forget error: method not implemented");
+      }
+      async initialize() {
+        try {
+          if (!this.opened) {
+            this.device.open();
+            if (this.deviceClass === 255 && (0, os_1.platform)() === "darwin") {
+              await this.setConfigurationAsync(1);
+            }
+          }
+          this.manufacturerName = await this.getStringDescriptor(this.device.deviceDescriptor.iManufacturer);
+          this.productName = await this.getStringDescriptor(this.device.deviceDescriptor.iProduct);
+          this.serialNumber = await this.getStringDescriptor(this.device.deviceDescriptor.iSerialNumber);
+          this.configurations = await this.getConfigurations();
+        } catch (error) {
+          throw new Error(`initialize error: ${error}`);
+        } finally {
+          if (this.opened) {
+            this.device.close();
+          }
+        }
+      }
+      decodeVersion(version) {
+        const hex = `0000${version.toString(16)}`.slice(-4);
+        return {
+          major: parseInt(hex.substr(0, 2), void 0),
+          minor: parseInt(hex.substr(2, 1), void 0),
+          sub: parseInt(hex.substr(3, 1), void 0)
+        };
+      }
+      async getStringDescriptor(index) {
+        try {
+          const buffer = await this.getStringDescriptorAsync(index);
+          return buffer ? buffer.toString() : "";
+        } catch (error) {
+          return "";
+        }
+      }
+      async getConfigurations() {
+        const configs = [];
+        for (const config of this.device.allConfigDescriptors) {
+          const interfaces = [];
+          for (const iface of config.interfaces) {
+            const alternates = [];
+            for (const alternate2 of iface) {
+              const endpoints = [];
+              for (const endpoint of alternate2.endpoints) {
+                endpoints.push({
+                  endpointNumber: endpoint.bEndpointAddress & ENDPOINT_NUMBER_MASK,
+                  direction: endpoint.bEndpointAddress & usb.LIBUSB_ENDPOINT_IN ? "in" : "out",
+                  type: (endpoint.bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) === usb.LIBUSB_TRANSFER_TYPE_BULK ? "bulk" : (endpoint.bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) === usb.LIBUSB_TRANSFER_TYPE_INTERRUPT ? "interrupt" : "isochronous",
+                  packetSize: endpoint.wMaxPacketSize
+                });
+              }
+              alternates.push({
+                alternateSetting: alternate2.bAlternateSetting,
+                interfaceClass: alternate2.bInterfaceClass,
+                interfaceSubclass: alternate2.bInterfaceSubClass,
+                interfaceProtocol: alternate2.bInterfaceProtocol,
+                interfaceName: await this.getStringDescriptor(alternate2.iInterface),
+                endpoints
+              });
+            }
+            const interfaceNumber = iface[0].bInterfaceNumber;
+            const alternate = alternates.find((alt) => alt.alternateSetting === this.device.interface(interfaceNumber).altSetting);
+            if (alternate) {
+              interfaces.push({
+                interfaceNumber,
+                alternate,
+                alternates,
+                claimed: false
+              });
+            }
+          }
+          configs.push({
+            configurationValue: config.bConfigurationValue,
+            configurationName: await this.getStringDescriptor(config.iConfiguration),
+            interfaces
+          });
+        }
+        return configs;
+      }
+      getEndpoint(address) {
+        if (!this.device.interfaces) {
+          return void 0;
+        }
+        for (const iface of this.device.interfaces) {
+          const endpoint = iface.endpoint(address);
+          if (endpoint) {
+            return endpoint;
+          }
+        }
+        return void 0;
+      }
+      controlTransferParamsToType(setup, direction) {
+        const recipient = setup.recipient === "device" ? usb.LIBUSB_RECIPIENT_DEVICE : setup.recipient === "interface" ? usb.LIBUSB_RECIPIENT_INTERFACE : setup.recipient === "endpoint" ? usb.LIBUSB_RECIPIENT_ENDPOINT : usb.LIBUSB_RECIPIENT_OTHER;
+        const requestType = setup.requestType === "standard" ? usb.LIBUSB_REQUEST_TYPE_STANDARD : setup.requestType === "class" ? usb.LIBUSB_REQUEST_TYPE_CLASS : usb.LIBUSB_REQUEST_TYPE_VENDOR;
+        return recipient | requestType | direction;
+      }
+      async _releaseInterface(interfaceNumber) {
+        if (!this.opened) {
+          throw new Error("releaseInterface error: invalid state");
+        }
+        if (!this.configuration) {
+          throw new Error("releaseInterface error: interface not found");
+        }
+        const iface = this.configuration.interfaces.find((usbInterface) => usbInterface.interfaceNumber === interfaceNumber);
+        if (!iface) {
+          throw new Error("releaseInterface error: interface not found");
+        }
+        if (!iface.claimed) {
+          return;
+        }
+        try {
+          const iface2 = this.device.interface(interfaceNumber);
+          await iface2.releaseAsync();
+        } catch (error) {
+          throw new Error(`releaseInterface error: ${error}`);
+        }
+      }
+      checkDeviceOpen() {
+        if (!this.opened) {
+          throw new Error("The device must be opened first");
+        }
+      }
+    };
+    exports2.WebUSBDevice = WebUSBDevice;
+  }
+});
+
+// node_modules/usb/dist/webusb/index.js
+var require_webusb = __commonJS({
+  "node_modules/usb/dist/webusb/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.WebUSB = exports2.getWebUsb = void 0;
+    var usb = require_usb();
+    var events_1 = require("events");
+    var webusb_device_1 = require_webusb_device();
+    var getWebUsb = () => {
+      if (navigator && navigator.usb) {
+        return navigator.usb;
+      }
+      return new WebUSB();
+    };
+    exports2.getWebUsb = getWebUsb;
+    var NamedError = class extends Error {
+      constructor(message, name) {
+        super(message);
+        this.name = name;
+      }
+    };
+    var WebUSB = class {
+      constructor(options = {}) {
+        this.options = options;
+        this.emitter = new events_1.EventEmitter();
+        this.knownDevices = /* @__PURE__ */ new Map();
+        this.authorisedDevices = /* @__PURE__ */ new Set();
+        const deviceConnectCallback = async (device) => {
+          const webDevice = await this.getWebDevice(device);
+          if (webDevice && this.isAuthorisedDevice(webDevice)) {
+            const event = {
+              type: "connect",
+              device: webDevice
+            };
+            this.emitter.emit("connect", event);
+          }
+        };
+        const deviceDisconnectCallback = async (device) => {
+          if (this.knownDevices.has(device)) {
+            const webDevice = this.knownDevices.get(device);
+            if (webDevice && this.isAuthorisedDevice(webDevice)) {
+              const event = {
+                type: "disconnect",
+                device: webDevice
+              };
+              this.emitter.emit("disconnect", event);
+            }
+          }
+        };
+        this.emitter.on("newListener", (event) => {
+          const listenerCount = this.emitter.listenerCount(event);
+          if (listenerCount !== 0) {
+            return;
+          }
+          if (event === "connect") {
+            usb.addListener("attach", deviceConnectCallback);
+          } else if (event === "disconnect") {
+            usb.addListener("detach", deviceDisconnectCallback);
+          }
+        });
+        this.emitter.on("removeListener", (event) => {
+          const listenerCount = this.emitter.listenerCount(event);
+          if (listenerCount !== 0) {
+            return;
+          }
+          if (event === "connect") {
+            usb.removeListener("attach", deviceConnectCallback);
+          } else if (event === "disconnect") {
+            usb.removeListener("detach", deviceDisconnectCallback);
+          }
+        });
+      }
+      set onconnect(fn) {
+        if (this._onconnect) {
+          this.removeEventListener("connect", this._onconnect);
+          this._onconnect = void 0;
+        }
+        if (fn) {
+          this._onconnect = fn;
+          this.addEventListener("connect", this._onconnect);
+        }
+      }
+      set ondisconnect(fn) {
+        if (this._ondisconnect) {
+          this.removeEventListener("disconnect", this._ondisconnect);
+          this._ondisconnect = void 0;
+        }
+        if (fn) {
+          this._ondisconnect = fn;
+          this.addEventListener("disconnect", this._ondisconnect);
+        }
+      }
+      addEventListener(type, listener) {
+        this.emitter.addListener(type, listener);
+      }
+      removeEventListener(type, callback) {
+        this.emitter.removeListener(type, callback);
+      }
+      dispatchEvent(_event) {
+        return false;
+      }
+      /**
+       * Requests a single Web USB device
+       * @param options The options to use when scanning
+       * @returns Promise containing the selected device
+       */
+      async requestDevice(options) {
+        if (!options) {
+          throw new TypeError("requestDevice error: 1 argument required, but only 0 present");
+        }
+        if (options.constructor !== {}.constructor) {
+          throw new TypeError("requestDevice error: parameter 1 (options) is not an object");
+        }
+        if (!options.filters) {
+          throw new TypeError("requestDevice error: required member filters is undefined");
+        }
+        if (options.filters.constructor !== [].constructor) {
+          throw new TypeError("requestDevice error: the provided value cannot be converted to a sequence");
+        }
+        options.filters.forEach((filter) => {
+          if (filter.protocolCode && !filter.subclassCode) {
+            throw new TypeError("requestDevice error: subclass code is required");
+          }
+          if (filter.subclassCode && !filter.classCode) {
+            throw new TypeError("requestDevice error: class code is required");
+          }
+        });
+        let devices = await this.loadDevices(options.filters);
+        devices = devices.filter((device) => this.filterDevice(device, options.filters));
+        if (devices.length === 0) {
+          throw new NamedError("Failed to execute 'requestDevice' on 'USB': No device selected.", "NotFoundError");
+        }
+        try {
+          const device = this.options.devicesFound ? await this.options.devicesFound(devices) : devices[0];
+          if (!device) {
+            throw new NamedError("Failed to execute 'requestDevice' on 'USB': No device selected.", "NotFoundError");
+          }
+          this.authorisedDevices.add({
+            vendorId: device.vendorId,
+            productId: device.productId,
+            classCode: device.deviceClass,
+            subclassCode: device.deviceSubclass,
+            protocolCode: device.deviceProtocol,
+            serialNumber: device.serialNumber || void 0
+          });
+          return device;
+        } catch (error) {
+          throw new NamedError("Failed to execute 'requestDevice' on 'USB': No device selected.", "NotFoundError");
+        }
+      }
+      /**
+       * Gets all allowed Web USB devices which are connected
+       * @returns Promise containing an array of devices
+       */
+      async getDevices() {
+        const preFilters = this.options.allowAllDevices ? void 0 : this.options.allowedDevices;
+        const devices = await this.loadDevices(preFilters);
+        return devices.filter((device) => this.isAuthorisedDevice(device));
+      }
+      async loadDevices(preFilters) {
+        let devices = usb.getDeviceList();
+        devices = this.quickFilter(devices, preFilters);
+        const refreshedKnownDevices = /* @__PURE__ */ new Map();
+        for (const device of devices) {
+          const webDevice = await this.getWebDevice(device);
+          if (webDevice) {
+            refreshedKnownDevices.set(device, webDevice);
+          }
+        }
+        this.knownDevices = refreshedKnownDevices;
+        return [...this.knownDevices.values()];
+      }
+      // Get a WebUSBDevice corresponding to underlying device.
+      // Returns undefined the device was not found and could not be created.
+      async getWebDevice(device) {
+        if (!this.knownDevices.has(device)) {
+          if (this.options.deviceTimeout) {
+            device.timeout = this.options.deviceTimeout;
+          }
+          try {
+            const webDevice = await webusb_device_1.WebUSBDevice.createInstance(device, this.options.autoDetachKernelDriver);
+            this.knownDevices.set(device, webDevice);
+          } catch {
+          }
+        }
+        return this.knownDevices.get(device);
+      }
+      // Undertake quick filter on devices before creating WebUSB devices if possible
+      quickFilter(devices, preFilters) {
+        if (!preFilters || !preFilters.length) {
+          return devices;
+        }
+        return devices.filter((device) => preFilters.some((filter) => {
+          if (filter.vendorId && filter.vendorId !== device.deviceDescriptor.idVendor)
+            return false;
+          if (filter.productId && filter.productId !== device.deviceDescriptor.idProduct)
+            return false;
+          return true;
+        }));
+      }
+      // Filter WebUSB devices
+      filterDevice(device, filters) {
+        if (!filters || !filters.length) {
+          return true;
+        }
+        return filters.some((filter) => {
+          if (filter.vendorId && filter.vendorId !== device.vendorId)
+            return false;
+          if (filter.productId && filter.productId !== device.productId)
+            return false;
+          if (filter.classCode) {
+            if (!device.configuration) {
+              return false;
+            }
+            const match = device.configuration.interfaces.some((iface) => {
+              if (filter.classCode && filter.classCode !== iface.alternate.interfaceClass)
+                return false;
+              if (filter.subclassCode && filter.subclassCode !== iface.alternate.interfaceSubclass)
+                return false;
+              if (filter.protocolCode && filter.protocolCode !== iface.alternate.interfaceProtocol)
+                return false;
+              return true;
+            });
+            if (match) {
+              return true;
+            }
+          }
+          if (filter.classCode && filter.classCode !== device.deviceClass)
+            return false;
+          if (filter.subclassCode && filter.subclassCode !== device.deviceSubclass)
+            return false;
+          if (filter.protocolCode && filter.protocolCode !== device.deviceProtocol)
+            return false;
+          if (filter.serialNumber && filter.serialNumber !== device.serialNumber)
+            return false;
+          return true;
+        });
+      }
+      // Check whether a device is authorised
+      isAuthorisedDevice(device) {
+        if (this.options.allowAllDevices) {
+          return true;
+        }
+        if (this.options.allowedDevices && this.filterDevice(device, this.options.allowedDevices)) {
+          return true;
+        }
+        return [...this.authorisedDevices.values()].some((authorised) => authorised.vendorId === device.vendorId && authorised.productId === device.productId && authorised.classCode === device.deviceClass && authorised.subclassCode === device.deviceSubclass && authorised.protocolCode === device.deviceProtocol && authorised.serialNumber === device.serialNumber);
+      }
+    };
+    exports2.WebUSB = WebUSB;
+  }
+});
+
+// node_modules/usb/dist/usb/descriptors.js
+var require_descriptors = __commonJS({
+  "node_modules/usb/dist/usb/descriptors.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// node_modules/usb/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/usb/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LibUSBException = exports2.useUsbDkBackend = exports2.getDeviceList = exports2.Transfer = exports2.Device = exports2.webusb = exports2.findBySerialNumber = exports2.findByIds = exports2.usb = void 0;
+    var util_1 = require("util");
+    var webusb_1 = require_webusb();
+    var usb = require_usb();
+    exports2.usb = usb;
+    var findByIds = (vid, pid) => {
+      const devices = usb.getDeviceList();
+      return devices.find((item) => item.deviceDescriptor.idVendor === vid && item.deviceDescriptor.idProduct === pid);
+    };
+    exports2.findByIds = findByIds;
+    var findBySerialNumber = async (serialNumber) => {
+      const devices = usb.getDeviceList();
+      const opened = (device) => !!device.interfaces;
+      for (const device of devices) {
+        try {
+          if (!opened(device)) {
+            device.open();
+          }
+          const getStringDescriptor = (0, util_1.promisify)(device.getStringDescriptor).bind(device);
+          const buffer = await getStringDescriptor(device.deviceDescriptor.iSerialNumber);
+          if (buffer && buffer.toString() === serialNumber) {
+            return device;
+          }
+        } catch {
+        } finally {
+          try {
+            if (opened(device)) {
+              device.close();
+            }
+          } catch {
+          }
+        }
+      }
+      return void 0;
+    };
+    exports2.findBySerialNumber = findBySerialNumber;
+    var webusb = new webusb_1.WebUSB();
+    exports2.webusb = webusb;
+    var usb_1 = require_usb();
+    Object.defineProperty(exports2, "Device", { enumerable: true, get: function() {
+      return usb_1.Device;
+    } });
+    Object.defineProperty(exports2, "Transfer", { enumerable: true, get: function() {
+      return usb_1.Transfer;
+    } });
+    Object.defineProperty(exports2, "getDeviceList", { enumerable: true, get: function() {
+      return usb_1.getDeviceList;
+    } });
+    Object.defineProperty(exports2, "useUsbDkBackend", { enumerable: true, get: function() {
+      return usb_1.useUsbDkBackend;
+    } });
+    Object.defineProperty(exports2, "LibUSBException", { enumerable: true, get: function() {
+      return usb_1.LibUSBException;
+    } });
+    __exportStar(require_capability(), exports2);
+    __exportStar(require_descriptors(), exports2);
+    __exportStar(require_endpoint(), exports2);
+    __exportStar(require_interface(), exports2);
+    __exportStar(require_webusb(), exports2);
+    __exportStar(require_webusb_device(), exports2);
+  }
+});
+
+// src/usb-transport.ts
+function listUsbDevices(log) {
+  let usb;
+  try {
+    usb = require_dist();
+  } catch {
+    log.debug?.("usb package not available, skipping raw USB discovery");
+    return [];
+  }
+  try {
+    const deviceList = usb.getDeviceList();
+    const results = [];
+    for (const device of deviceList) {
+      const desc = device.deviceDescriptor;
+      if (desc.idVendor === SIGNOTEC_VID && desc.idProduct === SIGNOTEC_PID) {
+        results.push({
+          path: `usb:${desc.idVendor}:${desc.idProduct}:${device.busNumber}:${device.deviceAddress}`,
+          serialNumber: "",
+          product: "Signotec Pad",
+          _usbDevice: device
+        });
+      }
+    }
+    return results;
+  } catch (err) {
+    log.error?.("Failed to enumerate USB devices:", err.message);
+    return [];
+  }
+}
+function openUsbDevice(descriptor, log) {
+  return new UsbTransportDevice(descriptor._usbDevice, log);
+}
+var import_events, SIGNOTEC_VID, SIGNOTEC_PID, REPORT_SIZE, UsbTransportDevice;
+var init_usb_transport = __esm({
+  "src/usb-transport.ts"() {
+    "use strict";
+    import_events = require("events");
+    SIGNOTEC_VID = 8499;
+    SIGNOTEC_PID = 1;
+    REPORT_SIZE = 63;
+    UsbTransportDevice = class extends import_events.EventEmitter {
+      constructor(usbDevice, log) {
+        super();
+        this.usbDevice = null;
+        this.iface = null;
+        this.inEndpoint = null;
+        this.outEndpoint = null;
+        this.closed = false;
+        this.polling = false;
+        this.transferSize = REPORT_SIZE;
+        /**
+         * Write queue: each entry is a callback that starts the OUT transfer and
+         * calls `next()` when the transfer completes. This ensures the previous
+         * USB transfer is fully on the wire before the next one starts — matching
+         * node-hid's synchronous write() behavior.
+         */
+        this.writeQueue = [];
+        this.writeBusy = false;
+        /** Resolve callback for close() waiting on the write queue to drain. */
+        this.drainResolve = null;
+        this.usbDevice = usbDevice;
+        this.log = log;
+        try {
+          this.usbDevice.open();
+        } catch (err) {
+          throw new Error(`Cannot open USB device: ${err.message}`);
+        }
+        const { iface, inEp, outEp } = this.findEndpoints();
+        this.iface = iface;
+        this.inEndpoint = inEp;
+        this.outEndpoint = outEp;
+        this.transferSize = this.inEndpoint.descriptor?.wMaxPacketSize || REPORT_SIZE;
+        this.log.info?.(`USB endpoint max packet size: ${this.transferSize}`);
+        try {
+          if (this.iface.isKernelDriverActive?.()) {
+            this.iface.detachKernelDriver();
+          }
+        } catch {
+        }
+        try {
+          this.iface.claim();
+        } catch (err) {
+          this.usbDevice.close();
+          throw new Error(
+            `Cannot claim USB interface: ${err.message}. On Windows, you may need to install WinUSB driver using Zadig.`
+          );
+        }
+        this.startPolling();
+      }
+      findEndpoints() {
+        const interfaces = this.usbDevice.interfaces;
+        for (const iface of interfaces) {
+          let inEp = null;
+          let outEp = null;
+          for (const ep of iface.endpoints) {
+            if (ep.transferType === 3) {
+              if (ep.direction === "in") inEp = ep;
+              else if (ep.direction === "out") outEp = ep;
+            }
+          }
+          if (inEp && outEp) {
+            return { iface, inEp, outEp };
+          }
+        }
+        throw new Error(
+          "No suitable USB interface found with interrupt IN+OUT endpoints. The device may require a different driver."
+        );
+      }
+      startPolling() {
+        if (this.closed || !this.inEndpoint || this.polling) return;
+        this.polling = true;
+        this.inEndpoint.startPoll(3, this.transferSize);
+        this.inEndpoint.on("data", (data) => {
+          if (this.closed) return;
+          if (!data || data.length === 0) return;
+          this.emit("data", Buffer.from(data));
+        });
+        this.inEndpoint.on("error", (err) => {
+          if (this.closed) return;
+          if (err.message?.includes("LIBUSB_TRANSFER_CANCELLED")) return;
+          if (err.message?.includes("LIBUSB_TRANSFER_NO_DEVICE")) {
+            this.emit("error", new Error("Device disconnected"));
+            return;
+          }
+          this.log.error?.("USB IN error:", err.message);
+          this.emit("error", err);
+        });
+      }
+      /**
+       * Queue an OUT transfer. Transfers are serialized: each one completes
+       * before the next starts. This matches node-hid's synchronous write().
+       */
+      write(data) {
+        if (this.closed || !this.outEndpoint) {
+          throw new Error("Device not connected");
+        }
+        const buf = Buffer.alloc(REPORT_SIZE, 0);
+        for (let i = 0; i < Math.min(data.length, REPORT_SIZE); i++) {
+          buf[i] = data[i];
+        }
+        this.writeQueue.push(() => {
+          if (this.closed || !this.outEndpoint) {
+            queueMicrotask(() => this.drainNext());
+            return;
+          }
+          this.outEndpoint.transfer(buf, (err) => {
+            if (err && !this.closed) {
+              this.log.error("USB write error:", err.message);
+              this.emit("error", err);
+            }
+            this.drainNext();
+          });
+        });
+        if (!this.writeBusy) {
+          this.drainNext();
+        }
+      }
+      drainNext() {
+        const next = this.writeQueue.shift();
+        if (next) {
+          this.writeBusy = true;
+          next();
+        } else {
+          this.writeBusy = false;
+          this.drainResolve?.();
+          this.drainResolve = null;
+        }
+      }
+      /**
+       * Close the device. Waits up to 1s for any in-flight transfer to complete
+       * before releasing the USB interface.
+       */
+      close() {
+        if (this.closed) return;
+        this.closed = true;
+        this.writeQueue.length = 0;
+        const finish = () => {
+          if (this.polling && this.inEndpoint) {
+            try {
+              this.inEndpoint.removeAllListeners("data");
+              this.inEndpoint.removeAllListeners("error");
+              this.inEndpoint.stopPoll(() => this.releaseAndClose());
+            } catch {
+              this.releaseAndClose();
+            }
+          } else {
+            this.releaseAndClose();
+          }
+          this.polling = false;
+          this.removeAllListeners();
+        };
+        if (this.writeBusy) {
+          const timeout = setTimeout(() => {
+            this.log.warn("USB close: in-flight transfer did not complete in 1s, forcing close");
+            this.writeBusy = false;
+            finish();
+          }, 1e3);
+          new Promise((resolve) => {
+            this.drainResolve = resolve;
+          }).then(() => {
+            clearTimeout(timeout);
+            finish();
+          });
+        } else {
+          finish();
+        }
+      }
+      releaseAndClose() {
+        if (this.iface) {
+          try {
+            this.iface.release(true, () => {
+              try {
+                this.usbDevice?.close();
+              } catch {
+              }
+              this.usbDevice = null;
+            });
+          } catch {
+            try {
+              this.usbDevice?.close();
+            } catch {
+            }
+            this.usbDevice = null;
+          }
+        } else {
+          try {
+            this.usbDevice?.close();
+          } catch {
+          }
+          this.usbDevice = null;
+        }
+        this.inEndpoint = null;
+        this.outEndpoint = null;
+        this.iface = null;
+      }
+    };
+  }
+});
+
+// src/hid-protocol.ts
+var SIGNOTEC_VID2, SIGNOTEC_PID2, HID_REPORT_SIZE, DEFAULTS, CMD, BUTTON_CMD, RESP, REG, SIG_EVENT, HidProtocol;
+var init_hid_protocol = __esm({
+  "src/hid-protocol.ts"() {
+    "use strict";
+    init_usb_transport();
+    SIGNOTEC_VID2 = 8499;
+    SIGNOTEC_PID2 = 1;
+    HID_REPORT_SIZE = 63;
+    DEFAULTS = {
+      commandTimeout: 3e3,
+      imageTransferTimeout: 15e3,
+      flashStoreTimeout: 25e3,
+      chunkDelayMs: 2,
+      maxRetries: 2,
+      reconnectAttempts: 10,
+      reconnectIntervalMs: 2e3,
+      logger: console
+    };
+    CMD = {
+      READ_REG: 1,
+      WRITE_REG: 16,
+      START_SIGN: 130,
+      STOP_SIGN: 131,
+      DRAW_IMAGE: 132,
+      IMAGE_DONE: 133,
+      ERASE_DISPLAY: 134,
+      STORE_IMAGE: 137,
+      SHOW_STORED: 138,
+      DATA_CHUNK: 96,
+      STORE_CHUNK: 112,
+      SLIDESHOW_CONFIG: 164,
+      EXTENDED: 168,
+      ADVANCED_BUTTON: 173
+    };
+    BUTTON_CMD = {
+      CLEAR_ALL: 1,
+      SET_RECT: 4,
+      ENABLE_MONITORING: 10
+    };
+    RESP = {
+      READ: 32,
+      ACK: 144,
+      START_ACK: 146,
+      STOP_ACK: 147,
+      IMAGE_ACK: 148,
+      ERROR: 224,
+      IDLE: 80
+    };
+    REG = {
+      DEVICE_ID: 0,
+      FW_VERSION1: 1,
+      FW_VERSION2: 2,
+      STATE: 16,
+      CAPABILITIES: 17,
+      SERIAL: 20,
+      DISPLAY_WIDTH: 21,
+      DISPLAY_HEIGHT: 22,
+      SIGN_LEFT: 50,
+      SIGN_TOP: 51,
+      SIGN_RIGHT: 52,
+      SIGN_BOTTOM: 53
+    };
+    SIG_EVENT = {
+      PEN_UP: 64,
+      PEN_DATA: 65,
+      PEN_DATA_EXT: 66,
+      HOTSPOT: 67
+    };
+    HidProtocol = class {
+      constructor(config) {
+        this.device = null;
+        this.pending = null;
+        this.signatureCallback = null;
+        this.disconnectCallback = null;
+        this.connected = false;
+        this.closing = false;
+        /** Cached USB device descriptors from last listDevices() call (for USB fallback). */
+        this.usbDeviceMap = /* @__PURE__ */ new Map();
+        this.config = {
+          commandTimeout: config?.commandTimeout ?? DEFAULTS.commandTimeout,
+          imageTransferTimeout: config?.imageTransferTimeout ?? DEFAULTS.imageTransferTimeout,
+          flashStoreTimeout: config?.flashStoreTimeout ?? DEFAULTS.flashStoreTimeout,
+          chunkDelayMs: config?.chunkDelayMs ?? DEFAULTS.chunkDelayMs,
+          maxRetries: config?.maxRetries ?? DEFAULTS.maxRetries,
+          reconnectAttempts: config?.reconnectAttempts ?? DEFAULTS.reconnectAttempts,
+          reconnectIntervalMs: config?.reconnectIntervalMs ?? DEFAULTS.reconnectIntervalMs
+        };
+        this.log = config?.logger === null ? { info() {
+        }, warn() {
+        }, error() {
+        }, debug() {
+        } } : config?.logger ?? DEFAULTS.logger;
+        try {
+          this.HID = require("node-hid");
+        } catch {
+          throw new Error(
+            "node-hid is required for Signotec HID support. Install with: npm install node-hid"
+          );
+        }
+      }
+      // ─── Device Management ──────────────────────────────────────────────────────
+      /**
+       * Discover all connected Signotec pads.
+       * Tries node-hid first; falls back to raw USB enumeration (libusb) if no
+       * HID devices are found (e.g., Windows without HID class driver).
+       * @returns Array of device descriptors (never throws).
+       */
+      listDevices() {
+        this.usbDeviceMap.clear();
+        try {
+          const hidDevices = this.HID.devices().filter((d) => d.vendorId === SIGNOTEC_VID2 && d.productId === SIGNOTEC_PID2).map((d) => ({
+            path: d.path,
+            serialNumber: d.serialNumber || "",
+            product: d.product || "Signotec Pad"
+          }));
+          if (hidDevices.length > 0) {
+            this.log.info(`Found ${hidDevices.length} Signotec pad(s) via HID`);
+            return hidDevices;
+          }
+        } catch (err) {
+          this.log.warn("HID enumeration failed:", err.message);
+        }
+        this.log.info("No Signotec pads found via HID, trying raw USB...");
+        try {
+          const usbDevices = listUsbDevices(this.log);
+          if (usbDevices.length > 0) {
+            this.log.info(`Found ${usbDevices.length} Signotec pad(s) via raw USB`);
+            for (const d of usbDevices) {
+              this.usbDeviceMap.set(d.path, d);
+            }
+            return usbDevices.map((d) => ({
+              path: d.path,
+              serialNumber: d.serialNumber || "",
+              product: d.product || "Signotec Pad"
+            }));
+          }
+        } catch (err) {
+          this.log.warn("USB enumeration failed:", err.message);
+        }
+        this.logDiscoveryDiagnostics();
+        return [];
+      }
+      /** Log diagnostic info when no devices are found. */
+      logDiscoveryDiagnostics() {
+        try {
+          const allHid = this.HID.devices();
+          const signotecHid = allHid.filter((d) => d.vendorId === SIGNOTEC_VID2);
+          this.log.warn(
+            `No Signotec pads found. HID bus: ${allHid.length} devices total, ${signotecHid.length} matching VID=0x${SIGNOTEC_VID2.toString(16)}.`
+          );
+          if (signotecHid.length > 0) {
+            this.log.warn("Signotec HID entries (wrong PID?):", JSON.stringify(
+              signotecHid.map((d) => ({ pid: d.productId, usagePage: d.usagePage, product: d.product }))
+            ));
+          }
+        } catch {
+        }
+        const platform = process.platform;
+        if (platform === "linux") {
+          this.log.warn(
+            "Linux: ensure udev rules are installed. Copy 99-signotec.rules to /etc/udev/rules.d/ and run: sudo udevadm control --reload-rules && sudo udevadm trigger"
+          );
+        } else if (platform === "darwin") {
+          this.log.warn(
+            "macOS: check System Preferences > Security & Privacy > Input Monitoring permissions."
+          );
+        } else if (platform === "win32") {
+          this.log.warn(
+            "Windows: the device may need the WinUSB driver. Install it using Zadig (https://zadig.akeo.ie/) by selecting the Signotec device and choosing WinUSB."
+          );
+        }
+      }
+      /**
+       * Open a device by its path (HID path or USB path).
+       * USB paths start with "usb:" and use the raw USB transport fallback.
+       * @throws Error if the device cannot be opened.
+       */
+      open(devicePath) {
+        if (this.device) this.close();
+        this.closing = false;
+        const usbDescriptor = this.usbDeviceMap.get(devicePath);
+        if (usbDescriptor) {
+          this.log.info("Opening Signotec pad via raw USB transport");
+          this.device = openUsbDevice(usbDescriptor, this.log);
+        } else {
+          this.device = new this.HID.HID(devicePath);
+        }
+        this.connected = true;
+        this.device.on("data", (data) => this.handleData(Buffer.from(data)));
+        this.device.on("error", (err) => {
+          if (this.closing) return;
+          this.log.error("Signotec HID error:", err.message);
+          this.connected = false;
+          this.disconnectCallback?.();
+        });
+      }
+      /** Close the device connection and release resources. */
+      close() {
+        this.closing = true;
+        this.connected = false;
+        if (this.pending) {
+          clearTimeout(this.pending.timer);
+          this.pending.resolve(null);
+          this.pending = null;
+        }
+        if (this.device) {
+          try {
+            this.device.removeAllListeners?.();
+          } catch {
+          }
+          try {
+            this.device.close();
+          } catch (err) {
+            this.log.warn("Error closing HID device:", err.message);
+          }
+          this.device = null;
+        }
+        this.signatureCallback = null;
+      }
+      /** Check if the device connection is alive. */
+      isConnected() {
+        return this.connected && this.device !== null && !this.closing;
+      }
+      /**
+       * Verify the device is actually responsive (sends a register read and checks response).
+       * Useful after reconnection or before starting a session.
+       */
+      async isResponsive() {
+        if (!this.isConnected()) return false;
+        const resp = await this.readRegister(REG.STATE);
+        return resp !== null;
+      }
+      /** Register a callback for device disconnect events. */
+      onDisconnect(cb) {
+        this.disconnectCallback = cb;
+      }
+      /** Register a callback for signature/hotspot events from the device. */
+      onSignatureEvent(cb) {
+        this.signatureCallback = cb;
+      }
+      // ─── Core I/O ─────────────────────────────────────────────────────────────────
+      send(bytes) {
+        if (!this.device || !this.connected) throw new Error("Device not connected");
+        const buf = Buffer.alloc(HID_REPORT_SIZE, 0);
+        for (let i = 0; i < Math.min(bytes.length, HID_REPORT_SIZE); i++) {
+          buf[i] = bytes[i];
+        }
+        this.device.write([...buf]);
+      }
+      /**
+       * Send a command and wait for the response.
+       * @returns Response buffer, or null on timeout/error.
+       */
+      sendCommand(bytes, timeout) {
+        const t = timeout ?? this.config.commandTimeout;
+        if (!this.device || !this.connected) return Promise.resolve(null);
+        if (this.pending) {
+          clearTimeout(this.pending.timer);
+          this.pending.resolve(null);
+          this.pending = null;
+        }
+        return new Promise((resolve) => {
+          const timer = setTimeout(() => {
+            if (this.pending?.resolve === resolve) {
+              this.pending = null;
+              resolve(null);
+            }
+          }, t);
+          this.pending = { resolve, timer };
+          try {
+            this.send(bytes);
+          } catch {
+            clearTimeout(timer);
+            this.pending = null;
+            this.connected = false;
+            resolve(null);
+          }
+        });
+      }
+      /**
+       * Send a command with automatic retry on failure.
+       * @param bytes Command bytes to send
+       * @param validateFn Function to check if response is valid (defaults to non-null + non-error)
+       * @param timeout Timeout per attempt
+       * @param maxRetries Max retry count (from config if not specified)
+       */
+      async sendCommandWithRetry(bytes, validateFn, timeout, maxRetries) {
+        const retries = maxRetries ?? this.config.maxRetries;
+        const validate = validateFn ?? ((r) => r[0] !== RESP.ERROR);
+        for (let attempt = 0; attempt <= retries; attempt++) {
+          const resp = await this.sendCommand(bytes, timeout);
+          if (resp && validate(resp)) return resp;
+          if (attempt < retries) {
+            this.log.warn(`HID command 0x${bytes[0]?.toString(16)} failed (attempt ${attempt + 1}/${retries + 1}), retrying...`);
+            await new Promise((r) => setTimeout(r, 100 * (attempt + 1)));
+          }
+        }
+        return null;
+      }
+      /** Send raw bytes without waiting for a response (fire-and-forget). */
+      sendRaw(bytes) {
+        try {
+          this.send(bytes);
+        } catch {
+          this.connected = false;
+        }
+      }
+      /**
+       * Send a bulk data chunk for image transfers.
+       * @param cmdByte Command byte (0x60 for display, 0x70 for flash store)
+       * @param data Source buffer
+       * @param offset Starting offset in data
+       * @param maxPayload Max bytes per chunk (default 62)
+       */
+      sendChunk(cmdByte, data, offset, maxPayload = 62) {
+        const chunk = Buffer.alloc(HID_REPORT_SIZE, 0);
+        chunk[0] = cmdByte;
+        const toCopy = Math.min(maxPayload, data.length - offset);
+        data.copy(chunk, 1, offset, offset + toCopy);
+        try {
+          this.device?.write([...chunk]);
+        } catch {
+          this.connected = false;
+        }
+      }
+      handleData(buf) {
+        const type = buf[0];
+        if (type === RESP.IDLE || type === 81) return;
+        if (type === SIG_EVENT.PEN_DATA || type === SIG_EVENT.PEN_UP || type === SIG_EVENT.PEN_DATA_EXT || type === SIG_EVENT.HOTSPOT) {
+          this.signatureCallback?.(type, buf);
+          return;
+        }
+        if (this.pending) {
+          clearTimeout(this.pending.timer);
+          const p = this.pending;
+          this.pending = null;
+          p.resolve(buf);
+        }
+      }
+      // ─── Register Operations ──────────────────────────────────────────────────────
+      /** Read a device register. Returns the data portion or null on error/timeout. */
+      async readRegister(reg) {
+        const resp = await this.sendCommand([CMD.READ_REG, reg]);
+        if (resp && (resp[0] & 240) === 32) {
+          const len = resp[2];
+          return Buffer.from(resp.slice(3, 3 + len));
+        }
+        return null;
+      }
+      /** Write a 4-byte little-endian value to a register. */
+      async writeRegister(reg, value) {
+        const resp = await this.sendCommand([
+          CMD.WRITE_REG,
+          reg,
+          4,
+          value & 255,
+          value >> 8 & 255,
+          value >> 16 & 255,
+          value >> 24 & 255
+        ]);
+        if (!resp) return false;
+        return (resp[0] & 240) === 32 || (resp[0] & 240) === 144;
+      }
+      /** Read full device info from registers. */
+      async getDeviceInfo() {
+        const info = {
+          serialNo: "unknown",
+          displayWidth: 320,
+          displayHeight: 160,
+          sensorWidth: 320,
+          sensorHeight: 160,
+          deviceId: 0,
+          fwMajor: 0,
+          fwMinor: 0,
+          capabilities: 0
+        };
+        const serial = await this.readRegister(REG.SERIAL);
+        if (serial) info.serialNo = serial.toString("utf16le").replace(/[\0#]/g, "");
+        const devId = await this.readRegister(REG.DEVICE_ID);
+        if (devId?.length && devId.length >= 4) info.deviceId = devId.readUInt32LE(0);
+        const fw1 = await this.readRegister(REG.FW_VERSION1);
+        if (fw1?.length && fw1.length >= 4) {
+          info.fwMajor = fw1.readUInt16LE(0);
+          info.fwMinor = fw1.readUInt16LE(2);
+        }
+        const caps = await this.readRegister(REG.CAPABILITIES);
+        if (caps?.length && caps.length >= 4) info.capabilities = caps.readUInt32LE(0);
+        const dw = await this.readRegister(REG.DISPLAY_WIDTH);
+        if (dw?.length && dw.length >= 4) info.displayWidth = dw.readUInt32LE(0);
+        const dh = await this.readRegister(REG.DISPLAY_HEIGHT);
+        if (dh?.length && dh.length >= 4) info.displayHeight = dh.readUInt32LE(0);
+        return info;
+      }
+      // ─── Display Commands ─────────────────────────────────────────────────────────
+      /** Erase the pad display (clear to white). */
+      async eraseDisplay() {
+        const resp = await this.sendCommandWithRetry(
+          [CMD.ERASE_DISPLAY],
+          (r) => r[0] === RESP.ACK
+        );
+        return resp !== null;
+      }
+      /**
+       * Send monochrome 1bpp bitmap data to the pad display.
+       * Protocol: 0x84 header → 0x60 data chunks → 0x85 done.
+       * Automatically inverts polarity (pad uses 1=black, framebuffer uses 0=black).
+       */
+      async drawImage(x, y, width, height, bitmapData) {
+        const imgHeader = Buffer.alloc(25, 0);
+        imgHeader[0] = CMD.DRAW_IMAGE;
+        imgHeader.writeInt32LE(x, 1);
+        imgHeader.writeInt32LE(y, 5);
+        imgHeader.writeInt32LE(width, 9);
+        imgHeader.writeInt32LE(height, 13);
+        const resp = await this.sendCommandWithRetry(
+          [...imgHeader],
+          (r) => r[0] === RESP.ACK,
+          this.config.imageTransferTimeout
+        );
+        if (!resp) return false;
+        const invertedData = Buffer.alloc(bitmapData.length);
+        for (let i = 0; i < bitmapData.length; i++) {
+          invertedData[i] = bitmapData[i] ^ 255;
+        }
+        const chunkPayload = 62;
+        for (let offset = 0; offset < invertedData.length; offset += chunkPayload) {
+          this.sendChunk(CMD.DATA_CHUNK, invertedData, offset, chunkPayload);
+          if (offset % (chunkPayload * 10) === 0 && offset > 0) {
+            await new Promise((r) => setTimeout(r, this.config.chunkDelayMs));
+          }
+        }
+        const doneResp = await this.sendCommand([CMD.IMAGE_DONE], this.config.imageTransferTimeout);
+        return doneResp !== null && (doneResp[0] === RESP.IMAGE_ACK || doneResp[0] === RESP.ACK);
+      }
+      // ─── Flash Storage ────────────────────────────────────────────────────────────
+      /**
+       * Store a 1bpp bitmap to the pad's non-volatile flash as standby image.
+       * Persists across power cycles and USB disconnects.
+       *
+       * Protocol: 0x89 header → 0x70 data chunks → 0xA4 standby config.
+       * Flash uses direct polarity (opposite of display), auto-detected.
+       */
+      async storeStandbyImage(width, height, bitmapData) {
+        let ones = 0;
+        for (let i = 0; i < bitmapData.length; i++) {
+          for (let b = 0; b < 8; b++) {
+            if (bitmapData[i] & 1 << b) ones++;
+          }
+        }
+        const needsInvert = ones > bitmapData.length * 4;
+        const storeData = Buffer.alloc(bitmapData.length);
+        for (let i = 0; i < bitmapData.length; i++) {
+          storeData[i] = needsInvert ? bitmapData[i] ^ 255 : bitmapData[i];
+        }
+        const storeHeader = Buffer.alloc(33, 0);
+        storeHeader[0] = CMD.STORE_IMAGE;
+        storeHeader.writeInt32LE(0, 1);
+        storeHeader.writeInt32LE(0, 5);
+        storeHeader.writeInt32LE(width, 9);
+        storeHeader.writeInt32LE(height, 13);
+        storeHeader.writeInt32LE(0, 17);
+        storeHeader.writeInt32LE(1, 21);
+        storeHeader.writeInt32LE(1, 25);
+        storeHeader.writeInt32LE(0, 29);
+        const resp1 = await this.sendCommand([...storeHeader], this.config.flashStoreTimeout);
+        if (!resp1 || resp1[0] !== RESP.ACK) {
+          this.log.error("Flash store header rejected:", resp1 ? `0x${resp1[0].toString(16)}` : "timeout");
+          return false;
+        }
+        const chunkPayload = 62;
+        for (let offset = 0; offset < storeData.length; offset += chunkPayload) {
+          this.sendChunk(CMD.STORE_CHUNK, storeData, offset, chunkPayload);
+          if (offset % (chunkPayload * 20) === 0 && offset > 0) {
+            await new Promise((r) => setTimeout(r, this.config.chunkDelayMs * 3));
+          }
+        }
+        await new Promise((r) => setTimeout(r, 500));
+        return this.sendSlideshowConfig(2, 3, 100, 1);
+      }
+      /**
+       * Show the stored standby image from flash on the display.
+       * Command 0x8A = "draw stored image" (from APIClosePad → APIDrawStoredImage).
+       *
+       * Single HID command - no image data transfer. Works regardless of who
+       * stored the image (our library, Signotec SlideShow tool, etc.)
+       */
+      async showStandbyFromFlash() {
+        const cmd = Buffer.alloc(33, 0);
+        cmd[0] = CMD.SHOW_STORED;
+        const resp = await this.sendCommand([...cmd], this.config.imageTransferTimeout);
+        return resp !== null && (resp[0] === RESP.ACK || resp[0] === 152);
+      }
+      /**
+       * Send a slideshow/standby configuration command (0xA4).
+       * Automatically wraps in 0xA8 for Sigma pads (which don't support direct 0xA4).
+       */
+      async sendSlideshowConfig(action, mode, count, flag) {
+        const configCmd = Buffer.alloc(49, 0);
+        configCmd[0] = CMD.SLIDESHOW_CONFIG;
+        configCmd.writeInt32LE(action, 1);
+        configCmd.writeInt32LE(mode, 5);
+        configCmd.writeInt32LE(count, 9);
+        configCmd.writeInt32LE(flag, 13);
+        let resp = await this.sendCommand([...configCmd], 5e3);
+        if (!resp || resp[0] === RESP.ERROR) {
+          const a8cmd = Buffer.alloc(50, 0);
+          a8cmd[0] = CMD.EXTENDED;
+          configCmd.copy(a8cmd, 1, 0, 49);
+          resp = await this.sendCommand([...a8cmd], 5e3);
+        }
+        return resp !== null && (resp[0] === RESP.ACK || (resp[0] & 240) === 144);
+      }
+      // ─── Sensor / Hotspot Commands ────────────────────────────────────────────────
+      /** Set the signature capture rectangle (left, top, width, height → registers 0x32-0x35). */
+      async setSignRect(left, top, width, height) {
+        const r1 = await this.writeRegister(REG.SIGN_LEFT, Math.round(left));
+        const r2 = await this.writeRegister(REG.SIGN_TOP, Math.round(top));
+        const r3 = await this.writeRegister(REG.SIGN_RIGHT, Math.round(left + width));
+        const r4 = await this.writeRegister(REG.SIGN_BOTTOM, Math.round(top + height));
+        return r1 && r2 && r3 && r4;
+      }
+      /** Clear all hotspot areas. */
+      async clearHotSpots() {
+        const resp = await this.sendCommand([CMD.ADVANCED_BUTTON, BUTTON_CMD.CLEAR_ALL]);
+        return resp !== null && (resp[0] & 240) === 144;
+      }
+      /**
+       * Add a hotspot (touch-sensitive button area).
+       * @param index Hotspot index (0-based)
+       * @param left X position
+       * @param top Y position
+       * @param width Width in pixels
+       * @param height Height in pixels
+       */
+      async addHotSpot(index, left, top, width, height) {
+        const resp = await this.sendCommand([
+          CMD.ADVANCED_BUTTON,
+          BUTTON_CMD.SET_RECT,
+          1,
+          Math.round(index) & 127 | 128,
+          Math.round(left) & 255,
+          Math.round(left) >> 8 & 255,
+          Math.round(top) & 255,
+          Math.round(top) >> 8 & 255,
+          0,
+          Math.round(width) & 255,
+          Math.round(width) >> 8 & 255,
+          Math.round(height) & 255,
+          Math.round(height) >> 8 & 255
+        ]);
+        return resp !== null && (resp[0] & 240) === 144;
+      }
+      /** Enable hotspot monitoring (call after addHotSpot). */
+      async enableHotspotMonitoring() {
+        const resp = await this.sendCommand([CMD.ADVANCED_BUTTON, BUTTON_CMD.ENABLE_MONITORING]);
+        return resp !== null && (resp[0] & 240) === 144;
+      }
+      // ─── Signature Session ────────────────────────────────────────────────────────
+      /** Start signature capture. Protocol: [0x82, 0x00, 0x00, 0x00, 0x00]. */
+      async startSignature() {
+        const resp = await this.sendCommandWithRetry(
+          [CMD.START_SIGN, 0, 0, 0, 0],
+          (r) => r[0] === RESP.START_ACK
+        );
+        return resp !== null;
+      }
+      /** Stop signature capture. */
+      async stopSignature() {
+        const resp = await this.sendCommand([CMD.STOP_SIGN]);
+        return resp !== null && resp[0] === RESP.STOP_ACK;
+      }
+    };
+  }
+});
+
+// src/font-8x13.ts
+var FONT_8X13;
+var init_font_8x13 = __esm({
+  "src/font-8x13.ts"() {
+    "use strict";
+    FONT_8X13 = {
+      // ─── Space ───────────────────────────────────────────────────────────────
+      " ": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      // ─── Digits ──────────────────────────────────────────────────────────────
+      "0": [0, 0, 60, 102, 110, 118, 102, 102, 102, 60, 0, 0, 0],
+      "1": [0, 0, 24, 56, 24, 24, 24, 24, 24, 126, 0, 0, 0],
+      "2": [0, 0, 60, 102, 6, 12, 24, 48, 96, 126, 0, 0, 0],
+      "3": [0, 0, 60, 102, 6, 28, 6, 6, 102, 60, 0, 0, 0],
+      "4": [0, 0, 12, 28, 44, 76, 126, 12, 12, 12, 0, 0, 0],
+      "5": [0, 0, 126, 96, 96, 124, 6, 6, 102, 60, 0, 0, 0],
+      "6": [0, 0, 28, 48, 96, 124, 102, 102, 102, 60, 0, 0, 0],
+      "7": [0, 0, 126, 6, 12, 24, 24, 48, 48, 48, 0, 0, 0],
+      "8": [0, 0, 60, 102, 102, 60, 102, 102, 102, 60, 0, 0, 0],
+      "9": [0, 0, 60, 102, 102, 102, 62, 6, 12, 56, 0, 0, 0],
+      // ─── Uppercase A–Z ───────────────────────────────────────────────────────
+      "A": [0, 0, 24, 60, 102, 102, 126, 102, 102, 102, 0, 0, 0],
+      "B": [0, 0, 124, 102, 102, 124, 102, 102, 102, 124, 0, 0, 0],
+      "C": [0, 0, 60, 102, 96, 96, 96, 96, 102, 60, 0, 0, 0],
+      "D": [0, 0, 120, 108, 102, 102, 102, 102, 108, 120, 0, 0, 0],
+      "E": [0, 0, 126, 96, 96, 124, 96, 96, 96, 126, 0, 0, 0],
+      "F": [0, 0, 126, 96, 96, 124, 96, 96, 96, 96, 0, 0, 0],
+      "G": [0, 0, 60, 102, 96, 96, 110, 102, 102, 62, 0, 0, 0],
+      "H": [0, 0, 102, 102, 102, 126, 102, 102, 102, 102, 0, 0, 0],
+      "I": [0, 0, 60, 24, 24, 24, 24, 24, 24, 60, 0, 0, 0],
+      "J": [0, 0, 30, 6, 6, 6, 6, 6, 102, 60, 0, 0, 0],
+      "K": [0, 0, 102, 108, 120, 112, 120, 108, 102, 102, 0, 0, 0],
+      "L": [0, 0, 96, 96, 96, 96, 96, 96, 96, 126, 0, 0, 0],
+      "M": [0, 0, 66, 102, 126, 126, 90, 66, 66, 66, 0, 0, 0],
+      "N": [0, 0, 98, 114, 122, 110, 102, 102, 102, 102, 0, 0, 0],
+      "O": [0, 0, 60, 102, 102, 102, 102, 102, 102, 60, 0, 0, 0],
+      "P": [0, 0, 124, 102, 102, 102, 124, 96, 96, 96, 0, 0, 0],
+      "Q": [0, 0, 60, 102, 102, 102, 102, 118, 108, 54, 0, 0, 0],
+      "R": [0, 0, 124, 102, 102, 124, 120, 108, 102, 102, 0, 0, 0],
+      "S": [0, 0, 60, 102, 96, 56, 12, 6, 102, 60, 0, 0, 0],
+      "T": [0, 0, 126, 24, 24, 24, 24, 24, 24, 24, 0, 0, 0],
+      "U": [0, 0, 102, 102, 102, 102, 102, 102, 102, 60, 0, 0, 0],
+      "V": [0, 0, 102, 102, 102, 102, 102, 60, 24, 24, 0, 0, 0],
+      "W": [0, 0, 66, 66, 66, 90, 90, 126, 102, 66, 0, 0, 0],
+      "X": [0, 0, 102, 102, 60, 24, 60, 102, 102, 102, 0, 0, 0],
+      "Y": [0, 0, 102, 102, 102, 60, 24, 24, 24, 24, 0, 0, 0],
+      "Z": [0, 0, 126, 6, 12, 24, 48, 96, 96, 126, 0, 0, 0],
+      // ─── Lowercase a–z ───────────────────────────────────────────────────────
+      // Baseline row = index 9 (row 10). Descenders use indices 10-11.
+      "a": [0, 0, 0, 0, 60, 6, 62, 102, 102, 62, 0, 0, 0],
+      "b": [0, 0, 96, 96, 124, 102, 102, 102, 102, 124, 0, 0, 0],
+      "c": [0, 0, 0, 0, 60, 102, 96, 96, 102, 60, 0, 0, 0],
+      "d": [0, 0, 6, 6, 62, 102, 102, 102, 102, 62, 0, 0, 0],
+      "e": [0, 0, 0, 0, 60, 102, 126, 96, 102, 60, 0, 0, 0],
+      "f": [0, 0, 14, 24, 24, 126, 24, 24, 24, 24, 0, 0, 0],
+      "g": [0, 0, 0, 0, 62, 102, 102, 102, 62, 6, 6, 60, 0],
+      "h": [0, 0, 96, 96, 124, 102, 102, 102, 102, 102, 0, 0, 0],
+      "i": [0, 0, 24, 0, 56, 24, 24, 24, 24, 60, 0, 0, 0],
+      "j": [0, 0, 6, 0, 14, 6, 6, 6, 6, 6, 70, 60, 0],
+      "k": [0, 0, 96, 96, 102, 108, 120, 124, 108, 102, 0, 0, 0],
+      "l": [0, 0, 56, 24, 24, 24, 24, 24, 24, 14, 0, 0, 0],
+      "m": [0, 0, 0, 0, 108, 126, 126, 106, 98, 98, 0, 0, 0],
+      "n": [0, 0, 0, 0, 124, 102, 102, 102, 102, 102, 0, 0, 0],
+      "o": [0, 0, 0, 0, 60, 102, 102, 102, 102, 60, 0, 0, 0],
+      "p": [0, 0, 0, 0, 124, 102, 102, 102, 124, 96, 96, 96, 0],
+      "q": [0, 0, 0, 0, 62, 102, 102, 102, 62, 6, 6, 6, 0],
+      "r": [0, 0, 0, 0, 108, 118, 96, 96, 96, 96, 0, 0, 0],
+      "s": [0, 0, 0, 0, 60, 102, 56, 12, 102, 60, 0, 0, 0],
+      "t": [0, 0, 24, 24, 126, 24, 24, 24, 24, 14, 0, 0, 0],
+      "u": [0, 0, 0, 0, 102, 102, 102, 102, 102, 62, 0, 0, 0],
+      "v": [0, 0, 0, 0, 102, 102, 102, 60, 60, 24, 0, 0, 0],
+      "w": [0, 0, 0, 0, 66, 66, 90, 90, 126, 36, 0, 0, 0],
+      "x": [0, 0, 0, 0, 102, 102, 60, 60, 102, 102, 0, 0, 0],
+      "y": [0, 0, 0, 0, 102, 102, 102, 62, 6, 6, 70, 60, 0],
+      "z": [0, 0, 0, 0, 126, 12, 24, 48, 96, 126, 0, 0, 0],
+      // ─── Punctuation ─────────────────────────────────────────────────────────
+      ".": [0, 0, 0, 0, 0, 0, 0, 0, 24, 24, 0, 0, 0],
+      ",": [0, 0, 0, 0, 0, 0, 0, 0, 24, 24, 8, 16, 0],
+      ":": [0, 0, 0, 0, 24, 24, 0, 0, 24, 24, 0, 0, 0],
+      ";": [0, 0, 0, 0, 24, 24, 0, 0, 24, 24, 8, 16, 0],
+      "!": [0, 0, 24, 24, 24, 24, 24, 24, 0, 24, 0, 0, 0],
+      "?": [0, 0, 60, 102, 6, 12, 24, 24, 0, 24, 0, 0, 0],
+      "-": [0, 0, 0, 0, 0, 0, 126, 0, 0, 0, 0, 0, 0],
+      "+": [0, 0, 0, 0, 24, 24, 126, 24, 24, 0, 0, 0, 0],
+      "=": [0, 0, 0, 0, 0, 126, 0, 126, 0, 0, 0, 0, 0],
+      "(": [0, 0, 12, 24, 48, 48, 48, 48, 24, 12, 0, 0, 0],
+      ")": [0, 0, 48, 24, 12, 12, 12, 12, 24, 48, 0, 0, 0],
+      "/": [0, 0, 2, 6, 12, 24, 48, 96, 64, 0, 0, 0, 0],
+      "\\": [0, 0, 64, 96, 48, 24, 12, 6, 2, 0, 0, 0, 0],
+      "'": [0, 24, 24, 16, 32, 0, 0, 0, 0, 0, 0, 0, 0],
+      '"': [0, 102, 102, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "_": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 126, 0, 0],
+      "@": [0, 0, 60, 102, 110, 106, 110, 96, 98, 60, 0, 0, 0],
+      "#": [0, 0, 36, 36, 126, 36, 36, 126, 36, 36, 0, 0, 0],
+      "&": [0, 0, 56, 108, 108, 56, 118, 206, 204, 118, 0, 0, 0],
+      "%": [0, 0, 98, 102, 12, 24, 48, 102, 70, 0, 0, 0, 0],
+      "*": [0, 0, 0, 102, 60, 255, 60, 102, 0, 0, 0, 0, 0],
+      "<": [0, 0, 0, 6, 28, 112, 112, 28, 6, 0, 0, 0, 0],
+      ">": [0, 0, 0, 96, 56, 14, 14, 56, 96, 0, 0, 0, 0],
+      "[": [0, 0, 60, 48, 48, 48, 48, 48, 48, 60, 0, 0, 0],
+      "]": [0, 0, 60, 12, 12, 12, 12, 12, 12, 60, 0, 0, 0],
+      "{": [0, 0, 14, 24, 24, 48, 24, 24, 24, 14, 0, 0, 0],
+      "}": [0, 0, 112, 24, 24, 12, 24, 24, 24, 112, 0, 0, 0],
+      "|": [0, 0, 24, 24, 24, 24, 24, 24, 24, 24, 0, 0, 0],
+      "~": [0, 0, 0, 0, 0, 114, 156, 0, 0, 0, 0, 0, 0],
+      "^": [0, 24, 60, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      "`": [0, 24, 12, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      // ─── German characters ────────────────────────────────────────────────────
+      // Umlauts: dots sit at rows 0-1, letter body follows below
+      "\xE4": [0, 36, 0, 0, 60, 6, 62, 102, 102, 62, 0, 0, 0],
+      "\xF6": [0, 36, 0, 0, 60, 102, 102, 102, 102, 60, 0, 0, 0],
+      "\xFC": [0, 36, 0, 0, 102, 102, 102, 102, 102, 62, 0, 0, 0],
+      "\xC4": [36, 0, 24, 60, 102, 102, 126, 102, 102, 102, 0, 0, 0],
+      "\xD6": [36, 0, 60, 102, 102, 102, 102, 102, 102, 60, 0, 0, 0],
+      "\xDC": [36, 0, 102, 102, 102, 102, 102, 102, 102, 60, 0, 0, 0],
+      // ß: sharp-s / eszett
+      "\xDF": [0, 0, 60, 102, 102, 124, 102, 102, 102, 124, 96, 96, 0],
+      // ─── Currency / special symbols ──────────────────────────────────────────
+      // € (Euro): slightly narrower than full width, classic double-bar C shape
+      "\u20AC": [0, 0, 30, 48, 124, 48, 124, 48, 48, 30, 0, 0, 0]
+    };
+  }
+});
+
+// src/png-decode.ts
+var png_decode_exports = {};
+__export(png_decode_exports, {
+  decodePng: () => decodePng
+});
+function decodePng(buf) {
+  if (buf[0] !== 137 || buf[1] !== 80 || buf[2] !== 78 || buf[3] !== 71) {
+    return null;
+  }
+  let offset = 8;
+  let width = 0, height = 0, bitDepth = 0, colorType = 0;
+  const idatChunks = [];
+  while (offset < buf.length) {
+    const chunkLen = buf.readUInt32BE(offset);
+    const chunkType = buf.toString("ascii", offset + 4, offset + 8);
+    if (chunkType === "IHDR") {
+      width = buf.readUInt32BE(offset + 8);
+      height = buf.readUInt32BE(offset + 12);
+      bitDepth = buf[offset + 16];
+      colorType = buf[offset + 17];
+    } else if (chunkType === "IDAT") {
+      idatChunks.push(buf.slice(offset + 8, offset + 8 + chunkLen));
+    } else if (chunkType === "IEND") {
+      break;
+    }
+    offset += 12 + chunkLen;
+  }
+  if (width === 0 || height === 0 || idatChunks.length === 0) return null;
+  let channels;
+  switch (colorType) {
+    case 0:
+      channels = 1;
+      break;
+    // Grayscale
+    case 2:
+      channels = 3;
+      break;
+    // RGB
+    case 4:
+      channels = 2;
+      break;
+    // Grayscale + Alpha
+    case 6:
+      channels = 4;
+      break;
+    // RGBA
+    default:
+      return null;
+  }
+  const compressed = Buffer.concat(idatChunks);
+  let decompressed;
+  try {
+    decompressed = import_zlib.default.inflateSync(compressed);
+  } catch {
+    return null;
+  }
+  const bytesPerPixel = channels * (bitDepth / 8);
+  const stride = width * bytesPerPixel;
+  const pixels = Buffer.alloc(height * stride);
+  let srcOffset = 0;
+  for (let y = 0; y < height; y++) {
+    const filterType = decompressed[srcOffset++];
+    const rowStart = y * stride;
+    const prevRowStart = (y - 1) * stride;
+    for (let x = 0; x < stride; x++) {
+      const raw = decompressed[srcOffset++];
+      let value;
+      switch (filterType) {
+        case 0:
+          value = raw;
+          break;
+        case 1:
+          value = raw + (x >= bytesPerPixel ? pixels[rowStart + x - bytesPerPixel] : 0);
+          break;
+        case 2:
+          value = raw + (y > 0 ? pixels[prevRowStart + x] : 0);
+          break;
+        case 3:
+          const left = x >= bytesPerPixel ? pixels[rowStart + x - bytesPerPixel] : 0;
+          const up = y > 0 ? pixels[prevRowStart + x] : 0;
+          value = raw + Math.floor((left + up) / 2);
+          break;
+        case 4:
+          const a = x >= bytesPerPixel ? pixels[rowStart + x - bytesPerPixel] : 0;
+          const b = y > 0 ? pixels[prevRowStart + x] : 0;
+          const c = x >= bytesPerPixel && y > 0 ? pixels[prevRowStart + x - bytesPerPixel] : 0;
+          value = raw + paethPredictor(a, b, c);
+          break;
+        default:
+          value = raw;
+      }
+      pixels[rowStart + x] = value & 255;
+    }
+  }
+  return { width, height, channels, data: pixels };
+}
+function paethPredictor(a, b, c) {
+  const p = a + b - c;
+  const pa = Math.abs(p - a);
+  const pb = Math.abs(p - b);
+  const pc = Math.abs(p - c);
+  if (pa <= pb && pa <= pc) return a;
+  if (pb <= pc) return b;
+  return c;
+}
+var import_zlib;
+var init_png_decode = __esm({
+  "src/png-decode.ts"() {
+    "use strict";
+    import_zlib = __toESM(require("zlib"));
+  }
+});
+
+// src/hid-display.ts
+function fontScale(fontSize) {
+  return Math.max(1, Math.min(3, Math.round(fontSize)));
+}
+function fontLineHeight(fontSize) {
+  return 13 * fontScale(fontSize) + 2;
+}
+function fontCharWidth(fontSize) {
+  return 9 * fontScale(fontSize);
+}
+var import_fs, DisplayRenderer;
+var init_hid_display = __esm({
+  "src/hid-display.ts"() {
+    "use strict";
+    import_fs = __toESM(require("fs"));
+    init_font_8x13();
+    DisplayRenderer = class {
+      // 1bpp, row-aligned to bytes
+      constructor(width, height) {
+        this.width = width;
+        this.height = height;
+        const rowBytes = Math.ceil(width / 8);
+        this.framebuffer = Buffer.alloc(rowBytes * height, 255);
+      }
+      get buffer() {
+        return this.framebuffer;
+      }
+      clear() {
+        this.framebuffer.fill(255);
+      }
+      /**
+       * Set a pixel (0=black, 1=white) in the framebuffer.
+       */
+      setPixel(x, y, black) {
+        if (x < 0 || x >= this.width || y < 0 || y >= this.height) return;
+        const rowBytes = Math.ceil(this.width / 8);
+        const byteIndex = y * rowBytes + Math.floor(x / 8);
+        const bitIndex = 7 - x % 8;
+        if (black) {
+          this.framebuffer[byteIndex] &= ~(1 << bitIndex);
+        } else {
+          this.framebuffer[byteIndex] |= 1 << bitIndex;
+        }
+      }
+      /**
+       * Draw a filled rectangle.
+       */
+      fillRect(x, y, w, h, black) {
+        for (let dy = 0; dy < h; dy++) {
+          for (let dx = 0; dx < w; dx++) {
+            this.setPixel(x + dx, y + dy, black);
+          }
+        }
+      }
+      /**
+       * Draw a horizontal line.
+       */
+      hLine(x, y, w) {
+        for (let dx = 0; dx < w; dx++) {
+          this.setPixel(x + dx, y, true);
+        }
+      }
+      /**
+       * Draw text using the 8x13 bitmap font.
+       * fontSize: 1=normal(8x13), 2=large(16x26), 3=headline(24x39)
+       * bold: draws text twice with 1px right shift for thicker strokes
+       */
+      drawText(x, y, text, fontSize = 1, bold = false) {
+        const w = this._renderText(x, y, text, fontSize, true);
+        if (bold) this._renderText(x + 1, y, text, fontSize, true);
+        return w;
+      }
+      /** Draw inverted text (white on black) for button labels. */
+      drawTextInverted(x, y, text, fontSize = 1, bold = false) {
+        const w = this._renderText(x, y, text, fontSize, false);
+        if (bold) this._renderText(x + 1, y, text, fontSize, false);
+        return w;
+      }
+      _renderText(x, y, text, fontSize, black) {
+        const cleanText = text.replace(/[\u200B-\u200F\u2028-\u202F\u2060-\u206F\uFEFF]/g, "");
+        const scale = fontScale(fontSize);
+        const charW = 9 * scale;
+        let curX = x;
+        for (const char of cleanText) {
+          const glyph = FONT_8X13[char] || FONT_8X13["?"];
+          if (!glyph) continue;
+          for (let row = 0; row < 13; row++) {
+            for (let col = 0; col < 8; col++) {
+              if (glyph[row] & 1 << 7 - col) {
+                for (let sy = 0; sy < scale; sy++) {
+                  for (let sx = 0; sx < scale; sx++) {
+                    this.setPixel(curX + col * scale + sx, y + row * scale + sy, black);
+                  }
+                }
+              }
+            }
+          }
+          curX += charW;
+        }
+        return curX - x;
+      }
+      /**
+       * Draw text fitted within a rectangle. Wraps words and scales to fit.
+       */
+      drawTextInRect(left, top, width, height, text, fontSize = 1) {
+        const charW = fontCharWidth(fontSize);
+        const charH = fontLineHeight(fontSize);
+        const maxCols = Math.floor(width / charW);
+        const maxRows = Math.floor(height / charH);
+        const words = text.split(" ");
+        const lines = [];
+        let currentLine = "";
+        for (const word of words) {
+          if (currentLine.length + word.length + 1 <= maxCols) {
+            currentLine += (currentLine ? " " : "") + word;
+          } else {
+            if (currentLine) lines.push(currentLine);
+            currentLine = word;
+          }
+        }
+        if (currentLine) lines.push(currentLine);
+        for (let i = 0; i < Math.min(lines.length, maxRows); i++) {
+          this.drawText(left, top + i * charH, lines[i], fontSize);
+        }
+      }
+      /**
+       * Load a BMP file and draw it at the specified position.
+       * Supports 1-bit, 8-bit, and 24-bit BMPs.
+       */
+      drawBmpFile(x, y, filePath) {
+        try {
+          const data = import_fs.default.readFileSync(filePath);
+          return this.drawBmpData(x, y, data);
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Load a PNG file and draw it at the specified position.
+       * Uses a minimal PNG decoder (no external dependencies).
+       */
+      drawPngFile(x, y, filePath) {
+        try {
+          const data = import_fs.default.readFileSync(filePath);
+          return this.drawImageData(x, y, data, filePath);
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Draw image data. Detects format from header.
+       */
+      drawImageData(x, y, data, hint = "") {
+        if (data[0] === 66 && data[1] === 77) {
+          return this.drawBmpData(x, y, data);
+        }
+        if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71) {
+          return this.drawPngData(x, y, data);
+        }
+        return false;
+      }
+      drawBmpData(x, y, data) {
+        if (data.length < 54) return false;
+        const dataOffset = data.readUInt32LE(10);
+        const bmpWidth = data.readInt32LE(18);
+        const bmpHeight = data.readInt32LE(22);
+        const bitsPerPixel = data.readUInt16LE(28);
+        const isBottomUp = bmpHeight > 0;
+        const absHeight = Math.abs(bmpHeight);
+        for (let row = 0; row < absHeight; row++) {
+          const srcRow = isBottomUp ? absHeight - 1 - row : row;
+          const dstY = y + row;
+          if (bitsPerPixel === 1) {
+            const rowBytes = Math.ceil(bmpWidth / 8);
+            const paddedRowBytes = Math.ceil(rowBytes / 4) * 4;
+            const rowOffset = dataOffset + srcRow * paddedRowBytes;
+            for (let col = 0; col < bmpWidth; col++) {
+              const byteIdx = rowOffset + Math.floor(col / 8);
+              const bitIdx = 7 - col % 8;
+              const pixel = data[byteIdx] >> bitIdx & 1;
+              this.setPixel(x + col, dstY, pixel === 0);
+            }
+          } else if (bitsPerPixel === 24) {
+            const paddedRowBytes = Math.ceil(bmpWidth * 3 / 4) * 4;
+            const rowOffset = dataOffset + srcRow * paddedRowBytes;
+            for (let col = 0; col < bmpWidth; col++) {
+              const idx = rowOffset + col * 3;
+              const b = data[idx];
+              const g = data[idx + 1];
+              const r = data[idx + 2];
+              const brightness = (r * 299 + g * 587 + b * 114) / 1e3;
+              this.setPixel(x + col, dstY, brightness < 128);
+            }
+          } else if (bitsPerPixel === 8) {
+            const paddedRowBytes = Math.ceil(bmpWidth / 4) * 4;
+            const rowOffset = dataOffset + srcRow * paddedRowBytes;
+            for (let col = 0; col < bmpWidth; col++) {
+              const pixel = data[rowOffset + col];
+              this.setPixel(x + col, dstY, pixel < 128);
+            }
+          }
+        }
+        return true;
+      }
+      drawPngData(x, y, data) {
+        try {
+          const { decodePng: decodePng2 } = (init_png_decode(), __toCommonJS(png_decode_exports));
+          const pixels = decodePng2(data);
+          if (!pixels) return false;
+          for (let row = 0; row < pixels.height; row++) {
+            for (let col = 0; col < pixels.width; col++) {
+              const idx = (row * pixels.width + col) * pixels.channels;
+              let brightness;
+              if (pixels.channels >= 3) {
+                brightness = (pixels.data[idx] * 299 + pixels.data[idx + 1] * 587 + pixels.data[idx + 2] * 114) / 1e3;
+              } else {
+                brightness = pixels.data[idx];
+              }
+              if (pixels.channels === 4 || pixels.channels === 2) {
+                const alpha = pixels.data[idx + pixels.channels - 1];
+                if (alpha < 128) continue;
+              }
+              this.setPixel(x + col, y + row, brightness < 128);
+            }
+          }
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Send the entire framebuffer to the pad.
+       */
+      async sendToDevice(protocol) {
+        return protocol.drawImage(0, 0, this.width, this.height, this.framebuffer);
+      }
+      /**
+       * Send a region of the framebuffer to the pad.
+       */
+      async sendRegionToDevice(protocol, x, y, w, h) {
+        const rowBytes = Math.ceil(this.width / 8);
+        const regionRowBytes = Math.ceil(w / 8);
+        const regionBuf = Buffer.alloc(regionRowBytes * h, 255);
+        for (let row = 0; row < h; row++) {
+          for (let col = 0; col < w; col++) {
+            const srcByteIdx = (y + row) * rowBytes + Math.floor((x + col) / 8);
+            const srcBitIdx = 7 - (x + col) % 8;
+            const pixel = this.framebuffer[srcByteIdx] >> srcBitIdx & 1;
+            const dstByteIdx = row * regionRowBytes + Math.floor(col / 8);
+            const dstBitIdx = 7 - col % 8;
+            if (pixel === 0) {
+              regionBuf[dstByteIdx] &= ~(1 << dstBitIdx);
+            }
+          }
+        }
+        return protocol.drawImage(x, y, w, h, regionBuf);
+      }
+    };
+  }
+});
+
+// src/hid-crypto.ts
+var import_crypto, KAESDEFKEY, PEN_UP_PRESSURE, SignatureDecryptor;
+var init_hid_crypto = __esm({
+  "src/hid-crypto.ts"() {
+    "use strict";
+    import_crypto = __toESM(require("crypto"));
+    KAESDEFKEY = Buffer.from([
+      38,
+      212,
+      165,
+      168,
+      144,
+      1,
+      171,
+      19,
+      127,
+      113,
+      49,
+      81,
+      217,
+      47,
+      207,
+      31,
+      17,
+      135,
+      134,
+      22,
+      78,
+      129,
+      183,
+      148,
+      45,
+      142,
+      223,
+      210,
+      218,
+      6,
+      36,
+      245
+    ]);
+    PEN_UP_PRESSURE = 65535;
+    SignatureDecryptor = class _SignatureDecryptor {
+      constructor(key) {
+        this.key = Buffer.from(key || KAESDEFKEY);
+        this.iv = Buffer.alloc(16, 0);
+      }
+      /**
+       * Create a decryptor using the static default key.
+       * This works for Sigma USB pads (verified).
+       */
+      static withDefaultKey() {
+        return new _SignatureDecryptor();
+      }
+      /**
+       * Reset the CBC IV to all zeros (for retry/new signature session).
+       */
+      resetIv() {
+        this.iv = Buffer.alloc(16, 0);
+      }
+      /**
+       * Decrypt a single 16-byte AES block from a 0x41 HID event.
+       * The ciphertext is at bytes 4-19 of the HID report.
+       *
+       * Implements AES-256-CBC manually:
+       * 1. ECB decrypt the block
+       * 2. XOR with previous IV
+       * 3. Update IV to current ciphertext
+       */
+      decryptBlock(ciphertext) {
+        if (ciphertext.length < 16) return null;
+        try {
+          const block = ciphertext.slice(0, 16);
+          const decipher = import_crypto.default.createDecipheriv("aes-256-ecb", this.key, null);
+          decipher.setAutoPadding(false);
+          const decrypted = Buffer.concat([decipher.update(block), decipher.final()]);
+          for (let i = 0; i < 16; i++) {
+            decrypted[i] ^= this.iv[i];
+          }
+          block.copy(this.iv, 0, 0, 16);
+          const timestamp = decrypted.readUInt32LE(0);
+          const x = decrypted.readUInt16LE(4);
+          const y = decrypted.readUInt16LE(6);
+          const pressure = decrypted.readUInt16LE(8);
+          return {
+            timestamp,
+            x,
+            y,
+            pressure,
+            penUp: pressure === PEN_UP_PRESSURE
+          };
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Decrypt a point from a raw 0x41 HID event buffer.
+       * Extracts the 16-byte ciphertext from bytes 4-19.
+       */
+      decryptEvent(eventData) {
+        if (eventData.length < 20) return null;
+        return this.decryptBlock(eventData.slice(4, 20));
+      }
+    };
+  }
+});
+
+// src/signature-renderer.ts
+function renderSignaturePng(strokes, sensorWidth, sensorHeight, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const { width, height, strokeWidth, strokeColor, backgroundColor, padding } = opts;
+  const pixels = Buffer.alloc(width * height * 4);
+  for (let i = 0; i < width * height; i++) {
+    pixels[i * 4] = backgroundColor.r;
+    pixels[i * 4 + 1] = backgroundColor.g;
+    pixels[i * 4 + 2] = backgroundColor.b;
+    pixels[i * 4 + 3] = 255;
+  }
+  if (strokes.length === 0) {
+    return encodePng(pixels, width, height);
+  }
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const stroke of strokes) {
+    for (const pt of stroke) {
+      if (pt.x < minX) minX = pt.x;
+      if (pt.y < minY) minY = pt.y;
+      if (pt.x > maxX) maxX = pt.x;
+      if (pt.y > maxY) maxY = pt.y;
+    }
+  }
+  const dataWidth = maxX - minX || 1;
+  const dataHeight = maxY - minY || 1;
+  const scaleX = (width - padding * 2) / dataWidth;
+  const scaleY = (height - padding * 2) / dataHeight;
+  const scale = Math.min(scaleX, scaleY);
+  const offsetX = padding + (width - padding * 2 - dataWidth * scale) / 2;
+  const offsetY = padding + (height - padding * 2 - dataHeight * scale) / 2;
+  for (const stroke of strokes) {
+    if (stroke.length < 2) continue;
+    for (let i = 1; i < stroke.length; i++) {
+      const x0 = offsetX + (stroke[i - 1].x - minX) * scale;
+      const y0 = offsetY + (stroke[i - 1].y - minY) * scale;
+      const x1 = offsetX + (stroke[i].x - minX) * scale;
+      const y1 = offsetY + (stroke[i].y - minY) * scale;
+      drawLine(pixels, width, height, x0, y0, x1, y1, strokeWidth, strokeColor);
+    }
+  }
+  return encodePng(pixels, width, height);
+}
+function drawLine(pixels, imgWidth, imgHeight, x0, y0, x1, y1, thickness, color) {
+  const dx = Math.abs(x1 - x0);
+  const dy = Math.abs(y1 - y0);
+  const sx = x0 < x1 ? 1 : -1;
+  const sy = y0 < y1 ? 1 : -1;
+  let err = dx - dy;
+  const steps = Math.max(Math.ceil(Math.sqrt(dx * dx + dy * dy)), 1);
+  const radius = thickness / 2;
+  for (let step = 0; step <= steps; step++) {
+    const t = steps > 0 ? step / steps : 0;
+    const cx = x0 + (x1 - x0) * t;
+    const cy = y0 + (y1 - y0) * t;
+    const r = Math.ceil(radius);
+    for (let dy2 = -r; dy2 <= r; dy2++) {
+      for (let dx2 = -r; dx2 <= r; dx2++) {
+        if (dx2 * dx2 + dy2 * dy2 <= radius * radius) {
+          const px = Math.round(cx + dx2);
+          const py = Math.round(cy + dy2);
+          if (px >= 0 && px < imgWidth && py >= 0 && py < imgHeight) {
+            const idx = (py * imgWidth + px) * 4;
+            pixels[idx] = color.r;
+            pixels[idx + 1] = color.g;
+            pixels[idx + 2] = color.b;
+            pixels[idx + 3] = 255;
+          }
+        }
+      }
+    }
+  }
+}
+function encodePng(pixels, width, height) {
+  const rawData = Buffer.alloc(height * (1 + width * 4));
+  for (let y = 0; y < height; y++) {
+    rawData[y * (1 + width * 4)] = 0;
+    pixels.copy(
+      rawData,
+      y * (1 + width * 4) + 1,
+      y * width * 4,
+      (y + 1) * width * 4
+    );
+  }
+  const compressed = import_zlib2.default.deflateSync(rawData);
+  const chunks = [];
+  chunks.push(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]));
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 6;
+  ihdr[10] = 0;
+  ihdr[11] = 0;
+  ihdr[12] = 0;
+  chunks.push(pngChunk("IHDR", ihdr));
+  chunks.push(pngChunk("IDAT", compressed));
+  chunks.push(pngChunk("IEND", Buffer.alloc(0)));
+  return Buffer.concat(chunks);
+}
+function pngChunk(type, data) {
+  const length = Buffer.alloc(4);
+  length.writeUInt32BE(data.length, 0);
+  const typeAndData = Buffer.concat([Buffer.from(type, "ascii"), data]);
+  const crc = crc32(typeAndData);
+  const crcBuf = Buffer.alloc(4);
+  crcBuf.writeUInt32BE(crc >>> 0, 0);
+  return Buffer.concat([length, typeAndData, crcBuf]);
+}
+function crc32(data) {
+  let crc = 4294967295;
+  for (let i = 0; i < data.length; i++) {
+    crc = CRC_TABLE[(crc ^ data[i]) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+var import_zlib2, DEFAULT_OPTIONS, CRC_TABLE;
+var init_signature_renderer = __esm({
+  "src/signature-renderer.ts"() {
+    "use strict";
+    import_zlib2 = __toESM(require("zlib"));
+    DEFAULT_OPTIONS = {
+      width: 400,
+      height: 200,
+      strokeWidth: 2,
+      strokeColor: { r: 0, g: 0, b: 0 },
+      backgroundColor: { r: 255, g: 255, b: 255 },
+      padding: 10,
+      smooth: true
+    };
+    CRC_TABLE = [];
+    for (let n = 0; n < 256; n++) {
+      let c = n;
+      for (let k = 0; k < 8; k++) {
+        if (c & 1) {
+          c = 3988292384 ^ c >>> 1;
+        } else {
+          c = c >>> 1;
+        }
+      }
+      CRC_TABLE[n] = c;
+    }
+  }
+});
+
+// src/assets-embedded.ts
+var CANCEL_BMP, OK_BMP, RETRY_PNG;
+var init_assets_embedded = __esm({
+  "src/assets-embedded.ts"() {
+    "use strict";
+    CANCEL_BMP = Buffer.from(`Qk02IQAAAAAAADYAAAAoAAAAVQAAACEAAAABABgAAAAAAAAAAAATCwAAEwsAAAAAAAAAAAAA////////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////////////////////////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////////////////////8AAAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAAAAAAAAAD/////////////AAAAAAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAA/////////wAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAAAAAP////8AAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAD///////////////////////////////////////////////////////////////8AAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAD/AAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAA////////////////////////////////////////////////////////AAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAA/wAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAAAAAAAAAAAAAP///////////////////////////////////////////////wAAAAAAAAAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAP8AAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////////////////////////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAD/AAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAA////////////////////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAA/wAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAP///////////////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAP8AAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAD/AAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAA////////AAAAAAAAAAAAAAAAAAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAA/wAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAP8AAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAD/AAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAA/wAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAP8AAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAD/AAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAA/wAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAP8AAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAD/AAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAA////////AAAAAAAAAAAAAAAAAAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAA/wAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAP///////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAP8AAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAD/AAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAA////////////////////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAA/wAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAP///////////////////////////////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAP8AAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////8AAAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAD/AAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAA////////////////////////////////////////////////////////AAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAA/////wAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAP///////////////////////////////////////////////////////////////wAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAAAAAP////////8AAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAAAAAD/////////////AAAAAAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAAAAAA/////////////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////////////////////////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////////////////////`, "base64");
+    OK_BMP = Buffer.from(`Qk02IQAAAAAAADYAAAAoAAAAVQAAACEAAAABABgAAAAAAAAAAAATCwAAEwsAAAAAAAAAAAAA////////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////////////////////////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////////////////////8AAAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAAAAAAAAAD/////////////AAAAAAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAA/////////wAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAAAAAP////8AAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAD/AAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAA/wAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAAAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAP8AAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAD/AAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAA/wAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAP8AAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAD/AAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAA/wAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAP///////wAAAAAAAAAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAP8AAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAAAAAAAAAAAAAD///////////8AAAAAAAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAD/AAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAA////////////////////AAAAAAAAAAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAA/wAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAAAAAP///////////////////////wAAAAAAAAAAAAAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAP8AAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAD///////////////////////////////8AAAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAD/AAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAA/wAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAAAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAP8AAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAD/AAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAA/wAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAAAAAAAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAP8AAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAD/AAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAA/wAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAAAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAP8AAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAD/AAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAA/////wAAAAAAAAAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAP///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////wAAAAAAAAAAAP////////8AAAAAAAAAAAAAAAAAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAAAAAAAAAAAAAAAAAAD/////////////AAAAAAAAAAAAAAAA////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAAAAAA/////////////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////////////////////////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////////////////`, "base64");
+    RETRY_PNG = Buffer.from(`iVBORw0KGgoAAAANSUhEUgAAAFUAAAAhCAYAAACoRueNAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAONSURBVHgB7Zo5ViMxEIbL/SZgXyKWCEIi1gPADeAEwA3gBMAN4ATADeAE+ADeUkd25CXyviXW1F+0euSxPdPGYHWg7z09tdUS6P1dKm1Fyqff76taraZKpZJaW1tTROTSfxJ0KpfLqtFoiH6amJ8Ti0nHx8fU6/WoUqnQ6uoqOcbDBig5dFpcXKREIkEbGxsUi8UoBoVZbTo8PBRhwdbWFqVSKZqbmyPHIJ7nUavVoqOjI8mbzSbBKKFZMpmkzc1NIpju9va2mDOrrLhQFYvFAXN2DKJdZaFQEL3IdwcsrJR7ULvdbovZwnzT6XRgxo7RQJuVlRWxSoxoWCmA6+x0OhSDs4V/WFpaomw2KxWdoOFhwyW4z729PfGz8LFetVqVlxAVDjcqgqJfT09PdHFxQbu7u58TAKf19XU6Ozuj19dXyufzQ+1QF2lWoE+Ye5AgsNZTlgbwD1Hwo7zyUPf396GXdTc3N9JGo8tnCXTDPGT0+VNUOFjb5HI5tbOzEwhzenqqnp+fpVzDPl/Kzs/Pg3poo+vYEBXgww6Jan5tG5iCIv/4+Ji4DX47UQ20OAcHBxP1BXUvLy8DYZ2oPvChWpSv9ANt8DFMXztrTFF/kWUwg7Oo8sxDnrhjodrc3t4GMy0wn21jXdR4PC45TzzElhqqDQR8e3sb+z7s3/kprIuK9SaAqGHhoS5W/a/3NonE8Af7+/s0CbzcoqjikWW0qLat6zuxLup38/DwINtb21hdUum1JVusmhbstshfms0ac0ll3VL1sNergGnIZDKS2579rYuqJ5yXlxealvf3d8mvrq7INlaHvzlswuz3x2Hu+80DmFkRqeGPHRQf38nz9fX1l3ZGaIMzVnB3d2d9+APre3/872kOVPS+38YEZfYj8kd/YYYwT24Tt/kpcB49JGoUblD/PqTGQTRPYIpn9aAOll4owwE2jTiktgF0w83JgKhIuGq1ba0a9ouhI0RQ13a/6/W6XE/jil/6ho7hR1SsVQPLw7UJLNK0XjzDgh8fHyNhBNpK+co60BFRKYpvKINgABdIER594YdRrgVFbJU3Pz8fhPdwBQlnQfhPo9GQK1fHMMq/isZ9v9YLLCwsSJJYKhTql7jHXl5elhgARF+gEtchxx+63a7EniGHuEPRPb4li6AnJycSAmRGtDlGo8XE5gWjHVF/QXSP6R8QrObiUyeLT4VeWKOa89Bv69GHm+SvZlsAAAAASUVORK5CYII=`, "base64");
+  }
+});
+
+// src/driver-hid.ts
+var driver_hid_exports = {};
+__export(driver_hid_exports, {
+  createHidDriver: () => createHidDriver
+});
+function sensorToDisplay(sx, sy, dw, dh) {
+  return {
+    x: Math.round(sx * dw / SENSOR_RANGE),
+    y: Math.round(sy * dh / SENSOR_RANGE)
+  };
+}
+function createHidDriver(config) {
+  const log = config?.logger === null ? { info() {
+  }, warn() {
+  }, error() {
+  } } : config?.logger ?? console;
+  const onDriverEvent = config?.onDriverEvent;
+  function emit(level, message, category, data) {
+    if (level === "error") log.error(`[${category}] ${message}`, data ?? "");
+    else if (level === "warn") log.warn(`[${category}] ${message}`, data ?? "");
+    else log.info(`[${category}] ${message}`, data ?? "");
+    onDriverEvent?.({
+      level,
+      message,
+      category,
+      data,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  let protocol = null;
+  let padInfo = null;
+  let currentHandlers = null;
+  let currentSerialNo = null;
+  let lastOptions = null;
+  let lastDevicePath = null;
+  let isCapturing = false;
+  let sessionLock = Promise.resolve();
+  let decryptor = null;
+  let currentStroke = [];
+  let allStrokes = [];
+  let signatureEventCount = 0;
+  let tapStartTime = 0;
+  let tapStartPoint = null;
+  let tapPointCount = 0;
+  let tapMaxDrift = 0;
+  let reconnectTimer = null;
+  let cachedDeviceList = null;
+  let cacheTimestamp = 0;
+  const CACHE_TTL = 2e3;
+  let cleanupPromise = Promise.resolve();
+  function cleanup() {
+    if (reconnectTimer) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+    isCapturing = false;
+    const prot = protocol;
+    protocol = null;
+    currentHandlers = null;
+    currentSerialNo = null;
+    decryptor = null;
+    currentStroke = [];
+    allStrokes = [];
+    signatureEventCount = 0;
+    tapStartPoint = null;
+    tapPointCount = 0;
+    tapMaxDrift = 0;
+    if (!prot) {
+      cleanupPromise = Promise.resolve();
+      return cleanupPromise;
+    }
+    prot.onSignatureEvent(null);
+    prot.onDisconnect(null);
+    cleanupPromise = (async () => {
+      try {
+        if (prot.isConnected()) {
+          await prot.stopSignature().catch(() => {
+          });
+          await new Promise((r) => setTimeout(r, 200));
+          await prot.eraseDisplay().catch(() => {
+          });
+          await new Promise((r) => setTimeout(r, 300));
+          await prot.showStandbyFromFlash().catch(() => {
+          });
+          await new Promise((r) => setTimeout(r, 100));
+        }
+      } catch (err) {
+        emit("warn", "Error during cleanup: " + err.message, "session");
+      }
+      try {
+        prot.close();
+      } catch (err) {
+        emit("warn", "Error closing device: " + err.message, "device");
+      }
+      await new Promise((r) => setTimeout(r, 500));
+    })();
+    return cleanupPromise;
+  }
+  function checkHotspot(x, y) {
+    for (const hs of HOTSPOTS) {
+      if (x >= hs.left && x <= hs.left + hs.width && y >= hs.top && y <= hs.top + hs.height) {
+        return hs.id;
+      }
+    }
+    return null;
+  }
+  function handleSignatureEvent(type, data) {
+    if (!isCapturing || !currentHandlers || !currentSerialNo || !decryptor) return;
+    const dw = padInfo?.displayWidth || 320;
+    const dh = padInfo?.displayHeight || 160;
+    if (type === SIG_EVENT.PEN_DATA || type === SIG_EVENT.PEN_DATA_EXT) {
+      signatureEventCount++;
+      const point = decryptor.decryptEvent(data);
+      if (!point) return;
+      const display = sensorToDisplay(point.x, point.y, dw, dh);
+      if (tapPointCount === 0) {
+        tapStartTime = Date.now();
+        tapStartPoint = { x: display.x, y: display.y };
+        tapMaxDrift = 0;
+      } else if (tapStartPoint) {
+        const drift = Math.abs(display.x - tapStartPoint.x) + Math.abs(display.y - tapStartPoint.y);
+        if (drift > tapMaxDrift) tapMaxDrift = drift;
+      }
+      tapPointCount++;
+      if (display.y > 39 && !point.penUp) {
+        currentStroke.push({ x: point.x, y: point.y, pressure: point.pressure });
+        const dllX = Math.round(180 + point.x / SENSOR_RANGE * 7620);
+        const dllY = Math.round(1024 + point.y / SENSOR_RANGE * 2431);
+        currentHandlers.onSignatureData("liveData", {
+          point: { x: dllX, y: dllY, pressure: point.pressure },
+          serialNo: currentSerialNo
+        });
+      }
+    } else if (type === SIG_EVENT.PEN_UP) {
+      const tapDuration = Date.now() - tapStartTime;
+      const isTap = tapPointCount > 0 && tapPointCount < TAP.MAX_POINTS && tapDuration < TAP.MAX_DURATION && tapMaxDrift < TAP.MAX_DRIFT;
+      if (isTap && tapStartPoint) {
+        const hotspotId = checkHotspot(tapStartPoint.x, tapStartPoint.y);
+        if (hotspotId !== null) {
+          handleHotspotPress(hotspotId);
+        }
+      }
+      if (currentStroke.length > 0) {
+        allStrokes.push([...currentStroke]);
+        currentStroke = [];
+      }
+      tapPointCount = 0;
+      tapStartPoint = null;
+      tapMaxDrift = 0;
+    }
+  }
+  function handleHotspotPress(id) {
+    if (!currentHandlers || !currentSerialNo) return;
+    switch (id) {
+      case 0:
+        emit("info", "Cancel button pressed", "session");
+        isCapturing = false;
+        currentHandlers.onUserEvent("cancel", { serialNo: currentSerialNo });
+        cleanup();
+        break;
+      case 1:
+        emit("info", "Retry button pressed", "session");
+        currentStroke = [];
+        allStrokes = [];
+        signatureEventCount = 0;
+        decryptor?.resetIv();
+        tapPointCount = 0;
+        tapStartPoint = null;
+        currentHandlers.onSignatureData("clear", { serialNo: currentSerialNo });
+        if (protocol?.isConnected() && lastOptions) {
+          isCapturing = false;
+          (async () => {
+            try {
+              await protocol.stopSignature();
+              await protocol.eraseDisplay();
+              await new Promise((r) => setTimeout(r, 200));
+              await drawPadUI(lastOptions);
+              await new Promise((r) => setTimeout(r, 200));
+              await protocol.setSignRect(8, 40, 300, 95);
+              isCapturing = true;
+              await protocol.startSignature();
+            } catch (err) {
+              log.error("Error during retry:", err.message);
+            }
+          })();
+        }
+        break;
+      case 2:
+        emit("info", "Confirm button pressed", "session");
+        driver2.confirmSignature();
+        break;
+    }
+  }
+  function handleDisconnect() {
+    emit("warn", "Pad disconnected during signing", "usb");
+    isCapturing = false;
+    if (lastDevicePath && currentHandlers) {
+      attemptReconnect();
+    }
+  }
+  function attemptReconnect() {
+    if (reconnectTimer) return;
+    const maxAttempts = config?.reconnectAttempts ?? 10;
+    const interval = config?.reconnectIntervalMs ?? 2e3;
+    let attempts = 0;
+    const tryReconnect = () => {
+      attempts++;
+      if (attempts > maxAttempts) {
+        log.error(`Signotec pad reconnection failed after ${maxAttempts} attempts`);
+        currentHandlers?.onUserEvent("cancel", { serialNo: currentSerialNo || "unknown" });
+        cleanup();
+        return;
+      }
+      log.info(`Signotec reconnect attempt ${attempts}/${maxAttempts}...`);
+      try {
+        const prot = new HidProtocol(config);
+        const devices = prot.listDevices();
+        if (devices.length > 0) {
+          log.info("Signotec pad reconnected - cancelling session (state lost)");
+          currentHandlers?.onUserEvent("cancel", { serialNo: currentSerialNo || "unknown" });
+          cleanup();
+          return;
+        }
+      } catch (err) {
+        log.warn("Reconnect probe error:", err.message);
+      }
+      reconnectTimer = setTimeout(tryReconnect, interval);
+    };
+    reconnectTimer = setTimeout(tryReconnect, 1e3);
+  }
+  async function drawPadUI(options) {
+    if (!protocol || !padInfo) return;
+    const w = padInfo.displayWidth;
+    const h = padInfo.displayHeight;
+    const renderer = new DisplayRenderer(w, h);
+    renderer.clear();
+    for (const hs of HOTSPOTS) {
+      renderer.fillRect(hs.left, hs.top, hs.width, hs.height, true);
+    }
+    renderer.drawTextInverted(16, 12, "Abbruch", 1);
+    renderer.drawTextInverted(124, 12, "Neustart", 1);
+    renderer.drawTextInverted(251, 12, "OK", 1);
+    const dd = options?.displayData;
+    let textY = 40;
+    const bodySpacing = 15;
+    const drawBodyLine = (line) => {
+      const fs3 = Math.max(1, Math.min(3, line.fontSize ?? 1));
+      renderer.drawText(8, textY, `${line.label} ${line.content}`, fs3);
+      textY += bodySpacing;
+    };
+    if (dd?.body?.line1) drawBodyLine(dd.body.line1);
+    if (dd?.body?.line2) drawBodyLine(dd.body.line2);
+    if (dd?.body?.line3) drawBodyLine(dd.body.line3);
+    if (dd?.body?.line4) drawBodyLine(dd.body.line4);
+    renderer.drawText(8, 120, "Unterschrift:", 1, true);
+    renderer.hLine(8, 135, w - 16);
+    if (dd?.footer?.line1) {
+      const fs3 = Math.max(1, Math.min(3, dd.footer.line1.fontSize ?? 1));
+      renderer.drawText(8, 140, `${dd.footer.line1.label} ${dd.footer.line1.content}`, fs3);
+    }
+    if (dd?.footer?.line2) {
+      const fs3 = Math.max(1, Math.min(3, dd.footer.line2.fontSize ?? 1));
+      renderer.drawText(203, 140, `${dd.footer.line2.label} ${dd.footer.line2.content}`, fs3);
+    }
+    try {
+      renderer.drawImageData(8, 5, CANCEL_BMP);
+      renderer.drawImageData(223, 5, OK_BMP);
+      renderer.drawImageData(115, 5, RETRY_PNG);
+    } catch (err) {
+      log.warn("Could not render button images:", err.message);
+    }
+    await renderer.sendToDevice(protocol);
+  }
+  async function doStartSession(serialNo, handlers, options) {
+    await cleanupPromise;
+    if (protocol?.isConnected()) {
+      log.warn("Signotec: Previous session still active, cleaning up first");
+      await cleanup();
+    }
+    protocol = new HidProtocol(config);
+    const devices = protocol.listDevices();
+    if (devices.length === 0) {
+      protocol = null;
+      throw new Error(`No device with serialNo.: ${serialNo} was found.`);
+    }
+    const targetDevice = devices.find((d) => d.serialNumber === serialNo) || devices[0];
+    lastDevicePath = targetDevice.path;
+    const maxOpenRetries = 3;
+    for (let attempt = 1; attempt <= maxOpenRetries; attempt++) {
+      try {
+        protocol.open(targetDevice.path);
+        break;
+      } catch (err) {
+        if (attempt < maxOpenRetries) {
+          log.warn(`Device open attempt ${attempt}/${maxOpenRetries} failed, retrying in 500ms...`);
+          await new Promise((r) => setTimeout(r, 500));
+        } else {
+          protocol = null;
+          throw new Error(`Failed to open device after ${maxOpenRetries} attempts: ${err.message}`);
+        }
+      }
+    }
+    const responsive = await protocol.isResponsive();
+    if (!responsive) {
+      protocol.close();
+      protocol = null;
+      throw new Error("Device is connected but not responding. Check USB connection.");
+    }
+    protocol.onDisconnect(handleDisconnect);
+    protocol.onSignatureEvent(handleSignatureEvent);
+    currentHandlers = handlers;
+    currentSerialNo = serialNo;
+    lastOptions = options;
+    currentStroke = [];
+    allStrokes = [];
+    signatureEventCount = 0;
+    tapPointCount = 0;
+    tapStartPoint = null;
+    tapMaxDrift = 0;
+    decryptor = SignatureDecryptor.withDefaultKey();
+    padInfo = await protocol.getDeviceInfo();
+    log.info(`Signotec pad: ${padInfo.serialNo} (${padInfo.displayWidth}x${padInfo.displayHeight})`);
+    const erased = await protocol.eraseDisplay();
+    if (!erased) {
+      await cleanup();
+      throw new Error("Failed to erase display. Device may be unresponsive.");
+    }
+    await new Promise((r) => setTimeout(r, 300));
+    await drawPadUI(options);
+    await new Promise((r) => setTimeout(r, 200));
+    await protocol.setSignRect(8, 40, 300, 95);
+    isCapturing = true;
+    const started = await protocol.startSignature();
+    if (!started) {
+      await cleanup();
+      throw new Error("Failed to start signature capture on device.");
+    }
+    emit("info", "Signing session started", "session", { serialNo: currentSerialNo });
+  }
+  const driver2 = {
+    getSignotecPads() {
+      if (cachedDeviceList && Date.now() - cacheTimestamp < CACHE_TTL) {
+        return cachedDeviceList;
+      }
+      try {
+        const prot = new HidProtocol(config);
+        const devices = prot.listDevices();
+        cachedDeviceList = devices.map((d, i) => ({
+          serialNo: d.serialNumber || `signotec-${i}`,
+          type: 1,
+          name: d.product || "Sigma USB",
+          vendor: "Signotec"
+        }));
+        cacheTimestamp = Date.now();
+        return cachedDeviceList;
+      } catch (err) {
+        emit("error", "Device discovery failed: " + err.message, "device");
+        return [];
+      }
+    },
+    async startSigningProcess(serialNo, handlers, options) {
+      let startError = null;
+      await new Promise((resolve, reject) => {
+        sessionLock = sessionLock.then(async () => {
+          try {
+            await doStartSession(serialNo, handlers, options);
+            resolve();
+          } catch (err) {
+            startError = err;
+            resolve();
+          }
+        });
+      });
+      if (startError) throw startError;
+    },
+    cancelSignature() {
+      if (!currentSerialNo) return { status: false, message: "No signature process started" };
+      log.info("Signotec: Signature cancelled (external)");
+      const serial = currentSerialNo;
+      currentHandlers?.onUserEvent("cancel", { serialNo: serial });
+      cleanup();
+      return { status: true, message: "Signature process stopped" };
+    },
+    confirmSignature() {
+      if (!currentSerialNo || !currentHandlers) {
+        throw new Error("No active signature process.");
+      }
+      const serialNo = currentSerialNo;
+      const handlers = currentHandlers;
+      if (currentStroke.length > 0) {
+        allStrokes.push([...currentStroke]);
+        currentStroke = [];
+      }
+      let base64Img = "";
+      if (allStrokes.length > 0 && allStrokes.some((s) => s.length >= 2)) {
+        try {
+          const pngBuffer = renderSignaturePng(
+            allStrokes,
+            SENSOR_RANGE,
+            SENSOR_RANGE,
+            {
+              width: lastOptions?.outputOptions?.imageSize?.width || 400,
+              height: lastOptions?.outputOptions?.imageSize?.height || 200,
+              strokeWidth: lastOptions?.outputOptions?.strokeWidth || 2
+            }
+          );
+          if (pngBuffer.length >= MIN_SIGNATURE_SIZE) {
+            base64Img = "data:image/png;base64," + pngBuffer.toString("base64");
+          } else {
+            log.warn("Signature too small, may be invalid");
+          }
+        } catch (err) {
+          log.error("Signature image rendering error:", err.message);
+        }
+      }
+      log.info(`Signotec: Signature confirmed (${allStrokes.length} strokes, ${base64Img.length} chars)`);
+      handlers.onUserEvent("confirm", { base64Img, serialNo });
+      cleanup();
+    },
+    async continueWithoutSignature() {
+      if (!currentSerialNo) return { status: false, message: "No matching device found" };
+      log.info("Signotec: Continue without signature");
+      try {
+        currentHandlers?.onUserEvent("confirm", { serialNo: currentSerialNo, base64Img: "" });
+        cleanup();
+        return { status: true, message: "User prompt cleared" };
+      } catch (err) {
+        log.error("continueWithoutSignature error:", err.message);
+        cleanup();
+        return { status: false, message: "User prompt could not be cleared" };
+      }
+    },
+    async setStandbyImage(imagePath) {
+      if (!imagePath) return true;
+      if (!import_fs2.default.existsSync(imagePath)) {
+        log.error(`Standby image not found: ${imagePath}`);
+        return false;
+      }
+      const ext = import_path.default.extname(imagePath).toLowerCase();
+      if (ext !== ".png" && ext !== ".bmp") {
+        log.error(`Unsupported standby image format: ${ext}. Use .png or .bmp`);
+        return false;
+      }
+      try {
+        const prot = new HidProtocol(config);
+        const devices = prot.listDevices();
+        if (devices.length === 0) {
+          log.error("No Signotec device connected for standby image upload");
+          return false;
+        }
+        prot.open(devices[0].path);
+        const info = await prot.getDeviceInfo();
+        const w = info.displayWidth || 320;
+        const h = info.displayHeight || 160;
+        const renderer = new DisplayRenderer(w, h);
+        renderer.clear();
+        if (ext === ".png") renderer.drawPngFile(0, 0, imagePath);
+        else renderer.drawBmpFile(0, 0, imagePath);
+        log.info(`Storing standby image to flash: ${imagePath} (${w}x${h})`);
+        const ok = await prot.storeStandbyImage(w, h, renderer.buffer);
+        if (ok) {
+          await prot.eraseDisplay();
+          await new Promise((r) => setTimeout(r, 200));
+          await prot.drawImage(0, 0, w, h, renderer.buffer);
+          log.info("Standby image stored to flash successfully");
+        } else {
+          log.error("Failed to store standby image to flash");
+        }
+        await new Promise((r) => setTimeout(r, 300));
+        prot.close();
+        return ok;
+      } catch (err) {
+        log.error("setStandbyImage error:", err.message);
+        return false;
+      }
+    },
+    async waitForDevice(timeoutMs = 3e4) {
+      const start = Date.now();
+      const interval = 1e3;
+      while (Date.now() - start < timeoutMs) {
+        const pads = driver2.getSignotecPads();
+        if (pads.length > 0) return pads[0];
+        await new Promise((r) => setTimeout(r, interval));
+      }
+      return null;
+    }
+  };
+  return driver2;
+}
+var import_path, import_fs2, HOTSPOTS, SENSOR_RANGE, TAP, MIN_SIGNATURE_SIZE;
+var init_driver_hid = __esm({
+  "src/driver-hid.ts"() {
+    "use strict";
+    import_path = __toESM(require("path"));
+    import_fs2 = __toESM(require("fs"));
+    init_hid_protocol();
+    init_hid_display();
+    init_hid_crypto();
+    init_signature_renderer();
+    init_assets_embedded();
+    HOTSPOTS = [
+      { id: 0, label: "Cancel", left: 8, top: 5, width: 85, height: 33 },
+      { id: 1, label: "Retry", left: 115, top: 5, width: 85, height: 33 },
+      { id: 2, label: "Confirm", left: 223, top: 5, width: 85, height: 33 }
+    ];
+    SENSOR_RANGE = 4096;
+    TAP = {
+      MAX_POINTS: 200,
+      // max pen-data events for a tap (~800ms at 250Hz)
+      MAX_DURATION: 800,
+      // max tap duration in ms
+      MAX_DRIFT: 30
+      // max pen movement in display pixels
+    };
+    MIN_SIGNATURE_SIZE = 500;
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEVICE_TYPE_MAPPINGS: () => DEVICE_TYPE_MAPPINGS,
+  cancelSignature: () => cancelSignature,
+  configure: () => configure,
+  confirmSignature: () => confirmSignature,
+  continueWithoutSignature: () => continueWithoutSignature,
+  createHidDriver: () => createHidDriver,
+  getSignotecPads: () => getSignotecPads,
+  setStandbyImage: () => setStandbyImage,
+  startSigningProcess: () => startSigningProcess,
+  waitForDevice: () => waitForDevice
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var DEVICE_TYPE_MAPPINGS = {
+  1: "Sigma USB",
+  2: "Sigma seriell",
+  5: "Zeta USB",
+  6: "Zeta seriell",
+  11: "Omega USB",
+  12: "Omega seriell",
+  15: "Gamma USB",
+  16: "Gamma seriell",
+  21: "Delta USB",
+  22: "Delta seriell",
+  23: "Delta IP",
+  31: "Alpha USB",
+  32: "Alpha seriell",
+  33: "Alpha IP"
+};
+
+// src/index.ts
+init_driver_hid();
+var driver = null;
+var driverError = null;
+var driverConfig;
+function configure(config) {
+  driverConfig = config;
+  driver = null;
+  driverError = null;
+}
+function getDriver() {
+  if (driver) return driver;
+  if (driverError) throw driverError;
+  try {
+    const { createHidDriver: createHidDriver2 } = (init_driver_hid(), __toCommonJS(driver_hid_exports));
+    driver = createHidDriver2(driverConfig);
+  } catch (err) {
+    driverError = err;
+    throw err;
+  }
+  return driver;
+}
+var getSignotecPads = () => getDriver().getSignotecPads();
+var startSigningProcess = async (serialNo, handlers, options) => getDriver().startSigningProcess(serialNo, handlers, options);
+var cancelSignature = () => getDriver().cancelSignature();
+var confirmSignature = () => getDriver().confirmSignature();
+var continueWithoutSignature = async () => getDriver().continueWithoutSignature();
+var setStandbyImage = async (imagePath) => getDriver().setStandbyImage?.(imagePath) ?? false;
+var waitForDevice = async (timeoutMs) => getDriver().waitForDevice?.(timeoutMs) ?? null;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEVICE_TYPE_MAPPINGS,
+  cancelSignature,
+  configure,
+  confirmSignature,
+  continueWithoutSignature,
+  createHidDriver,
+  getSignotecPads,
+  setStandbyImage,
+  startSigningProcess,
+  waitForDevice
+});
+//# sourceMappingURL=index.js.map