homebridge-plugin-utils 1.34.0 → 2.0.0

package/dist/logclient/socket.js

@@ -0,0 +1,620 @@
+/* Copyright(C) 2017-2026, HJD (https://github.com/hjdhjd). All rights reserved.
+ *
+ * logclient/socket.ts: AsyncDisposable Socket.IO log-stream client with reconnect, ping-liveness, and a bounded push-to-pull line stream.
+ */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+/**
+ * AsyncDisposable live-log socket for the Homebridge UI log stream.
+ *
+ * {@link LogSocket} owns a single WebSocket connection to the homebridge-config-ui-x Socket.IO log namespace and surfaces the raw `stdout` text the server streams as a
+ * bounded push-to-pull `AsyncIterable<string>`. It composes the library's own primitives rather than reinventing them: {@link composeSignals} / {@link onAbort} for
+ * lifetime, {@link Watchdog} for ping liveness, {@link retry} (driving the connect phase with the log client's own dev-tuned backoff curve), and {@link HbpuAbortError}
+ * for the abort taxonomy. The wire framing is delegated entirely to the pure {@link decodeFrame} / {@link encodeFrame} codec.
+ *
+ * Lifecycle, in one pass:
+ *
+ * - A background reconnect loop runs for the socket's lifetime: `while(!signal.aborted)`, each iteration `retry()`s the CONNECT PHASE ONLY (re-acquire the token, open
+ *   the WebSocket, await the Engine.IO open handshake, join the `/log` namespace, emit `tail-log`). Wrapping only the connect phase in `retry` means the exponential
+ *   backoff curve RESETS after every healthy session - a socket that stays connected for hours and then drops reconnects briskly rather than at the climbed-up delay a
+ *   single long-lived `retry` would have reached.
+ * - The connect-phase backoff is the log client's own jittered exponential curve: a 500 ms base (`RECONNECT_BASE_MS`) doubling each attempt and plateauing at a 5-second
+ *   ceiling (`RECONNECT_CAP_MS`), deliberately snappier than `defaultRetryBackoff`'s 30-second ceiling so the tail resumes promptly after a Homebridge restart. `random`
+ *   is injectable (default `Math.random`) so the jitter is deterministic in tests.
+ * - `shouldRetry` vetoes a retry the instant a permanent authentication failure surfaces (wrong password, missing OTP, noauth disabled), so a credential problem fails
+ *   the socket fast with an actionable error rather than looping forever.
+ * - Once connected, each server ping (`"2"`) is answered with a pong (`"3"`) and re-arms the liveness {@link Watchdog}; if no ping arrives within
+ *   `pingInterval + pingTimeout + MARGIN_MS`, the watchdog aborts the session and the loop reconnects.
+ * - A Socket.IO CONNECT_ERROR (`44/log,`) on the namespace is surfaced as a connect-phase failure - transient and retried for a refreshable credential (password/noauth),
+ *   permanent and made terminal by the `shouldRetry` veto for a static token that cannot be refreshed.
+ *
+ * Teardown is idempotent and state-gated: it sends a namespace DISCONNECT (`41/log,`) only when the socket is still OPEN, ALWAYS issues `close(1000)`, clears the
+ * watchdog, and settles the parked stdout waiter exactly once. The class introduces NO `Clock` dependency - reconnect timing is exercised in tests by injecting a
+ * near-zero `backoff`, and the watchdog by `node:test` `mock.timers`.
+ *
+ * @module
+ */
+import { DEFAULT_PORT, JITTER_FRACTION, LOG_NAMESPACE, MARGIN_MS, PTY_COLUMNS, PTY_ROWS, RECONNECT_BASE_MS, RECONNECT_CAP_MS } from "./settings.js";
+import { HbpuAbortError, Watchdog, composeSignals, formatErrorMessage, onAbort, retry } from "../util.js";
+import { LOG_NAMESPACE_PATH, decodeFrame, encodeFrame } from "./frame.js";
+import { LogAuthError, isPermanentAuthError } from "./auth.js";
+import { LogLineSplitter } from "./parser.js";
+import { socketUrl } from "./endpoints.js";
+// The default high-water mark for the stdout queue: the maximum number of lines buffered between the WebSocket producer and a slow consumer before the oldest lines are
+// dropped. A live consumer (a terminal, a grep) keeps up in practice, so this bound is a safety valve against an unbounded backlog rather than a routine limit; it is
+// generous enough to absorb the server's ~500-line seed plus normal jitter, and overflow is logged once so a chronically-slow consumer is not silently lossy.
+const DEFAULT_STDOUT_HIGH_WATER = 10000;
+/**
+ * The numeric `readyState` value denoting an open WebSocket. The DOM `WebSocket.OPEN` constant is `1`; we name it as a module constant so the seam interface does not
+ * have to carry the static constant and teardown can gate on it without depending on the concrete class.
+ *
+ * @category Log Client
+ */
+export const WEBSOCKET_OPEN = 1;
+/**
+ * The production {@link WebSocketFactory}: constructs the platform global `WebSocket`. A consumer holds the factory typed as the seam abstraction; a test substitutes a
+ * double. The platform `WebSocket` begins connecting on construction, which is exactly the factory contract.
+ *
+ * @param url - The connect URL.
+ *
+ * @returns A live platform `WebSocket`, typed as the {@link WebSocketLike} seam.
+ *
+ * @category Log Client
+ */
+export const webSocketFactory = (url) => new WebSocket(url);
+// Add up-to-`JITTER_FRACTION` upward random jitter to a base delay. Jitter spreads reconnect attempts so a fleet of clients does not stampede the server in lockstep
+// after a shared outage. The `random` source is injected so the jittered delay is deterministic in tests; with `random` pinned near zero the delay is effectively the
+// base, which is how the reconnect tests drive the loop without real waits.
+function withJitter(base, random) {
+    return Math.round(base + (base * JITTER_FRACTION * random()));
+}
+/**
+ * The log client's connect-phase reconnect backoff policy: a dev-tuned jittered exponential curve with a low ceiling.
+ *
+ * This is the single source of truth for the socket's default reconnect timing. The base delay is `RECONNECT_BASE_MS` (500 ms) and it doubles with each successive
+ * connect attempt, plateauing at the `RECONNECT_CAP_MS` ceiling (5 s) - deliberately snappier than `defaultRetryBackoff`'s 30-second ceiling, because a log-tailing
+ * dev tool should resume the tail promptly after the frequent Homebridge restarts a plugin developer does rather than back off to a half-minute lag. Up to
+ * `JITTER_FRACTION` of the computed base is added as upward jitter so a fleet of clients does not reconnect in lockstep after a shared outage.
+ *
+ * It is exported (rather than left inline in the constructor) so the bare schedule is a directly unit-testable function: with `random` pinned to `0` the curve yields the
+ * exact, deterministic 500, 1000, 2000, 4000, 5000, 5000, ... sequence. `retry` invokes the socket's backoff 1-indexed with the attempt about to run and never with
+ * `attempt === 1` (the first attempt runs immediately), so `attempt - 2` is the zero-based exponent for the second-and-later attempts.
+ *
+ * @param attempt - The 1-indexed connect attempt about to run. Called only for the second and later attempts (the first runs with no wait).
+ * @param random  - Source of `[0, 1)` randomness for the jitter. Defaults to `Math.random`; pinned in tests for a deterministic schedule.
+ *
+ * @returns The delay, in milliseconds, to wait before running `attempt`.
+ *
+ * @category Log Client
+ */
+export function reconnectBackoff(attempt, random = Math.random) {
+    return withJitter(Math.min(RECONNECT_CAP_MS, RECONNECT_BASE_MS * (2 ** (attempt - 2))), random);
+}
+/**
+ * AsyncDisposable client for the live Homebridge log stream over a single Socket.IO WebSocket, with automatic reconnect, ping liveness, and a bounded push-to-pull line
+ * stream.
+ *
+ * @example
+ *
+ * ```ts
+ * await using socket = new LogSocket({
+ *
+ *   host: "localhost",
+ *   log,
+ *   refreshable: true,
+ *   tokenProvider: (signal) => acquireToken(credentials, { host: "localhost", port: 8581, signal }),
+ *   signal: session.signal
+ * });
+ *
+ * for await (const line of socket.stdout()) {
+ *
+ *   process.stdout.write(line + "\n");
+ * }
+ * ```
+ *
+ * @category Log Client
+ */
+export class LogSocket {
+    /**
+     * The composed abort signal representing this socket's lifetime. Aborts exactly once - when {@link LogSocket.abort} is called, the parent signal fires, or the
+     * reconnect loop gives up on a permanent failure - and `signal.reason` names the cause.
+     */
+    signal;
+    // The private controller whose signal is composed into `this.signal`. Owned internally so the only abort verb is `abort()`.
+    #controller;
+    #backoff;
+    #host;
+    #log;
+    #port;
+    #random;
+    #refreshable;
+    #stdoutHighWater;
+    #tls;
+    #tokenProvider;
+    #webSocketFactory;
+    // The bounded queue of raw stdout lines staged for the `stdout()` consumer, plus the single parked waiter the consumer blocks on when the queue is empty. The class is
+    // single-consumer by design, mirroring `Mp4SegmentAssembler`: one parked-waiter slot is sufficient.
+    #stdoutQueue = [];
+    #stdoutWaiter;
+    // The number of lines dropped because the stdout queue hit its high-water mark, and a one-time flag so a chronically-slow consumer is warned exactly once rather than
+    // on every drop. Tracking the count lets the single warning report the magnitude of the loss.
+    #droppedLines = 0;
+    #overflowLogged = false;
+    // The background reconnect loop's promise, retained so `[Symbol.asyncDispose]` can await its completion before returning.
+    #loopTask;
+    // The current live session, or `undefined` between sessions / after teardown. Held so teardown can close the live WebSocket and so the message handler can address the
+    // correct connection's `send`.
+    #session;
+    /**
+     * Construct and start a new live-log socket. The reconnect loop starts synchronously as part of construction: by the time the constructor returns, the first connect
+     * attempt is already in flight (unless the signal was pre-aborted, in which case the socket tears down immediately).
+     *
+     * @param init - Required init options. See {@link LogSocketInit}.
+     */
+    constructor(init) {
+        this.#host = init.host;
+        this.#log = init.log;
+        this.#port = init.port ?? DEFAULT_PORT;
+        this.#random = init.random ?? Math.random;
+        this.#refreshable = init.refreshable;
+        this.#stdoutHighWater = init.stdoutHighWater ?? DEFAULT_STDOUT_HIGH_WATER;
+        this.#tls = init.tls ?? false;
+        this.#tokenProvider = init.tokenProvider;
+        this.#webSocketFactory = init.webSocketFactory ?? webSocketFactory;
+        // The connect-phase backoff. Defaults to the log client's own jittered exponential curve via {@link reconnectBackoff} - a 500 ms base doubling each attempt and
+        // plateauing at a 5-second ceiling, deliberately snappier than `defaultRetryBackoff`'s 30-second ceiling because a dev tool should resume the tail promptly after the
+        // frequent Homebridge restarts a plugin developer does. A caller (a test) may inject a near-zero policy to drive the reconnect loop without real waits. Resolved once
+        // here, closing over the socket's injected `random`, so the hot reconnect path reads a single field rather than re-deriving the default each attempt.
+        this.#backoff = init.backoff ?? ((attempt) => reconnectBackoff(attempt, this.#random));
+        this.#controller = new AbortController();
+        this.signal = composeSignals(init.signal, this.#controller.signal);
+        // Single teardown convergence point. `onAbort` registers the one-shot teardown for the normal abort path AND runs it inline when the signal is already aborted at
+        // construction time (a pre-aborted parent), so the stdout waiter is settled and the live connection closed regardless of which path fired.
+        onAbort(this.signal, () => this.#teardown());
+        if (this.signal.aborted) {
+            return;
+        }
+        // Start the background reconnect loop. The returned promise is retained so disposal can await its completion; the loop is written to always resolve (it classifies
+        // its own faults), so no `markHandled` wrapper is needed.
+        this.#loopTask = this.#runLoop();
+    }
+    /**
+     * Abort the socket and tear it down. Defaults to `HbpuAbortError("shutdown")` when no reason is supplied; explicit reasons pass through unchanged.
+     *
+     * Safe to call more than once: the underlying signal aborts only once, so subsequent calls are no-ops.
+     *
+     * @param reason - Optional abort reason. Typically an {@link HbpuAbortError}.
+     */
+    abort(reason) {
+        if (this.aborted) {
+            return;
+        }
+        this.#controller.abort(reason ?? new HbpuAbortError("shutdown"));
+    }
+    /**
+     * `AsyncDisposable` implementation. Aborts the socket (defaulting to `"shutdown"`) and awaits the reconnect loop's completion before returning, so callers using
+     * `await using` are guaranteed the connection is closed and the loop has unwound by the time the block exits.
+     *
+     * @returns A promise that resolves once the reconnect loop has fully exited.
+     */
+    async [Symbol.asyncDispose]() {
+        this.abort();
+        if (this.#loopTask) {
+            // The loop is written to always resolve; the catch is belt-and-suspenders so disposal never surfaces a cleanup-side failure the caller cannot react to.
+            await this.#loopTask.catch(() => { });
+        }
+    }
+    /**
+     * `true` once `this.signal` has aborted. Derived from the signal; no independent state.
+     */
+    get aborted() {
+        return this.signal.aborted;
+    }
+    /**
+     * The number of stdout lines dropped so far because the consumer fell behind the high-water mark. Zero in steady state; non-zero only after the bounded queue
+     * overflowed, which is also logged once.
+     */
+    get droppedLines() {
+        return this.#droppedLines;
+    }
+    /**
+     * The bounded push-to-pull stream of raw log lines (ANSI intact, terminators removed) the server streams over the log namespace's `stdout` events.
+     *
+     * The server delivers `stdout` as raw text chunks whose boundaries do not align with log lines; the socket runs each chunk through a per-session
+     * {@link LogLineSplitter}, yields complete lines here, and flushes it on each session's close so the final line is never stranded. Mirroring
+     * `Mp4SegmentAssembler.segments`, a bounded queue decouples the WebSocket producer from this consumer, and a single parked waiter blocks the consumer when the queue is
+     * empty until a line is pushed or the socket aborts. The queue survives reconnects - the same iterable keeps yielding across a drop-and-reconnect - so a consumer
+     * iterates it once for the whole socket lifetime. The stream terminates (returns) when the socket aborts; the queue is drained before it returns, so a line already
+     * staged before teardown is never lost.
+     *
+     * **Single-consumer only.** The parked-waiter slot is single-writer; iterating `stdout()` concurrently from two consumers is unsupported.
+     *
+     * @returns An async generator yielding raw log lines in stream order.
+     */
+    async *stdout() {
+        for (;;) {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                // Swap-drain the queue: take whatever the producer has staged, leave a fresh empty array for it to push into, then yield the snapshot. Draining unconditionally
+                // before the abort check preserves the "no staged line lost on teardown" invariant.
+                while (this.#stdoutQueue.length > 0) {
+                    const drained = this.#stdoutQueue;
+                    this.#stdoutQueue = [];
+                    for (const line of drained) {
+                        yield line;
+                    }
+                }
+                if (this.signal.aborted) {
+                    return;
+                }
+                // Park until a line is pushed (producer resolves the waiter) or the socket aborts (teardown resolves it). A per-iteration resolver keeps the waiter always fresh.
+                const waiter = Promise.withResolvers();
+                this.#stdoutWaiter = waiter;
+                // `onAbort` unifies registration, the pre-aborted-signal pitfall, and one-shot `{ once: true }` semantics; the disposer is handed to `using` so the listener is
+                // removed on every scope-exit path. Matches the parked-wait shape `Mp4SegmentAssembler` uses.
+                const _abortRegistration = __addDisposableResource(env_1, onAbort(this.signal, () => waiter.resolve()), false);
+                try {
+                    // eslint-disable-next-line no-await-in-loop
+                    await waiter.promise;
+                }
+                finally {
+                    this.#stdoutWaiter = undefined;
+                }
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                __disposeResources(env_1);
+            }
+        }
+    }
+    // The background reconnect loop. Runs for the socket's lifetime: each iteration `retry()`s the connect phase to obtain a live session, then streams until the session
+    // ends. A clean socket-level abort exits the loop; any other session end loops again, and because only the connect phase is wrapped in `retry`, the next attempt
+    // starts from a fresh (reset) backoff curve.
+    async #runLoop() {
+        while (!this.signal.aborted) {
+            let session;
+            try {
+                // Connect phase only. `retry` owns the backoff and the permanent-failure veto; `Infinity` attempts means the loop reconnects indefinitely until the socket is
+                // aborted or a permanent failure is vetoed. The default backoff is the log client's own dev-tuned exponential curve (a 500 ms base doubling each attempt and
+                // capped at a 5-second ceiling, snappier than `defaultRetryBackoff`'s 30-second ceiling) with up-to-`JITTER_FRACTION` upward jitter layered on, so a fleet of
+                // clients does not stampede the server in lockstep after a shared outage. Because only the connect phase is wrapped, the backoff resets every time this returns -
+                // a socket that stayed healthy for hours reconnects briskly rather than at a climbed-up delay.
+                // eslint-disable-next-line no-await-in-loop
+                session = await retry((attemptSignal) => this.#connect(attemptSignal), {
+                    attempts: Infinity,
+                    backoff: this.#backoff,
+                    shouldRetry: (error) => !isPermanentAuthError(error),
+                    signal: this.signal
+                });
+            }
+            catch (error) {
+                // The connect phase exhausted its retries or hit a permanent failure (a vetoed auth error), or the socket was aborted mid-connect. When the socket is already
+                // aborted, this is orderly teardown - stay quiet and exit. Otherwise classify the connection as permanently failed, abort the socket so `stdout()` terminates,
+                // and surface an actionable error. The signal's aborted state changes asynchronously while `await retry(...)` is in flight, so the loop-condition narrowing the
+                // compiler applies here does not reflect the runtime value.
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                if (this.signal.aborted) {
+                    return;
+                }
+                this.#log.error("Unable to connect to the Homebridge log stream: %s.", formatErrorMessage(error));
+                this.#controller.abort(new HbpuAbortError("failed", { cause: error }));
+                return;
+            }
+            // Stream until the session ends (peer close, error, watchdog timeout, or socket abort). When it returns, loop to reconnect unless the socket itself was aborted.
+            // eslint-disable-next-line no-await-in-loop
+            await this.#stream(session);
+        }
+    }
+    // Connect phase. Re-acquires a fresh token, opens the WebSocket, awaits the Engine.IO open handshake (capturing its ping cadence), joins the `/log` namespace, and
+    // emits `tail-log`. Resolves with the live session once `tail-log` has been emitted; rejects on any handshake fault (WebSocket error, CONNECT_ERROR, peer close, or
+    // attempt abort), so `retry` governs the backoff. A per-attempt controller composed under the attempt signal ensures a failed attempt's WebSocket and listeners are
+    // torn down before the next attempt opens a new one; on success that same controller becomes the session controller, so the streaming phase shares the teardown path.
+    async #connect(attemptSignal) {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const token = await this.#tokenProvider(attemptSignal);
+            const url = socketUrl({ host: this.#host, port: this.#port, tls: this.#tls, token });
+            const controller = new AbortController();
+            const composed = composeSignals(attemptSignal, controller.signal);
+            const ws = this.#webSocketFactory(url);
+            // Capture the Engine.IO open handshake's ping cadence so the streaming phase can size the liveness watchdog from the server's real cadence rather than a guess.
+            let pingInterval = 0;
+            let pingTimeout = 0;
+            // The connect handshake is a one-shot promise resolved by the message handler once `tail-log` has been emitted, or rejected by an error / close / CONNECT_ERROR /
+            // abort.
+            const { promise: connected, resolve, reject } = Promise.withResolvers();
+            // Tear down this attempt's WebSocket when the composed signal aborts (attempt abort or our own controller abort), and reject the connect promise so a pending
+            // handshake unwinds. The `using` disposer removes the listener when this method's scope exits.
+            const _abortRegistration = __addDisposableResource(env_2, onAbort(composed, () => {
+                reject(composed.reason);
+                this.#closeWebSocket(ws);
+            }), false);
+            ws.addEventListener("error", (event) => {
+                reject(new HbpuAbortError("failed", { cause: this.#describeWsError(event) }));
+            });
+            ws.addEventListener("close", (event) => {
+                // A close during the connect handshake is a connect-phase failure (the server hung up before we finished joining the namespace); reject so `retry` backs off.
+                reject(new HbpuAbortError("closed", { cause: { code: event.code } }));
+            });
+            ws.addEventListener("message", (event) => {
+                if (typeof event.data !== "string") {
+                    return;
+                }
+                const decoded = decodeFrame(event.data);
+                switch (decoded.kind) {
+                    case "open": {
+                        // The Engine.IO handshake. Record the ping cadence and join the `/log` namespace; the server replies with a namespace CONNECT acknowledgement (or a
+                        // CONNECT_ERROR).
+                        pingInterval = decoded.pingInterval;
+                        pingTimeout = decoded.pingTimeout;
+                        ws.send(encodeFrame({ kind: "connect", namespace: LOG_NAMESPACE }));
+                        return;
+                    }
+                    case "namespaceConnect": {
+                        // The namespace is joined. Request the tail with the advertised PTY geometry, then consider the handshake complete - from here the server streams `stdout`.
+                        ws.send(encodeFrame({ args: { cols: PTY_COLUMNS, rows: PTY_ROWS }, event: "tail-log", kind: "event", namespace: LOG_NAMESPACE }));
+                        resolve();
+                        return;
+                    }
+                    case "namespaceError": {
+                        // The server rejected the namespace join (a Socket.IO CONNECT_ERROR, commonly an auth failure on a stale or invalid token). How we classify it depends on
+                        // whether the backing credential can mint a fresh token on the next attempt. With a refreshable credential (password/noauth) the next reconnect re-auths from
+                        // the stored credentials, so this is a transient connect-phase failure and we surface it as a plain `HbpuAbortError("failed")` that `retry` governs. With
+                        // a static `token` credential there is nothing to refresh, so retrying the same rejected token would loop forever; we raise a PERMANENT `LogAuthError` instead,
+                        // so the connect-phase `shouldRetry` veto (`!isPermanentAuthError`) makes the socket fail fast with an actionable error rather than spinning on a doomed token.
+                        if (this.#refreshable) {
+                            reject(new HbpuAbortError("failed", { cause: { reason: decoded.reason } }));
+                            return;
+                        }
+                        reject(new LogAuthError("Authentication rejected; the token cannot be refreshed - provide a fresh --token or use --user/--pass.", { cause: { reason: decoded.reason }, kind: "permanent" }));
+                        return;
+                    }
+                    default: {
+                        // ping/pong/message/unknown during the handshake are not part of the connect sequence; ignore them. The server does not stream `stdout` until `tail-log` is
+                        // emitted, so a `message` before that is not expected, but ignoring it is harmless.
+                        return;
+                    }
+                }
+            });
+            // Await the handshake. On any failure path - a WebSocket error, a CONNECT_ERROR, a peer close mid-handshake, or an attempt abort - close this attempt's WebSocket so
+            // a failed attempt never leaks its connection before `retry` opens the next one. The `using` abort registration handles the abort path's close; this catch covers
+            // the listener-driven rejections (error / close / CONNECT_ERROR) where the composed signal did not abort.
+            try {
+                await connected;
+            }
+            catch (error) {
+                this.#closeWebSocket(ws);
+                throw error;
+            }
+            return { closed: false, controller, pingInterval, pingTimeout, ws };
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
+        }
+    }
+    // Streaming phase. The session is connected; split `stdout` chunks into lines and route them into the bounded queue, answer pings with pongs and re-arm the liveness
+    // watchdog, and end the session on close / error / watchdog timeout. Resolves when the session's signal aborts - which the outer loop reads to decide whether to
+    // reconnect. The watchdog window is sized from the server's advertised ping cadence plus a margin; the watchdog uses real timers (no `Clock` seam), so tests drive it
+    // with `mock.timers`.
+    async #stream(session) {
+        const env_3 = { stack: [], error: void 0, hasError: false };
+        try {
+            this.#session = session;
+            const composed = composeSignals(this.signal, session.controller.signal);
+            // The per-session line splitter. The server delivers `stdout` events as raw text chunks whose boundaries do not align with log lines; the splitter reassembles lines
+            // across chunk boundaries and normalizes the mixed newline conventions. It is per-session (a fresh connection starts with a clean carry) and is flushed on session
+            // close so the final line - which the splitter withholds when a chunk ends on a lone line-feed pending a possible cross-chunk pair - surfaces rather than stranding.
+            const splitter = new LogLineSplitter();
+            // The liveness watchdog, sized from the server's advertised ping cadence captured during the connect handshake: one ping interval plus the ping timeout plus a fixed
+            // margin, so a single late ping does not trip it. A zero/absent cadence (malformed handshake) falls back to the margin alone. Each inbound ping re-arms it; if the
+            // window lapses with no ping, it aborts the SESSION (not the whole socket), so the outer loop reconnects. The watchdog uses real timers (no `Clock` seam), so tests
+            // drive its firing with `node:test` `mock.timers`.
+            const windowMs = ((session.pingInterval > 0) ? session.pingInterval : 0) + ((session.pingTimeout > 0) ? session.pingTimeout : 0) + MARGIN_MS;
+            const watchdog = new Watchdog({ onFire: () => session.controller.abort(new HbpuAbortError("timeout")), signal: composed, timeoutMs: windowMs });
+            // A single resolver settled when the session ends so this method awaits the session lifetime without a busy loop. `onAbort` settles it on session abort; the message
+            // and close handlers drive the session controller, which aborts the composed signal, which fires this.
+            const { promise: ended, resolve: endSession } = Promise.withResolvers();
+            const _watchdog = __addDisposableResource(env_3, watchdog, false);
+            const _abortRegistration = __addDisposableResource(env_3, onAbort(composed, () => endSession()), false);
+            // Arm the watchdog immediately so a session that never receives a single ping (a silently-wedged connection) still trips the liveness timer; each inbound ping
+            // re-arms it from here.
+            watchdog.arm();
+            session.ws.addEventListener("message", (event) => {
+                this.#handleStreamMessage(session, watchdog, splitter, event.data);
+            });
+            session.ws.addEventListener("close", (event) => {
+                // The peer closed the connection. End the session with `"closed"` so the outer loop reconnects (the socket-level signal is untouched, so this is a session end,
+                // not a socket end).
+                if (!session.controller.signal.aborted) {
+                    session.controller.abort(new HbpuAbortError("closed", { cause: { code: event.code } }));
+                }
+            });
+            session.ws.addEventListener("error", (event) => {
+                if (!session.controller.signal.aborted) {
+                    session.controller.abort(new HbpuAbortError("failed", { cause: this.#describeWsError(event) }));
+                }
+            });
+            await ended;
+            // Flush the splitter on session end so the final line - withheld by the splitter when the last chunk ended on a lone line-feed pending a possible cross-chunk pair -
+            // surfaces rather than stranding. This is the load-bearing flush the wiring note calls for; mid-stream the next chunk drains the carry, but at session close no next
+            // chunk arrives.
+            for (const line of splitter.flush()) {
+                this.#enqueueStdout(line);
+            }
+            // Tear down the session's WebSocket on the way out: send the namespace DISCONNECT only when still OPEN, then always close(1000). Clearing `#session` prevents a stale
+            // reference from leaking into the next iteration's teardown.
+            this.#closeSession(session);
+            if (this.#session === session) {
+                this.#session = undefined;
+            }
+        }
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
+        }
+        finally {
+            __disposeResources(env_3);
+        }
+    }
+    // Handle a message in the streaming phase. A ping is answered with a pong and re-arms the liveness watchdog (each ping is the server's heartbeat). A `stdout` message's
+    // payload is a raw log-text chunk; it is fed through the per-session splitter and every complete line it yields is enqueued for the consumer (the server's chunk
+    // boundaries do not align with log lines, so splitting must happen here, before the bounded queue).
+    #handleStreamMessage(session, watchdog, splitter, data) {
+        if (typeof data !== "string") {
+            return;
+        }
+        const event = decodeFrame(data);
+        switch (event.kind) {
+            case "ping": {
+                // Answer the heartbeat and re-arm the liveness watchdog. Re-arming on each ping is the liveness contract: as long as pings keep arriving, the watchdog never
+                // fires.
+                session.ws.send(encodeFrame({ kind: "pong" }));
+                watchdog.arm();
+                return;
+            }
+            case "message": {
+                // A namespace event. The log stream's only event is `stdout`, whose payload is a raw text chunk; split it into lines and enqueue each for the consumer. Any other
+                // event name is ignored.
+                if ((event.event === "stdout") && (typeof event.payload === "string")) {
+                    for (const line of splitter.consume(event.payload)) {
+                        this.#enqueueStdout(line);
+                    }
+                }
+                return;
+            }
+            default: {
+                // open / pong / namespaceConnect / namespaceError / unknown in the streaming phase are not actionable here; ignore them.
+                return;
+            }
+        }
+    }
+    // Enqueue a complete log line for the `stdout()` consumer, enforcing the high-water bound. When the queue is at capacity the OLDEST line is dropped (a live tail cares
+    // about recent output, not stale backlog), the drop counter is incremented, and a single warning is logged so a chronically-slow consumer learns it is lossy without
+    // the log being flooded. Resolving the parked waiter wakes a blocked consumer.
+    #enqueueStdout(line) {
+        if (this.#stdoutQueue.length >= this.#stdoutHighWater) {
+            this.#stdoutQueue.shift();
+            this.#droppedLines++;
+            if (!this.#overflowLogged) {
+                this.#overflowLogged = true;
+                this.#log.warn("The Homebridge log stream is producing output faster than it is being consumed; the oldest buffered lines are being dropped.");
+            }
+        }
+        this.#stdoutQueue.push(line);
+        this.#stdoutWaiter?.resolve();
+    }
+    // Render a WebSocket `"error"` event for diagnostics. The DOM error event carries no structured detail; a Node `ws` error event may carry an `error` field. We surface
+    // whichever is present, falling back to a generic label, so the abort cause is at least minimally informative.
+    #describeWsError(event) {
+        if ((typeof event === "object") && (event !== null) && ("error" in event)) {
+            return event.error;
+        }
+        return new Error("WebSocket connection error.");
+    }
+    // Close a session's WebSocket cleanly: send the namespace DISCONNECT (`41/log,`) only when the connection is still OPEN, then ALWAYS issue `close(1000)`. Idempotent
+    // via the session's one-shot `closed` latch - both the streaming phase's post-end cleanup and the socket-level teardown can reach the same live session, and the latch
+    // ensures the DISCONNECT-and-close sequence runs exactly once. The readyState gate avoids a send on a half-closed connection; the unconditional close is the teardown
+    // invariant.
+    #closeSession(session) {
+        if (session.closed) {
+            return;
+        }
+        session.closed = true;
+        if (session.ws.readyState === WEBSOCKET_OPEN) {
+            try {
+                session.ws.send("41" + LOG_NAMESPACE_PATH + ",");
+            }
+            catch {
+                // A send on a connection that closed between the readyState check and here is harmless; the close below is what matters.
+            }
+        }
+        this.#closeWebSocket(session.ws);
+    }
+    // Issue the orderly WebSocket close, swallowing any throw (closing an already-closed or still-connecting socket can throw on some platforms). `close(1000)` is the
+    // normal-closure code; teardown always sends it so the server sees a clean disconnect.
+    #closeWebSocket(ws) {
+        try {
+            ws.close(1000);
+        }
+        catch {
+            // Closing a socket that is already closed (or in a state where close throws) is a no-op for our purposes.
+        }
+    }
+    // Single teardown convergence point, fired exactly once when `this.signal` aborts. Closes the live session's WebSocket (sending the namespace DISCONNECT if OPEN, then
+    // always close(1000)) and settles the parked stdout waiter so the consumer's `stdout()` generator wakes, drains the queue, and returns. The reconnect loop observes the
+    // aborted signal and exits on its next iteration boundary; the watchdog self-cleans through its own composed-signal listener.
+    #teardown() {
+        if (this.#session !== undefined) {
+            this.#closeSession(this.#session);
+            this.#session = undefined;
+        }
+        this.#stdoutWaiter?.resolve();
+    }
+}
+/**
+ * The production {@link LogSocketFactory}: builds the concrete WebSocket-backed {@link LogSocket}. A client holds the factory typed as the seam abstraction; a test
+ * substitutes a fake factory. `create` is exactly the {@link LogSocket} constructor call, so wiring construction through this seam is behavior-neutral.
+ *
+ * @category Log Client
+ */
+export const logSocketFactory = {
+    create: (init) => new LogSocket(init)
+};
+//# sourceMappingURL=socket.js.map

