@mega-yfue/eufy-sdk 0.2.0-beta.0 → 0.2.0-beta.2

package/README.md

@@ -23,11 +23,6 @@
 
 ---
 
-> [!IMPORTANT]
-> **Not usable yet.** This repository is being set up: the scaffold, the CI gate and the docs pipeline
-> are in place, the library source lands next. `0.0.1` exists on npm only to prove the release
-> pipeline works — it is an empty package. Wait for `0.1.0`.
-
 ## What it is
 
 A TypeScript SDK for the Anker eufy cloud that the current eufy app speaks. It logs in (captcha and 2FA
@@ -37,14 +32,18 @@ you drive through a **typed, fluent API**:
 ```ts
 const dev = await eufy.getDevice(sn);
 
-const stored = await dev.camera()?.snapshotStored?.(); // latest retained push JPEG
-const fresh = await dev.camera()?.snapshotLive(); // explicit fresh live capture
-await dev.panTilt()?.rotate(PtzDirection.left);
-await dev.light()?.setBrightness(60);
+const stored = await dev.camera?.()?.snapshotStored?.(); // latest retained push JPEG
+const fresh = await dev.camera?.()?.snapshotLive?.(); // explicit fresh live capture
+await dev.ptz?.()?.rotate(PtzDirection.left);
+await dev.light?.()?.setBrightness(60);
 
-eufy.on("motion", (e) => console.log(e.device.name, "saw something"));
+eufy.on("motion", (e) => console.log(e.deviceSn, "saw something"));
 ```
 
+Accessors and methods are optional because both are **evidence-gated**: a device exposes exactly the
+features it reported, so the optionality states that one may be absent. An **unverified write path
+throws** rather than send a frame it cannot stand behind.
+
 Realtime arrives over **P2P** (cameras and HomeBases), **secure MQTT** (appliances) and **push**
 (events), all surfaced as typed semantic events. Live **video streaming** works, with one shared pull
 fanned out to every consumer.
@@ -56,12 +55,10 @@ code path and an unlisted or future device resolves the same way as a known one.
 ## Install
 
 ```bash
-npm install @mega-yfue/eufy-sdk
+npm install @mega-yfue/eufy-sdk         # latest stable
+npm install @mega-yfue/eufy-sdk@beta    # the prerelease of the version in review
 ```
 
-Releases go to **npmjs**, published from CI with provenance. Prereleases ship on the `beta` channel
-(`npm install @mega-yfue/eufy-sdk@beta`) while a version is still under review.
-
 **Node.js ≥ 24.5.0** is required, not just recommended (see [`.nvmrc`](./.nvmrc)). `ffmpeg` is
 optional — only the live JPEG snapshot and one-shot mp4 record paths use it,
 and a host that ships its own build names it with `new EufyMega({ ffmpegPath })` rather than needing
@@ -69,34 +66,13 @@ one on `PATH`.
 
 ## Documentation
 
-The guides at **<https://mega-yfue.github.io/>** are the source of truth; this README stays a thin
-landing page. They cover installing and logging in, devices and capabilities, events and realtime
-transports, consuming live media, and the generated API reference. Runnable, typechecked samples live
-in [`examples/`](./examples/).
-
-## Design
-
-Four layers, one dependency direction — `core` → `transport` → `model` → `client`:
-
-```
-src/
-  core/         shared floor: crypto, cross-layer contracts, value types, session store
-  transport/    every byte-on-a-wire module: http, mqtt, p2p, push, tuya
-  model/        Device + one self-contained module per capability
-  client/       the facade: login, device registry, event fan-out
-  index.ts      public surface — one `export *` per layer barrel
-```
-
-**Capability ↔ transport decorrelation is a hard, CI-enforced rule:** `model/` never imports
-`transport/` and vice versa. A capability describes what a value MEANS; a transport moves bytes and
-never names a feature. Anything genuinely shared is a contract in `core/`. That rule and the rest of
-the code practice are in [AGENTS.md](./AGENTS.md).
-
-Three runtime dependencies — `mqtt`, `protobufjs`, `jpeg-js` — and that is deliberate. HTTP is native
-`fetch`, hashing and ciphers are `node:crypto`, 64-bit integers are `BigInt`.
+The guides at **<https://mega-yfue.github.io/>** cover installing and logging in, devices and
+capabilities, events and realtime transports, consuming live media, and the generated API reference.
+Runnable, typechecked samples live in [`examples/`](./examples/).
 
-**Unverified write paths throw rather than guess.** Some writes are fire-and-forget, so a guessed
-frame looks exactly like success; the SDK refuses instead of pretending.
+The architecture — four layers with one dependency direction, and the CI-enforced rule that keeps
+capabilities and transports from importing each other — is in [AGENTS.md](./AGENTS.md), with the rest of
+the code practice.
 
 ## Develop
 

package/dist/client/eufy-mega.d.ts

@@ -707,11 +707,38 @@ export declare class EufyMega extends EventEmitter {
      * {@link ensureMqttStarted} owns installing it, subscribing devices, and the epoch check, so that
      * lifecycle lives in exactly one place. Only ever called through {@link ensureMqttStarted}.
      *
+     * Identified by a client id built from this client's `openudid`, not by the certificate's name:
+     * that name is `{user_id}-{app_name}`, which every client on the account shares per line, and a
+     * duplicate client id is a takeover the broker resolves by evicting the incumbent. The id shape is
+     * the app's own (`android-{app_name}-{uid}-{uuid}-{ts}`, see {@link buildAppShapedClientId}), which
+     * the broker grants on the `eufy_security` credential.
+     *
+     * It separates two clients exactly as far as their `openudid` does: a caller that supplies none
+     * gets the value derived from the account, which every such client shares — the same condition
+     * under which their logins already displace each other (`MegaClientConfig.openudid`).
+     *
+     * A client id the broker REFUSES falls back to the certificate's name, since a shared channel beats
+     * none, and that transport then keeps that name until {@link disconnect}. Only a refusal: a connect
+     * that fails for any other reason rejects the bring-up, which clears its memo in
+     * {@link ensureMqttStarted} so the next one asks under this client's own id again — a dropped
+     * socket must not be what moves a process onto the shared name for good.
+     */
+    private startMqtt;
+    /**
+     * Connect one secure-MQTT transport under `clientId`, or under the certificate's own name when it is
+     * omitted, and wire its decode and fan-out. See {@link startMqtt} for which id is used and why.
+     *
+     * The fan-out is wired once the connection stands, so an attempt that is discarded — a client id the
+     * broker refuses, a socket that dies mid-handshake — never reports a connection a consumer never had;
+     * the connect it just completed is announced here instead. Errors raised while connecting are held
+     * only to keep an emitter without an `error` listener from throwing, and are reported once the
+     * transport is one a consumer owns.
+     *
      * The inbound decode is gated by the reporting device's own capabilities, so one line's decoder never
      * runs against another's traffic, and the DP frame is unwrapped here — the layer that may import the
      * transport — so a capability reads tags without owning any framing.
      */
-    private startMqtt;
+    private connectMqtt;
     /**
      * Subscribe the devices on one credential scope; a failing subscribe is reported, not fatal (one
      * unreachable device must not stop the rest of the roster from coming up).

package/dist/index.js

@@ -967,7 +967,15 @@ var MegaHttpClient = class {
    *  restored-session short-circuit must NOT treat it as a usable session. Cleared on Ok/reset. */
   pending2fa = false;
   tokenExpiresAt = 0;
-  /** Stable per-install device id — the auth token is bound to it. */
+  /**
+   * Stable per-install device id: `openudid` as configured, as restored from the session store, or as
+   * derived from the ACCOUNT when neither supplied one — two clients that configure none therefore
+   * share it, and are one install as far as everything keyed on this is concerned.
+   *
+   * Two things are keyed on it, and both fail the same way when it is shared: the auth token is bound
+   * to it, so each login displaces the other's session, and the secure-MQTT client id is built from it,
+   * so each connection evicts the other's channel.
+   */
   openudid;
   /** The device model reported to the cloud (explicit `phoneModel`, else a stable random one). */
   phoneModel;
@@ -1805,6 +1813,9 @@ function parseSecureTopic(topic) {
 
 // dist/transport/mqtt/secure-mqtt.js
 var SUBACK_FAILURE = 128;
+function isNotAuthorized(err) {
+  return err instanceof Error && /connection refused/i.test(err.message) && /not authori[sz]ed/i.test(err.message);
+}
 var SecureMqtt = class extends EventEmitter {
   kind = "smqtt";
   client;
@@ -1864,6 +1875,7 @@ var SecureMqtt = class extends EventEmitter {
         }
         this.emit("connect");
       });
+      client.on("connect", () => this.logger.info(`[smqtt] connected (${c.app_name ?? "default"})`));
       client.on("reconnect", () => this.logger.warn("[smqtt] reconnecting"));
       client.on("close", () => this.emit("disconnect", "close"));
       client.on("error", (err) => {
@@ -1932,6 +1944,16 @@ var SecureMqtt = class extends EventEmitter {
   }
 };
 
+// dist/transport/mqtt/app-client-id.js
+import { createHash as createHash4 } from "node:crypto";
+function buildAppShapedClientId(input) {
+  const ts = input.timestamp ?? Math.floor(Date.now() / 1e3);
+  return `android-${input.appName}-${input.uid}-${input.mqttUuid}-${ts}`;
+}
+function mqttUuidFrom(installId) {
+  return createHash4("sha256").update(installId).digest("hex").slice(0, 16);
+}
+
 // dist/core/util.js
 var Timer = class {
   handle;
@@ -6868,6 +6890,16 @@ var KEYPAD = {
 // dist/model/capabilities/arming.js
 var STATION_CHANNEL2 = 255;
 var ArmingMode = {
+  /** Armed — full protection, nobody home (wire value 0). */
+  away: "away",
+  /** Armed for occupancy — reduced/perimeter protection while home (wire value 1). */
+  home: "home",
+  /** Custom 1 — a user-defined posture configured in the app (wire value 3). */
+  custom1: "custom1",
+  /** Disarmed — no alarms; sensors still report state (wire value 63). */
+  disarmed: "disarmed"
+};
+var AlarmDelayMode = {
   /** Armed — full protection, nobody home (wire value 0). */
   away: "away",
   /** Armed for occupancy — reduced/perimeter protection while home (wire value 1). */
@@ -6883,10 +6915,11 @@ var ARMING_CMD = {
    * mValue3:0, `payload:{mode_type:<int>, user_name:<string>}`.
    *
    * ⚠️ Only 3 of the 9 modes were exercised in that capture — `mode_type` 0 (away), 63 (disarmed), 1
-   * (home), all confirmed byte-exact, and those three are the whole of {@link ArmingMode}. Re-confirmed
-   * live 2026-08-05: each reported its own MODE_SWITCH push within ~5s of the write. The remaining six are
-   * named by the app but never observed leaving it, so this capability reads them and refuses to send
-   * them. See `ARMING_MODE_WIRE` for the per-value breakdown.
+   * (home), all confirmed byte-exact. Re-confirmed live 2026-08-05: each reported its own MODE_SWITCH push
+   * within ~5s of the write. `custom1` 3 joined {@link ArmingMode} on a live confirmation rather than a
+   * capture, making four settable in total. The remaining five are named by the app but never observed
+   * leaving it, so this capability reads them and refuses to send them. See `ARMING_MODE_WIRE` for the
+   * per-value breakdown.
    */
   SET_ARMING: 1224,
   /**
@@ -6922,7 +6955,6 @@ var ARMING_MODE_WIRE = {
   schedule: 2,
   // ⚠️ reportable, NOT settable — see the doc comment above
   custom1: 3,
-  // ⚠️ reportable, NOT settable — see the doc comment above
   custom2: 4,
   // ⚠️ reportable, NOT settable — see the doc comment above
   custom3: 5,
@@ -6965,9 +6997,9 @@ function alarmDelayCommand(mode, config, ctx) {
 var ARMING_MEMBERS = {
   /**
    * The one member whose write domain is NARROWER than its read: `enumValues` names all nine modes a
-   * station can report, and the argument's `values` publishes only the three whose wire was captured. That
-   * argument IS the domain the derived setter enforces and the refusal names, so an uncaptured mode is
-   * refused by naming the three that work — nine labels for the read and three for the write, off one
+   * station can report, and the argument's `values` publishes only the four whose write is confirmed. That
+   * argument IS the domain the derived setter enforces and the refusal names, so an unconfirmed mode is
+   * refused by naming the four that work — nine labels for the read and four for the write, off one
    * declaration.
    *
    * `armingCommand` may also throw synchronously (missing account identity) and `bindMembers` turns that
@@ -6988,7 +7020,7 @@ var ARMING_MEMBERS = {
     enumValues: ARMING_MODE_LABELS,
     provenance: "verified",
     args: [{ name: "mode", kind: "enum", values: SETTABLE_MODES }],
-    description: "Guard mode (verified: param 1224 = GUARD_MODE, read/write mechanism confirmed). Reads all 9 modes the app defines; SETS only the 3 whose write is wire-captured (away/home/disarmed) \u2014 schedule/custom1/custom2/custom3/off/geo are named by the app but no capture shows one being sent, so they are refused rather than guessed; see ARMING_MODE_WIRE in arming.ts for the breakdown.",
+    description: "Guard mode (verified: param 1224 = GUARD_MODE, read/write mechanism confirmed). Reads all 9 modes the app defines; SETS only the 4 whose write is confirmed (away/home/custom1/disarmed) \u2014 schedule/custom2/custom3/off/geo are named by the app but no capture shows one being sent, so they are refused rather than guessed; see ARMING_MODE_WIRE in arming.ts for the breakdown.",
     observation: {
       event: "armingModeChanged",
       reflects: (value) => ({ param: ARMING_CMD.SET_ARMING, expected: ARMING_MODE_WIRE[armingModeOf(value)] }),
@@ -7009,9 +7041,10 @@ var ARMING_MEMBERS = {
    * this mode — there is no known GET to fetch it automatically, and a wrong guess here can silently
    * misconfigure which sensors arm/trigger for real.
    *
-   * Takes {@link ArmingMode}, so a delay can only be configured for a mode whose `mode_id` integer is
-   * captured. The frame carries that same integer, so a schedule/custom mode would be the identical guess
-   * `setMode` refuses.
+   * Takes {@link AlarmDelayMode}, not {@link ArmingMode}: a delay is configurable only for a mode whose
+   * integer is captured on THIS command, and `custom1` is confirmed on cmd 1224 only. The frame carries
+   * that integer in `mode_id` with no runtime validation and no readback, so a mode outside this union
+   * would be the same unverified guess `setMode` refuses.
    */
   setAlarmDelayConfig: method(({ ctx, sink }) => (mode, config) => {
     try {
@@ -20168,17 +20201,7 @@ var P2PCommandRouter = class _P2PCommandRouter {
 };
 
 // dist/transport/mqtt/command-router.js
-import { randomBytes as randomBytes4 } from "node:crypto";
-
-// dist/transport/mqtt/app-client-id.js
 import { randomBytes as randomBytes3 } from "node:crypto";
-function buildAppShapedClientId(input) {
-  const ts = input.timestamp ?? Math.floor(Date.now() / 1e3);
-  return `android-${input.appName}-${input.uid}-${input.mqttUuid}-${ts}`;
-}
-function generateMqttUuid() {
-  return randomBytes3(8).toString("hex");
-}
 
 // dist/transport/mqtt/broker-discovery.js
 import { resolve4 } from "node:dns/promises";
@@ -20556,9 +20579,9 @@ function buildFf09MqttEnvelope(input) {
   const head = {
     version: "1.0.0.1",
     client_id: input.clientId,
-    sess_id: input.sessId ?? randomBytes4(2).toString("hex"),
+    sess_id: input.sessId ?? randomBytes3(2).toString("hex"),
     msg_seq: 1,
-    seed: input.seed ?? randomBytes4(16).toString("hex"),
+    seed: input.seed ?? randomBytes3(16).toString("hex"),
     timestamp: input.timestamp ?? Math.floor(Date.now() / 1e3),
     cmd_status: 2,
     cmd: 9,
@@ -20569,9 +20592,6 @@ function buildFf09MqttEnvelope(input) {
 var MqttCommandRouter = class _MqttCommandRouter {
   deps;
   logger;
-  /** Stable per-process install id for the app-shaped MQTT client_id (see {@link buildAppShapedClientId}) —
-   * generated once, reused for every security-MQTT connect this router makes. */
-  mqttUuid;
   constructor(deps) {
     this.deps = deps;
     this.logger = deps.logger ?? noopLogger;
@@ -20678,9 +20698,7 @@ var MqttCommandRouter = class _MqttCommandRouter {
    */
   async ensureSecurityMqttFor(dev) {
     const creds = await this.deps.mega.getUserMqttInfo("eufy_security");
-    if (!this.mqttUuid)
-      this.mqttUuid = generateMqttUuid();
-    const mqttUuid = this.mqttUuid;
+    const mqttUuid = mqttUuidFrom(this.deps.mega.openudid);
     const clientIdFor = () => buildAppShapedClientId({ appName: "eufy_security", uid: creds.user_id ?? "", mqttUuid });
     const results = await discoverReachableInstance({
       hostname: creds.endpoint_addr,
@@ -21175,7 +21193,7 @@ function deriveTuyaAccount(eufyUserId, phoneCode) {
 }
 
 // dist/transport/tuya/sign.js
-import { createHash as createHash4, createHmac as createHmac3 } from "node:crypto";
+import { createHash as createHash5, createHmac as createHmac3 } from "node:crypto";
 var SIGN_ALLOWLIST = /* @__PURE__ */ new Set([
   "a",
   "v",
@@ -21199,7 +21217,7 @@ var SIGN_ALLOWLIST = /* @__PURE__ */ new Set([
   "sp"
 ]);
 function swapMd5(postData) {
-  const h = createHash4("md5").update(postData, "utf-8").digest("hex");
+  const h = createHash5("md5").update(postData, "utf-8").digest("hex");
   return h.slice(8, 16) + h.slice(0, 8) + h.slice(24, 32) + h.slice(16, 24);
 }
 function buildSignPreimage(params) {
@@ -21224,7 +21242,7 @@ var HmacSigner = class {
 var TUYA_CHKEY = "7cbfe6d8";
 
 // dist/transport/tuya/client.js
-import { randomBytes as randomBytes5, createHash as createHash5, createPublicKey, publicEncrypt, constants as constants2 } from "node:crypto";
+import { randomBytes as randomBytes4, createHash as createHash6, createPublicKey, publicEncrypt, constants as constants2 } from "node:crypto";
 
 // dist/transport/tuya/request.js
 import { randomUUID as randomUUID3 } from "node:crypto";
@@ -21336,7 +21354,7 @@ function buildUidTokenCreateAction(countryCode, uid) {
 
 // dist/transport/tuya/client.js
 function genDeviceId() {
-  return randomBytes5(22).toString("hex");
+  return randomBytes4(22).toString("hex");
 }
 function rsaEncryptPassword(password, publicKeyDecimal, exponentDecimal) {
   const bigintToBuffer = (n) => {
@@ -21351,7 +21369,7 @@ function rsaEncryptPassword(password, publicKeyDecimal, exponentDecimal) {
     },
     format: "jwk"
   });
-  const md5Hex = createHash5("md5").update(password).digest("hex");
+  const md5Hex = createHash6("md5").update(password).digest("hex");
   return publicEncrypt({ key: rsaKey, padding: constants2.RSA_PKCS1_PADDING }, Buffer.from(md5Hex)).toString("hex");
 }
 var TuyaClient = class {
@@ -22443,7 +22461,7 @@ var PushClient = class _PushClient extends EventEmitter8 {
 };
 
 // dist/transport/push/fcm.js
-import { randomBytes as randomBytes6 } from "node:crypto";
+import { randomBytes as randomBytes5 } from "node:crypto";
 import { setTimeout as sleep3 } from "node:timers/promises";
 var FCM = {
   PROJECT_ID: "batterycam-3250a",
@@ -22456,7 +22474,7 @@ var FCM = {
   SDK_VERSION: "a:16.3.1"
 };
 function generateFid() {
-  const b = randomBytes6(17);
+  const b = randomBytes5(17);
   b[0] = 112 + b[0] % 16;
   return b.toString("base64url").slice(0, 22);
 }
@@ -24750,9 +24768,21 @@ var EufyMega = class extends EventEmitter9 {
    * {@link ensureMqttStarted} owns installing it, subscribing devices, and the epoch check, so that
    * lifecycle lives in exactly one place. Only ever called through {@link ensureMqttStarted}.
    *
-   * The inbound decode is gated by the reporting device's own capabilities, so one line's decoder never
-   * runs against another's traffic, and the DP frame is unwrapped here — the layer that may import the
-   * transport — so a capability reads tags without owning any framing.
+   * Identified by a client id built from this client's `openudid`, not by the certificate's name:
+   * that name is `{user_id}-{app_name}`, which every client on the account shares per line, and a
+   * duplicate client id is a takeover the broker resolves by evicting the incumbent. The id shape is
+   * the app's own (`android-{app_name}-{uid}-{uuid}-{ts}`, see {@link buildAppShapedClientId}), which
+   * the broker grants on the `eufy_security` credential.
+   *
+   * It separates two clients exactly as far as their `openudid` does: a caller that supplies none
+   * gets the value derived from the account, which every such client shares — the same condition
+   * under which their logins already displace each other (`MegaClientConfig.openudid`).
+   *
+   * A client id the broker REFUSES falls back to the certificate's name, since a shared channel beats
+   * none, and that transport then keeps that name until {@link disconnect}. Only a refusal: a connect
+   * that fails for any other reason rejects the bring-up, which clears its memo in
+   * {@link ensureMqttStarted} so the next one asks under this client's own id again — a dropped
+   * socket must not be what moves a process onto the shared name for good.
    */
   async startMqtt(scope) {
     const auth = this.mega.auth;
@@ -24761,7 +24791,41 @@ var EufyMega = class extends EventEmitter9 {
     if (!this.registry.list().length)
       await this.getDevices();
     const creds = await this.getUserMqttInfo(mqttAppName(scope));
-    const transport = new SecureMqtt({ credentials: creds, logger: this.opts.logger });
+    const ownClientId = buildAppShapedClientId({
+      appName: creds.app_name ?? mqttAppName(scope) ?? "eufy_mega",
+      uid: creds.user_id ?? auth.userId,
+      mqttUuid: mqttUuidFrom(this.mega.openudid)
+    });
+    try {
+      return await this.connectMqtt(creds, ownClientId);
+    } catch (e) {
+      if (!isNotAuthorized(e))
+        throw e;
+      this.opts.logger?.warn("[smqtt] the broker refused this client's own id; connecting under the certificate's name, which another client signed in to this account takes over", e);
+      return await this.connectMqtt(creds);
+    }
+  }
+  /**
+   * Connect one secure-MQTT transport under `clientId`, or under the certificate's own name when it is
+   * omitted, and wire its decode and fan-out. See {@link startMqtt} for which id is used and why.
+   *
+   * The fan-out is wired once the connection stands, so an attempt that is discarded — a client id the
+   * broker refuses, a socket that dies mid-handshake — never reports a connection a consumer never had;
+   * the connect it just completed is announced here instead. Errors raised while connecting are held
+   * only to keep an emitter without an `error` listener from throwing, and are reported once the
+   * transport is one a consumer owns.
+   *
+   * The inbound decode is gated by the reporting device's own capabilities, so one line's decoder never
+   * runs against another's traffic, and the DP frame is unwrapped here — the layer that may import the
+   * transport — so a capability reads tags without owning any framing.
+   */
+  async connectMqtt(creds, clientId) {
+    const transport = new SecureMqtt({ credentials: creds, clientId, logger: this.opts.logger });
+    const whileConnecting = [];
+    const hold = (e) => void whileConnecting.push(e);
+    transport.on("error", hold);
+    await transport.connect();
+    transport.off("error", hold);
     transport.on("connect", () => this.emit("connect"));
     transport.on("disconnect", (r) => this.emit("disconnect", r));
     transport.on("message", (m) => {
@@ -24800,7 +24864,9 @@ var EufyMega = class extends EventEmitter9 {
         this.emitSemantic(out.event, out.payload, { edge: true, refresh: out.refresh });
     });
     transport.on("error", (e) => this.reportError(e));
-    await transport.connect();
+    this.emit("connect");
+    for (const e of whileConnecting)
+      this.reportError(e);
     return transport;
   }
   /**
@@ -25257,6 +25323,7 @@ export {
   AUDIO_MEMBERS,
   AccessUnitAssembler,
   AiDetectType,
+  AlarmDelayMode,
   ArmingMode,
   BATTERY_MEMBERS,
   BIZ_CHANNEL,
@@ -25443,7 +25510,6 @@ export {
   freshestLanIp,
   genId,
   generateFid,
-  generateMqttUuid,
   getCapabilityModule,
   getIdSuffix,
   getImageBaseCode,
@@ -25456,6 +25522,7 @@ export {
   inferName,
   inspectParams,
   isKnownValueKind,
+  isNotAuthorized,
   isPrivateIpv4,
   isSessionValid,
   isV1Image,
@@ -25471,6 +25538,7 @@ export {
   mergeProperties,
   mqttAppName,
   mqttScopeFor,
+  mqttUuidFrom,
   namespaceForCodec,
   needsRealtimeInit,
   noopLogger,