@testpulse.run/reporter 0.1.1

package/README.md

@@ -0,0 +1,38 @@
+# @testpulse.run/reporter
+
+Playwright reporter for streaming TestPulse runs and optional live browser capture.
+
+## Install
+
+```bash
+npm install @playwright/test @testpulse.run/reporter
+```
+
+## Usage
+
+```ts
+import { defineConfig } from "@playwright/test";
+
+export default defineConfig({
+  reporter: [
+    ["list"],
+    ["@testpulse.run/reporter", {
+      projectId: "demo-project",
+      apiKey: "<project-api-key>"
+    }]
+  ]
+});
+```
+
+## Auto Live Capture
+
+```ts
+import { expect, test } from "@testpulse.run/reporter/fixtures";
+
+test("streams automatically when page is used", async ({ page }) => {
+  await page.goto("https://playwright.dev");
+  await expect(page).toHaveTitle(/Playwright/i);
+});
+```
+
+When `liveStreamingEnabled` is enabled on the reporter, the fixture automatically starts and stops live capture for tests that use the `page` fixture. The package bundles `ffmpeg` automatically. To override the encoder path, set `TESTPULSE_FFMPEG_PATH`.

package/dist/fixtures/createTestPulseTest.d.ts

@@ -0,0 +1,14 @@
+import type { Page } from "@playwright/test";
+import { startLiveCapture } from "../live/LiveCaptureService.js";
+import type { LiveCaptureHandle, LivePage } from "../live/types.js";
+import type { TestPulseFixturesOptions } from "./types.js";
+type StartLiveCaptureFn = (page: LivePage, options?: Parameters<typeof startLiveCapture>[1]) => Promise<LiveCaptureHandle>;
+export declare function createAutoLiveCapturePageFixture(options?: TestPulseFixturesOptions, startCapture?: StartLiveCaptureFn): ({ page }: {
+    page: Page;
+}, use: (page: Page) => Promise<void>, testInfo: {
+    title: string;
+}) => Promise<void>;
+export declare function createTestPulseTest(options?: TestPulseFixturesOptions): import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
+declare const expect: import("@playwright/test").Expect<{}>;
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
+export { expect };

package/dist/fixtures/createTestPulseTest.js

