@camstack/addon-post-analysis 1.2.51 → 1.2.52

package/dist/{dist-CnSzKo7x.js → dist-k21GqaWS.js}

@@ -19,7 +19,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
-require("node:crypto");
+//#endregion
 //#region ../types/dist/event-category-41fKf-q9.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
@@ -7157,473 +7157,6 @@ function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
 }
 //#endregion
-//#region ../types/dist/fmp4-box-splitter-B53u9-Nu.mjs
-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.analyzeDurationUs !== void 0) args.push("-analyzeduration", String(input.analyzeDurationUs));
-	if (input.probeSizeBytes !== void 0) args.push("-probesize", String(input.probeSizeBytes));
-	if (input.fflags?.length) for (const flag of input.fflags) args.push("-fflags", flag);
-	if (input.rtspTransport) args.push("-rtsp_transport", input.rtspTransport);
-	args.push("-i", input.url);
-	return args;
-}
-/** The `-vf` filter args, or `[]` when a consumer `-vf` already claims the slot. */
-function buildVideoFilterArgs(scale, outputArgs) {
-	if (!scale) return [];
-	if (outputArgs.some((a) => a === "-vf")) return [];
-	if (scale.mode === "exact") return ["-vf", `scale=${scale.width}:${scale.height}`];
-	return ["-vf", `scale='min(${scale.width},iw)':'min(${scale.height},ih)':force_original_aspect_ratio=decrease:force_divisible_by=2`];
-}
-/** 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) {
-	if (video.kind === "copy") return [
-		"-c:v",
-		"copy",
-		...video.bitstreamFilter ? ["-bsf:v", video.bitstreamFilter] : []
-	];
-	const args = [
-		...buildVideoFilterArgs(video.scale, outputArgs),
-		"-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.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>                         ─┘
-*   <video block>  <threads>  <audio block>   ─┐ OUTPUT options.
-*   <consumer outputArgs verbatim>             │
-*   <sink>                                    ─┘ terminal
-*/
-function buildFfmpegArgs(inv) {
-	const head = [...logBannerArgs(inv.logLevel), ...buildInputArgs(inv.input, inv.decodeHwAccel)];
-	const threadArgs = inv.threadCount > 0 ? ["-threads", String(inv.threadCount)] : [];
-	if (inv.sink.kind === "rtp-outputs") {
-		const videoLeg = inv.sink.video ? [
-			"-an",
-			"-map",
-			"0:v:0",
-			...buildVideoArgs(inv.video, inv.outputArgs),
-			...threadArgs,
-			...inv.outputArgs,
-			...buildRtpOutputArgs(inv.sink.video)
-		] : [];
-		const audioLeg = inv.sink.audio ? [
-			"-vn",
-			"-map",
-			"0:a:0?",
-			...buildAudioArgs(inv.audio),
-			...buildRtpOutputArgs(inv.sink.audio)
-		] : [];
-		return [
-			...head,
-			...videoLeg,
-			...audioLeg
-		];
-	}
-	const audioArgs = isElementaryVideoSink(inv.sink) ? ["-an"] : buildAudioArgs(inv.audio);
-	const sinkArgs = buildStdoutOrRtspSinkArgs(inv.sink);
-	return [
-		...head,
-		...buildVideoArgs(inv.video, inv.outputArgs),
-		...threadArgs,
-		...audioArgs,
-		...inv.outputArgs,
-		...sinkArgs,
-		...inv.audioSidecar ? buildAudioSidecarArgs(inv.audioSidecar) : []
-	];
-}
-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 ../types/dist/err-msg-IQTHeDzc.mjs
 /**
 import { errMsg } from '@camstack/types'
@@ -9645,6 +9178,69 @@ var StreamFormatSchema = _enum([
 	"mjpeg",
 	"rtsp"
 ]);
+/** A container `produceEventMedia` can emit. */
+var EventMediaKindSchema = _enum(["mp4", "gif"]);
+/**
+* One produced artifact, referenced by HANDLE.
+*
+* Never inline bytes: a produced clip is 200 KB–5 MB and every consumer of this
+* method is in another runner ([D9](../../../../docs/decisions/adr-0009.md),
+* [D18](../../../../docs/decisions/adr-0018.md) — cross-process media is fetched
+* on demand, compressed, by handle). `bytes` is here so a caller can decide
+* whether it wants the fetch at all.
+*/
+var EventMediaArtifactSchema = object({
+	kind: EventMediaKindSchema,
+	/** Opaque, single-camera, short-lived. Redeem with `fetchEventMedia`. */
+	handle: string(),
+	/**
+	* The node holding the bytes — the ROUTING key for `fetchEventMedia`.
+	*
+	* `stream-broker` is a singleton cap and an unpinned call never leaves the
+	* hub, so a handle produced on an agent's broker would be redeemed against
+	* the hub's store and come back `null`. Same contract, same field name and
+	* the same reason as `FrameHandleSchema.nodeId`: the producer stamps where it
+	* lives and the consumer pins to it.
+	*/
+	nodeId: string(),
+	mime: string(),
+	bytes: number().int(),
+	width: number().int(),
+	height: number().int()
+});
+/**
+* What a production actually covered — the answer to the only question an
+* operator asks about a notification clip.
+*
+* `fromTs`/`toTs` are WALL CLOCK, derived from the ring's own packet timeline,
+* so a caller can state "this clip starts 4.1 s before the event" instead of
+* inferring it from a duration. A production whose `fromTs` is later than the
+* event is a production with no pre-roll, and that is exactly the defect this
+* method exists to make visible rather than plausible.
+*/
+var EventMediaCoverageSchema = object({
+	fromTs: number(),
+	toTs: number(),
+	/** Encoded packets in the muxed window. */
+	packets: number().int()
+});
+/**
+* The result of ONE cut, in every container the caller asked for.
+*
+* Every artifact in `media` came out of the SAME window of the SAME rendition —
+* that is the whole reason this is one method rather than one call per format.
+* A consumer attaching a gif and a video can no longer show two different
+* moments, because it never chose two sources.
+*/
+var EventMediaProductionSchema = object({
+	media: array(EventMediaArtifactSchema).readonly(),
+	coverage: EventMediaCoverageSchema,
+	/** The rendition actually cut from — what the default or the fallback chose. */
+	profile: CamProfileSchema,
+	/** `copy` = the camera's own H.264, untouched. `encode` = re-encoded (H.265
+	*  source, a downscale, or a playback rate other than 1). */
+	video: _enum(["copy", "encode"])
+});
 var RtspRestreamEntrySchema = object({
 	brokerId: string(),
 	url: string(),
@@ -10044,6 +9640,34 @@ method(object({
 }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({
+	deviceId: number(),
+	/** Absent = the largest H.264 rendition at or below 1080p, which is
+	*  also the one that can be copied. Falls back to whatever the ring
+	*  actually retained, and the answer says which. */
+	profile: CamProfileSchema.optional(),
+	aroundMs: number(),
+	preSeconds: number().min(0).max(20).default(4),
+	postSeconds: number().min(0).max(20).default(6),
+	kinds: array(EventMediaKindSchema).min(1).default(["mp4"]),
+	/** GIF geometry. The video keeps the source's own. */
+	gifMaxWidth: number().int().min(120).max(1280).default(640),
+	gifFps: number().int().min(1).max(15).default(8),
+	/**
+	* Playback rate, applied to EVERY container so they stay one clip.
+	* `1` is real time and is what allows the copy branch.
+	*/
+	speed: number().min(1).max(8).default(1)
+}), EventMediaProductionSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ handle: string() }), object({
+	base64: string(),
+	mime: string(),
+	bytes: number().int()
+}).nullable(), {
+	kind: "mutation",
+	auth: "admin"
 }), method(_void(), array(CameraStreamSchema).readonly()), method(_void(), array(ProfileSlotSchema).readonly()), method(object({ brokerId: string() }), BrokerStatsSchema), method(object({ brokerId: string() }), object({
 	probed: boolean(),
 	summary: string()
@@ -32608,6 +32232,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"streamBroker.fetchEventMedia": {
+		capName: "stream-broker",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"streamBroker.getAllRtspEntries": {
 		capName: "stream-broker",
 		capScope: "system",
@@ -32692,6 +32322,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"streamBroker.produceEventMedia": {
+		capName: "stream-broker",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"streamBroker.publishCameraStream": {
 		capName: "stream-broker",
 		capScope: "system",
@@ -33743,12 +33379,6 @@ Object.defineProperty(exports, "EventCategory", {
 		return EventCategory;
 	}
 });
-Object.defineProperty(exports, "Fmp4BoxSplitter", {
-	enumerable: true,
-	get: function() {
-		return Fmp4BoxSplitter;
-	}
-});
 Object.defineProperty(exports, "LabelAttributionSchema", {
 	enumerable: true,
 	get: function() {
@@ -33899,12 +33529,6 @@ Object.defineProperty(exports, "buildEventKindDescriptor", {
 		return buildEventKindDescriptor;
 	}
 });
-Object.defineProperty(exports, "buildFfmpegArgs", {
-	enumerable: true,
-	get: function() {
-		return buildFfmpegArgs;
-	}
-});
 Object.defineProperty(exports, "cosineSimilarity", {
 	enumerable: true,
 	get: function() {
@@ -33977,12 +33601,6 @@ Object.defineProperty(exports, "isScheduleActive", {
 		return isScheduleActive;
 	}
 });
-Object.defineProperty(exports, "isSoftwareDecode", {
-	enumerable: true,
-	get: function() {
-		return isSoftwareDecode;
-	}
-});
 Object.defineProperty(exports, "kebabToCamel", {
 	enumerable: true,
 	get: function() {

package/dist/embedding-encoder/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-CnSzKo7x.js");
+const require_dist = require("../dist-k21GqaWS.js");
 let node_fs = require("node:fs");
 let node_fs$1 = require_dist.__toESM(node_fs, 1);
 node_fs = require_dist.__toESM(node_fs);

package/dist/embedding-encoder/index.mjs

@@ -1,4 +1,4 @@
-import { M as hfModelUrl, k as embeddingEncoderCapability, q as BaseAddon } from "../dist-DTeVOZBt.mjs";
+import { M as hfModelUrl, W as BaseAddon, k as embeddingEncoderCapability } from "../dist-CDLLzMJw.mjs";
 import { createRequire } from "node:module";
 import * as fs from "node:fs";
 import "node:fs";