homebridge-plugin-utils 1.35.0 → 2.0.0

package/dist/ffmpeg/mp4-assembler.js

@@ -0,0 +1,387 @@
+/* Copyright(C) 2017-2026, HJD (https://github.com/hjdhjd). All rights reserved.
+ *
+ * ffmpeg/mp4-assembler.ts: AsyncDisposable fMP4 segment assembler composing Mp4BoxParser against a Readable byte source.
+ */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+/**
+ * AsyncDisposable fMP4 segment assembler.
+ *
+ * The assembler composes a {@link Mp4BoxParser} against an arbitrary Node {@link Readable} source (typically an FFmpeg process's stdout, but any Readable of well-formed
+ * fMP4 bytes works - including in-memory fixtures for tests) and exposes two views over the single-pass box pipeline:
+ *
+ *   - `initSegment: Promise<Buffer>` - resolves once with the concatenated bytes of every box that appeared before the first `moof` (typically ftyp + moov).
+ *   - `segments(): AsyncGenerator<Buffer>` - yields each subsequent `moof` / `mdat` pair concatenated into a single Buffer.
+ *
+ * One-shot artifacts (the init segment) are promises; continuous streams (media segments) are async generators. Lifetime is governed by
+ * a composed {@link AbortSignal}: external abort, parent signal propagation, source error, source end, or an optional inter-segment watchdog timeout all converge on the
+ * same signal. The class is single-consumer by design - `initSegment` and `segments()` are two views on one internal drain loop, not independent subscriptions.
+ *
+ * @module
+ */
+import { BOX_TYPE_MDAT, BOX_TYPE_MOOF, Mp4BoxParser } from "./mp4-parser.js";
+import { HbpuAbortError, Watchdog, composeSignals, isTimeoutReason, markHandled, onAbort, waitWithSignal } from "../util.js";
+import { on } from "node:events";
+/**
+ * AsyncDisposable fMP4 segment assembler that converts a Readable byte source into an init segment promise and a media-segment async generator.
+ *
+ * Construction kicks off a background drain loop that feeds {@link Mp4BoxParser} from the source's `data` events and routes each parsed box through a small state
+ * machine: everything before the first `moof` accumulates into the initialization segment; from the first `moof` onward, boxes accumulate into the current media
+ * segment until an `mdat` flushes the accumulated pair to the output queue.
+ *
+ * The single public teardown verb is {@link Mp4SegmentAssembler.abort}, mirroring `AbortController.abort()`. `Symbol.asyncDispose` is implemented in terms of it and
+ * awaits the drain loop's completion before returning, so `await using` guarantees the assembler has fully unwound by the time the surrounding scope exits.
+ *
+ * @example
+ *
+ * ```ts
+ * import { Mp4SegmentAssembler } from "homebridge-plugin-utils";
+ *
+ * await using assembler = new Mp4SegmentAssembler(ffmpegStdout, { segmentTimeout: 4500, signal: session.signal });
+ *
+ * const initSegment = await assembler.initSegment;
+ *
+ * for await (const segment of assembler.segments()) {
+ *
+ *   // Forward segment bytes to HomeKit.
+ * }
+ * ```
+ *
+ * @see Mp4BoxParser
+ *
+ * @category FFmpeg
+ */
+export class Mp4SegmentAssembler {
+    /**
+     * The composed abort signal representing this assembler's lifetime. Aborts exactly once when the source ends, the source errors, the parent signal fires, the
+     * watchdog timeout expires, or {@link Mp4SegmentAssembler.abort} is called; the reason encoded on `signal.reason` names the cause.
+     */
+    signal;
+    /**
+     * Promise that resolves with the concatenated initialization-segment bytes (typically `ftyp` + `moov`) once the first `moof` box arrives on the source. Rejects with
+     * `this.signal.reason` if the assembler is aborted before the initialization segment completes.
+     */
+    initSegment;
+    // The private AbortController whose signal is composed into `this.signal`. Owning the controller internally keeps teardown reachable from any handler - the parser,
+    // the source error listener, the watchdog - without giving callers a handle to the raw controller.
+    #controller;
+    // The byte source. Held so drain-path listeners (`end`, `error`) can be attached and detached in one place.
+    #source;
+    // The box parser driving the drain loop. Stateful: carries residual bytes across chunks.
+    #parser;
+    // Inter-segment watchdog composed over this.signal, or `undefined` when no `segmentTimeout` was configured. Armed when the init segment resolves and re-armed on each
+    // completed media segment; fires the composed controller with `HbpuAbortError("timeout")` on lapse. Self-cleans when the signal aborts for any other reason.
+    #watchdog;
+    // Resolver pair for {@link initSegment}. Resolved when the first `moof` arrives (with the accumulated init parts); rejected from the teardown path if still pending.
+    #initResolvers;
+    // Accumulated box bytes for the initialization segment. Flipped to empty and concatenated once the first `moof` flushes them into `initSegment`.
+    #initParts = [];
+    // Set `true` once the initialization segment has resolved. The phase flag for the drain state machine: `false` means "collecting init boxes"; `true` means "collecting
+    // media boxes."
+    #initResolved = false;
+    // Accumulated box bytes for the media segment currently being built. Reset to empty each time an `mdat` flushes the pair into the output queue.
+    #segmentParts = [];
+    // Completed media segments waiting to be yielded from `segments()`. A FIFO queue decouples the drain loop (producer) from the generator (consumer), which lets the
+    // consumer fall behind momentarily without dropping data.
+    #segmentQueue = [];
+    // Parked waiter the generator uses to block until a segment is pushed or the signal aborts. A single-slot optional field is enough because the class is
+    // single-consumer by design.
+    #segmentWaiter;
+    // The drain loop's promise. Held so `[Symbol.asyncDispose]` can await actual completion before returning, so callers using `await using` are guaranteed all drain
+    // listeners have been detached by the time the block exits.
+    #drainTask;
+    /**
+     * Construct and start a new fMP4 segment assembler.
+     *
+     * The drain loop starts synchronously as part of construction: by the time the constructor returns, the source's `data` events are being observed and the parser is
+     * ready to emit boxes. There is no separate `start()` step.
+     *
+     * @param source - Any {@link Readable} producing fMP4 byte chunks. Typically an FFmpeg process's stdout; any Readable works, which keeps the class testable in
+     *                 isolation with in-memory fixture streams.
+     * @param init   - Optional init options. See {@link Mp4SegmentAssemblerInit}.
+     */
+    constructor(source, init = {}) {
+        const { signal: parentSignal, segmentTimeout } = init;
+        this.#controller = new AbortController();
+        this.signal = composeSignals(parentSignal, this.#controller.signal);
+        this.#source = source;
+        this.#parser = new Mp4BoxParser();
+        // Instantiate the inter-segment watchdog only when the caller opted into timeout enforcement. When undefined, no watchdog is constructed and every `arm()` site
+        // becomes a cheap `?.` no-op. The watchdog self-cleans when the composed signal aborts, so nothing else in this class needs to know about it.
+        this.#watchdog = (segmentTimeout !== undefined) ? new Watchdog({
+            onFire: () => {
+                this.#controller.abort(new HbpuAbortError("timeout"));
+            },
+            signal: this.signal,
+            timeoutMs: segmentTimeout
+        }) : undefined;
+        // Wire up the init resolvers before starting any listeners. Callers reading `initSegment` should see a promise that can be awaited regardless of whether the source
+        // has already emitted anything by the time they get the reference. `markHandled` opts the promise out of Node's unhandled-rejection tracker for the case where a
+        // consumer uses only `segments()` and never awaits the init segment directly.
+        this.#initResolvers = Promise.withResolvers();
+        this.initSegment = markHandled(this.#initResolvers.promise);
+        // Attach a permanent source `"error"` absorber. Node's EventEmitter crashes the host process when `"error"` is emitted with no listeners, and the
+        // `events.on`-driven error handling inside `#drain` only protects while the drain loop is active. A phantom listener that lives for the assembler's lifetime
+        // guarantees no stray source error can crash the host - even during the sub-microtask window between drain termination and our teardown, or after teardown if the
+        // caller keeps the source alive past the assembler's useful life. During drain, Node dispatches `"error"` to every listener in registration order so `events.on`
+        // still rejects the iterator; the absorber just backstops the cases `events.on` does not cover. Released with the assembler instance.
+        this.#source.on("error", () => { });
+        // Single teardown convergence point. `onAbort` registers the one-shot teardown listener for the normal abort path AND handles the "pre-aborted signal" edge case
+        // where `addEventListener("abort", ...)` would otherwise silently skip the handler (the AbortSignal spec does not re-dispatch historical events). Pairing it with
+        // the `signal.aborted` short-circuit below means `initSegment` settles consistently regardless of whether the parent signal was live at construction time.
+        onAbort(this.signal, () => this.#teardown());
+        if (this.signal.aborted) {
+            return;
+        }
+        // Start the drain pipeline. The returned promise is retained so `[Symbol.asyncDispose]` can await the drain's completion before returning. `#drain` is written to
+        // always resolve - its body catches and classifies errors inline - so nothing can reject out of it, and no `markHandled` wrapper is needed here.
+        this.#drainTask = this.#drain();
+    }
+    /**
+     * Abort the assembler and tear it down. Defaults to `HbpuAbortError("shutdown")` when no reason is supplied; explicit reasons pass through unchanged.
+     *
+     * Safe to call more than once: subsequent calls are no-ops because the underlying signal only aborts once. Calling `abort()` after natural completion is also safe
+     * for the same reason.
+     *
+     * @param reason - Optional abort reason. Typically an {@link HbpuAbortError}; platform errors (`TimeoutError`, `AbortError`) also interoperate by convention.
+     */
+    abort(reason) {
+        if (this.aborted) {
+            return;
+        }
+        this.#controller.abort(reason ?? new HbpuAbortError("shutdown"));
+    }
+    /**
+     * `AsyncDisposable` implementation. Aborts the assembler (defaulting to `"shutdown"`) and awaits actual drain-loop completion before returning, so callers using
+     * `await using` are guaranteed every internal listener has been detached by the time the block exits.
+     *
+     * @returns A promise that resolves once the drain loop has fully exited.
+     */
+    async [Symbol.asyncDispose]() {
+        this.abort();
+        if (this.#drainTask) {
+            // Drain failures are already observed internally; swallow here so `await using` does not surface cleanup-side errors the caller cannot react to.
+            await this.#drainTask.catch(() => { });
+        }
+    }
+    /**
+     * `true` once `this.signal` has aborted. Derived from the signal; no independent state.
+     */
+    get aborted() {
+        return this.signal.aborted;
+    }
+    /**
+     * `true` when the abort reason indicates a timeout. Matches both the canonical `HbpuAbortError("timeout")` emitted by the inter-segment watchdog and the platform
+     * `TimeoutError` emitted by `AbortSignal.timeout()`. The discrimination lives in {@link isTimeoutReason} so this getter stays a one-line delegation and every
+     * resource class in the library shares one definition of "timeout."
+     */
+    get isTimedOut() {
+        return isTimeoutReason(this.signal.reason);
+    }
+    /**
+     * The number of completed media segments buffered between the drain loop and the {@link Mp4SegmentAssembler.segments} consumer - the segments the producer has
+     * assembled but the consumer has not yet pulled. A consumer pacing its reads slower than the source produces accrues a reserve here, and that reserve is what
+     * absorbs an upstream stall: the consumer keeps pulling buffered segments while no new ones arrive. It is zero in steady state when the consumer keeps pace.
+     */
+    get bufferedSegments() {
+        return this.#segmentQueue.length;
+    }
+    /**
+     * Async generator yielding each completed media segment (concatenated `moof` + `mdat` pair) as a single Buffer.
+     *
+     * Yields only after {@link Mp4SegmentAssembler.initSegment} has resolved - the init segment is not surfaced through this stream. Terminates cleanly when the source
+     * ends, the assembler aborts, or the optional caller signal aborts; in every case the queue is drained before the generator returns, so a consumer never loses a
+     * segment that was already assembled before teardown.
+     *
+     * **Single-consumer only.** The internal parked-waiter slot is single-writer; calling `segments()` concurrently with another consumer on the same assembler is
+     * unsupported and will hang one of the consumers when the producer's wake-up resolves only the later parker. If fan-out is needed, tee at the consumer side by
+     * replicating each yielded Buffer into per-consumer queues external to the assembler.
+     *
+     * @param init - Optional init options. `signal` composes with the assembler's own signal - aborting it terminates only this generator call, not the assembler.
+     *
+     * @returns An async generator yielding concatenated `moof` + `mdat` pair buffers in stream order.
+     */
+    async *segments(init = {}) {
+        // Compose the per-call signal with the assembler's own signal upfront so every wait in this method honors caller cancellation uniformly. A caller who passes
+        // `init.signal` can terminate just this iterator (e.g., to drop a per-session consumer while the assembler keeps running for another session), while the
+        // assembler's signal still governs the underlying pipeline.
+        const composed = composeSignals(this.signal, init.signal);
+        // Gate media-segment delivery on the init-first contract. `waitWithSignal` races the init promise against the composed signal so a caller abort during the init
+        // wait terminates the iterator immediately rather than hanging until the assembler's own signal settles init.
+        try {
+            await waitWithSignal(this.initSegment, composed);
+        }
+        catch {
+            return;
+        }
+        for (;;) {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                // Swap-drain the queue: hand ourselves whatever the producer has staged, leave a fresh empty array for the producer to push into, then yield the snapshot. The
+                // outer for-loop re-enters on every yielded batch so segments pushed while the consumer awaited a previous yield are picked up on the next pass. Drain
+                // unconditionally before checking abort - "no bytes lost" is the invariant for segments already assembled before teardown.
+                while (this.#segmentQueue.length > 0) {
+                    const drained = this.#segmentQueue;
+                    this.#segmentQueue = [];
+                    for (const segment of drained) {
+                        yield segment;
+                    }
+                }
+                if (composed.aborted) {
+                    return;
+                }
+                // Park until either a new segment is pushed (producer resolves the waiter) or the composed signal aborts. A per-iteration resolver is used so the waiter is
+                // always fresh; sharing a resolver across iterations would require manual reset logic.
+                const waiter = Promise.withResolvers();
+                this.#segmentWaiter = waiter;
+                // `onAbort` handles listener registration, the pre-aborted-signal pitfall, and the one-shot `{ once: true }` semantic through one primitive; the returned
+                // `Disposable` is handed to `using` so the listener is deterministically removed on every scope-exit path (segment push via `#handleBox`, caller signal abort,
+                // assembler abort, thrown error in the generator). The single unified primitive matches the shape `waitWithSignal` uses for exactly the same kind of parked wait.
+                const _abortRegistration = __addDisposableResource(env_1, onAbort(composed, () => waiter.resolve()), false);
+                try {
+                    // eslint-disable-next-line no-await-in-loop
+                    await waiter.promise;
+                }
+                finally {
+                    this.#segmentWaiter = undefined;
+                }
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                __disposeResources(env_1);
+            }
+        }
+    }
+    // Drain loop. Attaches the source's `end` listener, then iterates `events.on(source, "data", { signal })` until the composed signal aborts. For each chunk, the
+    // parser is fed and every complete box is dispatched through `#handleBox`. Every exit path - source end, source error, external abort - converges on the signal
+    // being aborted, which lets the generator's park loop unwind uniformly via `composed.aborted`.
+    async #drain() {
+        // Source end: the byte producer has nothing more to say. Drive teardown through the signal with reason `"closed"`; the signal's teardown listener will resolve the
+        // generator's parked waiter and reject any pending init. Guard against double-abort when the signal already fired (e.g., external teardown that destroyed the
+        // source and produced both `end` and our own abort).
+        const onEnd = () => {
+            if (this.aborted) {
+                return;
+            }
+            this.#controller.abort(new HbpuAbortError("closed"));
+        };
+        this.#source.once("end", onEnd);
+        try {
+            // `events.on` yields each emission as an array of event arguments. For Readable's `data` event the array is `[chunk]`; we destructure inside the loop so the
+            // typing stays explicit. The `{ signal }` option wires abort-driven termination into the iterator directly - when the signal fires, the iterator rejects its next
+            // call with the signal's reason. `events.on` also listens to the source's `"error"` events internally and rejects the iterator with the emitted error; the catch
+            // block below classifies both exit paths.
+            for await (const eventArgs of on(this.#source, "data", { signal: this.signal })) {
+                const [chunk] = eventArgs;
+                for (const box of this.#parser.consume(chunk)) {
+                    this.#handleBox(box);
+                }
+            }
+        }
+        catch (error) {
+            // Single classification point. Every rejection this loop can produce lands here, classified into one of two reasons today: our composed signal aborted
+            // (already carries a structured `signal.reason`, `this.aborted` is true, pass through unchanged) or the source emitted an `"error"` event (the emitted error
+            // is our `cause`, wrap into the `"failed"` reason so every consumer sees the same taxonomy). Parser failures would also land here if the parser ever threw,
+            // which today it does not - `#handleBox` is synchronous and side-effect-only.
+            if (!this.aborted) {
+                this.#controller.abort(new HbpuAbortError("failed", { cause: error }));
+            }
+        }
+        finally {
+            this.#source.off("end", onEnd);
+        }
+    }
+    // Single-box state machine. Before init resolves, boxes accumulate into `#initParts`; the first `moof` flushes them into the init promise, transitions to media
+    // collection, and starts the first media segment with itself as the opening box. From there, each box is appended to the current segment; an `mdat` closes the pair
+    // and pushes it to the output queue.
+    #handleBox(box) {
+        if (!this.#initResolved) {
+            if (box.type === BOX_TYPE_MOOF) {
+                // First `moof` - the preceding boxes (typically ftyp + moov) are the complete init segment. Concatenate them once, resolve the promise, and transition into
+                // media-collection mode with this `moof` starting the first segment.
+                const init = Buffer.concat(this.#initParts);
+                this.#initParts = [];
+                this.#initResolved = true;
+                this.#initResolvers.resolve(init);
+                this.#segmentParts.push(box.bytes);
+                this.#watchdog?.arm();
+                return;
+            }
+            this.#initParts.push(box.bytes);
+            return;
+        }
+        // Media-collection phase: every box contributes to the current pair, and `mdat` is the flush signal. Non-moof/non-mdat boxes (uncommon in fMP4 fragments, but
+        // possible) are appended to the current pair so the downstream consumer sees the stream verbatim.
+        this.#segmentParts.push(box.bytes);
+        if (box.type === BOX_TYPE_MDAT) {
+            const segment = Buffer.concat(this.#segmentParts);
+            this.#segmentParts = [];
+            this.#segmentQueue.push(segment);
+            this.#segmentWaiter?.resolve();
+            this.#watchdog?.arm();
+        }
+    }
+    // Single teardown convergence point, fired exactly once when `this.signal` aborts. Rejects a pending init promise and unblocks the generator so the drain-and-return
+    // sequence can run. The watchdog self-cleans through its own signal listener, and `exited`-style promises are not in this class's contract - the generator is the
+    // exit surface and it wakes up via the resolved waiter.
+    #teardown() {
+        // Promise resolvers are idempotent after first settlement, so calling reject on an already-resolved init promise is a safe no-op. This lets us keep the teardown
+        // path uniform regardless of whether init arrived before the abort or not.
+        this.#initResolvers.reject(this.signal.reason);
+        this.#segmentWaiter?.resolve();
+    }
+}
+//# sourceMappingURL=mp4-assembler.js.map

