@camstack/addon-pipeline 0.1.0 → 0.1.2

package/dist/index.d.cts

@@ -1,8 +1,6 @@
-export { A as AvailabilityRange, C as CleanupQueueEntry, a as CleanupStatus, D as DataCategory, P as PipelineAddon, R as RecordingCoordinator, b as RecordingDb, c as RecordingEnableConfig, d as RecordingEngineDependencies, e as RecordingEngineV2Dependencies, f as RecordingMode, g as RecordingPolicy, h as RecordingSegment, i as RecordingStorageConfig, j as RecordingThumbnail, S as ScheduleRule, k as SegmentWriterState, l as StorageEstimate, m as StorageUsage, n as StreamEstimate, o as StreamPolicy } from './addon-CwDFZWAb.cjs';
-import { IDecoderProvider, IStreamBroker, IScopedLogger, BrokerStatus, IRestreamer, StreamSource, EncodedPacket, Unsubscribe, DecodedFrame, DecodeOptions, DecodedAudioChunk, BrokerStats, DecoderSessionConfig, IDecoderSession, DecoderStats, IStorageLocation, SystemEvent, VideoFrame as VideoFrame$1, IStructuredStorage, IEventBus, AnalysisContext, ServerTrackedDetection, ICamstackAddon, AddonManifest, AddonContext, CapabilityProviderMap } from '@camstack/types';
+export { A as AvailabilityRange, C as CleanupQueueEntry, a as CleanupStatus, D as DataCategory, P as PipelineAddon, R as RecordingCoordinator, b as RecordingDb, c as RecordingEnableConfig, d as RecordingEngineDependencies, e as RecordingEngineV2Dependencies, f as RecordingMode, g as RecordingPolicy, h as RecordingSegment, i as RecordingStorageConfig, j as RecordingThumbnail, S as ScheduleRule, k as SegmentWriterState, l as StorageEstimate, m as StorageUsage, n as StreamEstimate, o as StreamPolicy } from './addon-DK7eQ0PN.cjs';
+import { IDecoderProvider, IStreamBroker, IScopedLogger, BrokerStatus, IRestreamer, StreamSource, EncodedPacket, Unsubscribe, DecodedFrame, DecodeOptions, DecodedAudioChunk, BrokerStats, DecoderSessionConfig, IDecoderSession, DecoderStats, IStorageLocation, SystemEvent, VideoFrame, IStructuredStorage, IEventBus, AnalysisContext, ServerTrackedDetection, ICamstackAddon, AddonManifest, AddonContext, CapabilityProviderMap } from '@camstack/types';
 export { BrokerStats, BrokerStatus } from '@camstack/types';
