bridge: publish through a Publisher; devices no longer hold the broker client

src/transport.ts has the Publisher interface, MqttPublisher (the client the bridge has at the time) and
MemoryPublisher (tests without a broker); src/topics.ts names the four topics the library publishes to.
Device, AlexaStatusMessage, AlexaErrorResponse and sendSceneResponse shared three copies of the
publish-and-report code: they now call one send() that resolves the topic or "" and never rejects.
registerDevice() and addDevice() work before connect(); a send() without a connection resolves "" and the
"error" event says to call connect(). unregisterDevice() and clearDevices() take the publisher from the device.
Device.setMqttClient() is gone, the first constructor argument of Device is ignored, and the message classes
take a Publisher where they took the client. Tests: 108 -> 113.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

dist/cjs/transport.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryPublisher = exports.MqttPublisher = void 0;
+exports.send = send;
+const asError = (err) => (err instanceof Error ? err : new Error(String(err)));
+/**
+ * Publishes to the broker through the client the bridge has at the time: a new one after disconnect() and connect(),
+ * none before connect() and after disconnect(). Without a client the publish is refused. With a client that lost
+ * its connection mqtt.js keeps the message and sends it after the reconnect, and the publish resolves then.
+ */
+class MqttPublisher {
+    constructor(client) {
+        this.client = client;
+    }
+    publish(topic, message) {
+        const client = this.client();
+        return new Promise((resolve) => {
+            const failed = (err) => resolve({ ok: false, topic, error: asError(err) });
+            if (!client) {
+                failed(new Error(`nothing was published to ${topic}: the bridge is not connected, call connect() first`));
+                return;
+            }
+            try {
+                client.publish(topic, JSON.stringify(message), (err) => (err ? failed(err) : resolve({ ok: true, topic })));
+            }
+            catch (err) {
+                failed(err);
+            }
+        });
+    }
+}
+exports.MqttPublisher = MqttPublisher;
+/**
+ * Keeps what it is asked to publish, for tests and dry runs without a broker:
+ *
+ *   const sent = new MemoryPublisher();
+ *   device.publisher = sent;
+ *   await device.getStatusMessage(token, true).addPowerControllerProp(PowerController.ON).send();
+ *   sent.published[0]   // { topic: "<root>/<endpointId>/alexaResponce", message: { event, context } }
+ */
+class MemoryPublisher {
+    constructor() {
+        /** Oldest first. The message is what a subscriber gets after JSON.parse. */
+        this.published = [];
+        /** Set it and every publish fails with this error, as a publish to a broker that is gone does. */
+        this.failWith = null;
+    }
+    publish(topic, message) {
+        if (this.failWith)
+            return Promise.resolve({ ok: false, topic, error: this.failWith });
+        try {
+            this.published.push({ topic, message: JSON.parse(JSON.stringify(message)) });
+        }
+        catch (err) {
+            return Promise.resolve({ ok: false, topic, error: asError(err) });
+        }
+        return Promise.resolve({ ok: true, topic });
+    }
+}
+exports.MemoryPublisher = MemoryPublisher;
+/**
+ * send() as 1.x promises it: resolves with the topic, or with "" when nothing was published, and never rejects
+ * (1.5.1 rejected, and a send() nobody caught killed the host on any broker hiccup). What went wrong goes to report:
+ * the message cannot be built, the device is on no bridge, or the publish failed.
+ */
+async function send(publisher, topic, build, report) {
+    let result;
+    try {
+        const message = build();
+        if (!publisher) {
+            throw new Error(`nothing was published to ${topic}: the device is on no bridge, register it with addDevice() or registerDevice()`);
+        }
+        result = await publisher.publish(topic, message);
+    }
+    catch (err) {
+        result = { ok: false, topic, error: asError(err) };
+    }
+    if (result.ok)
+        return topic;
+    if (report)
+        report(result.error);
+    return "";
+}