package/dist/ffmpeg/mp4-assembler.js.map

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

package/dist/ffmpeg/mp4-parser.d.ts

@@ -0,0 +1,94 @@
+/**
+ * ISO BMFF box type code for the `ftyp` (file type) box, encoded as a 32-bit big-endian integer. Useful for discriminating on {@link Mp4Box.type} without re-encoding
+ * the 4-character ASCII tag on every comparison.
+ *
+ * @category FFmpeg
+ */
+export declare const BOX_TYPE_FTYP = 1718909296;
+/**
+ * ISO BMFF box type code for the `mdat` (media data) box. The mdat box carries the sample payload for the preceding `moof` in an fMP4 fragment and is the end-of-segment
+ * marker that {@link ffmpeg/mp4-assembler!Mp4SegmentAssembler | Mp4SegmentAssembler} watches for.
+ *
+ * @category FFmpeg
+ */
+export declare const BOX_TYPE_MDAT = 1835295092;
+/**
+ * ISO BMFF box type code for the `moof` (movie fragment) box. Marks the start of a new fMP4 media fragment; the first `moof` in a stream also marks the end of the
+ * initialization segment.
+ *
+ * @category FFmpeg
+ */
+export declare const BOX_TYPE_MOOF = 1836019558;
+/**
+ * ISO BMFF box type code for the `moov` (movie) box. Part of the initialization segment that precedes the first `moof` in an fMP4 stream.
+ *
+ * @category FFmpeg
+ */
+export declare const BOX_TYPE_MOOV = 1836019574;
+/**
+ * A complete parsed ISO BMFF box emitted by {@link Mp4BoxParser}.
+ *
+ * @property bytes   - The complete box bytes, including the 8-byte header. The buffer is typically a zero-copy subarray view over the feed chunk; consumers that need
+ *                     to hold it past the iteration loop should copy with `Buffer.from()` if the upstream chunk lifetime is suspect.
+ * @property type    - The box type encoded as a 32-bit big-endian integer. Compare against the `BOX_TYPE_*` constants exported from this module; numeric comparison
+ *                     avoids the per-box string allocation that an ASCII tag comparison would incur.
+ *
+ * @category FFmpeg
+ */
+export interface Mp4Box {
+    bytes: Buffer;
+    type: number;
+}
+/**
+ * Pure stateful parser that converts a stream of ISO BMFF byte chunks into discrete {@link Mp4Box} records.
+ *
+ * Feed each chunk from the byte source through {@link Mp4BoxParser.consume} and iterate the returned values for every complete box now available. The parser carries
+ * only the bytes of an incomplete trailing box across calls; chunk boundaries in the middle of a box are handled transparently. A single chunk may produce zero, one, or
+ * many boxes depending on how the stream falls on chunk boundaries.
+ *
+ * The class is intentionally signal-free and event-free. It performs one job, synchronously, and leaves resource lifecycle and async consumption to the composing
+ * caller - typically {@link ffmpeg/mp4-assembler!Mp4SegmentAssembler | Mp4SegmentAssembler} for fMP4 streams driven by an FFmpeg process.
+ *
+ * @remarks **Trust boundary.** The parser does not bound the size field it reads from the wire. A source that claims a multi-gigabyte box size would cause the parser
+ * to accumulate incoming chunks into its internal pending buffer until the declared box completes. This is safe for trusted sources like FFmpeg stdout, where the
+ * size field reflects the actual payload. Callers feeding untrusted byte streams (e.g., user-uploaded media, network input from arbitrary peers) should impose their
+ * own bound - either by truncating chunks that would exceed a budget, or by wrapping the parser in a guard that rejects implausibly large declared sizes before
+ * feeding the chunk.
+ *
+ * @example
+ *
+ * ```ts
+ * import { BOX_TYPE_MDAT, Mp4BoxParser } from "homebridge-plugin-utils";
+ *
+ * const parser = new Mp4BoxParser();
+ *
+ * for(const box of parser.consume(chunk)) {
+ *
+ *   if(box.type === BOX_TYPE_MDAT) {
+ *
+ *     // We have just received a complete mdat box.
+ *   }
+ * }
+ * ```
+ *
+ * @see Mp4SegmentAssembler
+ *
+ * @category FFmpeg
+ */
+export declare class Mp4BoxParser {
+    #private;
+    /**
+     * Feed the parser a new byte chunk and yield every complete box now available.
+     *
+     * The iterable is single-pass: consume it with a `for...of` loop (or spread into an array) before the next call to `consume`. Emitted `bytes` are typically
+     * zero-copy subarray views over the input chunk; copy with `Buffer.from()` if you intend to hold a box past the upstream chunk's lifetime.
+     *
+     * Chunk boundaries in the middle of a box are handled internally: the incomplete trailing bytes are stashed and prepended to the next call's input.
+     *
+     * @param chunk - A contiguous slice of box-stream bytes from the source.
+     *
+     * @returns An iterable of every box contained in (or completed by) this chunk, in stream order.
+     */
+    consume(chunk: Buffer): Iterable<Mp4Box>;
+}
+//# sourceMappingURL=mp4-parser.d.ts.map