-import { ChildProcess } from 'node:child_process';
-import { EventEmitter } from 'node:events';
 import 'better-sqlite3';
 
 declare class DecoderRegistry {
@@ -231,7 +229,7 @@ declare class EventPersistenceService {
     /** Save annotated frame (thumbnail + full-res) for an event */
     saveAnnotatedFrame(eventId: string, result: AnnotatedSnapshotResult): void;
     /** Save original frame for an event */
-    saveOriginalFrame(eventId: string, frame: VideoFrame$1): Promise<void>;
+    saveOriginalFrame(eventId: string, frame: VideoFrame): Promise<void>;
     /**
      * Get all media files for a specific event (from buffer or storage).
      * Returns immediately — serves from in-memory buffer if not yet flushed.
@@ -549,919 +547,4 @@ declare class BuiltinAnalysisAddon implements ICamstackAddon {
     isAvailable(): boolean;
 }
 
-/**
- * Core types for media stream servers.
- * Protocol-agnostic frame types used across all server implementations.
- */
-type VideoCodec = "H264" | "H265";
-type AudioCodec = "Aac" | "Adpcm" | "Opus" | "Pcmu" | "Pcma";
-/**
- * A single video frame in Annex-B format (with start codes).
- */
-interface VideoFrame {
-    /** Raw video data in Annex-B format (NAL units with 0x00000001 start codes) */
-    data: Buffer;
-    /** Video codec type */
-    codec: VideoCodec;
-    /** True if this is a keyframe (IDR for H.264, IRAP for H.265) */
-    isKeyframe: boolean;
-    /** Presentation timestamp in microseconds (monotonic) */
-    timestampMicros: number;
-    /** Optional: frame width in pixels */
-    width?: number;
-    /** Optional: frame height in pixels */
-    height?: number;
-}
-/**
- * A single audio frame.
- * For AAC: data should include ADTS headers.
- * For other codecs: raw audio samples.
- */
-interface AudioFrame {
-    /** Raw audio data */
-    data: Buffer;
-    /** Audio codec */
-    codec: AudioCodec;
-    /** Sample rate in Hz */
-    sampleRate: number;
-    /** Number of channels */
-    channels: number;
-    /** Presentation timestamp in microseconds */
-    timestampMicros: number;
-}
-/**
- * Tagged union for video/audio frames.
- */
-type MediaFrame = {
-    type: "video";
-    frame: VideoFrame;
-} | {
-    type: "audio";
-    frame: AudioFrame;
-};
-/**
- * Primary frame source interface.
- * Yields MediaFrame objects. Returning from the generator signals end of stream.
- * Throwing signals an error that should trigger reconnection.
- */
-type FrameSource = AsyncGenerator<MediaFrame, void, unknown>;
-/**
- * Factory that creates a new FrameSource.
- * Called each time the server needs to start/restart the stream.
- * The server is responsible for calling return() to stop the source.
- */
-type FrameSourceFactory = () => FrameSource;
-/**
- * Minimal logger interface compatible with console.
- */
-interface Logger {
-    log(message?: unknown, ...args: unknown[]): void;
-    info(message?: unknown, ...args: unknown[]): void;
-    warn(message?: unknown, ...args: unknown[]): void;
-    error(message?: unknown, ...args: unknown[]): void;
-    debug(message?: unknown, ...args: unknown[]): void;
-}
-/**
- * Accept Console or partial Logger implementations.
- */
-type LoggerLike = Partial<Logger> | Console;
-/**
- * Wrap a LoggerLike into a full Logger (no-op for missing methods).
- */
-declare function asLogger(logger?: LoggerLike): Logger;
-/**
- * Create a logger that discards all output.
- */
-declare function createNullLogger(): Logger;
-
-/**
- * NAL unit parsing utilities.
- * Protocol-agnostic functions for working with Annex-B NAL units.
- */
-
-/**
- * Returns true if the buffer starts with an Annex-B start code (0x00000001 or 0x000001).
- */
-declare function hasStartCodes(data: Buffer): boolean;
-/**
- * Split Annex-B data into individual NAL unit payloads (without start codes).
- * Works for both H.264 and H.265.
- */
-declare function splitAnnexBToNals(annexB: Buffer): Buffer[];
-/**
- * Prepend a 4-byte Annex-B start code to a NAL payload.
- */
-declare function prependStartCode(nal: Buffer): Buffer;
-/**
- * Join multiple NAL payloads (without start codes) into an Annex-B access unit.
- */
-declare function joinNalsToAnnexB(...nals: Array<Buffer | null | undefined>): Buffer | undefined;
-/**
- * Detect the actual video codec from raw NAL data.
- * Some cameras report wrong codec (e.g. "H264" but send H.265 data).
- * Analyzes the NAL header to determine the real codec.
- *
- * @param data - Raw video data (either Annex-B or length-prefixed)
- * @returns Detected codec type or null if detection fails
- */
-declare function detectVideoCodecFromNal(data: Buffer): VideoCodec | null;
-
-/**
- * H.264/AVC utilities.
- * AVCC to Annex-B conversion, SPS/PPS extraction, keyframe detection, RTP depacketization.
- */
-/**
- * Convert H.264 data from length-prefixed (AVCC) to Annex-B (start codes).
- * If already Annex-B, returns as-is.
- */
-declare function convertH264ToAnnexB(data: Buffer): Buffer;
-/**
- * Check if an H.264 Annex-B access unit is a keyframe (IDR + SPS + PPS).
- */
-declare function isH264KeyframeAnnexB(annexB: Buffer): boolean;
-/**
- * Check if an H.264 Annex-B access unit contains an IDR slice.
- */
-declare function isH264IdrAccessUnit(annexB: Buffer): boolean;
-/**
- * Extract SPS and PPS from an H.264 Annex-B access unit.
- */
-declare function extractH264ParamSets(annexB: Buffer): {
-    sps?: Buffer;
-    pps?: Buffer;
-    profileLevelId?: string;
-};
-/**
- * H.264 RTP depacketizer (RFC 6184).
- * Handles single NAL units, STAP-A aggregation, and FU-A/FU-B fragmentation.
- * Returns complete NAL units in Annex-B format (with start codes).
- */
-declare class H264RtpDepacketizer {
-    private fuNalHeader;
-    private fuParts;
-    private static parseRtpPayload;
-    reset(): void;
-    push(payload: Buffer): Buffer[];
-}
-
-/**
- * H.265/HEVC utilities.
- * HVCC to Annex-B conversion, VPS/SPS/PPS extraction, keyframe detection, RTP depacketization.
- */
-/**
- * Convert H.265 data from length-prefixed (HVCC) to Annex-B (start codes).
- * If already Annex-B, returns as-is.
- */
-declare function convertH265ToAnnexB(data: Buffer): Buffer;
-/**
- * Get H.265 NAL unit type from a NAL payload (without start code).
- */
-declare function getH265NalType(nalPayload: Buffer): number | null;
-/**
- * Check if an H.265 NAL unit type is an IRAP (Intra Random Access Point) picture.
- * IRAP types: BLA (16-18), IDR (19-20), CRA (21).
- */
-declare function isH265Irap(nalType: number): boolean;
-/**
- * Check if an H.265 Annex-B access unit is a keyframe (IRAP + VPS + SPS + PPS).
- */
-declare function isH265KeyframeAnnexB(annexB: Buffer): boolean;
-/**
- * Check if an H.265 Annex-B access unit contains an IRAP picture.
- */
-declare function isH265IrapAccessUnit(annexB: Buffer): boolean;
-/**
- * Extract VPS, SPS, and PPS from an H.265 Annex-B access unit.
- */
-declare function extractH265ParamSets(annexB: Buffer): {
-    vps?: Buffer;
-    sps?: Buffer;
-    pps?: Buffer;
-};
-/**
- * H.265 RTP depacketizer (RFC 7798).
- * Handles single NAL units, AP aggregation, and FU fragmentation.
- * Returns complete NAL units in Annex-B format (with start codes).
- */
-declare class H265RtpDepacketizer {
-    private fuParts;
-    private static parseRtpPayload;
-    reset(): void;
-    push(payload: Buffer): Buffer[];
-}
-
-/**
- * Stream fan-out utilities.
- * Distribute a single source stream to multiple consumers with bounded queues.
- */
-/**
- * Async bounded queue with push/pull interface.
- * When the queue is full, the oldest items are dropped (tail-drop).
- */
-declare class AsyncBoundedQueue<T> {
-    private readonly maxItems;
-    private readonly queue;
-    private waiting;
-    private closed;
-    constructor(maxItems: number);
-    push(item: T): void;
-    close(): void;
-    next(): Promise<IteratorResult<T>>;
-    isClosed(): boolean;
-    size(): number;
-}
-interface StreamFanoutOptions<T> {
-    /** Maximum items per subscriber queue before tail-drop */
-    maxQueueItems: number;
-    /** Factory to create the source stream */
-    createSource: () => AsyncGenerator<T, void, unknown>;
-    /** Optional callback for each frame (e.g. for extracting metadata) */
-    onFrame?: (frame: T) => void;
-    /** Optional error handler */
-    onError?: (error: unknown) => void;
-}
-/**
- * Fan-out a single async generator source to multiple subscribers.
- * The source stream is started when start() is called and frames are
- * distributed to all active subscriber queues.
- */
-declare class StreamFanout<T> {
-    private readonly opts;
-    private readonly queues;
-    private source;
-    private running;
-    private pumpPromise;
-    constructor(opts: StreamFanoutOptions<T>);
-    /** Start pumping frames from the source to all subscribers. */
-    start(): void;
-    /**
-     * Create a subscriber async generator.
-     * Returns an async generator that yields frames from the shared source.
-     * The generator terminates when the source ends or unsubscribe is called.
-     */
-    subscribe(id: string): AsyncGenerator<T, void, unknown>;
-    /** Unsubscribe a specific subscriber. */
-    unsubscribe(id: string): void;
-    /** Stop the source and close all subscriber queues. */
-    stop(): Promise<void>;
-    /** Returns true if the fan-out is running. */
-    isRunning(): boolean;
-    /** Returns the number of active subscribers. */
-    subscriberCount(): number;
-}
-
-/**
- * FFmpeg process lifecycle management.
- * Spawn and manage FFmpeg processes with proper cleanup.
- */
-
-interface FfmpegProcessOptions {
-    /** FFmpeg binary path (default: "ffmpeg") */
-    ffmpegPath?: string;
-    /** FFmpeg arguments */
-    args: string[];
-    /** Logger instance */
-    logger?: Logger;
-    /** Label for log messages */
-    label?: string;
-    /** Additional stdio configuration (e.g. ["pipe"] for pipe:3) */
-    extraStdio?: Array<"pipe" | "ignore" | "inherit">;
-    /** Callback when process exits */
-    onExit?: (code: number | null, signal: string | null) => void;
-    /** Callback for stderr output */
-    onStderr?: (data: string) => void;
-}
-/**
- * Managed FFmpeg process with proper lifecycle handling.
- */
-declare class FfmpegProcess {
-    private readonly options;
-    private process;
-    private killed;
-    private readonly logger;
-    private readonly label;
-    constructor(options: FfmpegProcessOptions);
-    /** Spawn the FFmpeg process. Returns stdin writable stream. */
-    start(): NodeJS.WritableStream | null;
-    /** Get a specific stdio stream by fd index (e.g. 3 for pipe:3). */
-    getStdio(fd: number): NodeJS.ReadableStream | NodeJS.WritableStream | null;
-    /** Get the underlying ChildProcess. */
-    getProcess(): ChildProcess | null;
-    /** Kill the FFmpeg process gracefully (SIGTERM then SIGKILL after timeout). */
-    kill(timeoutMs?: number): Promise<void>;
-    /** Check if the process is running. */
-    isRunning(): boolean;
-}
-
-/**
- * Frame source adapters.
- * Convert various input patterns (EventEmitter, push callbacks) into FrameSource async generators.
- */
-
-/**
- * Convert an EventEmitter-based source into a FrameSource async generator.
- *
- * @param emitter - The event emitter that fires video/audio frames
- * @param videoEvent - Event name for video frames (default: "videoFrame")
- * @param audioEvent - Event name for audio frames (default: "audioFrame")
- */
-declare function fromEventEmitter(emitter: EventEmitter, videoEvent?: string, audioEvent?: string): FrameSource;
-/**
- * Create a push-based frame source.
- * Returns a FrameSource async generator and push functions to deliver frames.
- */
-declare function fromPushCallback(): {
-    source: FrameSource;
-    pushVideo: (frame: VideoFrame) => void;
-    pushAudio: (frame: AudioFrame) => void;
-    close: () => void;
-};
-/**
- * Create a FrameSource from a raw async generator of { audio, data, codec, videoType, ... } frames.
- * This is the format used by reolink-baichuan-js's createNativeStream().
- */
-declare function fromNativeStream(native: AsyncGenerator<{
-    audio: boolean;
-    data: Buffer;
-    codec: string | null;
-    sampleRate: number | null;
-    microseconds: number | null;
-    videoType?: string;
-    isKeyframe?: boolean;
-}, void, unknown>): FrameSource;
-
-/**
- * Adaptive FFmpeg source — RTSP→FrameSource pipeline with hot-swappable encoding params.
- *
- * Spawns ffmpeg to transcode an RTSP source to raw H.264 Annex-B on stdout.
- * Supports dynamic bitrate/resolution changes by restarting ffmpeg with new params,
- * gating the transition on the next keyframe to avoid visual artifacts.
- */
-
-interface EncodingParams {
-    /** Max video bitrate in kbps (e.g. 8000 for 8 Mbps). */
-    maxBitrateKbps: number;
-    /** Output width (0 = keep source). */
-    width: number;
-    /** Output height (0 = keep source). */
-    height: number;
-    /** H.264 preset (default: "ultrafast"). */
-    preset?: string;
-}
-/** Audio mode: "copy" = passthrough G.711, "opus" = transcode to Opus, "off" = no audio */
-type AudioMode = "copy" | "opus" | "off";
-interface AdaptiveFfmpegSourceOptions {
-    /** RTSP source URL. */
-    rtspUrl: string;
-    /** Initial encoding parameters. */
-    initialParams: EncodingParams;
-    /** Audio mode (default: "copy"). */
-    audioMode?: AudioMode;
-    /** FFmpeg binary path (default: "ffmpeg"). */
-    ffmpegPath?: string;
-    /** Logger instance. */
-    logger?: Logger;
-    /** Label for logging. */
-    label?: string;
-}
-declare class AdaptiveFfmpegSource {
-    private readonly rtspUrl;
-    private readonly ffmpegPath;
-    private readonly logger;
-    private readonly label;
-    private readonly audioMode;
-    private currentParams;
-    private proc;
-    private audioProc;
-    private closed;
-    /** Push callback for the frame source. */
-    private pushFrame;
-    private closeSource;
-    /** The FrameSource async generator. Created once, survives ffmpeg restarts. */
-    readonly source: FrameSource;
-    constructor(options: AdaptiveFfmpegSourceOptions);
-    /** Start the ffmpeg process with current encoding params. */
-    start(): Promise<void>;
-    /** Get the current encoding parameters. */
-    getParams(): Readonly<EncodingParams>;
-    /**
-     * Hot-swap encoding parameters.
-     * Stops the current ffmpeg and starts a new one with updated params.
-     * The FrameSource continues seamlessly — the new ffmpeg's first keyframe
-     * is gated internally so consumers see a clean transition.
-     */
-    updateParams(params: Partial<EncodingParams>): Promise<void>;
-    /** Stop the source and kill ffmpeg. */
-    stop(): Promise<void>;
-    private spawnFfmpeg;
-    private killFfmpeg;
-}
-
-/**
- * Adaptive quality controller — state machine for bitrate/resolution/source adaptation.
- *
- * Monitors packet loss, jitter, and RTT from RTCP reports and client-reported stats.
- * Makes quality decisions using a three-tier degradation/recovery model:
- *
- * Level 1 — Reduce bitrate cap (ffmpeg -maxrate)
- * Level 2 — Downscale resolution (ffmpeg -vf scale=)
- * Level 3 — Switch source stream (main → sub via replaceTrack)
- *
- * Hysteresis prevents oscillation: degradation requires 2 consecutive bad intervals,
- * recovery requires 3 consecutive good intervals.
- */
-
-type QualityTier = "high" | "medium" | "low";
-interface QualityProfile {
-    tier: QualityTier;
-    /** Encoding params to apply. */
-    encoding: EncodingParams;
-    /** Source stream profile ("main" | "sub"). */
-    sourceProfile: "main" | "sub";
-}
-interface StreamStats {
-    /** Packet loss ratio (0.0 – 1.0). */
-    packetLoss: number;
-    /** Jitter in milliseconds. */
-    jitterMs: number;
-    /** Round-trip time in milliseconds. */
-    rttMs: number;
-    /** Timestamp of this measurement. */
-    timestamp: number;
-}
-interface AdaptiveControllerOptions {
-    /** Available quality profiles, ordered from highest to lowest. */
-    profiles: QualityProfile[];
-    /** Packet loss threshold to degrade (default: 0.02 = 2%). */
-    degradeThreshold?: number;
-    /** Packet loss threshold to recover (default: 0.005 = 0.5%). */
-    recoverThreshold?: number;
-    /** Consecutive bad intervals before degradation (default: 2). */
-    degradeCount?: number;
-    /** Consecutive good intervals before recovery (default: 3). */
-    recoverCount?: number;
-    /** Callback when quality should change. */
-    onQualityChange: (from: QualityProfile, to: QualityProfile) => void | Promise<void>;
-    /** Logger. */
-    logger?: Logger;
-}
-declare class AdaptiveController {
-    private readonly profiles;
-    private readonly degradeThreshold;
-    private readonly recoverThreshold;
-    private readonly degradeCount;
-    private readonly recoverCount;
-    private readonly onQualityChange;
-    private readonly logger;
-    private currentIndex;
-    private consecutiveBad;
-    private consecutiveGood;
-    private switching;
-    /** Smoothed stats per session (aggregated for decisions). */
-    private readonly sessionStats;
-    /** Manual override tier (null = auto). */
-    private forcedTier;
-    constructor(options: AdaptiveControllerOptions);
-    /** Get the current quality profile. */
-    get currentProfile(): QualityProfile;
-    /** Get the current quality tier. */
-    get currentTier(): QualityTier;
-    /** Get aggregated stats summary. */
-    getAggregatedStats(): {
-        packetLoss: number;
-        jitterMs: number;
-        rttMs: number;
-    };
-    /**
-     * Report stats from a session (RTCP or client-reported).
-     * Call this periodically (e.g. every 3–5 seconds).
-     */
-    reportStats(sessionId: string, stats: StreamStats): void;
-    /** Remove a session's stats (call on session close). */
-    removeSession(sessionId: string): void;
-    /** Force a specific quality tier (null = auto). */
-    forceQuality(tier: QualityTier | null): void;
-    /** Check if auto-adaptation is active (not forced). */
-    get isAuto(): boolean;
-    private evaluate;
-    private degrade;
-    private recover;
-    private switchTo;
-}
-
-/**
- * Adaptive WebRTC session — extends the base session pattern with:
- * - RTCP Receiver Report monitoring (packet loss, jitter, RTT)
- * - Source replacement (replaceTrack for seamless quality switching)
- * - Stats emission for the AdaptiveController
- *
- * Uses werift (optional peer dependency) for server-side WebRTC.
- */
-
-interface AdaptiveSessionOptions {
-    sessionId: string;
-    source: FrameSource;
-    intercom?: {
-        onAudioReceived: (data: Buffer, format: AudioCodec) => void | Promise<void>;
-    };
-    iceConfig?: {
-        stunServers?: string[];
-        turnServers?: Array<{
-            urls: string;
-            username?: string;
-            credential?: string;
-        }>;
-        portRange?: [number, number];
-        additionalHostAddresses?: string[];
-    };
-    /** Callback for RTCP stats (called every ~3s). */
-    onStats?: (stats: SessionStats) => void;
-    /** Enable verbose frame/RTP logging. */
-    debug?: boolean;
-    logger: Logger;
-}
-interface SessionStats {
-    sessionId: string;
-    /** Fraction of packets lost (0.0–1.0). */
-    packetLoss: number;
-    /** Interarrival jitter in ms. */
-    jitterMs: number;
-    /** Round-trip time in ms (from RTCP SR/RR). */
-    rttMs: number;
-    /** Total packets received. */
-    packetsReceived: number;
-    /** Total packets lost. */
-    packetsLost: number;
-    /** Timestamp. */
-    timestamp: number;
-}
-interface SessionInfo {
-    sessionId: string;
-    state: "new" | "connecting" | "connected" | "disconnected" | "closed";
-    createdAt: number;
-}
-declare class AdaptiveSession {
-    private readonly sessionId;
-    private source;
-    private readonly logger;
-    private readonly intercom;
-    private readonly iceConfig;
-    private readonly onStats;
-    readonly debug: boolean;
-    private readonly createdAt;
-    private state;
-    private pc;
-    private videoTrack;
-    private audioTrack;
-    /** Transceiver senders for direct sendRtp (more reliable than track.writeRtp) */
-    private videoSender;
-    private audioSender;
-    private feedAbort;
-    private closed;
-    private statsTimer;
-    /** RTP sequence number counter (must increment per packet). */
-    private videoSeqNum;
-    private audioSeqNum;
-    /** Previous RTCP stats for delta calculation. */
-    private prevPacketsReceived;
-    private prevPacketsLost;
-    constructor(options: AdaptiveSessionOptions);
-    /** Build PeerConnection options including H.264 codec config. */
-    private buildPcOptions;
-    /** Create offer SDP (server → client). */
-    createOffer(): Promise<{
-        sdp: string;
-        type: "offer";
-    }>;
-    /** Handle WHEP answer: client sends SDP answer, we set remote description and start feeding. */
-    handleAnswer(answer: {
-        sdp: string;
-        type: "answer";
-    }): Promise<void>;
-    /**
-     * Handle WHEP offer: client sends SDP offer, we create answer.
-     *
-     * Uses the server-creates-offer pattern internally: we create our own offer
-     * with sendonly tracks, then use the client's offer codecs to build a
-     * compatible answer. This avoids werift transceiver direction issues.
-     */
-    handleOffer(clientOffer: {
-        sdp: string;
-        type: "offer";
-    }): Promise<{
-        sdp: string;
-        type: "answer";
-    }>;
-    /** Add ICE candidate. */
-    addIceCandidate(candidate: any): Promise<void>;
-    /**
-     * Detach the frame source (for connection pooling).
-     * The session stays alive (ICE/DTLS connected) but stops feeding frames.
-     * Call replaceSource() later to reattach a camera.
-     */
-    detachSource(): void;
-    /** Whether the session has an active feed (vs idle/pooled). */
-    get isFeeding(): boolean;
-    /**
-     * Replace the frame source (for seamless source switching).
-     * The new source will take effect at the next keyframe.
-     */
-    replaceSource(newSource: FrameSource): void;
-    getInfo(): SessionInfo;
-    close(): Promise<void>;
-    private startFeedingFrames;
-    /** Build a serialized RTP packet for sender.sendRtp(). */
-    private buildRtpBuffer;
-    /** Max RTP payload size (MTU 1200 to stay under typical network MTU). */
-    private static readonly MAX_RTP_PAYLOAD;
-    private rtpPacketsSent;
-    private writeVideoNals;
-    private writeAudio;
-    private startStatsCollection;
-    private collectStats;
-}
-
-/**
- * Adaptive RTSP relay — transcodes an RTSP source via ffmpeg and outputs
- * a local RTSP stream that can be registered in go2rtc for WebRTC delivery.
- *
- * This avoids werift's SRTP/DTLS issues by letting go2rtc handle the
- * browser-facing WebRTC connection while we control the transcoding.
- *
- * Pipeline: Camera RTSP → ffmpeg (adaptive params) → RTSP localhost → go2rtc → WHEP → Browser
- */
-
-interface AdaptiveRtspRelayOptions {
-    /** RTSP source URL (camera or upstream go2rtc). */
-    rtspUrl: string;
-    /** Local RTSP output URL (e.g. rtsp://127.0.0.1:8554/adaptive_ingresso_main). */
-    rtspOutputUrl: string;
-    /** Initial encoding parameters. */
-    initialParams: EncodingParams;
-    /** FFmpeg binary path (default: "ffmpeg"). */
-    ffmpegPath?: string;
-    /** Logger. */
-    logger?: Logger;
-    /** Label for logging. */
-    label?: string;
-}
-declare class AdaptiveRtspRelay {
-    private readonly rtspUrl;
-    private readonly rtspOutputUrl;
-    private readonly ffmpegPath;
-    private readonly logger;
-    private readonly label;
-    private currentParams;
-    private proc;
-    private closed;
-    constructor(options: AdaptiveRtspRelayOptions);
-    getParams(): Readonly<EncodingParams>;
-    /** Start the ffmpeg relay. */
-    start(): void;
-    /** Hot-swap encoding parameters by restarting ffmpeg. */
-    updateParams(params: Partial<EncodingParams>): Promise<void>;
-    /** Stop the relay. */
-    stop(): Promise<void>;
-    /** Check if ffmpeg is running. */
-    isRunning(): boolean;
-    private spawnFfmpeg;
-    private killFfmpeg;
-}
-
-/**
- * SharedSession — single RTCPeerConnection with multiple dynamic video tracks.
- *
- * One connection per client. Tracks are added/removed via data channel messages.
- * Each track corresponds to one camera's ffmpeg source.
- *
- * Protocol (data channel JSON messages):
- *
- * Client → Server:
- *   { type: "addTrack", cameraName: string, trackId: string }
- *   { type: "removeTrack", trackId: string }
- *   { type: "answer", sdp: string }
- *
- * Server → Client:
- *   { type: "offer", sdp: string }
- *   { type: "trackReady", trackId: string, mid: string }
- *   { type: "trackRemoved", trackId: string }
- *   { type: "error", message: string }
- */
-
-interface SharedSessionOptions {
-    iceConfig?: {
-        stunServers?: string[];
-        turnServers?: Array<{
-            urls: string;
-            username?: string;
-            credential?: string;
-        }>;
-        portRange?: [number, number];
-        additionalHostAddresses?: string[];
-    };
-    /** Called when the server needs to attach a camera source for a track. */
-    onTrackRequested: (cameraName: string) => FrameSource | null;
-    /** Called when a track is removed. */
-    onTrackReleased?: (cameraName: string) => void;
-    /** Called when intercom audio is received from the client for a camera. */
-    onIntercomAudio?: (cameraName: string, data: Buffer) => void;
-    logger: Logger;
-}
-declare class SharedSession {
-    private readonly options;
-    private readonly logger;
-    private readonly iceConfig;
-    private readonly onTrackRequested;
-    private readonly onTrackReleased;
-    private pc;
-    private dataChannel;
-    private readonly activeTracks;
-    private closed;
-    private negotiating;
-    constructor(options: SharedSessionOptions);
-    /** Create the initial SDP offer (with data channel, no media tracks yet). */
-    createOffer(): Promise<string>;
-    /** Handle the client's SDP answer. */
-    handleAnswer(sdpAnswer: string): Promise<void>;
-    /** Close the shared session and all tracks. */
-    close(): Promise<void>;
-    private handleDataChannelMessage;
-    private handleAddTrack;
-    private handleRemoveTrack;
-    private handleRenegotiationAnswer;
-    private renegotiate;
-    private startFeeding;
-    private sendDC;
-    get isConnected(): boolean;
-    get trackCount(): number;
-}
-
-/**
- * Adaptive WebRTC streaming server — multi-camera manager with quality adaptation.
- *
- * For each camera:
- * - Spawns AdaptiveFfmpegSource to transcode RTSP → H.264 with configurable params
- * - Uses StreamFanout to distribute frames to multiple viewer sessions
- * - AdaptiveController monitors stats and adjusts quality per-camera
- *
- * Usage:
- *   const server = new AdaptiveStreamServer({ ... });
- *   server.addCamera("front_door", { rtspUrl: "rtsp://...", profiles: [...] });
- *   const { sessionId, answer } = await server.handleWhepOffer("front_door", sdpOffer);
- */
-
-interface AdaptiveStreamServerOptions {
-    /** FFmpeg binary path (default: "ffmpeg"). */
-    ffmpegPath?: string;
-    /** STUN servers for ICE. */
-    stunServers?: string[];
-    /** TURN servers for ICE. */
-    turnServers?: Array<{
-        urls: string;
-        username?: string;
-        credential?: string;
-    }>;
-    /** ICE port range. */
-    icePortRange?: [number, number];
-    /** Additional host IPs to announce. */
-    iceAdditionalHostAddresses?: string[];
-    /** Logger. */
-    logger?: Logger;
-}
-interface CameraConfig {
-    /** Primary RTSP source URL (typically main stream). */
-    rtspUrl: string;
-    /** Secondary RTSP source URL (typically sub stream, for Level 3 switching). */
-    subRtspUrl?: string;
-    /** Quality profiles ordered from highest to lowest quality. */
-    profiles: QualityProfile[];
-    /** Audio mode: "copy" (G.711 passthrough), "opus" (transcode), "off" (no audio). Default: "copy". */
-    audioMode?: "copy" | "opus" | "off";
-}
-/** Default quality profiles for adaptive streaming. */
-declare function createDefaultProfiles(): QualityProfile[];
-declare class AdaptiveStreamServer extends EventEmitter {
-    private readonly ffmpegPath;
-    private readonly stunServers;
-    private readonly turnServers;
-    private readonly icePortRange;
-    private readonly iceAdditionalHostAddresses;
-    private readonly logger;
-    private readonly cameras;
-    private readonly sessionCamera;
-    private stopped;
-    constructor(options?: AdaptiveStreamServerOptions);
-    /** Register a camera with adaptive streaming. */
-    addCamera(name: string, config: CameraConfig): void;
-    /** Remove a camera and close all its sessions. */
-    removeCamera(name: string): Promise<void>;
-    getCameraNames(): string[];
-    /**
-     * Create an adaptive session for a camera.
-     * Returns a server-generated SDP offer that the client must answer.
-     *
-     * Flow: createSession() → server offer → client sets remote, creates answer → handleAnswer()
-     */
-    createSession(cameraName: string): Promise<{
-        sessionId: string;
-        sdpOffer: string;
-    }>;
-    /**
-     * Handle the client's SDP answer for an adaptive session.
-     * Call after createSession() with the client's answer.
-     */
-    handleAnswer(sessionId: string, sdpAnswer: string): Promise<void>;
-    /**
-     * Convenience: handleWhepOffer is NOT supported — werift requires server-initiated offers.
-     * Use createSession() + handleAnswer() instead.
-     */
-    handleWhepOffer(_cameraName: string, _sdpOffer: string): Promise<{
-        sessionId: string;
-        sdpAnswer: string;
-    }>;
-    /** Pooled sessions: sessionId → true (idle, no camera attached). */
-    private readonly pooledSessions;
-    /**
-     * Create a pooled session (no camera attached yet).
-     * The SDP exchange happens, ICE connects, but no ffmpeg is started.
-     * Call attachCamera() later to start feeding frames.
-     */
-    createPooledSession(): Promise<{
-        sessionId: string;
-        sdpOffer: string;
-    }>;
-    /**
-     * Attach a camera to a pooled session.
-     * Starts the ffmpeg transcoder and begins feeding frames.
-     */
-    attachCamera(sessionId: string, cameraName: string): Promise<void>;
-    /**
-     * Detach a camera from a session (session returns to pool).
-     */
-    detachCamera(sessionId: string): Promise<void>;
-    /** Check if a session is in the idle pool. */
-    isPooledSession(sessionId: string): boolean;
-    /** Set debug flag on all sessions for a camera. */
-    setDebug(cameraName: string, debug: boolean): number;
-    /** Get count of idle pooled sessions. */
-    getPoolSize(): number;
-    /** Close a specific session. */
-    closeSession(sessionId: string): Promise<void>;
-    /**
-     * Report client-side stats for a session (supplements RTCP monitoring).
-     * Call from tRPC route when the client pushes stats.
-     */
-    reportClientStats(sessionId: string, stats: StreamStats): {
-        currentTier: QualityTier;
-        currentBitrateKbps: number;
-        currentResolution: {
-            width: number;
-            height: number;
-        };
-        sourceProfile: "main" | "sub";
-    } | null;
-    /** Force quality for a camera (null = auto). */
-    forceQuality(cameraName: string, tier: QualityTier | null): boolean;
-    /** Get current quality info for a camera. */
-    getCameraQuality(cameraName: string): {
-        tier: QualityTier;
-        encoding: EncodingParams;
-        isAuto: boolean;
-        stats: {
-            packetLoss: number;
-            jitterMs: number;
-            rttMs: number;
-        };
-        sessionCount: number;
-        sourceProfile: "main" | "sub";
-    } | null;
-    /** Get all sessions. */
-    getSessions(cameraName?: string): SessionInfo[];
-    getSessionCount(cameraName?: string): number;
-    /** Stop all cameras and sessions. */
-    stop(): Promise<void>;
-    /** Get the currently active fanout for a camera. */
-    private getActiveFanout;
-    private ensureCameraRunning;
-    private scheduleCameraAutoStop;
-    /**
-     * Handle a quality change from the AdaptiveController.
-     * When the sourceProfile changes (main ↔ sub), performs a seamless source
-     * switch for all active sessions. When only encoding params change (same
-     * sourceProfile), updates ffmpeg params in-place.
-     */
-    private handleQualityChange;
-    /**
-     * Switch all active sessions from one source to another (main ↔ sub).
-     *
-     * Steps:
-     * 1. Create/start the target ffmpeg source + fanout
-     * 2. For each session: subscribe to new fanout, call replaceSource()
-     * 3. Unsubscribe all from old fanout
-     * 4. Stop old ffmpeg + fanout (save resources)
-     * 5. Update activeSourceProfile
-     */
-    private switchSource;
-}
-
-export { AdaptiveController, type AdaptiveControllerOptions, AdaptiveFfmpegSource, type AdaptiveFfmpegSourceOptions, AdaptiveRtspRelay, type AdaptiveRtspRelayOptions, AdaptiveSession, type AdaptiveSessionOptions, AdaptiveStreamServer, type AdaptiveStreamServerOptions, type AnnotatedSnapshotResult, AsyncBoundedQueue, type AudioCodec, type AudioFrame, type AudioMode, BuiltinAnalysisAddon, type CameraConfig, type ClipRecognizer, DEFAULT_RETENTION, DecoderRegistry, type EncodingParams, type EventBufferStatus, type EventPersistenceDeps, EventPersistenceService, FfmpegDecoderProvider, FfmpegDecoderSession, FfmpegProcess, type FfmpegProcessOptions, FrameDropper, type FrameSource, type FrameSourceFactory, type GlobalIdentity, H264RtpDepacketizer, H265RtpDepacketizer, type IAnalysisDataPersistence, type KnownFaceEntry, type KnownFacesDeps, KnownFacesService, type LoggerLike, type MediaFrame, type ObjectSnapshotResult, type PersistableEvent, type QualityProfile, type QualityTier, type RetentionConfig, type RetentionDeps, type RetentionReport, RetentionService, type SessionInfo, type SessionStats, type SessionTrack, type SessionTrackerDeps, SessionTrackerService, SharedSession, type SharedSessionOptions, StreamBroker, StreamBrokerManager, StreamFanout, type StreamFanoutOptions, StreamPipeServer, type StreamStats, type TrackCaptureConfig, type TrackMediaFile, type TrackMediaType, type TrackPosition, type TrackSnapshot, type TrackTrail, type TrackTrailDeps, TrackTrailService, type VideoCodec, type Logger as WebRtcLogger, type VideoFrame as WebRtcVideoFrame, asLogger, convertH264ToAnnexB, convertH265ToAnnexB, cosineSimilarity, createDefaultProfiles, createNullLogger, detectVideoCodecFromNal, extractH264ParamSets, extractH265ParamSets, fromEventEmitter, fromNativeStream, fromPushCallback, getH265NalType, hasStartCodes, isH264IdrAccessUnit, isH264KeyframeAnnexB, isH265Irap, isH265IrapAccessUnit, isH265KeyframeAnnexB, joinNalsToAnnexB, prependStartCode, splitAnnexBToNals };
+export { type AnnotatedSnapshotResult, BuiltinAnalysisAddon, type ClipRecognizer, DEFAULT_RETENTION, DecoderRegistry, type EventBufferStatus, type EventPersistenceDeps, EventPersistenceService, FfmpegDecoderProvider, FfmpegDecoderSession, FrameDropper, type GlobalIdentity, type IAnalysisDataPersistence, type KnownFaceEntry, type KnownFacesDeps, KnownFacesService, type ObjectSnapshotResult, type PersistableEvent, type RetentionConfig, type RetentionDeps, type RetentionReport, RetentionService, type SessionTrack, type SessionTrackerDeps, SessionTrackerService, StreamBroker, StreamBrokerManager, StreamPipeServer, type TrackCaptureConfig, type TrackMediaFile, type TrackMediaType, type TrackPosition, type TrackSnapshot, type TrackTrail, type TrackTrailDeps, TrackTrailService, cosineSimilarity };