npm - tirtc-devtools-cli - Versions diffs - 0.0.1 - Mend

tirtc-devtools-cli 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (156) hide show

package/vendor/app-server/dist/host/WebPreviewGateway.js ADDED Viewed

@@ -0,0 +1,815 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebPreviewGateway = void 0;
+const fs = __importStar(require("fs"));
+const http = __importStar(require("http"));
+const crypto = __importStar(require("crypto"));
+const MAGIC = 0x54525046; // 'TRPF'
+const HEADER_SIZE = 24;
+const POLL_MS = 40;
+function nowIsoString() {
+    return new Date().toISOString();
+}
+function parseHeader(buffer) {
+    if (buffer.length < HEADER_SIZE) {
+        return undefined;
+    }
+    const magic = buffer.readUInt32LE(0);
+    if (magic !== MAGIC) {
+        return undefined;
+    }
+    const version = buffer.readUInt8(4);
+    if (version !== 1) {
+        return undefined;
+    }
+    return {
+        kind: buffer.readUInt8(5),
+        flags: buffer.readUInt8(6),
+        streamId: buffer.readUInt32LE(8),
+        timestampMs: buffer.readUInt32LE(12),
+        payloadLength: buffer.readUInt32LE(16),
+    };
+}
+function normalizePreviewMedia(kind, fallback) {
+    if (kind >= 65 && kind <= 127) {
+        return 'video';
+    }
+    if (kind > 0 && kind < 65) {
+        return 'audio';
+    }
+    return fallback;
+}
+function renderViewerHtml(endpoint, token) {
+    const escapedEndpoint = endpoint.replace(/&/g, '&amp;').replace(/</g, '&lt;');
+    return `<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width,initial-scale=1" />
+  <title>TiRTC Preview</title>
+  <style>
+    body { margin: 0; font-family: ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, Helvetica, Arial, sans-serif; background: #0b0f14; color: #d7e0ea; }
+    .wrap { display: grid; grid-template-rows: auto 1fr; min-height: 100vh; }
+    .top { padding: 10px 14px; border-bottom: 1px solid #1f2a36; background: #111923; }
+    .meta { font-size: 12px; color: #9fb0c3; }
+    .controls { display: flex; gap: 8px; margin-top: 8px; }
+    button { border: 1px solid #2b3a4a; background: #172332; color: #d7e0ea; border-radius: 6px; padding: 6px 10px; cursor: pointer; }
+    button:hover { background: #1b2b3d; }
+    .stage { display: grid; place-items: center; padding: 12px; }
+    canvas { width: min(96vw, 1280px); aspect-ratio: 16 / 9; background: #000; border: 1px solid #1f2a36; }
+  </style>
+</head>
+<body>
+  <div class="wrap">
+    <div class="top">
+      <div>TiRTC Local Preview</div>
+      <div class="meta">endpoint: ${escapedEndpoint}</div>
+      <div class="meta" id="status">status: connecting...</div>
+      <div class="controls">
+        <button id="start">Start Stream</button>
+        <button id="stop">Stop Stream</button>
+      </div>
+    </div>
+    <div class="stage"><canvas id="screen" width="1280" height="720"></canvas></div>
+  </div>
+  <script>
+    (() => {
+      const token = ${JSON.stringify(token)};
+      const statusEl = document.getElementById('status');
+      const canvas = document.getElementById('screen');
+      const ctx = canvas.getContext('2d');
+      const startBtn = document.getElementById('start');
+      const stopBtn = document.getElementById('stop');
+      const AUDIO_SAMPLE_RATE = 16000;
+      const AUDIO_TARGET_BUFFER_MS = 120;
+      const AUDIO_MAX_BUFFER_MS = 320;
+      const VIDEO_TARGET_BUFFER_MS = 100;
+      const VIDEO_RENDER_INTERVAL_MS = 33;
+      const VIDEO_MAX_QUEUE = 8;
+      const audioCtx = new (window.AudioContext || window.webkitAudioContext)();
+      let audioNode = null;
+      let audioReady = false;
+      let audioQueuedSamples = 0;
+      let audioUnderflows = 0;
+      let videoFrames = [];
+      let videoBaseTs = null;
+      let videoBaseWallMs = 0;
+      let videoTimer = null;
+      function setStatus(text) {
+        statusEl.textContent = text;
+      }
+      function resetVideoTimeline() {
+        for (const frame of videoFrames) {
+          try { frame.image.close(); } catch (_) {}
+        }
+        videoFrames = [];
+        videoBaseTs = null;
+        videoBaseWallMs = 0;
+      }
+      function resetAudioTimeline() {
+        audioQueuedSamples = 0;
+        if (audioNode) {
+          audioNode.port.postMessage({type: 'clear'});
+        }
+      }
+      async function ensureAudioWorklet() {
+        if (audioReady && audioNode) {
+          return;
+        }
+        const startThresholdSamples = Math.floor((AUDIO_TARGET_BUFFER_MS * AUDIO_SAMPLE_RATE) / 1000);
+        const codeLines = [
+          'class PcmRingProcessor extends AudioWorkletProcessor {',
+          '  constructor() {',
+          '    super();',
+          '    this.queue = [];',
+          '    this.offset = 0;',
+          '    this.queuedSamples = 0;',
+          '    this.underflowCount = 0;',
+          '    this.renderCount = 0;',
+          '    this.started = false;',
+          '    this.startThresholdSamples = 0;',
+          '    this.port.onmessage = (event) => {',
+          '      const data = event.data || {};',
+          '      if (data.type === "configure") {',
+          '        this.startThresholdSamples = Number(data.startThresholdSamples || 0);',
+          '        return;',
+          '      }',
+          '      if (data.type === "clear") {',
+          '        this.queue = [];',
+          '        this.offset = 0;',
+          '        this.queuedSamples = 0;',
+          '        this.started = false;',
+          '        return;',
+          '      }',
+          '      if (data.type === "pcm" && data.samples) {',
+          '        const chunk = new Float32Array(data.samples);',
+          '        if (chunk.length > 0) {',
+          '          this.queue.push(chunk);',
+          '          this.queuedSamples += chunk.length;',
+          '        }',
+          '      }',
+          '    };',
+          '  }',
+          '  process(inputs, outputs) {',
+          '    const output = outputs[0] && outputs[0][0];',
+          '    if (!output) { return true; }',
+          '    let outIndex = 0;',
+          '    if (!this.started && this.queuedSamples >= this.startThresholdSamples) {',
+          '      this.started = true;',
+          '    }',
+          '    if (!this.started) {',
+          '      output.fill(0);',
+          '      this.renderCount += 1;',
+          '      return true;',
+          '    }',
+          '    while (outIndex < output.length) {',
+          '      if (this.queue.length === 0) {',
+          '        for (; outIndex < output.length; outIndex += 1) { output[outIndex] = 0; }',
+          '        this.underflowCount += 1;',
+          '        break;',
+          '      }',
+          '      const head = this.queue[0];',
+          '      const remain = head.length - this.offset;',
+          '      const need = output.length - outIndex;',
+          '      const copy = remain < need ? remain : need;',
+          '      output.set(head.subarray(this.offset, this.offset + copy), outIndex);',
+          '      outIndex += copy;',
+          '      this.offset += copy;',
+          '      this.queuedSamples -= copy;',
+          '      if (this.offset >= head.length) {',
+          '        this.queue.shift();',
+          '        this.offset = 0;',
+          '      }',
+          '    }',
+          '    this.renderCount += 1;',
+          '    if ((this.renderCount % 20) === 0) {',
+          '      this.port.postMessage({type: "stats", queuedSamples: this.queuedSamples, underflowCount: this.underflowCount, started: this.started});',
+          '    }',
+          '    return true;',
+          '  }',
+          '}',
+          'registerProcessor("pcm-ring-processor", PcmRingProcessor);',
+        ];
+        const moduleCode = codeLines.join('\\n');
+        const blobUrl = URL.createObjectURL(new Blob([moduleCode], {type: 'text/javascript'}));
+        await audioCtx.audioWorklet.addModule(blobUrl);
+        URL.revokeObjectURL(blobUrl);
+        audioNode = new AudioWorkletNode(audioCtx, 'pcm-ring-processor', {
+          numberOfInputs: 0,
+          numberOfOutputs: 1,
+          outputChannelCount: [1],
+        });
+        audioNode.port.onmessage = (event) => {
+          const data = event.data || {};
+          if (data.type === 'stats') {
+            audioQueuedSamples = Number(data.queuedSamples || 0);
+            audioUnderflows = Number(data.underflowCount || 0);
+          }
+        };
+        audioNode.connect(audioCtx.destination);
+        audioNode.port.postMessage({type: 'configure', startThresholdSamples});
+        audioReady = true;
+      }
+      function enqueueAudioPcm(bytes) {
+        if (!audioReady || !audioNode || audioCtx.state !== 'running') {
+          return;
+        }
+        const frameCount = Math.floor(bytes.byteLength / 2);
+        if (frameCount <= 0) {
+          return;
+        }
+        const queuedMs = (audioQueuedSamples * 1000) / AUDIO_SAMPLE_RATE;
+        if (queuedMs > AUDIO_MAX_BUFFER_MS) {
+          return;
+        }
+        const pcm = new Int16Array(frameCount);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        for (let i = 0; i < frameCount; i += 1) {
+          pcm[i] = view.getInt16(i * 2, true);
+        }
+        const f32 = new Float32Array(frameCount);
+        for (let i = 0; i < frameCount; i += 1) {
+          f32[i] = pcm[i] / 32768;
+        }
+        audioNode.port.postMessage({type: 'pcm', samples: f32.buffer}, [f32.buffer]);
+        audioQueuedSamples += frameCount;
+      }
+      function scheduleVideoLoop() {
+        if (videoTimer) {
+          return;
+        }
+        videoTimer = setInterval(() => {
+          if (videoFrames.length === 0) {
+            return;
+          }
+          // Always render the freshest decoded frame to avoid timeline stalls
+          // when source timestamps are discontinuous.
+          const latest = videoFrames.pop();
+          while (videoFrames.length > 0) {
+            const stale = videoFrames.shift();
+            try { stale.image.close(); } catch (_) {}
+          }
+          if (!latest) {
+            return;
+          }
+          if (canvas.width !== latest.image.width || canvas.height !== latest.image.height) {
+            canvas.width = latest.image.width;
+            canvas.height = latest.image.height;
+          }
+          ctx.drawImage(latest.image, 0, 0, canvas.width, canvas.height);
+          latest.image.close();
+        }, VIDEO_RENDER_INTERVAL_MS);
+      }
+      async function enqueueVideoJpeg(bytes, timestampMs) {
+        const blob = new Blob([bytes], {type: 'image/jpeg'});
+        const image = await createImageBitmap(blob);
+        videoFrames.push({timestampMs: Number(timestampMs || 0), image});
+        videoFrames.sort((a, b) => a.timestampMs - b.timestampMs);
+        while (videoFrames.length > VIDEO_MAX_QUEUE) {
+          const old = videoFrames.shift();
+          try { old.image.close(); } catch (_) {}
+        }
+      }
+      async function triggerStart() {
+        try {
+          resetAudioTimeline();
+          resetVideoTimeline();
+          const response = await fetch('/preview/start?token=' + encodeURIComponent(token));
+          if (!response.ok) {
+            setStatus('status: start failed: http ' + response.status);
+            return;
+          }
+          const data = await response.json();
+          if (!data.ok) {
+            setStatus('status: start failed');
+            return;
+          }
+          // Audio resume/worklet can require user gesture; do not block stream start on it.
+          try {
+            if (audioCtx.state !== 'running') {
+              await audioCtx.resume();
+            }
+            await ensureAudioWorklet();
+          } catch (_) {}
+          setStatus('status: stream requested');
+        } catch (e) {
+          setStatus('status: start request error: ' + String(e));
+        }
+      }
+      async function triggerStop() {
+        try {
+          resetAudioTimeline();
+          resetVideoTimeline();
+          const response = await fetch('/preview/stop?token=' + encodeURIComponent(token), {keepalive: true});
+          if (!response.ok) {
+            setStatus('status: stop failed: http ' + response.status);
+            return;
+          }
+          const data = await response.json();
+          if (!data.ok) {
+            setStatus('status: stop failed');
+            return;
+          }
+          setStatus('status: stopped');
+        } catch (e) {
+          setStatus('status: stop request error: ' + String(e));
+        }
+      }
+      scheduleVideoLoop();
+      // Auto-start preview when page opens so URL click immediately begins rendering.
+      void triggerStart();
+      const ev = new EventSource('/preview/events?token=' + encodeURIComponent(token));
+      ev.onopen = () => {
+        setStatus('status: connected');
+      };
+      ev.onerror = () => {
+        setStatus('status: reconnecting...');
+      };
+      ev.addEventListener('frame', (event) => {
+        void (async () => {
+          try {
+            const payload = JSON.parse(event.data);
+            const bytes = Uint8Array.from(atob(payload.payloadBase64), (c) => c.charCodeAt(0));
+            if (payload.media === 'video') {
+              await enqueueVideoJpeg(bytes, Number(payload.timestampMs || 0));
+              return;
+            }
+            if (payload.media === 'audio') {
+              enqueueAudioPcm(bytes);
+            }
+          } catch (e) {
+            setStatus('status: frame error: ' + String(e));
+          }
+        })();
+      });
+      if (startBtn) {
+        startBtn.addEventListener('click', () => {
+          void triggerStart();
+        });
+      }
+      if (stopBtn) {
+        stopBtn.addEventListener('click', () => {
+          void triggerStop();
+        });
+      }
+      window.addEventListener('pagehide', () => {
+        try { ev.close(); } catch (_) {}
+        void triggerStop();
+      });
+    })();
+  </script>
+</body>
+</html>`;
+}
+class WebPreviewGateway {
+    server;
+    serverStarting;
+    pollTimer;
+    sources = new Map();
+    clients = new Set();
+    token = '';
+    port = 0;
+    parseStreamFilter(raw) {
+        if (!raw || raw.trim().length === 0) {
+            return undefined;
+        }
+        const items = raw
+            .split(',')
+            .map((v) => v.trim())
+            .filter((v) => v.length > 0);
+        if (items.length === 0) {
+            return undefined;
+        }
+        return new Set(items);
+    }
+    sourceMatchesFilter(source, filter) {
+        if (!filter) {
+            return true;
+        }
+        return filter.has(String(source.streamId)) || filter.has(`${source.streamId}:${source.media}`);
+    }
+    async startSources(filter) {
+        const requestedAt = nowIsoString();
+        let matchedSources = 0;
+        let stoppedSources = 0;
+        let alreadyStartedSources = 0;
+        const failedSources = [];
+        for (const source of this.sources.values()) {
+            if (!this.sourceMatchesFilter(source, filter)) {
+                continue;
+            }
+            matchedSources += 1;
+            if (source.started) {
+                alreadyStartedSources += 1;
+                continue;
+            }
+            try {
+                if (source.onStart) {
+                    await source.onStart();
+                }
+                source.started = true;
+                stoppedSources += 1;
+            }
+            catch (error) {
+                failedSources.push({
+                    outputId: source.outputId,
+                    reason: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        return {
+            ok: failedSources.length === 0,
+            requestedAt,
+            matchedSources,
+            startedSources: stoppedSources,
+            alreadyStartedSources,
+            failedSources,
+        };
+    }
+    async stopSources(filter) {
+        const requestedAt = nowIsoString();
+        let matchedSources = 0;
+        let startedSources = 0;
+        let alreadyStartedSources = 0;
+        const failedSources = [];
+        for (const source of this.sources.values()) {
+            if (!this.sourceMatchesFilter(source, filter)) {
+                continue;
+            }
+            matchedSources += 1;
+            if (!source.started) {
+                alreadyStartedSources += 1;
+                continue;
+            }
+            try {
+                if (source.onStop) {
+                    await source.onStop();
+                }
+                source.started = false;
+                startedSources += 1;
+            }
+            catch (error) {
+                failedSources.push({
+                    outputId: source.outputId,
+                    reason: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        return {
+            ok: failedSources.length === 0,
+            requestedAt,
+            matchedSources,
+            startedSources,
+            alreadyStartedSources,
+            failedSources,
+        };
+    }
+    getStatus() {
+        const sources = Array.from(this.sources.values()).map((source) => ({
+            outputId: source.outputId,
+            streamId: source.streamId,
+            media: source.media,
+            started: source.started,
+            frameCount: source.frameCount,
+            lastFrameAt: source.lastFrameAt,
+        }));
+        return {
+            ok: true,
+            endpoint: `http://127.0.0.1:${this.port}`,
+            sourceCount: sources.length,
+            startedSourceCount: sources.filter((source) => source.started).length,
+            clientCount: this.clients.size,
+            sources,
+        };
+    }
+    async ensureServer() {
+        if (this.server) {
+            return;
+        }
+        if (this.serverStarting) {
+            await this.serverStarting;
+            return;
+        }
+        const token = crypto.randomBytes(12).toString('hex');
+        const server = http.createServer((req, res) => {
+            const url = req.url ?? '/';
+            const method = req.method ?? 'GET';
+            if (method !== 'GET') {
+                res.writeHead(405);
+                res.end('method not allowed');
+                return;
+            }
+            if (url.startsWith('/preview/view')) {
+                const query = new URL(url, 'http://127.0.0.1').searchParams;
+                if (query.get('token') !== token) {
+                    res.writeHead(403);
+                    res.end('forbidden');
+                    return;
+                }
+                const endpoint = `http://127.0.0.1:${this.port}`;
+                res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
+                res.end(renderViewerHtml(endpoint, token));
+                return;
+            }
+            if (url.startsWith('/preview/events')) {
+                const query = new URL(url, 'http://127.0.0.1').searchParams;
+                if (query.get('token') !== token) {
+                    res.writeHead(403);
+                    res.end('forbidden');
+                    return;
+                }
+                res.writeHead(200, {
+                    'content-type': 'text/event-stream',
+                    'cache-control': 'no-cache',
+                    connection: 'keep-alive',
+                    'access-control-allow-origin': '*',
+                });
+                this.writeEvent(res, 'hello', { ok: true });
+                this.clients.add(res);
+                req.on('close', () => {
+                    this.clients.delete(res);
+                    if (this.clients.size === 0) {
+                        void this.stopSources();
+                    }
+                    try {
+                        res.end();
+                    }
+                    catch {
+                        // no-op
+                    }
+                });
+                return;
+            }
+            if (url.startsWith('/preview/start')) {
+                const query = new URL(url, 'http://127.0.0.1').searchParams;
+                if (query.get('token') !== token) {
+                    res.writeHead(403);
+                    res.end('forbidden');
+                    return;
+                }
+                const filter = this.parseStreamFilter(query.get('streams'));
+                void this.startSources(filter).then((result) => {
+                    const statusCode = result.ok ? 200 : 500;
+                    res.writeHead(statusCode, { 'content-type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify(result));
+                }).catch((error) => {
+                    res.writeHead(500, { 'content-type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({
+                        ok: false,
+                        requestedAt: nowIsoString(),
+                        reason: error instanceof Error ? error.message : String(error),
+                    }));
+                });
+                return;
+            }
+            if (url.startsWith('/preview/stop')) {
+                const query = new URL(url, 'http://127.0.0.1').searchParams;
+                if (query.get('token') !== token) {
+                    res.writeHead(403);
+                    res.end('forbidden');
+                    return;
+                }
+                const filter = this.parseStreamFilter(query.get('streams'));
+                void this.stopSources(filter).then((result) => {
+                    const statusCode = result.ok ? 200 : 500;
+                    res.writeHead(statusCode, { 'content-type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify(result));
+                }).catch((error) => {
+                    res.writeHead(500, { 'content-type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({
+                        ok: false,
+                        requestedAt: nowIsoString(),
+                        reason: error instanceof Error ? error.message : String(error),
+                    }));
+                });
+                return;
+            }
+            if (url.startsWith('/preview/status')) {
+                const query = new URL(url, 'http://127.0.0.1').searchParams;
+                if (query.get('token') !== token) {
+                    res.writeHead(403);
+                    res.end('forbidden');
+                    return;
+                }
+                res.writeHead(200, { 'content-type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify(this.getStatus()));
+                return;
+            }
+            res.writeHead(404);
+            res.end('not found');
+        });
+        this.serverStarting = new Promise((resolve, reject) => {
+            const onError = (error) => {
+                server.off('listening', onListening);
+                reject(error);
+            };
+            const onListening = () => {
+                server.off('error', onError);
+                resolve();
+            };
+            server.once('error', onError);
+            server.once('listening', onListening);
+            server.listen(0, '127.0.0.1');
+        });
+        try {
+            await this.serverStarting;
+            const address = server.address();
+            if (!address || typeof address === 'string') {
+                throw new Error('preview gateway failed to bind localhost');
+            }
+            this.server = server;
+            this.token = token;
+            this.port = address.port;
+            this.pollTimer = setInterval(() => this.pollOnce(), POLL_MS);
+        }
+        catch (error) {
+            try {
+                server.close();
+            }
+            catch {
+                // no-op
+            }
+            throw error;
+        }
+        finally {
+            this.serverStarting = undefined;
+        }
+    }
+    async registerSource(outputId, media, streamId, filePath, onStart, onStop) {
+        await this.ensureServer();
+        this.sources.set(outputId, {
+            outputId,
+            media,
+            streamId,
+            path: filePath,
+            offset: 0,
+            buffer: Buffer.alloc(0),
+            started: false,
+            frameCount: 0,
+            onStart,
+            onStop,
+        });
+        return {
+            url: `http://127.0.0.1:${this.port}/preview/view?token=${this.token}`,
+            token: this.token,
+            endpoint: `http://127.0.0.1:${this.port}`,
+        };
+    }
+    unregisterSource(outputId) {
+        this.sources.delete(outputId);
+        if (this.sources.size === 0) {
+            this.dispose();
+        }
+    }
+    dispose() {
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = undefined;
+        }
+        for (const client of this.clients) {
+            try {
+                client.end();
+            }
+            catch {
+                // no-op
+            }
+        }
+        this.clients.clear();
+        if (this.server) {
+            this.server.close();
+            this.server = undefined;
+        }
+        this.sources.clear();
+        this.token = '';
+        this.port = 0;
+    }
+    pollOnce() {
+        for (const source of this.sources.values()) {
+            if (!source.started) {
+                continue;
+            }
+            if (!fs.existsSync(source.path)) {
+                continue;
+            }
+            const stat = fs.statSync(source.path);
+            if (stat.size < source.offset) {
+                source.offset = 0;
+                source.buffer = Buffer.alloc(0);
+            }
+            if (stat.size === source.offset) {
+                continue;
+            }
+            const fd = fs.openSync(source.path, 'r');
+            try {
+                const chunk = Buffer.alloc(Number(stat.size - source.offset));
+                const bytesRead = fs.readSync(fd, chunk, 0, chunk.length, source.offset);
+                if (bytesRead <= 0) {
+                    continue;
+                }
+                source.offset += bytesRead;
+                source.buffer = Buffer.concat([source.buffer, chunk.subarray(0, bytesRead)]);
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            while (source.buffer.length >= HEADER_SIZE) {
+                const header = parseHeader(source.buffer);
+                if (!header) {
+                    source.buffer = source.buffer.subarray(1);
+                    continue;
+                }
+                const total = HEADER_SIZE + header.payloadLength;
+                if (source.buffer.length < total) {
+                    break;
+                }
+                const payload = source.buffer.subarray(HEADER_SIZE, total);
+                source.buffer = source.buffer.subarray(total);
+                const eventPayload = {
+                    at: nowIsoString(),
+                    media: normalizePreviewMedia(header.kind, source.media),
+                    streamId: source.streamId,
+                    timestampMs: header.timestampMs,
+                    keyFrame: (header.flags & 0x1) === 0x1,
+                    payloadBase64: payload.toString('base64'),
+                };
+                source.frameCount += 1;
+                source.lastFrameAt = String(eventPayload.at);
+                this.broadcast('frame', eventPayload);
+            }
+        }
+    }
+    writeEvent(client, eventName, data) {
+        client.write(`event: ${eventName}\ndata: ${JSON.stringify(data)}\n\n`);
+    }
+    broadcast(eventName, data) {
+        for (const client of this.clients) {
+            try {
+                this.writeEvent(client, eventName, data);
+            }
+            catch {
+                this.clients.delete(client);
+            }
+        }
+    }
+}
+exports.WebPreviewGateway = WebPreviewGateway;