@trillboards/edge-sdk 0.2.19 → 0.2.21

package/dist/connectorUpdate.d.ts

@@ -0,0 +1,369 @@
+/**
+ * connectorUpdate — the CONSUMER the published version manifest never had.
+ *
+ * Every release publishes `trillboards-connector-<platform>.version.json` to the
+ * CDN with `connectorVersion`, `gitSha`, `sha256`, `sizeBytes` and `publishedAt`.
+ * Until this module existed, repo-wide the ONLY references to that object were
+ * the workflow that writes it, a test asserting the workflow writes it, and a
+ * README line. It was a producer with no consumer — the mirror image of the
+ * defect class in `docs/runbooks/telemetry-producer-substrate.md`, and just as
+ * invisible: the artifact that says "you are out of date" was published,
+ * correct, and read by nobody, so a field fix reached a customer only when that
+ * customer happened to re-download 2.6 GB and re-run the installer.
+ *
+ * THIS FILE ONLY CHECKS AND REPORTS. Applying an update is a separate,
+ * platform-specific transaction — see `deploy/windows/apply-update.ps1` and
+ * `connectorUpdateApply.ts`. The split is deliberate: "am I stale?" is a
+ * question every platform can answer over one 401-byte GET, while "swap the
+ * running binaries" is a Windows scheduled-task transaction with a rollback.
+ *
+ * ── WHY A 200 IS NOT AN ANSWER ──────────────────────────────────────────────
+ * The CDN in front of these objects serves the marketing SPA as its default
+ * behavior, so a MISSING manifest answers `HTTP 200 text/html`, not 404. Proved
+ * against production while writing this:
+ *
+ *   $ curl -o /dev/null -w '%{http_code} %{content_type}\n' \
+ *       .../connector/this-file-does-not-exist-control.json
+ *   200 text/html
+ *
+ * That is the exact shape of `.claude/lessons/2026-08-14-a-broken-probe-and-a-
+ * true-absence-are-the-same-bytes.md`. So the check is not "did the GET
+ * succeed"; it is "did the body parse as a manifest whose every required field
+ * is present and well-formed". A body that fails that test yields `null` —
+ * meaning UNKNOWN — and `null` is never rendered as "up to date". A staleness
+ * oracle that reports "current" when it cannot reach its own oracle is worse
+ * than no oracle at all.
+ *
+ * For the same reason `parseConnectorVersion` is STRICT rather than lenient.
+ * `edge-core`'s ModelManager parses versions with `.split('.').map(Number)` and
+ * `|| 0`, so a non-numeric version silently becomes `0.0.0` and every later
+ * comparison quietly answers "not newer" — forever, with no error anywhere. A
+ * version we cannot parse is a manifest we do not trust.
+ */
+import { reportConnectorStatus } from './ConnectorStatusClient';
+import type { ConnectorUpdateApplier } from './connectorUpdateApply';
+/** Where the release workflows publish every platform's manifest. */
+export declare const CONNECTOR_UPDATE_BASE_URL = "https://screen.trillboards.com/connector";
+/**
+ * How often an install asks whether it is stale.
+ *
+ * Six hours. The GET is ~401 bytes, so the poll itself costs nothing, and the
+ * release workflow fires on every `production` push touching the edge
+ * workspaces (measured: 15 releases on 2026-08-13, 13 on 08-12), so a shorter
+ * period would only discover the same churn sooner. The FIRST check is deferred
+ * one whole interval, matching `ModelManager.start()` — a connector in a crash
+ * loop must not turn into a CDN hammer, and a machine that just installed is by
+ * definition current.
+ */
+export declare const CONNECTOR_UPDATE_CHECK_INTERVAL_MS: number;
+/**
+ * How old a release must be before an install will TAKE it.
+ *
+ * There is no canary ring in front of this. With ~13 releases a day reaching a
+ * fleet that auto-applies, a bad connector would be on every customer's PC
+ * within one check period, and the only recovery is another release. A bake
+ * window is the cheapest thing standing between "we merged a regression" and
+ * "every store stopped sensing", and it costs a fix at most one extra check.
+ *
+ * `publishedAt` comes from the manifest, i.e. from the same channel as the
+ * payload, so this is a release-hygiene control and NOT a security control. The
+ * security control is the Authenticode verification in the applier.
+ */
+export declare const CONNECTOR_UPDATE_MIN_RELEASE_AGE_MS: number;
+/**
+ * The published manifest, after strict validation.
+ *
+ * `updateUrl`/`updateCatalogUrl` are the code-only update payload and its
+ * Authenticode-signed hash catalog. They are OPTIONAL because a manifest
+ * published before the applier shipped carries neither, and an install that
+ * finds a newer version with no update payload must report the drift rather
+ * than fail — reporting is the half that works on every platform.
+ */
+export interface ConnectorVersionManifest {
+    schemaVersion: number;
+    platform: string;
+    connectorVersion: string;
+    gitSha: string;
+    sha256: string;
+    sizeBytes: number;
+    publishedAt: string;
+    downloadUrl: string;
+    updateUrl?: string;
+    updateCatalogUrl?: string;
+}
+/** A parsed `MAJOR.MINOR.PATCH`. */
+export interface ParsedConnectorVersion {
+    major: number;
+    minor: number;
+    patch: number;
+}
+/**
+ * Parse `MAJOR.MINOR.PATCH` (an optional leading `v`, an optional `-prerelease`
+ * or `+build` suffix that is IGNORED for ordering). Returns null — never a
+ * zeroed struct — for anything else.
+ */
+export declare function parseConnectorVersion(raw: unknown): ParsedConnectorVersion | null;
+/**
+ * Is `available` strictly newer than `installed`?
+ *
+ * FALSE whenever either side fails to parse. That direction is deliberate: an
+ * unparseable version must never authorise a swap of the running binaries. It
+ * also makes a DOWNGRADE impossible, which is the whole defence against a CDN
+ * that has been rolled back to an older (but still validly signed) payload.
+ */
+export declare function isNewerConnectorVersion(available: unknown, installed: unknown): boolean;
+/**
+ * The manifest object name for a platform, or null where no manifest is
+ * published. Linux has no packaged connector release and therefore no manifest;
+ * returning null keeps a Linux install from polling a URL that would answer 200
+ * with the marketing SPA on every check, forever.
+ */
+export declare function manifestObjectForPlatform(platform: string): string | null;
+/** Full manifest URL for a platform, or null. */
+export declare function manifestUrlForPlatform(platform: string, baseUrl?: string): string | null;
+/**
+ * Strictly validate a manifest body. Returns null when ANY required field is
+ * absent or malformed — including when the body is the CDN's HTML SPA fallback,
+ * which is what a deleted manifest looks like over the wire.
+ */
+export declare function parseVersionManifest(body: string): ConnectorVersionManifest | null;
+/** Injectable transport so tests never touch the network. */
+export type ManifestFetcher = (url: string, timeoutMs: number) => Promise<{
+    statusCode: number;
+    body: string;
+}>;
+/**
+ * GET a small public object with a HARD byte cap.
+ *
+ * Deliberately not `AudienceAnalyzeClient`'s `defaultHttpPoster`: that one is a
+ * POST-shaped transport that concatenates every chunk with no ceiling, which is
+ * fine for an API we authenticate to and wrong for an unauthenticated public
+ * object whose expected size is 401 bytes. A response that keeps coming is
+ * destroyed rather than buffered.
+ *
+ * `Cache-Control: no-cache` + `Pragma: no-cache` are belt-and-braces. The object
+ * is published `no-cache, no-store, must-revalidate` precisely because it is the
+ * staleness oracle, but an intercepting corporate proxy is not obliged to
+ * honour a response header, and a cached manifest reports the PREVIOUS release
+ * as current for the whole TTL.
+ */
+export declare const defaultManifestFetcher: ManifestFetcher;
+/** Reads the published manifest for one platform. */
+export declare class ConnectorManifestClient {
+    private readonly url;
+    private readonly timeoutMs;
+    private readonly fetcher;
+    constructor(options: {
+        platform: string;
+        baseUrl?: string;
+        timeoutMs?: number;
+    }, fetcher?: ManifestFetcher);
+    /** The resolved URL, or null on a platform that publishes no manifest. */
+    getEndpoint(): string | null;
+    /**
+     * The published manifest, or null for UNKNOWN — no platform manifest, a
+     * transport failure, a non-2xx, or a body that is not a valid manifest (the
+     * SPA-fallback case). Never throws; the caller keeps sensing either way.
+     */
+    fetchManifest(): Promise<ConnectorVersionManifest | null>;
+}
+/**
+ * What the connector is holding right now, as far as an update is concerned.
+ *
+ * Both numbers are read straight off `CloudSensingManager.getSensingHealth()`;
+ * nothing new is written or counted to support this.
+ */
+export interface ConnectorBusyness {
+    /** Analyses the admission gate has admitted and not yet released. */
+    inFlight: number;
+    /** Flagged frames the candidate buffer is holding for a free slot. */
+    buffered: number;
+}
+/**
+ * Is this a moment at which the connector may be stopped and replaced?
+ *
+ * The two quantities are the connector's IRRECOVERABLE work:
+ *
+ *  - `inFlight` — a frame the model is answering, or a POST in flight. There is
+ *    no store-and-forward on the Windows connector (`SignalBuffer` is
+ *    constructed only in `EdgeAgent`, which the Windows task never runs), so a
+ *    kill here loses that observation permanently.
+ *  - `buffered` — frames the motion cascade has ALREADY decided are
+ *    interesting: a person entering a restricted area, a spill, a fall. At a
+ *    30 s scan cadence the next look is a different event. `CloudSensingManager
+ *    .stop()` calls `candidates.reset()`, so these die on ANY stop, graceful or
+ *    not — stopping while the buffer is loaded is the dropped-alert failure, and
+ *    it is a product failure, not an implementation detail.
+ *
+ * NOT covered, and stated rather than hidden: a tick can be between
+ * `camera.getFrame()` and the admission gate — mid-decode, mid-motion-eval —
+ * with `inFlight === 0`, because on the cascade path the ticket is not taken
+ * until after the motion verdict. `LoopState.tickInFlight` is private and
+ * exposed nowhere. Losing that frame costs one SAMPLE that the cascade has not
+ * yet judged interesting, which is a different and much smaller loss than a
+ * flagged candidate, and the next tick captures a fresher frame. Widening the
+ * health struct to close it was judged not worth the blast radius.
+ */
+export declare function isSafeToApplyUpdate(busyness: ConnectorBusyness): boolean;
+/**
+ * Map a `getSensingHealth()` reading onto the two numbers that matter. Tolerant
+ * of a partial shape so a test fake or a future manager cannot crash the
+ * watcher; an absent field reads as 0, i.e. "not holding anything", which is
+ * only ever reached by a manager that has no buffer to hold anything in.
+ */
+export declare function busynessOf(health: {
+    inFlight?: number;
+    candidateBuffer?: {
+        buffered?: number;
+    };
+} | null | undefined): ConnectorBusyness;
+/** Has this release sat long enough to be taken? */
+export declare function isReleaseBakedEnough(manifest: ConnectorVersionManifest, nowMs: number, minAgeMs?: number): boolean;
+/** What one check concluded. */
+export interface ConnectorUpdateCheck {
+    installedVersion: string;
+    /** The published version, or null when the manifest could not be read. */
+    publishedVersion: string | null;
+    /** Published AND strictly newer than installed. Null when unknown. */
+    availableVersion: string | null;
+    /** The manifest itself, when it parsed. */
+    manifest: ConnectorVersionManifest | null;
+}
+/**
+ * One check: read the manifest, decide whether this install is behind.
+ *
+ * `availableVersion` is null both when the install is current AND when the
+ * manifest could not be read — but `publishedVersion` distinguishes them, so a
+ * caller that must not conflate "current" with "unknown" can.
+ */
+export declare function checkForConnectorUpdate(installedVersion: string, client: ConnectorManifestClient): Promise<ConnectorUpdateCheck>;
+/**
+ * Delay before the FIRST check.
+ *
+ * `ModelManager` defers its first check a whole hour, and that is right for a
+ * 2.4 GB model download. It is wrong here: this GET is 401 bytes, and deferring
+ * it six hours would mean a store PC that reboots nightly never reports its
+ * version at all — the fleet view would be blind to exactly the machines most
+ * likely to be stale. Sixty seconds is long enough for sensing to come up first
+ * and short enough that every start contributes a report.
+ *
+ * A fresh release still cannot be applied on that first check: the bake window
+ * is enforced separately, on `publishedAt`.
+ */
+export declare const CONNECTOR_UPDATE_INITIAL_DELAY_MS = 60000;
+/** How often the apply state machine looks at the world while an update is in flight. */
+export declare const CONNECTOR_UPDATE_POLL_INTERVAL_MS = 60000;
+/**
+ * How long to wait for staging to finish before giving up on this attempt.
+ *
+ * An hour. The payload is ~200 MB, and a store uplink is the slow case this
+ * number is for. Giving up is not a failure — the next check re-stages.
+ */
+export declare const CONNECTOR_UPDATE_STAGE_DEADLINE_MS: number;
+/**
+ * How long to wait for a safe point before applying anyway.
+ *
+ * Two hours, and the branch matters. On a saturated multi-camera install the
+ * candidate buffer may never reach zero — measured on a 24 h 32-camera
+ * simulation, 89,056 of 92,160 candidates were EVICTED, i.e. the buffer is
+ * permanently full and those frames are already being dropped by the buffer's
+ * own fairness bound. Waiting forever for a quiet moment on such a machine
+ * would mean it never receives another fix, which is the strictly worse
+ * outcome. So: take the first genuinely quiet moment; failing that, accept the
+ * loss after two hours and record which branch was taken.
+ */
+export declare const CONNECTOR_UPDATE_SAFE_POINT_DEADLINE_MS: number;
+/** Handle returned by the service, mirroring `GemmaModelOtaHandle`. */
+export interface ConnectorUpdateWatcherHandle {
+    stop(): void;
+}
+export interface ConnectorUpdateServiceDeps {
+    /** This install's version (`require('../package.json').version`). */
+    installedVersion: string;
+    /** `process.platform` in production; injected in tests. */
+    platform: string;
+    /** Where to report the version. */
+    apiBaseUrl: string;
+    /** One token per paired feed; each binds to its own screen. */
+    deviceTokens: string[];
+    /**
+     * The connector's current irrecoverable-work reading. Omit to CHECK and
+     * REPORT without ever applying — which is what every platform but Windows
+     * does, and what a caller with no manager to ask should do.
+     */
+    busyness?: () => ConnectorBusyness;
+    /**
+     * Stop sensing cleanly and end the process, handing the machine to the
+     * applier. Defaults to a bare `process.exit(0)`; the CLI entrypoints pass
+     * their existing shutdown closure so cameras are closed first.
+     */
+    requestExit?: () => void;
+    /** Windows applier. Omit (or pass null) to check and report only. */
+    applier?: ConnectorUpdateApplier | null;
+    log?: (message: string) => void;
+    client?: ConnectorManifestClient;
+    intervalMs?: number;
+    initialDelayMs?: number;
+    pollIntervalMs?: number;
+    stageDeadlineMs?: number;
+    safePointDeadlineMs?: number;
+    minReleaseAgeMs?: number;
+    now?: () => number;
+    reportStatus?: typeof reportConnectorStatus;
+    setTimeoutFn?: typeof setTimeout;
+    clearTimeoutFn?: typeof clearTimeout;
+    setIntervalFn?: typeof setInterval;
+    clearIntervalFn?: typeof clearInterval;
+}
+/**
+ * The whole update loop: check the manifest, tell the server where this install
+ * stands, and — on Windows, with a verified payload and a quiet moment — apply.
+ *
+ * Every branch is best-effort. A failed check, a failed report, an applier that
+ * will not launch: each is one log line, and sensing continues. The one thing
+ * this must never do is stop the connector for any reason other than a
+ * deliberate, verified handoff.
+ */
+export declare function startConnectorUpdateService(deps: ConnectorUpdateServiceDeps): ConnectorUpdateWatcherHandle | null;
+/**
+ * Every device token this install holds, de-duplicated.
+ *
+ * One token per feed, because a token binds to exactly one screen — so a
+ * 16-camera store reports 16 times and every screen's row carries the version
+ * of the one connector serving it. Structurally typed rather than importing
+ * `EdgeAgentConfig` so this stays testable without a config file on disk.
+ */
+export declare function connectorDeviceTokens(config: {
+    deviceToken?: string;
+    cameras?: Array<{
+        deviceToken?: string;
+    }> | null;
+}): string[];
+/**
+ * The one call every long-running sensing entrypoint makes.
+ *
+ * Deliberately NOT wired inside `buildCloudSensingManager`/
+ * `buildLocalSensingManager`: `auto-sense` builds BOTH managers and caches them,
+ * so a watcher created per manager would give that mode two update loops racing
+ * each other into the same swap. It belongs to the PROCESS, so it is started
+ * once per entrypoint.
+ *
+ * `combinedSense` (`sense`) is deliberately absent: the Windows task's
+ * `ValidateSet` admits only auto-sense/local-sense/cloud-sense, so that mode
+ * never runs on the platform this applies to.
+ */
+export declare function startConnectorUpdates(opts: {
+    config: {
+        apiBaseUrl?: string;
+        deviceToken?: string;
+        cameras?: Array<{
+            deviceToken?: string;
+        }> | null;
+    };
+    installedVersion: string;
+    busyness?: () => ConnectorBusyness;
+    requestExit?: () => void;
+    log?: (msg: string) => void;
+    platform?: string;
+}): ConnectorUpdateWatcherHandle | null;
+//# sourceMappingURL=connectorUpdate.d.ts.map

