@camstack/types 1.2.267 → 1.2.269

package/dist/canonical-hash-CSE4ioRi.js

@@ -1,792 +0,0 @@
-let node_crypto = require("node:crypto");
-//#region src/ffmpeg/invocation.ts
-var AUDIO_ENCODER_BY_CODEC = {
-	opus: "libopus",
-	aac: "aac",
-	pcmu: "pcm_mulaw",
-	pcma: "pcm_alaw"
-};
-/**
-* Camera-microphone audio, per codec. Lives HERE rather than in
-* `encode-defaults.ts` only to avoid an import cycle (`encode-defaults` depends
-* on these types); it is re-exported from there, which is where to read it.
-*
-* Every source in this repo is a mono camera mic. The former broker preset
-* encoded Opus at `channels: 2`, spending bitrate duplicating one channel —
-* that is the value this consolidation changed.
-*/
-var AUDIO_PRESETS = {
-	aac: {
-		kind: "encode",
-		codec: "aac",
-		bitrateKbps: 128,
-		sampleRateHz: 48e3,
-		channels: 1
-	},
-	opus: {
-		kind: "encode",
-		codec: "opus",
-		bitrateKbps: 64,
-		sampleRateHz: 48e3,
-		channels: 1
-	},
-	pcmu: {
-		kind: "encode",
-		codec: "pcmu",
-		sampleRateHz: 8e3,
-		channels: 1
-	}
-};
-/** `-hide_banner -loglevel <level>` — every ffmpeg site opens with this. */
-function logBannerArgs(level) {
-	return [
-		"-hide_banner",
-		"-loglevel",
-		level
-	];
-}
-/** `true` when the resolved value means "decode in software" (⇒ no `-hwaccel`). */
-function isSoftwareDecode(decodeHwAccel) {
-	return !decodeHwAccel || decodeHwAccel === "none" || decodeHwAccel === "copy";
-}
-/**
-* Every INPUT option, in order, terminated by `-i <url>`. Nothing may be
-* appended to this list by a caller — that is the whole point of the function.
-*/
-function buildInputArgs(input, decodeHwAccel) {
-	const args = [];
-	if (!isSoftwareDecode(decodeHwAccel)) args.push("-hwaccel", String(decodeHwAccel));
-	if (input.extraArgs?.length) args.push(...input.extraArgs);
-	if (input.decodeThreadCount !== void 0 && input.decodeThreadCount > 0) args.push("-threads", String(input.decodeThreadCount));
-	if (input.analyzeDurationUs !== void 0) args.push("-analyzeduration", String(input.analyzeDurationUs));
-	if (input.probeSizeBytes !== void 0) args.push("-probesize", String(input.probeSizeBytes));
-	if (input.lowDelay === true) args.push("-flags", "low_delay");
-	if (input.useWallclockTimestamps === true) args.push("-use_wallclock_as_timestamps", "1");
-	if (input.fflags?.length) for (const flag of input.fflags) args.push("-fflags", flag);
-	if (input.rtspTransport) args.push("-rtsp_transport", input.rtspTransport);
-	if (input.rawVideo !== void 0) {
-		const raw = input.rawVideo;
-		args.push("-f", "rawvideo", "-pix_fmt", raw.pixelFormat, "-video_size", `${String(raw.width)}x${String(raw.height)}`, "-framerate", String(raw.framerate));
-	}
-	args.push("-i", input.url);
-	return args;
-}
-/**
-* Derive the output `-map` selectors. The three cases, in the order they are
-* decided:
-*
-* 1. **A filter graph** — the picture is the graph's declared video pad, and
-*    the audio is its audio pad when it has one, otherwise input 0's mic. A
-*    graph's output is not addressable any other way.
-* 2. **N inputs, no graph** — map input 0 EXPLICITLY. ffmpeg's own selection
-*    picks the "best" stream across ALL inputs, so the egress would silently
-*    become whichever camera happens to have the largest frame.
-* 3. **One input, no graph** — no `-map`. Anything else would change the argv
-*    of every call site that exists today for no gain.
-*/
-function resolveStreamMaps(selection) {
-	const graph = selection.filterGraph;
-	if (graph) return {
-		video: `[${graph.videoOutLabel}]`,
-		audio: graph.audioOutLabel ? `[${graph.audioOutLabel}]` : "0:a:0?"
-	};
-	if (selection.extraInputs?.length) return {
-		video: "0:v:0",
-		audio: "0:a:0?"
-	};
-	return {
-		video: null,
-		audio: null
-	};
-}
-/** The `-vf` filter args, or `[]` when a consumer `-vf` already claims the slot. */
-function buildVideoFilterArgs(scale, outputArgs, filterGraph, hwUpload) {
-	if (filterGraph) {
-		if (scale) throw new Error("FfmpegInvocation: video.scale cannot be combined with a filter graph — scale inside the graph instead (the -vf would feed an output the graph already feeds)");
-		if (outputArgs.some((a) => a === "-vf")) throw new Error("FfmpegInvocation: outputArgs carries a -vf while a filter graph feeds the same output — fold the filter into the graph");
-		return [];
-	}
-	if (outputArgs.some((a) => a === "-vf")) return [];
-	if (!scale) return hwUpload.length > 0 ? ["-vf", hwUpload] : [];
-	const suffix = hwUpload.length > 0 ? `,${hwUpload}` : "";
-	if (scale.mode === "exact") return ["-vf", `scale=${scale.width}:${scale.height}${suffix}`];
-	return ["-vf", `scale='min(${scale.width},iw)':'min(${scale.height},ih)':force_original_aspect_ratio=decrease:force_divisible_by=2${suffix}`];
-}
-/**
-* The upload filter a hardware encode needs, or `''`.
-*
-* Nothing is uploaded when the DECODE already left the frames on the GPU
-* (`-hwaccel vaapi`): they are surfaces already, and uploading a surface is an
-* error rather than a no-op.
-*/
-function resolveHwUpload(device, decodeHwAccel) {
-	if (device === void 0) return "";
-	if (!isSoftwareDecode(decodeHwAccel)) return "";
-	return "format=nv12,hwupload";
-}
-/** Rate-control args for an encode plan. */
-function buildRateControlArgs(video) {
-	const kbps = video.bitrateKbps;
-	if (kbps === void 0) return [];
-	const rc = video.rateControl ?? {
-		kind: "cap",
-		vbvSeconds: 2
-	};
-	const bufsize = Math.max(1, Math.round(kbps * rc.vbvSeconds));
-	return [
-		...rc.kind === "cbr" ? ["-b:v", `${kbps}k`] : [],
-		"-maxrate",
-		`${kbps}k`,
-		"-bufsize",
-		`${bufsize}k`
-	];
-}
-/** The whole video block (`-vf` … `-c:v` … knobs), after `-i`. */
-function buildVideoArgs(video, outputArgs, filterGraph, hwEncode) {
-	if (video.kind === "raw") {
-		if (filterGraph && video.filter !== void 0) throw new Error("FfmpegInvocation: video.filter cannot be combined with a filter graph — fold the filter into the graph");
-		return [
-			...video.filter !== void 0 ? ["-vf", video.filter] : [],
-			"-c:v",
-			"rawvideo",
-			"-pix_fmt",
-			video.pixelFormat,
-			...video.fps !== void 0 ? ["-r", String(video.fps)] : []
-		];
-	}
-	if (video.kind === "copy") {
-		if (filterGraph) throw new Error("FfmpegInvocation: a filter graph produces a NEW picture, so video.kind must be `encode`");
-		return [
-			"-c:v",
-			"copy",
-			...video.bitstreamFilter ? ["-bsf:v", video.bitstreamFilter] : []
-		];
-	}
-	const hwUpload = hwEncode === void 0 ? "" : resolveHwUpload(hwEncode.device, hwEncode.decodeHwAccel);
-	if (hwEncode !== void 0 && filterGraph) throw new Error("FfmpegInvocation: a hardware encode fed by a filter graph must upload INSIDE the graph — hwEncodeDevice cannot be combined with filterGraph");
-	const args = [
-		...buildVideoFilterArgs(video.scale, outputArgs, filterGraph, hwUpload),
-		"-c:v",
-		video.encoder
-	];
-	if (video.preset !== void 0) args.push("-preset", video.preset);
-	if (video.tune !== void 0) args.push("-tune", video.tune);
-	if (video.singleSlicePerFrame === true && video.encoder === "libx264") args.push("-x264-params", "sliced-threads=0");
-	if (video.profile !== void 0) args.push("-profile:v", video.profile);
-	if (video.level !== void 0) args.push("-level", video.level);
-	if (video.pixelFormat !== void 0) args.push("-pix_fmt", video.pixelFormat);
-	if (video.fps !== void 0) args.push("-r", String(video.fps));
-	if (video.gopFrames !== void 0) args.push("-g", String(video.gopFrames));
-	if (video.forceKeyFramesSeconds !== void 0) args.push("-force_key_frames", `expr:gte(t,n_forced*${video.forceKeyFramesSeconds})`);
-	if (video.bf !== void 0) args.push("-bf", String(video.bf));
-	args.push(...buildRateControlArgs(video));
-	if (video.bitstreamFilter !== void 0) args.push("-bsf:v", video.bitstreamFilter);
-	return args;
-}
-/** The whole audio block, after `-i`. */
-function buildAudioArgs(audio) {
-	if (audio.kind === "none") return ["-an"];
-	if (audio.kind === "copy") return ["-c:a", "copy"];
-	const args = [];
-	if (audio.filter !== void 0) args.push("-af", audio.filter);
-	args.push("-c:a", AUDIO_ENCODER_BY_CODEC[audio.codec]);
-	if (audio.application !== void 0) args.push("-application", audio.application);
-	if (audio.frameDurationMs !== void 0) args.push("-frame_duration", String(audio.frameDurationMs));
-	if (audio.globalHeader === true) args.push("-flags", "+global_header");
-	if (audio.sampleRateHz !== void 0) args.push("-ar", String(audio.sampleRateHz));
-	if (audio.bitrateKbps !== void 0) args.push("-b:a", `${audio.bitrateKbps}k`);
-	if (audio.vbvBufferKbits !== void 0) args.push("-bufsize", `${audio.vbvBufferKbits}k`);
-	if (audio.channels !== void 0) args.push("-ac", String(audio.channels));
-	return args;
-}
-/** RTP output-leg args (`-payload_type`, `-ssrc`, `-sdp_file`, `-f rtp <url>`). */
-function buildRtpOutputArgs(out) {
-	const args = [];
-	if (out.payloadType !== void 0) args.push("-payload_type", String(out.payloadType));
-	if (out.ssrc !== void 0) args.push("-ssrc", String(out.ssrc));
-	if (out.sdpFile !== void 0) args.push("-sdp_file", out.sdpFile);
-	args.push("-f", "rtp", out.url);
-	return args;
-}
-/** `true` when the sink is a raw elementary bytestream that cannot mux audio. */
-function isElementaryVideoSink(sink) {
-	return sink.kind === "stdout" && (sink.container === "h264" || sink.container === "hevc");
-}
-/**
-* The fragmented-MP4 muxer flags, in the order the recorder has proven them
-* (`recorder/addon/ffmpeg-args.ts` passes the same `movflags` string through
-* `-segment_format_options`, across every vendor in the fleet):
-*
-* - `frag_keyframe` — cut a fragment at each key frame, so every fragment
-*   opens on a sync sample. HKSV's whole requirement.
-* - `empty_moov` — write `ftyp`+`moov` up front with no samples in it, which
-*   is what makes the head a standalone INITIALISATION segment.
-* - `default_base_moof` — fragment offsets are self-relative, so a fragment is
-*   demuxable without the bytes that preceded it. D31's byte-range read path
-*   depends on exactly this property of the recorder's segments.
-*/
-var FMP4_MOVFLAGS = "+frag_keyframe+empty_moov+default_base_moof";
-/**
-* The terminal sink args for every non-`rtp-outputs` sink. Exhaustive over the
-* union so a new member cannot fall through to `['-f', container, 'pipe:1']`,
-* which is what a plain `container` read would have done for `mp4` — a valid
-* argv that writes a NON-fragmented, unseekable-to-a-pipe MP4 and produces one
-* unusable byte stream.
-*/
-function buildStdoutOrRtspSinkArgs(sink) {
-	if (sink.kind === "rtsp-listen") return [
-		"-f",
-		"rtsp",
-		"-rtsp_transport",
-		"tcp",
-		"-rtsp_flags",
-		"listen",
-		sink.url
-	];
-	if (sink.kind === "rtp-outputs") return [];
-	return sink.container === "mp4" ? buildFmp4SinkArgs(sink) : [
-		"-f",
-		sink.container,
-		"pipe:1"
-	];
-}
-/**
-* How far BELOW the negotiated fragment length `-min_frag_duration` is set.
-*
-* `-min_frag_duration` refuses to cut before that much media has accumulated,
-* and then waits for the next key frame. Set to exactly `fragmentMs`, the
-* commonest camera configuration in existence — a key-frame grid EQUAL to the
-* requested fragment length — lands the deadline on the same instant as the key
-* frame, loses the race, and skips to the following one: **every fragment comes
-* out at twice the requested length.**
-*
-* Measured on the live fleet 2026-08-07, camera 615, `-c:v copy` (D84):
-*
-* | slot | GOP | `-min_frag_duration` | median gap |
-* | --- | --- | --- | --- |
-* | 1280×720 | 40 f @ 10 fps = 4.0 s | 4000 ms | **7944 ms** |
-* | 1280×720 | 40 f @ 10 fps = 4.0 s | 3600 ms | 3973 ms |
-* | 3840×2160 | 100 f @ 25 fps = 4.0 s | 4000 ms | 8042 ms |
-* | 3840×2160 | 100 f @ 25 fps = 4.0 s | 3600 ms | 3998 ms |
-*
-* A doubled fragment is not a cosmetic overshoot: HKSV requires every fragment
-* to be no longer than the length the controller SELECTED, so the shipped-but-
-* inert phase-1 sink would have violated the contract on its first real clip.
-*
-* 10 % is chosen against the two failures either side of it. Too small and
-* ordinary jitter (measured spread 3953-4096 ms) re-loses the race; too large
-* and a source with a key frame slightly EARLY than the grid gets cut there,
-* yielding a short fragment for no reason.
-*/
-var FMP4_MIN_FRAG_MARGIN = .9;
-/** `-movflags … -min_frag_duration <us> -f mp4 pipe:1`. */
-function buildFmp4SinkArgs(sink) {
-	return [
-		"-movflags",
-		FMP4_MOVFLAGS,
-		"-min_frag_duration",
-		String(Math.max(0, Math.round(sink.fragmentMs * FMP4_MIN_FRAG_MARGIN * 1e3))),
-		"-f",
-		"mp4",
-		"pipe:1"
-	];
-}
-/**
-* A second output mapping source audio to RTP-over-UDP. `0:a:0?` makes the
-* audio optional so a source with no audio skips it instead of failing the
-* whole invocation.
-*/
-function buildAudioSidecarArgs(sidecar) {
-	return [
-		"-map",
-		"0:a:0?",
-		...buildAudioArgs(sidecar.codec === "pcma" ? {
-			kind: "encode",
-			codec: "pcma",
-			sampleRateHz: 8e3,
-			channels: 1
-		} : AUDIO_PRESETS[sidecar.codec]),
-		...buildRtpOutputArgs({
-			url: sidecar.rtpUrl,
-			sdpFile: sidecar.sdpFile
-		})
-	];
-}
-/**
-* Assemble the full ffmpeg argument list. Layout:
-*
-*   -hide_banner -loglevel <level>
-*   [-hwaccel <backend|auto>]        ─┐ INPUT options — strictly before -i.
-*   [<input.extraArgs>]               │
-*   [-fflags <flag>…]                 │
-*   [-rtsp_transport tcp]             │
-*   -i <url>                         ─┘ …repeated per extraInput
-*   [-filter_complex <graph>]         ─ global, after the LAST -i
-*   [-map <video>]  <video block>  <threads>  ─┐ OUTPUT options.
-*   [-map <audio>]  <audio block>              │
-*   <consumer outputArgs verbatim>             │
-*   <sink>                                    ─┘ terminal
-*
-* The `-map`s are DERIVED (see {@link resolveStreamMaps}), never constants:
-* one input with no graph emits none at all, which is why the argv of every
-* call site that predates the N-input extension is unchanged to the byte.
-*
-* {@link FfmpegInvocation.audioSidecar} is the one map that stays literal
-* (`0:a:0?`): the sidecar is defined as the SOURCE's microphone on its own RTP
-* output, not as whatever the main output happens to carry.
-*/
-/** The hardware-encode context for this invocation, or `undefined`. */
-function hwEncodeFor(inv) {
-	return inv.hwEncodeDevice === void 0 ? void 0 : {
-		device: inv.hwEncodeDevice,
-		decodeHwAccel: inv.decodeHwAccel
-	};
-}
-function buildFfmpegArgs(inv) {
-	const graph = inv.filterGraph ?? null;
-	const head = [
-		...logBannerArgs(inv.logLevel),
-		...inv.hwEncodeDevice !== void 0 ? ["-vaapi_device", inv.hwEncodeDevice.renderNode] : [],
-		...buildInputArgs(inv.input, inv.decodeHwAccel),
-		...(inv.extraInputs ?? []).flatMap((extra) => buildInputArgs(extra, inv.decodeHwAccel)),
-		...graph ? ["-filter_complex", graph.graph] : []
-	];
-	const threadArgs = [...inv.threadCount > 0 ? ["-threads", String(inv.threadCount)] : [], ...inv.filterThreadCount !== void 0 && inv.filterThreadCount > 0 ? ["-filter_threads", String(inv.filterThreadCount)] : []];
-	const maps = resolveStreamMaps(inv);
-	const videoMapArgs = maps.video ? ["-map", maps.video] : [];
-	const audioMapArgs = maps.audio ? ["-map", maps.audio] : [];
-	if (inv.sink.kind === "rtp-outputs") {
-		const videoLeg = inv.sink.video ? [
-			"-an",
-			"-map",
-			maps.video ?? "0:v:0",
-			...buildVideoArgs(inv.video, inv.outputArgs, graph, hwEncodeFor(inv)),
-			...threadArgs,
-			...inv.outputArgs,
-			...buildRtpOutputArgs(inv.sink.video)
-		] : [];
-		const audioLeg = inv.sink.audio ? [
-			"-vn",
-			"-map",
-			maps.audio ?? "0:a:0?",
-			...buildAudioArgs(inv.audio),
-			...buildRtpOutputArgs(inv.sink.audio)
-		] : [];
-		return [
-			...head,
-			...videoLeg,
-			...audioLeg
-		];
-	}
-	const mutedAudio = isElementaryVideoSink(inv.sink) || inv.audio.kind === "none";
-	const audioArgs = isElementaryVideoSink(inv.sink) ? ["-an"] : buildAudioArgs(inv.audio);
-	return [
-		...head,
-		...videoMapArgs,
-		...buildVideoArgs(inv.video, inv.outputArgs, graph, hwEncodeFor(inv)),
-		...threadArgs,
-		...mutedAudio ? [] : audioMapArgs,
-		...audioArgs,
-		...inv.outputArgs,
-		...buildStdoutOrRtspSinkArgs(inv.sink),
-		...inv.audioSidecar ? buildAudioSidecarArgs(inv.audioSidecar) : []
-	];
-}
-/**
-* Hardware ENCODER ids per decode-hwaccel backend — a static, deterministic
-* map (the same shape the reference NVR uses: platform → encoder, no probe).
-*/
-var ENCODER_IDS_BY_BACKEND = {
-	videotoolbox: {
-		h264: "h264_videotoolbox",
-		h265: "hevc_videotoolbox"
-	},
-	vaapi: {
-		h264: "h264_vaapi",
-		h265: "hevc_vaapi"
-	},
-	qsv: {
-		h264: "h264_qsv",
-		h265: "hevc_qsv"
-	},
-	cuda: {
-		h264: "h264_nvenc",
-		h265: "hevc_nvenc"
-	},
-	nvdec: {
-		h264: "h264_nvenc",
-		h265: "hevc_nvenc"
-	},
-	amf: {
-		h264: "h264_amf",
-		h265: "hevc_amf"
-	}
-};
-/**
-* The hardware encoder for a target codec on `backend`, or the software one.
-* `'auto'` is NOT a backend identity (it is an instruction to ffmpeg), so it
-* maps to software encoding.
-*/
-function pickVideoEncoder(target, backend, useHardware) {
-	const software = target === "h264" ? "libx264" : "libx265";
-	if (!useHardware || backend === null || isSoftwareDecode(backend) || backend === "auto") return software;
-	const ids = ENCODER_IDS_BY_BACKEND[backend.toLowerCase()];
-	if (!ids) return software;
-	return target === "h264" ? ids.h264 : ids.h265;
-}
-/** Map an `EncodeProfile.audio` to an audio plan. */
-function audioPlanFromEncodeProfile(audio) {
-	if (audio === "passthrough") return { kind: "none" };
-	if (audio.codec === "copy") return { kind: "copy" };
-	return {
-		kind: "encode",
-		codec: audio.codec,
-		...audio.bitrateKbps !== void 0 ? { bitrateKbps: audio.bitrateKbps } : {},
-		...audio.sampleRateHz !== void 0 ? { sampleRateHz: audio.sampleRateHz } : {},
-		...audio.channels !== void 0 ? { channels: audio.channels } : {}
-	};
-}
-/**
-* Adapt an `EncodeProfile` (the operator/consumer-facing shape) into an
-* {@link FfmpegInvocation}. This is the ONLY bridge between the two models —
-* a second one is how the repo grew two argv builders that disagreed about
-* hardware.
-*
-* Smart video copy: when the source already speaks the requested codec the
-* encode block is elided entirely and ffmpeg runs as a re-muxer on the video
-* plane. Width / height / fps / bitrate in the profile are a downstream BUDGET,
-* not a forced rescale.
-*/
-function invocationFromEncodeProfile(input) {
-	const v = input.profile.video;
-	const shouldCopy = v.codec === "copy" || input.forceReencode !== true && v.codec === input.sourceCodec;
-	const scale = v.width !== void 0 && v.height !== void 0 ? {
-		mode: "fit",
-		width: v.width,
-		height: v.height
-	} : null;
-	const target = v.codec === "h265" ? "h265" : "h264";
-	const video = shouldCopy ? {
-		kind: "copy",
-		...input.bitstreamFilter !== void 0 ? { bitstreamFilter: input.bitstreamFilter } : {}
-	} : {
-		kind: "encode",
-		encoder: pickVideoEncoder(target, input.decodeHwAccel, input.hardwareEncoders === true),
-		scale,
-		...v.preset !== void 0 ? { preset: v.preset } : {},
-		...v.tune !== void 0 ? { tune: v.tune } : {},
-		...v.singleSlicePerFrame !== void 0 ? { singleSlicePerFrame: v.singleSlicePerFrame } : {},
-		...v.profile !== void 0 ? { profile: v.profile } : {},
-		...v.level !== void 0 ? { level: v.level } : {},
-		...input.pixelFormat !== void 0 ? { pixelFormat: input.pixelFormat } : {},
-		...v.fps !== void 0 ? { fps: v.fps } : {},
-		...v.gopFrames !== void 0 ? { gopFrames: v.gopFrames } : {},
-		...input.forceKeyFramesSeconds !== void 0 ? { forceKeyFramesSeconds: input.forceKeyFramesSeconds } : {},
-		...v.bf !== void 0 ? { bf: v.bf } : {},
-		...v.bitrateKbps !== void 0 ? { bitrateKbps: v.bitrateKbps } : {},
-		...input.rateControl !== void 0 ? { rateControl: input.rateControl } : {},
-		...input.bitstreamFilter !== void 0 ? { bitstreamFilter: input.bitstreamFilter } : {}
-	};
-	return {
-		logLevel: input.logLevel ?? "error",
-		decodeHwAccel: input.decodeHwAccel,
-		input: {
-			url: input.sourceUrl,
-			rtspTransport: "tcp",
-			fflags: ["+discardcorrupt"],
-			...input.profile.inputArgs?.length ? { extraArgs: input.profile.inputArgs } : {}
-		},
-		video,
-		audio: audioPlanFromEncodeProfile(input.profile.audio),
-		threadCount: input.threadCount ?? 0,
-		outputArgs: input.profile.outputArgs ?? [],
-		sink: input.sink,
-		...input.audioSidecar !== void 0 ? { audioSidecar: input.audioSidecar } : {}
-	};
-}
-//#endregion
-//#region src/ffmpeg/fmp4-box-splitter.ts
-var DEFAULT_MAX_UNIT_BYTES = 16 * 1024 * 1024;
-/** Header size for a normal box, and for one carrying a 64-bit `largesize`. */
-var BOX_HEADER_BYTES = 8;
-var LARGE_BOX_HEADER_BYTES = 16;
-var Fmp4BoxSplitter = class {
-	maxUnitBytes;
-	/** Bytes of the CURRENT unit plus any partial box after it. */
-	buffer = new Uint8Array(0);
-	/** Where the current unit starts inside {@link buffer}. */
-	unitStart = 0;
-	/** Where the box scanner has reached inside {@link buffer}. */
-	cursor = 0;
-	state = "init";
-	nextSequence = 0;
-	faultReason = null;
-	interstitial = /* @__PURE__ */ new Set();
-	constructor(options = {}) {
-		this.maxUnitBytes = options.maxUnitBytes ?? DEFAULT_MAX_UNIT_BYTES;
-	}
-	/**
-	* Non-null once the stream cannot be split. The splitter emits nothing
-	* further, so a caller polls this to kill the child rather than watching a
-	* silent stall — a fragmenter that quietly stops producing looks exactly like
-	* a camera with no motion.
-	*/
-	get fault() {
-		return this.faultReason;
-	}
-	/** Bytes currently held. The memory bound, observable rather than asserted. */
-	get pendingBytes() {
-		return this.buffer.length - this.unitStart;
-	}
-	/**
-	* Top-level box types seen BETWEEN fragments and discarded — `mfra`, `free`,
-	* a stray `sidx`. Reported rather than dropped in silence: they are legal and
-	* useless to a fragment consumer, but a type nobody expected showing up here
-	* is the first symptom of a muxer that is not writing what we think it is.
-	*/
-	get discardedInterstitialTypes() {
-		return [...this.interstitial];
-	}
-	/**
-	* Feed bytes; get back whatever units completed. Returns `[]` once faulted.
-	*/
-	push(chunk) {
-		if (this.faultReason !== null || chunk.length === 0) return [];
-		this.append(chunk);
-		if (this.pendingBytes > this.maxUnitBytes) return this.fail(`a single fMP4 unit exceeded ${this.maxUnitBytes} bytes — this stream is not fragmented`);
-		return this.drainBoxes();
-	}
-	append(chunk) {
-		if (this.buffer.length === 0) {
-			this.buffer = chunk.slice();
-			return;
-		}
-		const next = new Uint8Array(this.buffer.length + chunk.length);
-		next.set(this.buffer, 0);
-		next.set(chunk, this.buffer.length);
-		this.buffer = next;
-	}
-	/** Consume every COMPLETE top-level box now in the buffer. */
-	drainBoxes() {
-		const units = [];
-		for (;;) {
-			const header = this.readHeader();
-			if (this.faultReason !== null) return units;
-			if (header === null) break;
-			if (this.cursor + header.totalBytes > this.buffer.length) break;
-			const boxStart = this.cursor;
-			const boxEnd = boxStart + header.totalBytes;
-			this.cursor = boxEnd;
-			const unit = this.consumeBox(header.type, boxStart, boxEnd);
-			if (this.faultReason !== null) return units;
-			if (unit !== null) units.push(unit);
-		}
-		this.compact();
-		return units;
-	}
-	/**
-	* Apply one box to the state machine. Returns a unit when this box CLOSED
-	* one, `null` otherwise.
-	*/
-	consumeBox(type, boxStart, boxEnd) {
-		if (this.state === "init") {
-			if (type !== "moof") return null;
-			if (boxStart === this.unitStart) {
-				this.fail("a moof arrived before any initialisation box — there is no ftyp/moov to send");
-				return null;
-			}
-			const init = this.emit("init", this.unitStart, boxStart);
-			this.unitStart = boxStart;
-			this.state = "fragment";
-			return init;
-		}
-		if (this.state === "idle") {
-			if (type !== "moof") {
-				this.interstitial.add(type);
-				this.unitStart = boxEnd;
-				return null;
-			}
-			this.unitStart = boxStart;
-			this.state = "fragment";
-			return null;
-		}
-		if (type !== "mdat") return null;
-		const fragment = this.emit("fragment", this.unitStart, boxEnd);
-		this.unitStart = boxEnd;
-		this.state = "idle";
-		return fragment;
-	}
-	/**
-	* Parse the header at {@link cursor}, or `null` when too few bytes have
-	* arrived to know. Faults on a size the splitter cannot honour.
-	*/
-	readHeader() {
-		const available = this.buffer.length - this.cursor;
-		if (available < BOX_HEADER_BYTES) return null;
-		const view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
-		const size = view.getUint32(this.cursor);
-		const type = String.fromCharCode(this.buffer[this.cursor + 4] ?? 0, this.buffer[this.cursor + 5] ?? 0, this.buffer[this.cursor + 6] ?? 0, this.buffer[this.cursor + 7] ?? 0);
-		if (size === 0) {
-			this.fail(`box "${type}" declares size 0 (to EOF) — an unbounded box cannot be fragmented`);
-			return null;
-		}
-		if (size === 1) {
-			if (available < LARGE_BOX_HEADER_BYTES) return null;
-			const large = view.getBigUint64(this.cursor + BOX_HEADER_BYTES);
-			if (large > BigInt(this.maxUnitBytes)) {
-				this.fail(`box "${type}" declares ${large} bytes, over the ${this.maxUnitBytes} byte bound`);
-				return null;
-			}
-			return {
-				type,
-				totalBytes: Number(large)
-			};
-		}
-		if (size < BOX_HEADER_BYTES) {
-			this.fail(`box "${type}" declares an impossible size of ${size} bytes`);
-			return null;
-		}
-		return {
-			type,
-			totalBytes: size
-		};
-	}
-	emit(kind, start, end) {
-		const sequence = this.nextSequence;
-		this.nextSequence += 1;
-		return {
-			kind,
-			data: this.buffer.slice(start, end),
-			sequence
-		};
-	}
-	/**
-	* Drop everything already emitted or discarded. Without this the buffer is
-	* the whole stream and the process dies in hours, not minutes.
-	*/
-	compact() {
-		if (this.unitStart === 0) return;
-		this.buffer = this.buffer.slice(this.unitStart);
-		this.cursor -= this.unitStart;
-		this.unitStart = 0;
-	}
-	fail(reason) {
-		this.faultReason = reason;
-		this.buffer = new Uint8Array(0);
-		this.unitStart = 0;
-		this.cursor = 0;
-		return [];
-	}
-};
-//#endregion
-//#region src/utils/canonical-hash.ts
-/**
-* Deterministic SHA-256 hash of an arbitrary serialisable value. The
-* canonical form sorts object keys alphabetically at every depth so two
-* structurally-equal inputs with different key insertion orders produce
-* the same hash. Returns a 64-char lowercase hex digest.
-*
-* Used by export adapters (Alexa, HAP) to short-circuit re-discovery /
-* accessory-rebuild work when the upstream shape is byte-identical to
-* the last applied state — preventing user-visible "re-discovery"
-* notifications on every addon-runner respawn. Each respawn re-fires
-* `DeviceBindingsChanged` for every cap registration, which without
-* this guard would propagate redundant pushes.
-*
-* Note: this is a SYMPTOMATIC fix layered on top of the binding-change
-* subscription. The proper fix is a single "device ready" lifecycle
-* barrier so exports react only when the full cap set has landed —
-* tracked separately for post-HA-integration work.
-*/
-function canonicalHash(value) {
-	const canonical = JSON.stringify(value, replaceWithSortedKeys);
-	return (0, node_crypto.createHash)("sha256").update(canonical ?? "").digest("hex");
-}
-function replaceWithSortedKeys(_key, value) {
-	if (value && typeof value === "object" && !Array.isArray(value)) {
-		const obj = value;
-		const out = {};
-		for (const k of Object.keys(obj).toSorted()) out[k] = obj[k];
-		return out;
-	}
-	return value;
-}
-//#endregion
-Object.defineProperty(exports, "AUDIO_PRESETS", {
-	enumerable: true,
-	get: function() {
-		return AUDIO_PRESETS;
-	}
-});
-Object.defineProperty(exports, "Fmp4BoxSplitter", {
-	enumerable: true,
-	get: function() {
-		return Fmp4BoxSplitter;
-	}
-});
-Object.defineProperty(exports, "audioPlanFromEncodeProfile", {
-	enumerable: true,
-	get: function() {
-		return audioPlanFromEncodeProfile;
-	}
-});
-Object.defineProperty(exports, "buildAudioArgs", {
-	enumerable: true,
-	get: function() {
-		return buildAudioArgs;
-	}
-});
-Object.defineProperty(exports, "buildFfmpegArgs", {
-	enumerable: true,
-	get: function() {
-		return buildFfmpegArgs;
-	}
-});
-Object.defineProperty(exports, "buildInputArgs", {
-	enumerable: true,
-	get: function() {
-		return buildInputArgs;
-	}
-});
-Object.defineProperty(exports, "buildVideoArgs", {
-	enumerable: true,
-	get: function() {
-		return buildVideoArgs;
-	}
-});
-Object.defineProperty(exports, "canonicalHash", {
-	enumerable: true,
-	get: function() {
-		return canonicalHash;
-	}
-});
-Object.defineProperty(exports, "invocationFromEncodeProfile", {
-	enumerable: true,
-	get: function() {
-		return invocationFromEncodeProfile;
-	}
-});
-Object.defineProperty(exports, "isSoftwareDecode", {
-	enumerable: true,
-	get: function() {
-		return isSoftwareDecode;
-	}
-});
-Object.defineProperty(exports, "logBannerArgs", {
-	enumerable: true,
-	get: function() {
-		return logBannerArgs;
-	}
-});
-Object.defineProperty(exports, "pickVideoEncoder", {
-	enumerable: true,
-	get: function() {
-		return pickVideoEncoder;
-	}
-});
-Object.defineProperty(exports, "resolveStreamMaps", {
-	enumerable: true,
-	get: function() {
-		return resolveStreamMaps;
-	}
-});