@trillboards/edge-sdk 0.2.3 → 0.2.6

package/dist/CloudSensingManager.d.ts

@@ -0,0 +1,533 @@
+import { EventEmitter } from 'events';
+import type { CameraProvider } from '@trillboards/edge-core';
+import { AudienceAnalyzeClient, type AudienceAnalyzeResponse, type CameraHealthFailureClass, type CameraHealthReport, type HttpPoster } from './AudienceAnalyzeClient';
+import { SharedFrameSource } from './MosaicSource';
+import type { EdgeAgentConfig, MosaicTile, RecorderIdentity } from './config';
+import { type VlmAdmissionStats } from './VlmAdmissionGate';
+import { type MotionGateOptions } from './SceneChangeDetector';
+import type { DeployedCadence } from './deployedCadence';
+export declare function classifyRtspFailureClass(err: unknown): CameraHealthFailureClass;
+/**
+ * The subset of AudienceAnalyzeClient the cadence loop needs. A local-inference
+ * client (LocalSensingClient — see localSensing.ts) substitutes here to run the
+ * VLM ON-DEVICE and POST the structured result as `preAnalyzed`, so the manager
+ * runs UNCHANGED for both the cloud and local paths.
+ */
+export interface SensingClient {
+    analyze(request: {
+        jpeg: Buffer;
+        captureMode?: string;
+    }): Promise<AudienceAnalyzeResponse>;
+    reportCameraHealth?(cameraHealth: CameraHealthReport): Promise<AudienceAnalyzeResponse>;
+    getEndpoint(): string;
+    /**
+     * Cloud escalations this client has made (LocalSensingClient only). Optional
+     * so the plain cloud client — which has nothing to escalate TO — implements
+     * nothing. Aggregated into `getSensingHealth()` because a frame leaving the
+     * premises has to be countable by the operator, not just documented.
+     */
+    getEscalationStats?(): {
+        enabled: boolean;
+        escalated: number;
+    };
+}
+/** A camera + its dedicated sensing client (one feed = one token). */
+export interface SensingLoopDeps {
+    /** Label for logs/stats (defaults to the feed name or screenId). */
+    name: string;
+    camera: CameraProvider;
+    client: SensingClient;
+}
+export interface CloudSensingManagerOptions {
+    /** Per-feed capture loops. */
+    loops: SensingLoopDeps[];
+    /** Capture interval (ms) when NO faces. Default: 300000. */
+    periodicIntervalMs?: number;
+    /** Capture interval (ms) when faces ARE detected. Default: 30000. */
+    faceTriggeredIntervalMs?: number;
+    /** JPEG quality for the POSTed frame. Default: 70. */
+    jpegQuality?: number;
+    /** Skip the POST when no faces (still captures periodically). Default: true. */
+    skipPostWhenNoFaces?: boolean;
+    /** Frame width (for raw RGB24 → JPEG encoding). */
+    width?: number;
+    /** Frame height (for raw RGB24 → JPEG encoding). */
+    height?: number;
+    /**
+     * Initial delay (ms) before the first RTSP re-open attempt after a drop.
+     * Doubles each consecutive failure up to `reconnectMaxDelayMs`, then holds at
+     * the cap and retries FOREVER. Default: 1000. The connector self-recovers when
+     * the camera/feed comes back; it never permanently gives up.
+     */
+    reconnectInitialDelayMs?: number;
+    /** Cap (ms) for the exponential reconnect backoff. Default: 30000. */
+    reconnectMaxDelayMs?: number;
+    /**
+     * Additional per-feed phase offset (ms) added by loop index when multiple
+     * cameras run in one connector. Default: 1000 for multi-feed, 0 for single.
+     */
+    feedStaggerMs?: number;
+    /** Cap for the computed per-feed phase offset. Default: 15000. */
+    maxFeedStaggerMs?: number;
+    /**
+     * Consecutive non-auth RTSP failures tolerated before reporting failed
+     * camera health. Auth failures still report immediately. Default: 3.
+     */
+    cameraHealthFailureGraceCount?: number;
+    /**
+     * Decode-only camera probe cadence while every inference slot is busy.
+     * This keeps video liveness independent from AI throughput without opening
+     * a second persistent RTSP session. Default: 120000.
+     */
+    cameraHealthProbeIntervalMs?: number;
+    /** Maximum gap between connector/sensing status beacons. Default: 60000. */
+    cameraHealthHeartbeatIntervalMs?: number;
+    /**
+     * Concurrent analyze() calls allowed across ALL feeds in this process — the
+     * global admission gate. Default: one slot per loop (i.e. today's unbounded
+     * fan-out), so the cloud path, whose backend really is concurrent, is
+     * unchanged. LOCAL sensing MUST set this to 1: `litert-lm serve` is a
+     * single-conversation server and 16 free-running loops oversubscribe it ~17x.
+     */
+    maxConcurrentAnalyses?: number;
+    /**
+     * Reclaim an admission slot held longer than this (ms). Default 180000 — the
+     * provider's 120 s HTTP timeout plus retry headroom. Guards a 24/7 connector
+     * against one lost promise wedging every camera forever.
+     */
+    maxAnalysisInFlightMs?: number;
+    /**
+     * Delay (ms) before a tick the admission gate denied tries again. Default:
+     * the derived stagger step, clamped to 250…5000. Short on purpose — the loop
+     * dropped its frame, so this is a cheap poll for a freed slot, not a queue.
+     */
+    admissionRetryDelayMs?: number;
+    /**
+     * Cheap motion cascade in front of the model. Omitted ⇒ disabled and every
+     * captured frame is analyzed (today's behavior). `heartbeatIntervalMs`
+     * defaults to `periodicIntervalMs` and `minAnalyzeIntervalMs` to
+     * `faceTriggeredIntervalMs`, so the analyze rate stays inside the cadence
+     * band the config already declares — the gate can only REMOVE calls.
+     */
+    motionGate?: Partial<MotionGateOptions> & {
+        enabled?: boolean;
+        /**
+         * How often a STILL feed takes a look (ms) once the cascade is on.
+         * Defaults to `faceTriggeredIntervalMs`. Looking is the cheap half — an
+         * RTSP grab plus a few ms of motion — so it runs at the responsive
+         * cadence while `periodicIntervalMs` becomes the gate's heartbeat: the
+         * guaranteed reporting floor for a scene where genuinely nothing happens.
+         */
+        scanIntervalMs?: number;
+    };
+    /**
+     * Let the motion verdict drive the periodic/face-triggered cadence switch —
+     * finally supplying the `setFaceDetected` signal this loop was always
+     * documented to consume. Default: true whenever `motionGate` is enabled.
+     */
+    motionDrivesCadence?: boolean;
+    /**
+     * Where this connector learns the cadence its OPERATOR deployed. Polled every
+     * `cadenceRefreshIntervalMs`; a null answer leaves the current cadence alone.
+     * Omitted ⇒ the cadence is whatever the config said at construction, which is
+     * the behavior every connector had before this existed.
+     */
+    cadenceSource?: CadenceSource;
+    /** How often to ask `cadenceSource`. Default 300000 (the profile TTL). */
+    cadenceRefreshIntervalMs?: number;
+    /** Clock injection for tests. Default `Date.now`. */
+    now?: () => number;
+}
+/**
+ * The connector's link to the cadence its operator actually deployed.
+ *
+ * `resolve()` returns the FULL verdict rather than a number so the clamp — and,
+ * on the cloud path, the bill the operator is being protected from — stays
+ * legible in `getSensingHealth()` instead of being silently applied.
+ */
+export interface CadenceSource {
+    resolve(): Promise<DeployedCadence | null>;
+}
+export declare class CloudSensingManager extends EventEmitter {
+    private readonly loops;
+    /**
+     * NOT readonly: the deployed profile's cadence must be able to reach a
+     * RUNNING connector. Until this changed, the interval was frozen at
+     * construction and the only way to alter a venue's cadence was to edit
+     * trillboards.config.json on their machine and restart the process — while
+     * the server was already serving the operator's chosen value every 5 minutes
+     * to a client that discarded it. See setPeriodicIntervalMs + deployedCadence.
+     */
+    private periodicIntervalMs;
+    /** The last cadence verdict applied, surfaced by getSensingHealth(). */
+    private cadence;
+    private readonly cadenceSource?;
+    private readonly cadenceRefreshIntervalMs;
+    private cadenceTimer;
+    private readonly faceTriggeredIntervalMs;
+    private readonly jpegQuality;
+    private readonly skipPostWhenNoFaces;
+    private readonly width?;
+    private readonly height?;
+    private readonly reconnectInitialDelayMs;
+    private readonly reconnectMaxDelayMs;
+    private readonly feedStaggerMs;
+    private readonly maxFeedStaggerMs;
+    private readonly cameraHealthFailureGraceCount;
+    private readonly cameraHealthProbeIntervalMs;
+    private readonly cameraHealthHeartbeatIntervalMs;
+    private readonly admissionGate;
+    private readonly admissionRetryDelayMs;
+    private readonly motionDrivesCadence;
+    /** Retained so a cadence change can rebuild each feed's gate heartbeat. */
+    private motionGateOptions;
+    /** Look-rate for a still feed when the cascade is on. null ⇒ cascade off. */
+    private motionScanIntervalMs;
+    private readonly now;
+    private running;
+    private startGeneration;
+    private runStartedAtMs;
+    /** One decode-only probe at a time protects recorder session limits. */
+    private healthCaptureInFlight;
+    constructor(options: CloudSensingManagerOptions);
+    /**
+     * Retune a RUNNING connector's still-scene cadence.
+     *
+     * Timers are NOT cancelled: each loop re-arms from `nextDelayFor` in its own
+     * `.finally`, so the new interval takes effect on the next tick. Cancelling
+     * and rescheduling here would collapse every feed's carefully-staggered phase
+     * onto the same instant — the multi-camera NVR stampede `staggerStepMs`
+     * exists to prevent — for no gain, since the worst-case lag is one old
+     * period.
+     *
+     * The motion gate's HEARTBEAT tracks the cadence, because the heartbeat IS
+     * the still-scene reporting floor: leaving it at the old value would let a
+     * gate keep reporting on a cadence the operator has replaced.
+     *
+     * The heartbeat is retuned IN PLACE (`MotionGate.setHeartbeatIntervalMs`) and
+     * NOT by rebuilding the gate. A fresh `MotionGate` is a fresh
+     * `SceneChangeDetector`: no background model, `calibrating` re-armed, the
+     * contrast ring un-seeded, the stationary signature forgotten and — the
+     * expensive one — `lastAnalyzedAtMs` back to null, which makes the very next
+     * look heartbeat-DUE and forces an inference on a scene the gate had already
+     * proven still. Measured: a byte-identical still frame costs 0 analyses over
+     * ten looks, then exactly +1 per feed the instant the cadence moves. On a
+     * 16-camera store that is 16 forced generations against the connector's single
+     * slot for a change that was meant to cost nothing. Rebuilding also swapped
+     * the object mid-tick, so a frame's `evaluate()` and its `markAnalyzed()`
+     * could land on two different gates.
+     *
+     * @returns true when the interval actually changed.
+     */
+    setPeriodicIntervalMs(intervalMs: number): boolean;
+    /** The still-scene cadence currently in force. */
+    getPeriodicIntervalMs(): number;
+    /**
+     * Ask the cadence source what the operator deployed and apply it. Best-effort
+     * and never throws: a failed lookup leaves the running cadence untouched,
+     * because a connector that resets to a default every time the API blips is
+     * worse than one that is briefly stale.
+     */
+    refreshDeployedCadence(): Promise<DeployedCadence | null>;
+    /** Number of independent capture loops (== number of feeds/tokens). */
+    getLoopCount(): number;
+    /** Per-loop stats (capture + POST counts, cadence, cascade drops). */
+    getStats(): Array<{
+        name: string;
+        captureCount: number;
+        postCount: number;
+        faceDetected: boolean;
+        currentIntervalMs: number;
+        admissionDeniedCount: number;
+        motionSkipCount: number;
+    }>;
+    /** Live admission-gate counters (admitted / dropped / stale-reclaimed). */
+    getAdmissionStats(): VlmAdmissionStats;
+    /**
+     * The operator-facing answer to "why is my 16-camera store only sampling
+     * every N seconds?" — sustained analyses/minute is what the machine can
+     * actually do, and `effectiveSampleIntervalMs` is what that buys each camera.
+     * Drops are attributed: `admissionDenied` means the backend is the ceiling,
+     * `motionSkipped` means the cascade decided the frame was not worth paying
+     * for. Both are wins over the old failure mode, where the surplus vanished
+     * into 120 s timeouts.
+     */
+    getSensingHealth(): {
+        loops: number;
+        maxConcurrentAnalyses: number;
+        inFlight: number;
+        uptimeMs: number;
+        analyses: number;
+        analysesPerMinute: number;
+        effectiveSampleIntervalMs: number | null;
+        /** The still-scene cadence in force right now (a deployed profile can move it). */
+        periodicIntervalMs: number;
+        /**
+         * What the operator's deployed profile asked for, and what actually
+         * happened to it. null before the first successful lookup, or when this
+         * connector has no cadence source. The clamp is REPORTED rather than
+         * silently applied — an operator who set 30 s and is running 303 s has to
+         * be able to see both numbers and the reason.
+         */
+        deployedCadence: DeployedCadence | null;
+        admissionDenied: number;
+        motionSkipped: number;
+        /**
+         * Frames sent to the cloud VLM for confirmation (local sensing with
+         * escalation enabled). 0 — and `cloudEscalationEnabled:false` — for a
+         * fully-local or cloud-sensing deployment.
+         */
+        cloudEscalated: number;
+        cloudEscalationEnabled: boolean;
+        perFeed: Array<{
+            name: string;
+            captures: number;
+            analyses: number;
+            admissionDenied: number;
+            motionSkipped: number;
+            cloudEscalated: number;
+            faceDetected: boolean;
+            currentIntervalMs: number;
+        }>;
+    };
+    isRunning(): boolean;
+    /** Open cameras, prove one frame, and start capture loops without one slow feed blocking others. */
+    start(): Promise<void>;
+    /** Stop all loops and close cameras. */
+    stop(): Promise<void>;
+    /**
+     * Notify a loop (by feed name) that its face-detection state changed —
+     * switches that loop between the periodic and face-triggered cadence.
+     */
+    setFaceDetected(loopName: string, detected: boolean): void;
+    /**
+     * Same cadence switch, but from INSIDE a running tick: record the new state
+     * and announce it WITHOUT rescheduling. The tick's own `finally` already
+     * calls scheduleNext and will read the updated interval — rescheduling here
+     * as well would leave the feed running two concurrent timers.
+     */
+    private applyMotionCadence;
+    /**
+     * Capture + (conditionally) POST one frame for a given loop, immediately.
+     *
+     * Goes through the SAME cascade as a scheduled tick — an out-of-band capture
+     * that jumped the admission gate would break the very invariant the gate
+     * exists to hold. Returns `null` (rather than waiting) when the gate is
+     * closed or the motion stage judged the frame not worth an inference.
+     */
+    captureNow(loopName: string): Promise<AudienceAnalyzeResponse | null>;
+    private isCurrentStart;
+    private startLoop;
+    private closeCameraQuietly;
+    /**
+     * How long until this feed's next LOOK.
+     *
+     * Without the cascade this is the historical rule: fast while faces are
+     * present, slow otherwise. With the cascade on, a still feed keeps looking at
+     * the scan cadence — looking is cheap and only analysis is gated — and
+     * `periodicIntervalMs` becomes the gate's heartbeat, i.e. the floor on
+     * REPORTING rather than the rate of watching.
+     */
+    private intervalFor;
+    /**
+     * Per-feed phase step, derived from FEED COUNT and CADENCE instead of a fixed
+     * per-feed cap.
+     *
+     * The spread window is the smaller of the configured `maxFeedStaggerMs` and
+     * the fastest capture cadence (a spread longer than one period would just
+     * re-alias), and the step is the largest value that fits every feed inside
+     * it, never exceeding the configured `feedStaggerMs`. Small installs keep
+     * exactly today's offsets (4 feeds x 1000 ms); a 16-camera store gets 16
+     * DISTINCT offsets instead of feeds 15+ colliding on the cap.
+     */
+    private staggerStepMs;
+    private staggerFor;
+    /**
+     * Delay before the next tick.
+     *
+     * - Camera dropped → the reconnect backoff, PLUS the phase offset so a
+     *   recorder that rebooted does not get all N feeds re-opening in lock-step.
+     * - Admission denied → a short one-shot retry (consumed here) so the loop
+     *   takes the inference slot as soon as it frees rather than idling a full
+     *   cadence.
+     * - Otherwise → exactly the capture cadence. The phase offset is applied ONCE
+     *   at startup (and on reconnect); adding it to every tick would make feed i's
+     *   period `cadence + offset_i`, quietly stretching the last feed's cadence by
+     *   the whole spread window — a 47 % slower camera 16 at the 30 s cadence.
+     *   Equal periods preserve the startup phase difference forever.
+     */
+    private nextDelayFor;
+    /**
+     * Arm this feed's next tick, for ONE run of the manager.
+     *
+     * `generation` is not decoration. A tick re-arms from its own `.finally`, and
+     * that `.finally` can run AFTER a stop()/start() cycle — the auto-sense
+     * supervisor stops and restarts the SAME manager instance every time
+     * `litert-lm` appears or disappears, and a cloud analyze can be in flight for
+     * up to two minutes. Without the generation the surviving tick re-arms a
+     * chain, `startLoop` arms another, and `s.timer` holds only the second one, so
+     * `stop()` can never clear the first: the feed now captures twice per cadence,
+     * permanently, and every further flap adds another chain. Measured: two
+     * pending timers for ONE feed after a single cycle. On the cloud path
+     * `maxConcurrentAnalyses` defaults to one slot PER LOOP, so the duplicate
+     * chain is duplicate Vertex spend, not just duplicate RTSP load.
+     */
+    private scheduleNext;
+    /**
+     * One scheduled loop iteration with built-in RTSP self-recovery.
+     *
+     * If the camera is dropped (closed), this attempts to RE-OPEN it (the keystone
+     * 24/7 fix — a transient feed/network blip used to wedge the loop on "camera
+     * is not open" forever). On a successful re-open the backoff resets and the
+     * tick falls through to a normal capture so sensing resumes immediately; on a
+     * failed re-open the backoff doubles (capped) and we retry FOREVER. The
+     * per-attempt connect timeout still lives in the RTSP provider's open() — only
+     * the give-up-forever behavior changes to retry-forever.
+     */
+    private runScheduledTick;
+    /**
+     * Attempt one camera re-open. Returns true on success (backoff cleared, sensing
+     * resumes), false on failure (backoff doubled+capped for the next attempt).
+     * Emits `reconnecting` before each attempt and `reconnected` on recovery so
+     * operators can observe the self-healing on an unattended connector.
+     */
+    private tryReopen;
+    /**
+     * Put a loop into reconnect mode (camera dropped). Idempotent: an already
+     * dropped loop keeps its current (climbing) backoff rather than resetting to
+     * the initial delay.
+     */
+    private enterReconnect;
+    private emitLoopError;
+    private reportCameraFailure;
+    private reportCameraHealth;
+    private reportCameraOpen;
+    private healthProbeDue;
+    /**
+     * Prove video locally without waiting for the model. The global boolean keeps
+     * legacy recorders to one extra short-lived ffmpeg pull at a time.
+     */
+    private captureHealthFrame;
+    /**
+     * One cascade pass for a feed: admission → capture → motion → inference,
+     * with a bounded decode-only health probe when admission is denied.
+     *
+     * The admission check comes first so denied inference frames are dropped,
+     * never buffered. Video health is independent: at most one feed at a time
+     * may take a slow-cadence decode-only proof while the model is occupied.
+     */
+    private captureAndPost;
+    /**
+     * Convert a camera frame to JPEG bytes for the POST.
+     *
+     * RTSP frames arrive as raw RGB24 Buffers, so we encode them with `sharp`
+     * when available (the standard sensing dep). If `sharp` is missing AND the
+     * frame is already JPEG (some providers emit JPEG directly), we ship it
+     * as-is; raw-RGB-without-sharp is rejected loudly so it never silently POSTs
+     * an un-decodable frame.
+     *
+     * Dimensions are needed to decode raw RGB24. Resolution order: the camera's
+     * own getResolution() (passed in by the caller — works for multi-channel
+     * feeds with no top-level camera.width/height), then the manager's configured
+     * width/height, then EdgeImageData's own dims.
+     */
+    private toJpeg;
+}
+/**
+ * Build the per-feed capture loops from an EdgeAgentConfig — the bridge between
+ * config (`cameras: [...]` multi-channel, or single `camera`) and the manager.
+ *
+ * - Multi-channel: one loop per `cameras[]` entry, each with its own token +
+ *   its own RTSP provider.
+ * - Single-camera (back-compat): one loop from the top-level `camera`/token.
+ *
+ * `rtspProviderFactory` / `clientFactory` are injectable for tests; defaults
+ * use the neutral RTSP package + AudienceAnalyzeClient.
+ */
+export declare function buildSensingLoops(config: EdgeAgentConfig, deps?: {
+    rtspProviderFactory?: (feed: ResolvedFeed) => CameraProvider;
+    streamUrlResolver?: (feed: ResolvedFeed, currentUrl: string, error: Error) => Promise<string | null>;
+    clientFactory?: (feed: ResolvedFeed) => AudienceAnalyzeClient;
+    httpPoster?: HttpPoster;
+    /** Freshness window (ms) a mosaic tile reuses the shared pull. Default 5000. */
+    sharedFrameMaxAgeMs?: number;
+    /** Shared per-mosaic-source pull registry so the VLM attaches to the SAME
+     *  SharedFrameSource the on-device zoo uses (one RTSP pull for both rails). */
+    sharedSources?: Map<string, SharedFrameSource>;
+}): SensingLoopDeps[];
+/**
+ * Build one CameraProvider per feed, collapsing mosaic tiles that share a source
+ * onto a SINGLE shared RTSP pull. This is the ONE implementation of mosaic
+ * tiling, used by BOTH cloud-sense (buildSensingLoops) and local-sense
+ * (buildLocalSensingLoops) — no split-brain between run modes. Returns feed↔camera
+ * pairs so each caller attaches its own sensing client.
+ *
+ * Grouping: a feed opts into sharing a pull only via `sourceFeedId` (a tile → its
+ * mosaic source) or by being that source (`id`); a feed with neither is solo
+ * (keyed uniquely) and gets exactly the historical one-provider-per-feed path.
+ *
+ * `rtspFactory` builds the underlying RTSP provider and MUST honor `feed.crop`
+ * (used by the per-tile-pull fallback when no source feed is configured).
+ */
+export declare function buildTiledCameras(feeds: ResolvedFeed[], rtspFactory: (feed: ResolvedFeed) => CameraProvider, opts?: {
+    sharedFrameMaxAgeMs?: number;
+    /**
+     * Memoizes the per-mosaic-source SharedFrameSource so MULTIPLE consumers
+     * (the VLM rail AND the on-device ONNX zoo rail) attach to the SAME single
+     * RTSP pull instead of each opening its own. Keyed by the mosaic group key
+     * (the source feed's `id`). When omitted, each call builds its own sources
+     * (unchanged single-consumer behavior).
+     */
+    sharedSources?: Map<string, SharedFrameSource>;
+    /**
+     * Pixel format each tile's CropViewProvider emits: 'jpeg' (default, the
+     * VLM/cloud POST) or 'rgb24' (raw RGB the on-device ONNX FaceDetector
+     * consumes). Both carve from the SAME JPEG mosaic pull; only the per-tile
+     * re-encode differs, so two consumers can share one pull at different formats.
+     */
+    cropOutputFormat?: 'jpeg' | 'rgb24';
+}): Array<{
+    feed: ResolvedFeed;
+    camera: CameraProvider;
+}>;
+/** A fully-resolved feed (token + rtspUrl guaranteed present). */
+export interface ResolvedFeed {
+    name: string;
+    /** Config-local feed id (set on a mosaic source feed; tiles point at it). */
+    id?: string;
+    screenId?: string;
+    deviceToken: string;
+    rtspUrl: string;
+    sourceType?: 'recorder' | 'direct_url';
+    channelKey?: string;
+    recorder?: RecorderIdentity;
+    width?: number;
+    height?: number;
+    fps?: number;
+    transport?: 'tcp' | 'udp';
+    ffmpegPath?: string;
+    /**
+     * Mosaic tiling. `sourceFeedId` groups this tile with its mosaic source (the
+     * feed whose `id` matches) so the source RTSP is pulled ONCE; `crop` is the
+     * tile's sub-rectangle in source pixels, carved in ffmpeg. Both omitted ⇒ a
+     * normal whole-frame feed with its own dedicated pull (unchanged).
+     */
+    sourceFeedId?: string;
+    crop?: MosaicTile;
+    /**
+     * Frame encoding the RTSP provider should emit. Cloud-sense always wants
+     * 'jpeg' so ffmpeg encodes directly and NO image library (sharp) is needed
+     * for the POST. Set on every resolved feed by resolveFeeds().
+     */
+    outputFormat?: 'rgb24' | 'jpeg';
+    /** JPEG quality (1-100) when outputFormat='jpeg'. */
+    jpegQuality?: number;
+}
+/**
+ * Flatten an EdgeAgentConfig into the list of feeds to run. Multi-channel
+ * `cameras[]` wins; otherwise the single `camera` (+ top-level token) becomes
+ * a one-element list (back-compat). Feeds without both a token and rtspUrl are
+ * skipped (the single-camera fallback needs both for cloud sensing).
+ */
+export declare function resolveFeeds(config: EdgeAgentConfig): ResolvedFeed[];
+//# sourceMappingURL=CloudSensingManager.d.ts.map

package/dist/CloudSensingManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudSensingManager.d.ts","sourceRoot":"","sources":["../src/CloudSensingManager.ts"],"names":[],"mappings":"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"}