package/dist/logclient/socket.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket.js","sourceRoot":"","sources":["../../src/logclient/socket.ts"],"names":[],"mappings":"AAAA;;;GAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACpJ,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,cAAc,EAAE,kBAAkB,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAC1G,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAE/D,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,wKAAwK;AACxK,sKAAsK;AACtK,8JAA8J;AAC9J,MAAM,yBAAyB,GAAG,KAAK,CAAC;AAgDxC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC;AAEhC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAqB,CAAC,GAAW,EAAiB,EAAE,CAAC,IAAI,SAAS,CAAC,GAAG,CAAC,CAAC;AAuCrG,qKAAqK;AACrK,sKAAsK;AACtK,4EAA4E;AAC5E,SAAS,UAAU,CAAC,IAAY,EAAE,MAAoB;IAEpD,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,IAAI,GAAG,eAAe,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAAe,EAAE,SAAuB,IAAI,CAAC,MAAM;IAElF,OAAO,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,gBAAgB,EAAE,iBAAiB,GAAG,CAAC,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AAClG,CAAC;AA2ED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,OAAO,SAAS;IAEpB;;;OAGG;IACa,MAAM,CAAc;IAEpC,4HAA4H;IACnH,WAAW,CAAkB;IAE7B,QAAQ,CAA8B;IACtC,KAAK,CAAS;IACd,IAAI,CAA0B;IAC9B,KAAK,CAAS;IACd,OAAO,CAAe;IACtB,YAAY,CAAU;IACtB,gBAAgB,CAAS;IACzB,IAAI,CAAU;IACd,cAAc,CAAgB;IAC9B,iBAAiB,CAAmB;IAE7C,uKAAuK;IACvK,oGAAoG;IACpG,YAAY,GAAa,EAAE,CAAC;IAC5B,aAAa,CAAyC;IAEtD,sKAAsK;IACtK,8FAA8F;IAC9F,aAAa,GAAG,CAAC,CAAC;IAClB,eAAe,GAAG,KAAK,CAAC;IAExB,0HAA0H;IAC1H,SAAS,CAA4B;IAErC,uKAAuK;IACvK,+BAA+B;IAC/B,QAAQ,CAAsB;IAE9B;;;;;OAKG;IACH,YAAmB,IAAmB;QAEpC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC;QACrB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,IAAI,IAAI,YAAY,CAAC;QACvC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC;QAC1C,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC;QACrC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,eAAe,IAAI,yBAAyB,CAAC;QAC1E,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,IAAI,KAAK,CAAC;QAC9B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,aAAa,CAAC;QACzC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,gBAAgB,IAAI,gBAAgB,CAAC;QAEnE,gKAAgK;QAChK,sKAAsK;QACtK,sKAAsK;QACtK,sJAAsJ;QACtJ,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,OAAe,EAAU,EAAE,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QAEvG,IAAI,CAAC,WAAW,GAAG,IAAI,eAAe,EAAE,CAAC;QACzC,IAAI,CAAC,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QAEnE,kKAAkK;QAClK,2IAA2I;QAC3I,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;QAE7C,IAAG,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YAEvB,OAAO;QACT,CAAC;QAED,mKAAmK;QACnK,0DAA0D;QAC1D,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;IACnC,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,MAAgB;QAE3B,IAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YAEhB,OAAO;QACT,CAAC;QAED,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,MAAM,IAAI,IAAI,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;IACnE,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC;QAEhC,IAAI,CAAC,KAAK,EAAE,CAAC;QAEb,IAAG,IAAI,CAAC,SAAS,EAAE,CAAC;YAElB,wJAAwJ;YACxJ,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,GAAmC,CAAC,CAAC,CAAC;QACxE,CAAC;IACH,CAAC;IAED;;OAEG;IACH,IAAW,OAAO;QAEhB,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;IAC7B,CAAC;IAED;;;OAGG;IACH,IAAW,YAAY;QAErB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED;;;;;;;;;;;;;OAaG;IACI,KAAK,CAAC,CAAC,MAAM;QAElB,SAAQ,CAAC;;;gBAEP,gKAAgK;gBAChK,oFAAoF;gBACpF,OAAM,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAEnC,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC;oBAElC,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;oBAEvB,KAAI,MAAM,IAAI,IAAI,OAAO,EAAE,CAAC;wBAE1B,MAAM,IAAI,CAAC;oBACb,CAAC;gBACH,CAAC;gBAED,IAAG,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;oBAEvB,OAAO;gBACT,CAAC;gBAED,kKAAkK;gBAClK,MAAM,MAAM,GAA+B,OAAO,CAAC,aAAa,EAAE,CAAC;gBAEnE,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC;gBAE5B,gKAAgK;gBAChK,8FAA8F;gBAC9F,MAAM,kBAAkB,kCAAG,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,QAAA,CAAC;gBAExE,IAAI,CAAC;oBAEH,4CAA4C;oBAC5C,MAAM,MAAM,CAAC,OAAO,CAAC;gBACvB,CAAC;wBAAS,CAAC;oBAET,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;gBACjC,CAAC;;;;;;;;;SACF;IACH,CAAC;IAED,sKAAsK;IACtK,iKAAiK;IACjK,6CAA6C;IAC7C,KAAK,CAAC,QAAQ;QAEZ,OAAM,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YAE3B,IAAI,OAAgB,CAAC;YAErB,IAAI,CAAC;gBAEH,8JAA8J;gBAC9J,6JAA6J;gBAC7J,8JAA8J;gBAC9J,kKAAkK;gBAClK,+FAA+F;gBAC/F,4CAA4C;gBAC5C,OAAO,GAAG,MAAM,KAAK,CAAC,CAAC,aAAa,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE;oBAErE,QAAQ,EAAE,QAAQ;oBAClB,OAAO,EAAE,IAAI,CAAC,QAAQ;oBACtB,WAAW,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,oBAAoB,CAAC,KAAK,CAAC;oBACpD,MAAM,EAAE,IAAI,CAAC,MAAM;iBACpB,CAAC,CAAC;YACL,CAAC;YAAC,OAAM,KAAc,EAAE,CAAC;gBAEvB,8JAA8J;gBAC9J,+JAA+J;gBAC/J,gKAAgK;gBAChK,4DAA4D;gBAC5D,uEAAuE;gBACvE,IAAG,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;oBAEvB,OAAO;gBACT,CAAC;gBAED,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,qDAAqD,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC;gBAClG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,cAAc,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;gBAEvE,OAAO;YACT,CAAC;YAED,iKAAiK;YACjK,4CAA4C;YAC5C,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,mKAAmK;IACnK,oKAAoK;IACpK,oKAAoK;IACpK,sKAAsK;IACtK,KAAK,CAAC,QAAQ,CAAC,aAA0B;;;YAEvC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC;YACvD,MAAM,GAAG,GAAG,SAAS,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;YAErF,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;YACzC,MAAM,QAAQ,GAAG,cAAc,CAAC,aAAa,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC;YAClE,MAAM,EAAE,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;YAEvC,gKAAgK;YAChK,IAAI,YAAY,GAAG,CAAC,CAAC;YACrB,IAAI,WAAW,GAAG,CAAC,CAAC;YAEpB,kKAAkK;YAClK,SAAS;YACT,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,GAA+B,OAAO,CAAC,aAAa,EAAE,CAAC;YAEpG,8JAA8J;YAC9J,+FAA+F;YAC/F,MAAM,kBAAkB,kCAAG,OAAO,CAAC,QAAQ,EAAE,GAAG,EAAE;gBAEhD,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;gBACxB,IAAI,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC;YAC3B,CAAC,CAAC,QAAA,CAAC;YAEH,EAAE,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC,KAAc,EAAE,EAAE;gBAE9C,MAAM,CAAC,IAAI,cAAc,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;YAChF,CAAC,CAAC,CAAC;YAEH,EAAE,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC,KAAgC,EAAE,EAAE;gBAEhE,8JAA8J;gBAC9J,MAAM,CAAC,IAAI,cAAc,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;YACxE,CAAC,CAAC,CAAC;YAEH,EAAE,CAAC,gBAAgB,CAAC,SAAS,EAAE,CAAC,KAAiC,EAAE,EAAE;gBAEnE,IAAG,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;oBAElC,OAAO;gBACT,CAAC;gBAED,MAAM,OAAO,GAAG,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBAExC,QAAO,OAAO,CAAC,IAAI,EAAE,CAAC;oBAEpB,KAAK,MAAM,CAAC,CAAC,CAAC;wBAEZ,oJAAoJ;wBACpJ,kBAAkB;wBAClB,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;wBACpC,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;wBAClC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC;wBAEpE,OAAO;oBACT,CAAC;oBAED,KAAK,kBAAkB,CAAC,CAAC,CAAC;wBAExB,4JAA4J;wBAC5J,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC;wBAClI,OAAO,EAAE,CAAC;wBAEV,OAAO;oBACT,CAAC;oBAED,KAAK,gBAAgB,CAAC,CAAC,CAAC;wBAEtB,0JAA0J;wBAC1J,8JAA8J;wBAC9J,0JAA0J;wBAC1J,gKAAgK;wBAChK,gKAAgK;wBAChK,IAAG,IAAI,CAAC,YAAY,EAAE,CAAC;4BAErB,MAAM,CAAC,IAAI,cAAc,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAC;4BAE5E,OAAO;wBACT,CAAC;wBAED,MAAM,CAAC,IAAI,YAAY,CAAC,wGAAwG,EAC9H,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC;wBAE7D,OAAO;oBACT,CAAC;oBAED,OAAO,CAAC,CAAC,CAAC;wBAER,4JAA4J;wBAC5J,oFAAoF;wBAEpF,OAAO;oBACT,CAAC;gBACH,CAAC;YACH,CAAC,CAAC,CAAC;YAEH,qKAAqK;YACrK,kKAAkK;YAClK,0GAA0G;YAC1G,IAAI,CAAC;gBAEH,MAAM,SAAS,CAAC;YAClB,CAAC;YAAC,OAAM,KAAc,EAAE,CAAC;gBAEvB,IAAI,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC;gBAEzB,MAAM,KAAK,CAAC;YACd,CAAC;YAED,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC;;;;;;;;;KACrE;IAED,qKAAqK;IACrK,iKAAiK;IACjK,sKAAsK;IACtK,sBAAsB;IACtB,KAAK,CAAC,OAAO,CAAC,OAAgB;;;YAE5B,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;YAExB,MAAM,QAAQ,GAAG,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;YAExE,qKAAqK;YACrK,mKAAmK;YACnK,qKAAqK;YACrK,MAAM,QAAQ,GAAG,IAAI,eAAe,EAAE,CAAC;YAEvC,qKAAqK;YACrK,mKAAmK;YACnK,oKAAoK;YACpK,mDAAmD;YACnD,MAAM,QAAQ,GAAG,CAAC,CAAC,OAAO,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;YAC7I,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAS,EAAE,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,cAAc,CAAC,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAC;YAEtJ,qKAAqK;YACrK,uGAAuG;YACvG,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,GAA+B,OAAO,CAAC,aAAa,EAAE,CAAC;YAEpG,MAAM,SAAS,kCAAG,QAAQ,QAAA,CAAC;YAC3B,MAAM,kBAAkB,kCAAG,OAAO,CAAC,QAAQ,EAAE,GAAG,EAAE,CAAC,UAAU,EAAE,CAAC,QAAA,CAAC;YAEjE,+JAA+J;YAC/J,wBAAwB;YACxB,QAAQ,CAAC,GAAG,EAAE,CAAC;YAEf,OAAO,CAAC,EAAE,CAAC,gBAAgB,CAAC,SAAS,EAAE,CAAC,KAAiC,EAAE,EAAE;gBAE3E,IAAI,CAAC,oBAAoB,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;YACrE,CAAC,CAAC,CAAC;YAEH,OAAO,CAAC,EAAE,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC,KAAgC,EAAE,EAAE;gBAExE,gKAAgK;gBAChK,qBAAqB;gBACrB,IAAG,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;oBAEtC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,cAAc,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;gBAC1F,CAAC;YACH,CAAC,CAAC,CAAC;YAEH,OAAO,CAAC,EAAE,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC,KAAc,EAAE,EAAE;gBAEtD,IAAG,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;oBAEtC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,cAAc,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;gBAClG,CAAC;YACH,CAAC,CAAC,CAAC;YAEH,MAAM,KAAK,CAAC;YAEZ,qKAAqK;YACrK,qKAAqK;YACrK,iBAAiB;YACjB,KAAI,MAAM,IAAI,IAAI,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC;gBAEnC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;YAC5B,CAAC;YAED,sKAAsK;YACtK,6DAA6D;YAC7D,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;YAE5B,IAAG,IAAI,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;gBAE7B,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC;YAC5B,CAAC;;;;;;;;;KACF;IAED,wKAAwK;IACxK,iKAAiK;IACjK,oGAAoG;IACpG,oBAAoB,CAAC,OAAgB,EAAE,QAAkB,EAAE,QAAyB,EAAE,IAAa;QAEjG,IAAG,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YAE5B,OAAO;QACT,CAAC;QAED,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;QAEhC,QAAO,KAAK,CAAC,IAAI,EAAE,CAAC;YAElB,KAAK,MAAM,CAAC,CAAC,CAAC;gBAEZ,6JAA6J;gBAC7J,SAAS;gBACT,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;gBAC/C,QAAQ,CAAC,GAAG,EAAE,CAAC;gBAEf,OAAO;YACT,CAAC;YAED,KAAK,SAAS,CAAC,CAAC,CAAC;gBAEf,kKAAkK;gBAClK,yBAAyB;gBACzB,IAAG,CAAC,KAAK,CAAC,KAAK,KAAK,QAAQ,CAAC,IAAI,CAAC,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ,CAAC,EAAE,CAAC;oBAErE,KAAI,MAAM,IAAI,IAAI,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;wBAElD,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;oBAC5B,CAAC;gBACH,CAAC;gBAED,OAAO;YACT,CAAC;YAED,OAAO,CAAC,CAAC,CAAC;gBAER,yHAAyH;gBAEzH,OAAO;YACT,CAAC;QACH,CAAC;IACH,CAAC;IAED,uKAAuK;IACvK,qKAAqK;IACrK,+EAA+E;IAC/E,cAAc,CAAC,IAAY;QAEzB,IAAG,IAAI,CAAC,YAAY,CAAC,MAAM,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAErD,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;YAC1B,IAAI,CAAC,aAAa,EAAE,CAAC;YAErB,IAAG,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC;gBAEzB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;gBAC5B,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,8HAA8H,CAAC,CAAC;YACjJ,CAAC;QACH,CAAC;QAED,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC7B,IAAI,CAAC,aAAa,EAAE,OAAO,EAAE,CAAC;IAChC,CAAC;IAED,uKAAuK;IACvK,+GAA+G;IAC/G,gBAAgB,CAAC,KAAc;QAE7B,IAAG,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,KAAK,CAAC,EAAE,CAAC;YAEzE,OAAO,KAAK,CAAC,KAAK,CAAC;QACrB,CAAC;QAED,OAAO,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;IAClD,CAAC;IAED,qKAAqK;IACrK,uKAAuK;IACvK,sKAAsK;IACtK,aAAa;IACb,aAAa,CAAC,OAAgB;QAE5B,IAAG,OAAO,CAAC,MAAM,EAAE,CAAC;YAElB,OAAO;QACT,CAAC;QAED,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;QAEtB,IAAG,OAAO,CAAC,EAAE,CAAC,UAAU,KAAK,cAAc,EAAE,CAAC;YAE5C,IAAI,CAAC;gBAEH,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,GAAG,kBAAkB,GAAG,GAAG,CAAC,CAAC;YACnD,CAAC;YAAC,MAAM,CAAC;gBAEP,yHAAyH;YAC3H,CAAC;QACH,CAAC;QAED,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IACnC,CAAC;IAED,mKAAmK;IACnK,uFAAuF;IACvF,eAAe,CAAC,EAAiB;QAE/B,IAAI,CAAC;YAEH,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACjB,CAAC;QAAC,MAAM,CAAC;YAEP,0GAA0G;QAC5G,CAAC;IACH,CAAC;IAED,uKAAuK;IACvK,wKAAwK;IACxK,8HAA8H;IAC9H,SAAS;QAEP,IAAG,IAAI,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;YAE/B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAClC,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC;QAC5B,CAAC;QAED,IAAI,CAAC,aAAa,EAAE,OAAO,EAAE,CAAC;IAChC,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAqB;IAEhD,MAAM,EAAE,CAAC,IAAmB,EAAiB,EAAE,CAAC,IAAI,SAAS,CAAC,IAAI,CAAC;CACpE,CAAC"}