@zero-server/sdk 0.9.10 → 1.0.1

package/lib/webrtc/mcu/index.js

@@ -0,0 +1,211 @@
+/**
+ * @module webrtc/mcu
+ * @description Optional MCU (multipoint control unit) layer that sits on
+ *   top of an {@link SfuAdapter}. Where an SFU forwards each publisher's
+ *   stream untouched, an MCU mixes them down to a smaller number of
+ *   composite tracks (one audio mix + one tiled video) so receivers only
+ *   have to decode O(1) streams instead of O(N). The right topology for
+ *   SIP gateways, low-end clients, regulated recording, and ultra-large
+ *   rooms where consumer decode cost is the bottleneck.
+ *
+ *   zero-server ships no native mixer — JS-side Opus/H264 transcoding is
+ *   CPU-prohibitive. The MCU layer is a contract: adapters can spawn
+ *   ffmpeg (the included {@link FfmpegMcuAdapter}), shell out to a
+ *   GPU-backed mixer, or call into a managed service. The
+ *   {@link MemoryMcuAdapter} is bookkeeping only for tests and capacity
+ *   planning.
+ *
+ * @example | Bookkeeping-only mixer (tests, capacity planning)
+ *   const mcu = new MemoryMcuAdapter({ sfu });
+ *   const { mixedProducerId } = await mcu.mix('lobby', {
+ *       producerIds: ['p1', 'p2', 'p3'],
+ *       kind:        'audio',
+ *   });
+ *
+ * @example | Real audio mixing via ffmpeg
+ *   const mcu = new FfmpegMcuAdapter({ sfu });
+ *   const mix = await mcu.mix('lobby', {
+ *       producerIds: ['p1', 'p2'],
+ *       inputs:      [{ sdp: '/tmp/in1.sdp' }, { sdp: '/tmp/in2.sdp' }],
+ *       outputs:     [{ url: 'rtp://127.0.0.1:5004' }],
+ *       kind:        'audio',
+ *   });
+ */
+
+'use strict';
+
+const { WebRTCError } = require('../../errors');
+
+/** @typedef {'grid'|'presenter'|'presenter-strip'|'dominant'|'pip'} McuLayout */
+
+// --- McuAdapter base ---
+
+/**
+ * Abstract MCU base class. Adapter authors override `mix` / `unmix` /
+ * `setLayout` to back the composite with a real mixer. All methods default
+ * to throwing `WEBRTC_MCU_NOT_IMPLEMENTED` so missing capability surfaces
+ * immediately rather than silently no-oping.
+ *
+ * @class
+ * @section MCU
+ */
+class McuAdapter
+{
+    /**
+     * @constructor
+     * @param {object} [opts]
+     * @param {object} [opts.sfu]   - Bound SfuAdapter, used by subclasses that need to ingest/produce.
+     * @param {string} [opts.name]  - Adapter name, defaults to the constructor name.
+     */
+    constructor(opts)
+    {
+        const o = opts || {};
+        this.sfu = o.sfu || null;
+        this.name = o.name || this.constructor.name;
+    }
+
+    // -- Mixing --
+
+    /**
+     * Start a new composite.
+     *
+     * @param {string} _roomId
+     * @param {object} _opts  - `{ producerIds, kind:'audio'|'video'|'av', layout?, output? }`
+     * @returns {Promise<{mixedProducerId:string, kind:string, layout:McuLayout, sources:string[]}>}
+     * @section Mixing
+     */
+    // eslint-disable-next-line no-unused-vars
+    async mix(_roomId, _opts) { throw new WebRTCError(`${this.name}.mix not implemented`, { code: 'WEBRTC_MCU_NOT_IMPLEMENTED' }); }
+
+    /**
+     * Tear down a composite.
+     * @param {string} _mixedProducerId
+     * @section Mixing
+     */
+    // eslint-disable-next-line no-unused-vars
+    async unmix(_mixedProducerId) { throw new WebRTCError(`${this.name}.unmix not implemented`, { code: 'WEBRTC_MCU_NOT_IMPLEMENTED' }); }
+
+    /**
+     * Change video layout on the fly.
+     * @param {string} _mixedProducerId
+     * @param {McuLayout|object} _layout
+     * @section Mixing
+     */
+    // eslint-disable-next-line no-unused-vars
+    async setLayout(_mixedProducerId, _layout) { throw new WebRTCError(`${this.name}.setLayout not implemented`, { code: 'WEBRTC_MCU_NOT_IMPLEMENTED' }); }
+
+    /**
+     * Add a producer to an existing mix.
+     * @param {string} _mixedProducerId
+     * @param {string} _producerId
+     * @section Mixing
+     */
+    // eslint-disable-next-line no-unused-vars
+    async addSource(_mixedProducerId, _producerId) { throw new WebRTCError(`${this.name}.addSource not implemented`, { code: 'WEBRTC_MCU_NOT_IMPLEMENTED' }); }
+
+    /**
+     * Remove a producer from a mix.
+     * @param {string} _mixedProducerId
+     * @param {string} _producerId
+     * @section Mixing
+     */
+    // eslint-disable-next-line no-unused-vars
+    async removeSource(_mixedProducerId, _producerId) { throw new WebRTCError(`${this.name}.removeSource not implemented`, { code: 'WEBRTC_MCU_NOT_IMPLEMENTED' }); }
+
+    // -- Inspection --
+
+    /**
+     * Snapshot of active mixes.
+     * @returns {{mixes: Array<{id:string, sources:string[], layout:McuLayout, kind:string}>}}
+     * @section Inspection
+     */
+    stats() { return { mixes: [] }; }
+
+    /**
+     * Tear down every active mix.
+     * @section Lifecycle
+     */
+    async close() { /* override in subclasses */ }
+}
+
+// --- MemoryMcuAdapter ---
+
+/**
+ * Bookkeeping-only MCU. Doesn't touch media — useful for tests and for
+ * apps that want to model the MCU topology cost without paying for real
+ * mixing. Produces synthetic mixed-producer ids of the form
+ * `mcu:<roomId>:<n>`.
+ *
+ * @class
+ * @section MCU
+ */
+class MemoryMcuAdapter extends McuAdapter
+{
+    constructor(opts)
+    {
+        super(opts);
+        this._next  = 0;
+        /** @type {Map<string, {id:string, room:string, kind:string, layout:McuLayout, sources:Set<string>, output:object|null}>} */
+        this._mixes = new Map();
+    }
+
+    _id(roomId) { return `mcu:${roomId}:${++this._next}`; }
+
+    async mix(roomId, opts)
+    {
+        const o = opts || {};
+        if (!roomId) throw new WebRTCError('mix: roomId required', { code: 'WEBRTC_MCU_BAD_ARGS' });
+        const kind   = o.kind || 'audio';
+        const layout = o.layout || (kind === 'audio' ? 'audio-only' : 'grid');
+        const sources = new Set(Array.isArray(o.producerIds) ? o.producerIds : []);
+        const id = this._id(roomId);
+        this._mixes.set(id, { id, room: roomId, kind, layout, sources, output: o.output || null });
+        return { mixedProducerId: id, kind, layout, sources: [...sources] };
+    }
+
+    async unmix(mixedProducerId)
+    {
+        const m = this._mixes.get(mixedProducerId);
+        if (!m) return false;
+        this._mixes.delete(mixedProducerId);
+        return true;
+    }
+
+    async setLayout(mixedProducerId, layout)
+    {
+        const m = this._mixes.get(mixedProducerId);
+        if (!m) throw new WebRTCError('setLayout: unknown mix', { code: 'WEBRTC_MCU_NO_MIX' });
+        m.layout = typeof layout === 'string' ? layout : (layout && layout.name) || m.layout;
+        return m.layout;
+    }
+
+    async addSource(mixedProducerId, producerId)
+    {
+        const m = this._mixes.get(mixedProducerId);
+        if (!m) throw new WebRTCError('addSource: unknown mix', { code: 'WEBRTC_MCU_NO_MIX' });
+        m.sources.add(producerId);
+        return m.sources.size;
+    }
+
+    async removeSource(mixedProducerId, producerId)
+    {
+        const m = this._mixes.get(mixedProducerId);
+        if (!m) throw new WebRTCError('removeSource: unknown mix', { code: 'WEBRTC_MCU_NO_MIX' });
+        m.sources.delete(producerId);
+        return m.sources.size;
+    }
+
+    stats()
+    {
+        const mixes = [];
+        for (const m of this._mixes.values())
+        {
+            mixes.push({ id: m.id, room: m.room, sources: [...m.sources], layout: m.layout, kind: m.kind });
+        }
+        return { mixes };
+    }
+
+    async close() { this._mixes.clear(); }
+}
+
+module.exports = { McuAdapter, MemoryMcuAdapter };