package/dist/connectorUpdate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectorUpdate.d.ts","sourceRoot":"","sources":["../src/connectorUpdate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAIH,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAErE,qEAAqE;AACrE,eAAO,MAAM,yBAAyB,6CAA6C,CAAC;AAEpF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kCAAkC,QAAqB,CAAC;AAErE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mCAAmC,QAAqB,CAAC;AAQtE;;;;;;;;GAQG;AACH,MAAM,WAAW,wBAAwB;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,oCAAoC;AACpC,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,sBAAsB,GAAG,IAAI,CAKjF;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,GAAG,OAAO,CAOvF;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIzE;AAED,iDAAiD;AACjD,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,MAAkC,GAC1C,MAAM,GAAG,IAAI,CAIf;AAMD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,wBAAwB,GAAG,IAAI,CAoClF;AAED,6DAA6D;AAC7D,MAAM,MAAM,eAAe,GAAG,CAC5B,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,KACd,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEnD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,sBAAsB,EAAE,eA4CjC,CAAC;AAEL,qDAAqD;AACrD,qBAAa,uBAAuB;IAClC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAgB;IACpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkB;gBAGxC,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,EACnE,OAAO,CAAC,EAAE,eAAe;IAO3B,0EAA0E;IAC1E,WAAW,IAAI,MAAM,GAAG,IAAI;IAI5B;;;;OAIG;IACG,aAAa,IAAI,OAAO,CAAC,wBAAwB,GAAG,IAAI,CAAC;CAWhE;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,qEAAqE;IACrE,QAAQ,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAExE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,GACxF,iBAAiB,CAOnB;AAED,oDAAoD;AACpD,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,wBAAwB,EAClC,KAAK,EAAE,MAAM,EACb,QAAQ,GAAE,MAA4C,GACrD,OAAO,CAMT;AAED,gCAAgC;AAChC,MAAM,WAAW,oBAAoB;IACnC,gBAAgB,EAAE,MAAM,CAAC;IACzB,0EAA0E;IAC1E,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,sEAAsE;IACtE,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,2CAA2C;IAC3C,QAAQ,EAAE,wBAAwB,GAAG,IAAI,CAAC;CAC3C;AAED;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAC3C,gBAAgB,EAAE,MAAM,EACxB,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAAC,oBAAoB,CAAC,CAY/B;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iCAAiC,QAAS,CAAC;AAExD,yFAAyF;AACzF,eAAO,MAAM,iCAAiC,QAAS,CAAC;AAExD;;;;;GAKG;AACH,eAAO,MAAM,kCAAkC,QAAiB,CAAC;AAEjE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,uCAAuC,QAAqB,CAAC;AAE1E,uEAAuE;AACvE,MAAM,WAAW,4BAA4B;IAC3C,IAAI,IAAI,IAAI,CAAC;CACd;AAED,MAAM,WAAW,0BAA0B;IACzC,qEAAqE;IACrE,gBAAgB,EAAE,MAAM,CAAC;IACzB,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,CAAC;IACjB,mCAAmC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,iBAAiB,CAAC;IACnC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;IACzB,qEAAqE;IACrE,OAAO,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAAC;IACxC,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,MAAM,CAAC,EAAE,uBAAuB,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,qBAAqB,CAAC;IAC5C,YAAY,CAAC,EAAE,OAAO,UAAU,CAAC;IACjC,cAAc,CAAC,EAAE,OAAO,YAAY,CAAC;IACrC,aAAa,CAAC,EAAE,OAAO,WAAW,CAAC;IACnC,eAAe,CAAC,EAAE,OAAO,aAAa,CAAC;CACxC;AAID;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,0BAA0B,GAC/B,4BAA4B,GAAG,IAAI,CAsMrC;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,IAAI,CAAC;CAClD,GAAG,MAAM,EAAE,CAOX;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,MAAM,EAAE;QACN,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,OAAO,CAAC,EAAE,KAAK,CAAC;YAAE,WAAW,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,GAAG,IAAI,CAAC;KAClD,CAAC;IACF,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,iBAAiB,CAAC;IACnC,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;IACzB,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,4BAA4B,GAAG,IAAI,CAmCtC"}