@@ -0,0 +1,35 @@
+import { startLiveCapture } from "../live/LiveCaptureService.js";
+import { resolveTestPulseFixturesOptions } from "./options.js";
+import { loadConsumerPlaywrightTest } from "./runtime.js";
+export function createAutoLiveCapturePageFixture(options = {}, startCapture = startLiveCapture) {
+    return async ({ page }, use, testInfo) => {
+        const resolved = resolveTestPulseFixturesOptions(options);
+        let capture = null;
+        if (resolved.enabled) {
+            try {
+                capture = await startCapture(page, resolved.captureOptions);
+            }
+            catch (error) {
+                if (!resolved.swallowErrors) {
+                    throw error;
+                }
+                console.warn(`[TestPulse] Auto live capture skipped for test "${testInfo.title}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        try {
+            await use(page);
+        }
+        finally {
+            await capture?.stop();
+        }
+    };
+}
+export function createTestPulseTest(options = {}) {
+    const { test: base } = loadConsumerPlaywrightTest();
+    return base.extend({
+        page: createAutoLiveCapturePageFixture(options)
+    });
+}
+const { expect } = loadConsumerPlaywrightTest();
+export const test = createTestPulseTest();
+export { expect };

package/dist/fixtures/options.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedTestPulseFixturesOptions, TestPulseFixturesOptions } from "./types.js";
+export declare function resolveTestPulseFixturesOptions(options?: TestPulseFixturesOptions, environment?: NodeJS.ProcessEnv): ResolvedTestPulseFixturesOptions;

package/dist/fixtures/options.js

@@ -0,0 +1,35 @@
+import { resolveTestPulseEndpoint } from "../shared/endpoint.js";
+export function resolveTestPulseFixturesOptions(options = {}, environment = process.env) {
+    const enabled = options.enabled ?? environment.TESTPULSE_ENABLE_LIVE_STREAMING === "1";
+    const swallowErrors = options.swallowErrors ?? true;
+    return {
+        enabled,
+        swallowErrors,
+        captureOptions: {
+            endpoint: resolveTestPulseEndpoint(options.endpoint, environment),
+            runId: options.runId ?? trim(environment.TESTPULSE_RUN_ID),
+            streamPublisherToken: options.streamPublisherToken ?? trim(environment.TESTPULSE_STREAM_PUBLISHER_TOKEN),
+            sessionKey: options.sessionKey ?? trim(environment.TESTPULSE_LIVE_CAPTURE_SESSION_KEY),
+            stateDirectory: options.stateDirectory ?? trim(environment.TESTPULSE_LIVE_CAPTURE_STATE_DIRECTORY),
+            intervalMs: options.intervalMs ?? parseOptionalNumber(environment.TESTPULSE_LIVE_CAPTURE_INTERVAL_MS),
+            profile: options.profile ?? parseProfile(environment.TESTPULSE_LIVE_CAPTURE_PROFILE)
+        }
+    };
+}
+function trim(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function parseOptionalNumber(value) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+function parseProfile(value) {
+    return value === "focus" || value === "grid"
+        ? value
+        : undefined;
+}

package/dist/fixtures/runtime.d.ts

@@ -0,0 +1,3 @@
+type PlaywrightTestModule = typeof import("@playwright/test");
+export declare function loadConsumerPlaywrightTest(baseDirectory?: string): PlaywrightTestModule;
+export {};

package/dist/fixtures/runtime.js

@@ -0,0 +1,6 @@
+import { createRequire } from "node:module";
+import { cwd } from "node:process";
+export function loadConsumerPlaywrightTest(baseDirectory = cwd()) {
+    const require = createRequire(`${baseDirectory}/package.json`);
+    return require("@playwright/test");
+}

package/dist/fixtures/types.d.ts

@@ -0,0 +1,10 @@
+import type { LiveCaptureOptions } from "../live/types.js";
+export interface TestPulseFixturesOptions extends LiveCaptureOptions {
+    enabled?: boolean;
+    swallowErrors?: boolean;
+}
+export interface ResolvedTestPulseFixturesOptions {
+    enabled: boolean;
+    swallowErrors: boolean;
+    captureOptions: LiveCaptureOptions;
+}

package/dist/fixtures/types.js

@@ -0,0 +1 @@
+export {};

package/dist/fixtures.d.ts

@@ -0,0 +1,2 @@
+export { createAutoLiveCapturePageFixture, createTestPulseTest, expect, test } from "./fixtures/createTestPulseTest.js";
+export type { ResolvedTestPulseFixturesOptions, TestPulseFixturesOptions } from "./fixtures/types.js";

package/dist/fixtures.js

@@ -0,0 +1 @@
+export { createAutoLiveCapturePageFixture, createTestPulseTest, expect, test } from "./fixtures/createTestPulseTest.js";

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export type { TestPulseReporterOptions } from "./reporter/types.js";
+export { default } from "./reporter/PlaywrightReporter.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { default } from "./reporter/PlaywrightReporter.js";

package/dist/live/CaptureScheduler.d.ts

@@ -0,0 +1,22 @@
+import type { ChildProcessWithoutNullStreams } from "node:child_process";
+import type { LivePage, StreamDescriptor, TimingKey } from "./types.js";
+export declare class CaptureScheduler {
+    private readonly page;
+    private readonly encoder;
+    private readonly descriptor;
+    private readonly intervalMs;
+    private readonly logTimingOnce;
+    private stopped;
+    private frameWritable;
+    private latestFrame;
+    private captureInFlight;
+    private encoderTimer;
+    private captureTimer;
+    constructor(page: LivePage, encoder: ChildProcessWithoutNullStreams, descriptor: StreamDescriptor, intervalMs: number | undefined, logTimingOnce: (key: TimingKey, extra?: Record<string, number | string>) => void);
+    captureInitialFrame(): Promise<Buffer | null>;
+    writeInitialFrame(frame: Buffer | null): void;
+    start(): void;
+    stop(): void;
+    private captureFrame;
+    private writeFrameToEncoder;
+}

package/dist/live/CaptureScheduler.js

@@ -0,0 +1,87 @@
+export class CaptureScheduler {
+    page;
+    encoder;
+    descriptor;
+    intervalMs;
+    logTimingOnce;
+    stopped = false;
+    frameWritable = true;
+    latestFrame = null;
+    captureInFlight = null;
+    encoderTimer = null;
+    captureTimer = null;
+    constructor(page, encoder, descriptor, intervalMs, logTimingOnce) {
+        this.page = page;
+        this.encoder = encoder;
+        this.descriptor = descriptor;
+        this.intervalMs = intervalMs;
+        this.logTimingOnce = logTimingOnce;
+        this.encoder.stdin.on("drain", () => {
+            this.frameWritable = true;
+        });
+    }
+    async captureInitialFrame() {
+        return this.captureFrame();
+    }
+    writeInitialFrame(frame) {
+        this.writeFrameToEncoder(frame);
+    }
+    start() {
+        const encoderIntervalMs = Math.max(20, Math.round(1000 / this.descriptor.framesPerSecond));
+        const captureIntervalMs = Math.max(20, this.intervalMs ?? (this.descriptor.profile === "grid" ? 250 : 83));
+        this.encoderTimer = setInterval(() => {
+            if (this.stopped) {
+                return;
+            }
+            // Keep the encoder fed at a stable cadence so fragmented MP4 emits promptly
+            // even when screenshot capture itself is running at a lower interval.
+            this.writeFrameToEncoder(this.latestFrame);
+        }, encoderIntervalMs);
+        this.captureTimer = setInterval(() => {
+            if (this.stopped) {
+                return;
+            }
+            void this.captureFrame()
+                .then(() => undefined)
+                .catch(() => {
+                // Best-effort live capture should not fail the run.
+            });
+        }, captureIntervalMs);
+    }
+    stop() {
+        this.stopped = true;
+        if (this.encoderTimer) {
+            clearInterval(this.encoderTimer);
+        }
+        if (this.captureTimer) {
+            clearInterval(this.captureTimer);
+        }
+    }
+    async captureFrame() {
+        if (this.stopped) {
+            return null;
+        }
+        if (!this.captureInFlight) {
+            this.captureInFlight = this.page.screenshot({ type: "jpeg", quality: 60, scale: "css" })
+                .then((screenshot) => {
+                const frame = Buffer.from(screenshot);
+                this.latestFrame = frame;
+                this.logTimingOnce("firstScreenshotTaken", { bytes: frame.length });
+                return frame;
+            })
+                .catch(() => null)
+                .finally(() => {
+                this.captureInFlight = null;
+            });
+        }
+        return this.captureInFlight;
+    }
+    writeFrameToEncoder(frame) {
+        if (this.stopped || !frame || !this.frameWritable) {
+            return false;
+        }
+        this.frameWritable = this.encoder.stdin.write(frame);
+        this.logTimingOnce("firstFrameWrittenToEncoder", { bytes: frame.length });
+        return true;
+    }
+}

package/dist/live/EncoderProcess.d.ts

@@ -0,0 +1,5 @@
+import type { ChildProcessWithoutNullStreams } from "node:child_process";
+import type { StreamDescriptor } from "./types.js";
+export declare function startEncoderProcess(descriptor: StreamDescriptor): ChildProcessWithoutNullStreams;
+export declare function resolveFfmpegPath(): string;
+export declare function waitForEncoder(encoder: ChildProcessWithoutNullStreams): Promise<void>;

package/dist/live/EncoderProcess.js

@@ -0,0 +1,61 @@
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+export function startEncoderProcess(descriptor) {
+    const gopFrames = Math.max(1, Math.round(descriptor.framesPerSecond * descriptor.gopDurationMs / 1000));
+    const ffmpeg = spawn(resolveFfmpegPath(), [
+        "-loglevel", "error",
+        "-f", "image2pipe",
+        "-r", String(descriptor.framesPerSecond),
+        "-i", "pipe:0",
+        "-an",
+        "-vf", `scale=${descriptor.width}:${descriptor.height}:force_original_aspect_ratio=decrease,pad=${descriptor.width}:${descriptor.height}:(ow-iw)/2:(oh-ih)/2`,
+        "-c:v", "libx264",
+        "-preset", "veryfast",
+        "-tune", "zerolatency",
+        "-pix_fmt", "yuv420p",
+        "-profile:v", "baseline",
+        "-level", "3.0",
+        "-g", String(gopFrames),
+        "-keyint_min", String(gopFrames),
+        "-sc_threshold", "0",
+        "-force_key_frames", `expr:gte(t,n_forced*${descriptor.gopDurationMs / 1000})`,
+        "-b:v", `${descriptor.targetBitrateKbps}k`,
+        "-maxrate", `${descriptor.targetBitrateKbps}k`,
+        "-bufsize", `${descriptor.targetBitrateKbps * 2}k`,
+        "-movflags", "frag_keyframe+empty_moov+default_base_moof+separate_moof",
+        "-frag_duration", String(descriptor.segmentDurationMs * 1000),
+        "-f", "mp4",
+        "pipe:1"
+    ], {
+        stdio: ["pipe", "pipe", "pipe"]
+    });
+    ffmpeg.once("error", (error) => {
+        throw error;
+    });
+    return ffmpeg;
+}
+export function resolveFfmpegPath() {
+    const configuredPath = process.env.TESTPULSE_FFMPEG_PATH?.trim();
+    if (configuredPath) {
+        return configuredPath;
+    }
+    try {
+        const bundledPath = require("ffmpeg-static");
+        if (typeof bundledPath === "string" && bundledPath.trim()) {
+            return bundledPath;
+        }
+    }
+    catch {
+        // Fall back to PATH lookup below.
+    }
+    return "ffmpeg";
+}
+export async function waitForEncoder(encoder) {
+    const [code] = await once(encoder, "close");
+    if (code && code !== 0) {
+        const stderr = encoder.stderr.read()?.toString() ?? "";
+        throw new Error(`ffmpeg exited with code ${code}. ${stderr}`.trim());
+    }
+}

package/dist/live/LiveCaptureService.d.ts

@@ -0,0 +1,2 @@
+import type { LiveCaptureHandle, LiveCaptureOptions, LivePage } from "./types.js";
+export declare function startLiveCapture(page: LivePage, options?: LiveCaptureOptions): Promise<LiveCaptureHandle>;

package/dist/live/LiveCaptureService.js

@@ -0,0 +1,103 @@
+import { randomUUID } from "node:crypto";
+import { CaptureScheduler } from "./CaptureScheduler.js";
+import { startEncoderProcess, waitForEncoder } from "./EncoderProcess.js";
+import { resolveLiveCaptureSession } from "./LiveSessionResolver.js";
+import { wireFragmentedMp4Stream } from "./Mp4FragmentParser.js";
+import { SegmentQueue } from "./SegmentQueue.js";
+import { StreamUploader } from "./StreamUploader.js";
+import { createTimingLogger, logTiming } from "./telemetry.js";
+export async function startLiveCapture(page, options = {}) {
+    const session = await resolveLiveCaptureSession(options);
+    const intervalMs = options.intervalMs ?? session.intervalMs;
+    const profile = options.profile ?? session.profile ?? "focus";
+    const descriptor = await buildDescriptor(page, profile, intervalMs);
+    const streamId = randomUUID();
+    const captureStartedAt = Date.now();
+    const logTimingOnce = createTimingLogger(captureStartedAt);
+    const encoder = startEncoderProcess(descriptor);
+    const uploader = new StreamUploader(session, streamId, descriptor, captureStartedAt);
+    const uploadQueue = new SegmentQueue((error) => {
+        console.warn(`[TestPulse] Live streaming disabled for run ${session.runId}: ${error.message}`);
+    });
+    const scheduler = new CaptureScheduler(page, encoder, descriptor, intervalMs, logTimingOnce);
+    let stopped = false;
+    let previewUploaded = false;
+    let sequence = 0;
+    let gopId = 0;
+    logTiming("captureStart", captureStartedAt);
+    wireFragmentedMp4Stream(encoder.stdout, {
+        onInitSegment(payload) {
+            void enqueueSegment("init", payload);
+        },
+        onMediaSegment(payload) {
+            if ((sequence + 1) % Math.max(1, Math.round(descriptor.gopDurationMs / descriptor.segmentDurationMs)) === 0) {
+                gopId += 1;
+            }
+            void enqueueSegment("media", payload);
+        }
+    });
+    await uploader.start();
+    const initialFrame = await scheduler.captureInitialFrame();
+    if (initialFrame && !previewUploaded && !stopped) {
+        try {
+            await uploader.uploadPreview(initialFrame);
+            previewUploaded = true;
+            logTimingOnce("previewPosted", { bytes: initialFrame.length });
+        }
+        catch (error) {
+            console.warn(`[TestPulse] Live preview upload skipped for run ${session.runId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    scheduler.writeInitialFrame(initialFrame);
+    scheduler.start();
+    return {
+        async stop() {
+            if (stopped) {
+                return;
+            }
+            stopped = true;
+            scheduler.stop();
+            encoder.stdin.end();
+            await waitForEncoder(encoder);
+            await uploadQueue.flush();
+            await uploader.stop();
+        }
+    };
+    function enqueueSegment(segmentKind, payload) {
+        const segmentSequence = ++sequence;
+        return uploadQueue.enqueue(async () => {
+            await uploader.uploadSegment({
+                sequence: segmentSequence,
+                gopId,
+                segmentKind,
+                payload,
+                publishedAtUtc: new Date().toISOString()
+            });
+        });
+    }
+}
+async function buildDescriptor(page, profile, intervalMs) {
+    const viewport = page.viewportSize() ?? { width: 1280, height: 720 };
+    const focusWidth = Math.min(1280, viewport.width);
+    const focusHeight = even(Math.min(720, viewport.height));
+    const gridWidth = 640;
+    const gridHeight = 360;
+    const sampledFramesPerSecond = profile === "grid"
+        ? Math.max(1, Math.round(1000 / Math.max(250, intervalMs ?? 250)))
+        : Math.max(1, Math.round(1000 / Math.max(83, intervalMs ?? 83)));
+    const framesPerSecond = Math.max(8, sampledFramesPerSecond);
+    return {
+        streamId: randomUUID(),
+        profile,
+        mimeCodec: "video/mp4; codecs=\"avc1.42E01E\"",
+        width: even(profile === "grid" ? gridWidth : focusWidth),
+        height: profile === "grid" ? gridHeight : focusHeight,
+        framesPerSecond,
+        targetBitrateKbps: profile === "grid" ? 300 : 1200,
+        segmentDurationMs: 250,
+        gopDurationMs: 500
+    };
+}
+function even(value) {
+    return value % 2 === 0 ? value : value - 1;
+}

package/dist/live/LiveSessionResolver.d.ts

@@ -0,0 +1,2 @@
+import type { LiveCaptureOptions, LiveCaptureState } from "./types.js";
+export declare function resolveLiveCaptureSession(options: LiveCaptureOptions, now?: () => number, wait?: (ms: number) => Promise<unknown>): Promise<LiveCaptureState>;

package/dist/live/LiveSessionResolver.js

@@ -0,0 +1,66 @@
+import { readdir, readFile } from "node:fs/promises";
+import { getLiveCaptureStateDirectory, getLiveCaptureStatePath } from "./LiveSessionState.js";
+export async function resolveLiveCaptureSession(options, now = () => Date.now(), wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) {
+    if (options.endpoint && options.projectId && options.apiKey && options.runId && options.streamPublisherToken) {
+        return {
+            endpoint: options.endpoint,
+            projectId: options.projectId,
+            apiKey: options.apiKey,
+            runId: options.runId,
+            streamPublisherToken: options.streamPublisherToken,
+            createdAt: new Date(now()).toISOString()
+        };
+    }
+    const deadline = now() + 30_000;
+    while (now() < deadline) {
+        const session = options.sessionKey
+            ? await tryReadStateFile(getLiveCaptureStatePath(options.sessionKey, options.stateDirectory), now)
+            : await tryReadLatestStateFile(options.stateDirectory, now);
+        if (session) {
+            return session;
+        }
+        await wait(250);
+    }
+    const path = options.sessionKey
+        ? getLiveCaptureStatePath(options.sessionKey, options.stateDirectory)
+        : getLiveCaptureStateDirectory(options.stateDirectory);
+    throw new Error(`TestPulse live streaming session state was not found at ${path}.`);
+}
+async function tryReadLatestStateFile(stateDirectory, now) {
+    try {
+        const directory = getLiveCaptureStateDirectory(stateDirectory);
+        const entries = (await readdir(directory))
+            .filter((entry) => entry.endsWith(".json"))
+            .sort();
+        let freshest = null;
+        let freshestCreatedAt = -Infinity;
+        for (const entry of entries) {
+            const candidate = await tryReadStateFile(`${directory}/${entry}`, now);
+            if (!candidate) {
+                continue;
+            }
+            const createdAt = Date.parse(candidate.createdAt);
+            if (createdAt > freshestCreatedAt) {
+                freshest = candidate;
+                freshestCreatedAt = createdAt;
+            }
+        }
+        return freshest;
+    }
+    catch {
+        return null;
+    }
+}
+async function tryReadStateFile(path, now) {
+    try {
+        const payload = JSON.parse(await readFile(path, "utf8"));
+        const createdAt = Date.parse(payload.createdAt);
+        if (payload.endpoint && payload.projectId && payload.apiKey && payload.runId && payload.streamPublisherToken && !Number.isNaN(createdAt) && createdAt > now() - 60_000) {
+            return payload;
+        }
+    }
+    catch {
+        // Reporter may not have created the state file yet.
+    }
+    return null;
+}

package/dist/live/LiveSessionState.d.ts

@@ -0,0 +1,6 @@
+import type { LiveCaptureState } from "./types.js";
+export declare function getLiveCaptureSessionKey(sessionKey?: string): string;
+export declare function getLiveCaptureStateDirectory(stateDirectory?: string): string;
+export declare function getLiveCaptureStatePath(sessionKey?: string, stateDirectory?: string): string;
+export declare function writeLiveCaptureState(state: LiveCaptureState, sessionKey?: string, stateDirectory?: string): Promise<void>;
+export declare function deleteLiveCaptureState(sessionKey?: string, stateDirectory?: string): Promise<void>;

package/dist/live/LiveSessionState.js

@@ -0,0 +1,20 @@
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+export function getLiveCaptureSessionKey(sessionKey) {
+    return sessionKey?.trim() || "default";
+}
+export function getLiveCaptureStateDirectory(stateDirectory) {
+    return stateDirectory?.trim() || join(tmpdir(), "testpulse-live-capture");
+}
+export function getLiveCaptureStatePath(sessionKey, stateDirectory) {
+    return join(getLiveCaptureStateDirectory(stateDirectory), `${getLiveCaptureSessionKey(sessionKey)}.json`);
+}
+export async function writeLiveCaptureState(state, sessionKey, stateDirectory) {
+    const path = getLiveCaptureStatePath(sessionKey, stateDirectory);
+    await mkdir(getLiveCaptureStateDirectory(stateDirectory), { recursive: true });
+    await writeFile(path, JSON.stringify(state), "utf8");
+}
+export async function deleteLiveCaptureState(sessionKey, stateDirectory) {
+    await rm(getLiveCaptureStatePath(sessionKey, stateDirectory), { force: true });
+}

package/dist/live/Mp4FragmentParser.d.ts

@@ -0,0 +1,4 @@
+export declare function wireFragmentedMp4Stream(stdout: NodeJS.ReadableStream, handlers: {
+    onInitSegment(payload: Buffer): void;
+    onMediaSegment(payload: Buffer): void;
+}): void;

package/dist/live/Mp4FragmentParser.js

@@ -0,0 +1,32 @@
+export function wireFragmentedMp4Stream(stdout, handlers) {
+    let buffer = Buffer.alloc(0);
+    const initBoxes = [];
+    let initEmitted = false;
+    let pendingFragment = [];
+    stdout.on("data", (chunk) => {
+        buffer = Buffer.concat([buffer, chunk]);
+        while (buffer.length >= 8) {
+            const size = buffer.readUInt32BE(0);
+            if (size <= 0 || buffer.length < size) {
+                return;
+            }
+            const box = buffer.subarray(0, size);
+            buffer = buffer.subarray(size);
+            const type = box.subarray(4, 8).toString("ascii");
+            if (!initEmitted) {
+                initBoxes.push(box);
+                if (type === "moov") {
+                    initEmitted = true;
+                    handlers.onInitSegment(Buffer.concat(initBoxes));
+                    initBoxes.length = 0;
+                }
+                continue;
+            }
+            pendingFragment.push(box);
+            if (type === "mdat") {
+                handlers.onMediaSegment(Buffer.concat(pendingFragment));
+                pendingFragment = [];
+            }
+        }
+    });
+}

package/dist/live/SegmentQueue.d.ts

@@ -0,0 +1,9 @@
+export declare class SegmentQueue {
+    private readonly onError;
+    private chain;
+    private disabled;
+    private firstError;
+    constructor(onError: (error: Error) => void);
+    enqueue(task: () => Promise<void>): Promise<void>;
+    flush(): Promise<void>;
+}

package/dist/live/SegmentQueue.js

@@ -0,0 +1,32 @@
+export class SegmentQueue {
+    onError;
+    chain = Promise.resolve();
+    disabled = false;
+    firstError = null;
+    constructor(onError) {
+        this.onError = onError;
+    }
+    enqueue(task) {
+        if (this.disabled) {
+            return this.chain;
+        }
+        this.chain = this.chain.then(task).catch((error) => {
+            const resolved = error instanceof Error ? error : new Error(String(error));
+            if (!this.firstError) {
+                this.firstError = resolved;
+                this.onError(resolved);
+            }
+            this.disabled = true;
+        });
+        return this.chain;
+    }
+    async flush() {
+        await this.chain.catch((error) => {
+            const resolved = error instanceof Error ? error : new Error(String(error));
+            if (!this.firstError) {
+                this.firstError = resolved;
+                this.onError(resolved);
+            }
+        });
+    }
+}