package/lib/webrtc/observe.js

@@ -52,6 +52,21 @@ function _registerMetrics(registry)
             help:   'Detected ICE restarts (ufrag rotation) per room.',
             labels: ['room'],
         }),
+        peersPerMeshRoom: registry.gauge({
+            name:   'zs_webrtc_peers_per_mesh_room',
+            help:   'Current peer count for rooms still in full-mesh topology.',
+            labels: ['room'],
+        }),
+        meshOverflow: registry.counter({
+            name:   'zs_webrtc_mesh_overflow_total',
+            help:   'Rooms that exceeded `maxMeshPeers` while still in mesh topology (signals N² uplink risk).',
+            labels: ['room'],
+        }),
+        topologyPromotions: registry.counter({
+            name:   'zs_webrtc_topology_promotions_total',
+            help:   'Auto-promotions from one topology to another (e.g. mesh→sfu).',
+            labels: ['room', 'from', 'to'],
+        }),
     };
 }
 
@@ -73,6 +88,8 @@ function _bindMetrics(hub, m)
         m.peersActive.inc({ room: room.name });
         // Room newly non-empty?
         if (before === 0) m.roomsActive.inc();
+        if (room.topology === 'mesh')
+            m.peersPerMeshRoom.set({ room: room.name }, room.size);
     });
 
     hub.on('leave', ({ peer, room }) =>
@@ -80,6 +97,27 @@ function _bindMetrics(hub, m)
         m.peersActive.dec({ room: room.name });
         if (m.peersActive.get({ room: room.name }) <= 0)
             m.roomsActive.dec();
+        if (room.topology === 'mesh')
+            m.peersPerMeshRoom.set({ room: room.name }, room.size);
+    });
+
+    hub.on('peer:limit:reached', ({ room }) =>
+    {
+        if (room.topology === 'mesh')
+            m.meshOverflow.inc({ room: room.name });
+    });
+
+    hub.on('topology:promoted', ({ room, from, to }) =>
+    {
+        m.topologyPromotions.inc({ room: room.name, from, to });
+        // Promotion drains the mesh gauge.
+        m.peersPerMeshRoom.set({ room: room.name }, 0);
+    });
+
+    hub.on('topology:demoted', ({ room, from, to }) =>
+    {
+        m.topologyPromotions.inc({ room: room.name, from, to });
+        m.peersPerMeshRoom.set({ room: room.name }, room.size);
     });
 
     hub.on('joinFailed', ({ reason }) =>

package/lib/webrtc/recording.js

@@ -0,0 +1,410 @@
+/**
+ * @module webrtc/recording
+ * @description Adapter-agnostic recording / egress / ingress facade.
+ *   {@link RecordingManager} auto-detects which pipeline the bound
+ *   {@link SfuAdapter} supports (`livekit` egress, `ffmpeg` child, or
+ *   `memory` bookkeeping) and exposes a uniform `startRecording` /
+ *   `stopRecording` surface. {@link IngressManager} wraps the adapter's
+ *   `createIngress` / `deleteIngress` calls for WHIP / RTMP / SIP /
+ *   URL-pull sources.
+ *
+ * @example | Auto-pipeline recording on top of any adapter
+ *   const rec = new RecordingManager({ adapter: hub.sfu });
+ *   const { id, stop } = await rec.startRecording('lobby', {
+ *       layout: 'grid',
+ *       format: 'mp4',
+ *       sink:   { file: '/var/recordings/lobby.mp4' },
+ *   });
+ *   // later
+ *   await stop();
+ *
+ * @example | Force the ffmpeg pipeline
+ *   const rec = new RecordingManager({ adapter: hub.sfu, ffmpegPath: '/usr/bin/ffmpeg' });
+ *   await rec.startRecording('lobby', {
+ *       pipeline: 'ffmpeg',
+ *       inputs:   [{ sdp: '/tmp/in.sdp' }],
+ *       sink:     { file: '/tmp/out.mp4' },
+ *   });
+ *
+ * @example | Create a WHIP ingress and route it into a room
+ *   const ing = new IngressManager({ adapter: hub.sfu });
+ *   const stream = await ing.createIngress({ kind: 'whip', name: 'studio', roomName: 'lobby' });
+ *   // publish using stream.native.url
+ */
+
+'use strict';
+
+const { WebRTCError } = require('../errors');
+
+/** @typedef {'mp4'|'webm'|'mka'|'ogg'|'hls'} RecordingFormat */
+/** @typedef {'grid'|'presenter'|'presenter-strip'|'dominant'|'speaker'|'audio-only'} RecordingLayout */
+
+// --- RecordingManager ---
+
+/**
+ * Adapter-agnostic recording facade. Pipeline auto-resolves from
+ * `adapter.startRoomCompositeEgress` (LiveKit) → `livekit`; fall back is
+ * `memory` (bookkeeping only). Pass `pipeline: 'ffmpeg'` to spawn ffmpeg
+ * children.
+ *
+ * @class
+ * @section Recording
+ */
+class RecordingManager
+{
+    /**
+     * @constructor
+     * @param {object} opts
+     * @param {object} opts.adapter   - SfuAdapter (or anything exposing egress methods).
+     * @param {Function} [opts.spawn] - For `pipeline: 'ffmpeg'` (defaults to `child_process.spawn`).
+     * @param {string}   [opts.ffmpegPath]
+     */
+    constructor(opts)
+    {
+        const o = opts || {};
+        if (!o.adapter) throw new WebRTCError('RecordingManager requires { adapter }', { code: 'WEBRTC_RECORDING_NO_ADAPTER' });
+        this.adapter     = o.adapter;
+        this._spawn      = o.spawn || null;
+        this._ffmpegPath = o.ffmpegPath || null;
+        this._next       = 0;
+        /** @type {Map<string, {id:string, roomName:string, kind:string, backend:string, native:object|null, child:object|null, opts:object, status:string, startedAt:number, stoppedAt:number|null}>} */
+        this._records    = new Map();
+    }
+
+    _id() { return `rec-${++this._next}-${Date.now().toString(36)}`; }
+
+    /**
+     * Start a new recording for `roomName`.  The `pipeline` field selects
+     * the backend:
+     *
+     *   - `'livekit'` — call `adapter.startRoomCompositeEgress`.
+     *   - `'livekit-track'` — call `adapter.startTrackEgress`.
+     *   - `'ffmpeg'` — spawn an ffmpeg child process (requires
+     *     `{ ffmpegPath }` or `ffmpeg-static`; caller wires RTP).
+     *   - `'memory'` — bookkeeping only (default when no other backend
+     *     can be inferred).
+     *
+     * @param {string} roomName
+     * @param {object} [opts]
+     * @returns {Promise<{id:string, status:string, stop:Function, info():object}>}
+     * @section Recording
+     */
+    async startRecording(roomName, opts)
+    {
+        if (!roomName) throw new WebRTCError('startRecording: roomName required', { code: 'WEBRTC_RECORDING_BAD_ARGS' });
+        const o = opts || {};
+        const pipeline = o.pipeline || this._inferPipeline();
+        const id = this._id();
+        const entry = {
+            id, roomName,
+            kind:      o.kind || 'composite',
+            backend:   pipeline,
+            native:    null,
+            child:     null,
+            opts:      o,
+            status:    'starting',
+            startedAt: Date.now(),
+            stoppedAt: null,
+        };
+        this._records.set(id, entry);
+
+        try
+        {
+            if (pipeline === 'livekit')
+            {
+                if (typeof this.adapter.startRoomCompositeEgress !== 'function')
+                    throw new WebRTCError('adapter does not implement startRoomCompositeEgress', { code: 'WEBRTC_RECORDING_NO_BACKEND' });
+                entry.native = await this.adapter.startRoomCompositeEgress(roomName, o);
+            }
+            else if (pipeline === 'livekit-track')
+            {
+                if (typeof this.adapter.startTrackEgress !== 'function')
+                    throw new WebRTCError('adapter does not implement startTrackEgress', { code: 'WEBRTC_RECORDING_NO_BACKEND' });
+                entry.native = await this.adapter.startTrackEgress(roomName, o);
+            }
+            else if (pipeline === 'ffmpeg')
+            {
+                entry.child = this._spawnFfmpeg(o);
+            }
+            else if (pipeline === 'memory')
+            {
+                /* nothing to do — caller models the cost */
+            }
+            else
+            {
+                throw new WebRTCError(`unknown recording pipeline: ${pipeline}`, { code: 'WEBRTC_RECORDING_BAD_PIPELINE' });
+            }
+            entry.status = 'recording';
+        }
+        catch (err)
+        {
+            entry.status = 'failed';
+            entry.error  = err && err.message;
+            entry.stoppedAt = Date.now();
+            throw err;
+        }
+
+        return {
+            id,
+            status: entry.status,
+            stop:   () => this.stopRecording(id),
+            info:   () => this._snapshot(entry),
+        };
+    }
+
+    /**
+     * Stop an active recording by id.  Idempotent.
+     *
+     * @param {string} id
+     * @returns {Promise<boolean>} true if the recording was stopped here.
+     * @section Recording
+     */
+    async stopRecording(id)
+    {
+        const entry = this._records.get(id);
+        if (!entry) return false;
+        if (entry.status === 'stopped' || entry.status === 'failed') return false;
+        entry.status = 'stopping';
+        try
+        {
+            if (entry.backend === 'livekit' || entry.backend === 'livekit-track')
+            {
+                const egressId = entry.native && (entry.native.egressId || entry.native.egress_id || entry.native.id);
+                if (egressId && typeof this.adapter.stopEgress === 'function')
+                    await this.adapter.stopEgress(egressId);
+            }
+            else if (entry.backend === 'ffmpeg')
+            {
+                if (entry.child && typeof entry.child.kill === 'function')
+                {
+                    try { entry.child.kill('SIGTERM'); } catch { /* swallow */ }
+                }
+            }
+            entry.status    = 'stopped';
+            entry.stoppedAt = Date.now();
+            return true;
+        }
+        catch (err)
+        {
+            entry.status    = 'failed';
+            entry.error     = err && err.message;
+            entry.stoppedAt = Date.now();
+            throw err;
+        }
+    }
+
+    /**
+     * List every recording the manager knows about.
+     * @returns {Array<object>}
+     * @section Inspection
+     */
+    list()
+    {
+        const out = [];
+        for (const entry of this._records.values()) out.push(this._snapshot(entry));
+        return out;
+    }
+
+    /**
+     * Aggregate counts for observability.
+     * @returns {{recording:number, stopped:number, failed:number, total:number}}
+     * @section Inspection
+     */
+    stats()
+    {
+        let recording = 0, stopped = 0, failed = 0;
+        for (const e of this._records.values())
+        {
+            if (e.status === 'recording' || e.status === 'starting' || e.status === 'stopping') recording++;
+            else if (e.status === 'stopped') stopped++;
+            else if (e.status === 'failed')  failed++;
+        }
+        return { recording, stopped, failed, total: this._records.size };
+    }
+
+    /**
+     * Stop every active recording.  Safe to call during shutdown.
+     * @section Lifecycle
+     */
+    async close()
+    {
+        const active = [...this._records.values()].filter((e) => e.status === 'recording' || e.status === 'starting');
+        for (const e of active)
+        {
+            try { await this.stopRecording(e.id); } catch { /* swallow */ }
+        }
+    }
+
+    /** @private */
+    _snapshot(e)
+    {
+        return {
+            id:        e.id,
+            roomName:  e.roomName,
+            kind:      e.kind,
+            backend:   e.backend,
+            status:    e.status,
+            startedAt: e.startedAt,
+            stoppedAt: e.stoppedAt,
+            pid:       e.child && e.child.pid,
+            native:    e.native ? { id: e.native.egressId || e.native.id || null } : null,
+            error:     e.error || null,
+        };
+    }
+
+    /** @private */
+    _inferPipeline()
+    {
+        if (typeof this.adapter.startRoomCompositeEgress === 'function') return 'livekit';
+        return 'memory';
+    }
+
+    /** @private */
+    _spawnFfmpeg(opts)
+    {
+        const spawn = this._spawn || require('child_process').spawn;
+        let path = this._ffmpegPath;
+        if (!path)
+        {
+            try { path = require('ffmpeg-static'); }
+            catch
+            {
+                throw new WebRTCError(
+                    'ffmpeg pipeline requires `ffmpeg-static` (npm i ffmpeg-static) or { ffmpegPath }',
+                    { code: 'WEBRTC_RECORDING_NO_FFMPEG' },
+                );
+            }
+        }
+        const args = Array.isArray(opts.args) ? opts.args : this._buildFfmpegArgs(opts);
+        return spawn(path, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    }
+
+    /** @private */
+    _buildFfmpegArgs(opts)
+    {
+        const o = opts || {};
+        const inputs  = Array.isArray(o.inputs)  ? o.inputs  : [];
+        const sink    = o.sink || {};
+        const format  = o.format || (sink.file && sink.file.endsWith('.webm') ? 'webm' : 'mp4');
+        const args    = ['-y', '-loglevel', 'warning'];
+        for (const inp of inputs)
+        {
+            if (inp.sdp)      args.push('-protocol_whitelist', 'pipe,udp,rtp', '-f', 'sdp', '-i', inp.sdp);
+            else if (inp.url) args.push('-i', inp.url);
+        }
+        if (sink.file)      args.push('-f', format, sink.file);
+        else if (sink.url)  args.push('-f', sink.format || 'rtp', sink.url);
+        return args;
+    }
+}
+
+// --- IngressManager ---
+
+/**
+ * Tracks ingresses created via the adapter (WHIP / RTMP / URL pull / SIP)
+ * so callers don't need their own bookkeeping. Delegates the actual
+ * lifecycle to `adapter.createIngress` / `adapter.deleteIngress`.
+ *
+ * @class
+ * @section Recording
+ */
+class IngressManager
+{
+    /**
+     * @constructor
+     * @param {object} opts
+     * @param {object} opts.adapter
+     */
+    constructor(opts)
+    {
+        const o = opts || {};
+        if (!o.adapter) throw new WebRTCError('IngressManager requires { adapter }', { code: 'WEBRTC_INGRESS_NO_ADAPTER' });
+        this.adapter = o.adapter;
+        this._next   = 0;
+        /** @type {Map<string, {id:string, kind:string, roomName:string|null, native:object, opts:object, createdAt:number}>} */
+        this._ingresses = new Map();
+    }
+
+    _id() { return `ing-${++this._next}-${Date.now().toString(36)}`; }
+
+    /**
+     * Create an ingress (WHIP / RTMP / URL pull / SIP).
+     * @param {object} opts - `{ kind, roomName, name, ... }`
+     * @section Recording
+     */
+    async createIngress(opts)
+    {
+        const o = opts || {};
+        if (typeof this.adapter.createIngress !== 'function')
+            throw new WebRTCError('adapter does not implement createIngress', { code: 'WEBRTC_INGRESS_NO_BACKEND' });
+        const native = await this.adapter.createIngress(o);
+        const id = this._id();
+        const entry = {
+            id,
+            kind:      o.kind || o.inputType || 'rtmp',
+            roomName:  o.roomName || o.room || null,
+            native,
+            opts:      o,
+            createdAt: Date.now(),
+        };
+        this._ingresses.set(id, entry);
+        return { id, native, info: () => this._snapshot(entry) };
+    }
+
+    /**
+     * Tear down an ingress by id.  Idempotent.
+     * @param {string} id
+     * @returns {Promise<boolean>}
+     * @section Recording
+     */
+    async deleteIngress(id)
+    {
+        const entry = this._ingresses.get(id);
+        if (!entry) return false;
+        this._ingresses.delete(id);
+        if (typeof this.adapter.deleteIngress === 'function')
+        {
+            const ingressId = entry.native && (entry.native.ingressId || entry.native.id);
+            if (ingressId) await this.adapter.deleteIngress(ingressId);
+        }
+        return true;
+    }
+
+    /**
+     * List every known ingress.
+     * @returns {Array<object>}
+     * @section Inspection
+     */
+    list()
+    {
+        const out = [];
+        for (const entry of this._ingresses.values()) out.push(this._snapshot(entry));
+        return out;
+    }
+
+    /**
+     * Tear down every active ingress.  Safe to call during shutdown.
+     * @section Lifecycle
+     */
+    async close()
+    {
+        for (const id of [...this._ingresses.keys()])
+        {
+            try { await this.deleteIngress(id); } catch { /* swallow */ }
+        }
+    }
+
+    /** @private */
+    _snapshot(e)
+    {
+        return {
+            id:        e.id,
+            kind:      e.kind,
+            roomName:  e.roomName,
+            createdAt: e.createdAt,
+            native:    e.native ? { id: e.native.ingressId || e.native.id || null, url: e.native.url || e.native.streamKey || null } : null,
+        };
+    }
+}
+
+module.exports = { RecordingManager, IngressManager };