package/dist/ffmpeg/mp4-parser.js

@@ -0,0 +1,130 @@
+/* Copyright(C) 2017-2026, HJD (https://github.com/hjdhjd). All rights reserved.
+ *
+ * ffmpeg/mp4-parser.ts: Pure byte-to-record parser for ISO BMFF (fMP4) box streams.
+ */
+/**
+ * Pure stateful byte-to-record parser for ISO BMFF (fMP4) box streams.
+ *
+ * This module ships the streaming counterpart to the static predicates in {@link ffmpeg/fmp4! | fmp4}. The predicates (`findBox`, `isKeyframe`, `hasAudioTrack`,
+ * `splitMoofMdat`) answer one-shot questions about a complete Buffer. {@link Mp4BoxParser} solves a different problem: incrementally consuming an unbounded byte stream
+ * (typically FFmpeg stdout producing fMP4 fragments) and emitting each complete box as it becomes available.
+ *
+ * The parser is intentionally signal-free, event-free, and allocation-light. It carries only the bytes of an incomplete trailing box across calls and hands out
+ * zero-copy `subarray` views whenever possible. Resource lifetime, async consumption, and cancellation are not this class's job - those belong to the composing
+ * caller (see {@link ffmpeg/mp4-assembler!Mp4SegmentAssembler | Mp4SegmentAssembler}).
+ *
+ * @module
+ */
+import { BOX_HEADER_SIZE } from "./fmp4.js";
+/**
+ * ISO BMFF box type code for the `ftyp` (file type) box, encoded as a 32-bit big-endian integer. Useful for discriminating on {@link Mp4Box.type} without re-encoding
+ * the 4-character ASCII tag on every comparison.
+ *
+ * @category FFmpeg
+ */
+export const BOX_TYPE_FTYP = 0x66747970;
+/**
+ * ISO BMFF box type code for the `mdat` (media data) box. The mdat box carries the sample payload for the preceding `moof` in an fMP4 fragment and is the end-of-segment
+ * marker that {@link ffmpeg/mp4-assembler!Mp4SegmentAssembler | Mp4SegmentAssembler} watches for.
+ *
+ * @category FFmpeg
+ */
+export const BOX_TYPE_MDAT = 0x6D646174;
+/**
+ * ISO BMFF box type code for the `moof` (movie fragment) box. Marks the start of a new fMP4 media fragment; the first `moof` in a stream also marks the end of the
+ * initialization segment.
+ *
+ * @category FFmpeg
+ */
+export const BOX_TYPE_MOOF = 0x6D6F6F66;
+/**
+ * ISO BMFF box type code for the `moov` (movie) box. Part of the initialization segment that precedes the first `moof` in an fMP4 stream.
+ *
+ * @category FFmpeg
+ */
+export const BOX_TYPE_MOOV = 0x6D6F6F76;
+// Reusable empty buffer sentinel for the parser's pending-bytes state. Avoids repeated zero-byte allocations at the start of every parse cycle where no residual bytes
+// carried over from the previous chunk.
+const EMPTY_BUFFER = Buffer.alloc(0);
+/**
+ * Pure stateful parser that converts a stream of ISO BMFF byte chunks into discrete {@link Mp4Box} records.
+ *
+ * Feed each chunk from the byte source through {@link Mp4BoxParser.consume} and iterate the returned values for every complete box now available. The parser carries
+ * only the bytes of an incomplete trailing box across calls; chunk boundaries in the middle of a box are handled transparently. A single chunk may produce zero, one, or
+ * many boxes depending on how the stream falls on chunk boundaries.
+ *
+ * The class is intentionally signal-free and event-free. It performs one job, synchronously, and leaves resource lifecycle and async consumption to the composing
+ * caller - typically {@link ffmpeg/mp4-assembler!Mp4SegmentAssembler | Mp4SegmentAssembler} for fMP4 streams driven by an FFmpeg process.
+ *
+ * @remarks **Trust boundary.** The parser does not bound the size field it reads from the wire. A source that claims a multi-gigabyte box size would cause the parser
+ * to accumulate incoming chunks into its internal pending buffer until the declared box completes. This is safe for trusted sources like FFmpeg stdout, where the
+ * size field reflects the actual payload. Callers feeding untrusted byte streams (e.g., user-uploaded media, network input from arbitrary peers) should impose their
+ * own bound - either by truncating chunks that would exceed a budget, or by wrapping the parser in a guard that rejects implausibly large declared sizes before
+ * feeding the chunk.
+ *
+ * @example
+ *
+ * ```ts
+ * import { BOX_TYPE_MDAT, Mp4BoxParser } from "homebridge-plugin-utils";
+ *
+ * const parser = new Mp4BoxParser();
+ *
+ * for(const box of parser.consume(chunk)) {
+ *
+ *   if(box.type === BOX_TYPE_MDAT) {
+ *
+ *     // We have just received a complete mdat box.
+ *   }
+ * }
+ * ```
+ *
+ * @see Mp4SegmentAssembler
+ *
+ * @category FFmpeg
+ */
+export class Mp4BoxParser {
+    // Residual bytes from the previous call that did not complete a box. Prepended to the next chunk so a box split across two chunks is reassembled transparently. A
+    // zero-length sentinel is used when nothing is pending to avoid per-call allocation.
+    #pending = EMPTY_BUFFER;
+    /**
+     * Feed the parser a new byte chunk and yield every complete box now available.
+     *
+     * The iterable is single-pass: consume it with a `for...of` loop (or spread into an array) before the next call to `consume`. Emitted `bytes` are typically
+     * zero-copy subarray views over the input chunk; copy with `Buffer.from()` if you intend to hold a box past the upstream chunk's lifetime.
+     *
+     * Chunk boundaries in the middle of a box are handled internally: the incomplete trailing bytes are stashed and prepended to the next call's input.
+     *
+     * @param chunk - A contiguous slice of box-stream bytes from the source.
+     *
+     * @returns An iterable of every box contained in (or completed by) this chunk, in stream order.
+     */
+    *consume(chunk) {
+        // Prepend any pending partial box from the previous call. Buffer.concat is only paid when there is actually residual state; the common "chunk carries whole boxes
+        // and nothing is pending" path stays zero-allocation.
+        const buffer = (this.#pending.length > 0) ? Buffer.concat([this.#pending, chunk]) : chunk;
+        let offset = 0;
+        // Walk boxes by reading each header: 4 bytes size (big-endian) + 4 bytes type. The 32-bit type code is surfaced directly so consumers can compare against the
+        // exported BOX_TYPE_* constants without re-encoding a 4-character ASCII tag on every box.
+        while ((offset + BOX_HEADER_SIZE) <= buffer.length) {
+            const size = buffer.readUInt32BE(offset);
+            // Size must be at least the header size. Smaller values indicate corruption, a misaligned feed, or an unsupported extended-size box (size === 1 signals a 64-bit
+            // size field that we do not handle). Either way, the parser cannot make further progress - reset pending state so we do not busy-loop on the same bad byte on
+            // every subsequent chunk.
+            if (size < BOX_HEADER_SIZE) {
+                this.#pending = EMPTY_BUFFER;
+                return;
+            }
+            // Not enough bytes for a complete box yet. Stash the remainder - including the header - for the next call.
+            if ((offset + size) > buffer.length) {
+                break;
+            }
+            const type = buffer.readUInt32BE(offset + 4);
+            const bytes = buffer.subarray(offset, offset + size);
+            offset += size;
+            yield { bytes, type };
+        }
+        // Carry the trailing incomplete box (header + partial payload, or just the unconsumed tail) into the next call.
+        this.#pending = (offset === buffer.length) ? EMPTY_BUFFER : buffer.subarray(offset);
+    }
+}
+//# sourceMappingURL=mp4-parser.js.map

package/dist/ffmpeg/mp4-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mp4-parser.js","sourceRoot":"","sources":["../../src/ffmpeg/mp4-parser.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;AAExC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;AAExC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;AAExC;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;AAExC,uKAAuK;AACvK,wCAAwC;AACxC,MAAM,YAAY,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAkBrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,OAAO,YAAY;IAEvB,kKAAkK;IAClK,qFAAqF;IACrF,QAAQ,GAAW,YAAY,CAAC;IAEhC;;;;;;;;;;;OAWG;IACI,CAAC,OAAO,CAAC,KAAa;QAE3B,kKAAkK;QAClK,sDAAsD;QACtD,MAAM,MAAM,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAE,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QAC5F,IAAI,MAAM,GAAG,CAAC,CAAC;QAEf,8JAA8J;QAC9J,0FAA0F;QAC1F,OAAM,CAAC,MAAM,GAAG,eAAe,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;YAElD,MAAM,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;YAEzC,iKAAiK;YACjK,8JAA8J;YAC9J,0BAA0B;YAC1B,IAAG,IAAI,GAAG,eAAe,EAAE,CAAC;gBAE1B,IAAI,CAAC,QAAQ,GAAG,YAAY,CAAC;gBAE7B,OAAO;YACT,CAAC;YAED,2GAA2G;YAC3G,IAAG,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;gBAEnC,MAAM;YACR,CAAC;YAED,MAAM,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YAC7C,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC;YAErD,MAAM,IAAI,IAAI,CAAC;YAEf,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QACxB,CAAC;QAED,gHAAgH;QAChH,IAAI,CAAC,QAAQ,GAAG,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IACtF,CAAC;CACF"}