@camstack/addon-pipeline 1.2.220 → 1.2.222

package/dist/detection-pipeline/index.mjs

@@ -1,9 +1,9 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
-import { $t as parseJsonUnknown, B as defaultDeviceFor$1, Dt as resolvePoolMemoryPolicy, G as detectionPipelineCapability, It as errMsg, J as enumerateInferenceDevices, Jt as hydrateSchema, Pt as supportedRuntimes$1, Qt as nodePin, S as PoolMemoryWatchdog, Ut as BaseAddon, X as evaluateZoneRules, c as DEFAULT_CLUSTER_STEP_MODELS, gt as pickClusterStepSettings, hn as EventCategory, ht as pickClusterStepModels, in as array, it as loadContributionCapability, k as YAMNET_TO_MACRO, kt as runtimeDevices$1, l as DEFAULT_CLUSTER_STEP_SETTINGS, m as DEVICE_BACKEND_TO_FORMAT, mn as union, nn as sleep, nt as inferModelProvider, pn as string, pt as overlayClusterStepSettings, qt as createEvent, t as APPLE_SA_TO_MACRO, un as object, wt as resolveClusterStepModelId, yt as pipelineExecutorCapability } from "../dist-ClihWGOZ.mjs";
-import { o as readProcessCost } from "../node-DiaTmz84.mjs";
-import { a as ALL_PIPELINE_STEPS, c as getStep, d as landmarkPrecisionVerdict, l as getStepDefinition, n as resolveDefaultDetectionModel, o as ALL_STEPS, r as localFrameRegistry, s as getDefaultModelForFormat, u as resolveModelForFormat } from "../default-detection-model-DBNEc3iw.mjs";
+import { A as YAMNET_TO_MACRO, At as runtimeDevices$1, C as PoolMemoryWatchdog, Ft as supportedRuntimes$1, K as detectionPipelineCapability, Lt as errMsg, Ot as resolvePoolMemoryPolicy, Tt as resolveClusterStepModelId, V as defaultDeviceFor$1, Wt as BaseAddon, Y as enumerateInferenceDevices, Yt as createEvent, Z as evaluateZoneRules, Zt as hydrateSchema, _n as union, _t as pickClusterStepSettings, an as sleep, at as loadContributionCapability, bt as pipelineExecutorCapability, c as DEFAULT_CLUSTER_STEP_MODELS, gn as string, gt as pickClusterStepModels, l as DEFAULT_CLUSTER_STEP_SETTINGS, m as DEVICE_BACKEND_TO_FORMAT, mt as overlayClusterStepSettings, nn as parseJsonUnknown, pn as object, rt as inferModelProvider, sn as array, t as APPLE_SA_TO_MACRO, tn as nodePin, vn as EventCategory } from "../dist-BNzfbpF6.mjs";
+import { o as readProcessCost } from "../node-uYIx2aZF.mjs";
+import { a as ALL_PIPELINE_STEPS, c as getStep, d as landmarkPrecisionVerdict, l as getStepDefinition, n as resolveDefaultDetectionModel, o as ALL_STEPS, r as localFrameRegistry, s as getDefaultModelForFormat, u as resolveModelForFormat } from "../default-detection-model-BSX8cVHY.mjs";
 import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
-import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-D4t8hpJd.mjs";
+import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-CkoLpOV-.mjs";
 import * as os from "node:os";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";

package/dist/{dist-ClihWGOZ.mjs → dist-BNzfbpF6.mjs}

@@ -5345,6 +5345,118 @@ var ZodIssueCode = {
 /** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
+//#endregion
+//#region ../types/dist/sleep-BnujYGPe.mjs
+/**
+* The audio chunk plane's byte format, and the ONE expansion from a coded
+* window to float samples (D455).
+*
+* ## Why a format at all
+*
+* D450 took the plane off its 8 → 16 kHz upsample: it carries the SOURCE
+* RATE, and the one consumer that needs 16 kHz resamples next to the model.
+* It left the FORMAT alone — the broker still turned each G.711 byte into a
+* 4-byte f32le sample before the bytes entered the transport, so every leg of
+* the plane carried four times the source. The plane crosses hub-main twice on
+* the way to the analyzer, and the fleet's G.711 cameras are ~79 % of it.
+*
+* So the plane carries the source BYTES too, and whoever needs floats expands
+* them where it needs them. That is the same argument D450 made for the rate,
+* one step further along the same wire.
+*
+* ## Why the expansion lives here
+*
+* Two packages need it and they must never disagree: `addon-pipeline`'s broker
+* (which still has to serve a subscriber that did NOT ask for coded bytes —
+* `AudioChunkPlane` expands per subscription) and
+* `addon-pipeline-orchestrator`'s `AudioWindowAccumulator` (which flushes an
+* f32le window to the analyzer cap, whose `AudioChunkInput` contract is
+* unchanged and stays f32le). Both bundle the bare `@camstack/types` entry
+* into their own dist (`self-contained` externals), so this travels with a
+* `camstack deploy` and needs no published server.
+*
+* A second μ-law table anywhere else is the defect this module exists to
+* prevent. (`stream-broker.ts`'s `mulawToPcm` / `alawToPcm` are the ENCODE
+* direction for the WebRTC egress — a different transform, not a copy.)
+*
+* ## Absent means f32le
+*
+* `format` is optional on the wire and its absence means `f32le` — today's
+* bytes, byte for byte. A peer that never heard of the field is served what it
+* has always been served, because the broker only emits a coded window to a
+* subscription that DECLARED it accepts one (`AudioSubscribeOptions.accept`).
+* That is the D448 `rawForward` negotiation, and it is what makes this
+* deployable one addon at a time across three nodes.
+*/
+/** Every byte format the audio chunk plane can carry. `f32le` is the default. */
+var AUDIO_CHUNK_FORMATS = [
+	"f32le",
+	"pcmu",
+	"pcma"
+];
+/**
+* Bytes one sample of `format` occupies. This is the number every duration
+* calculation over a chunk's `data` must use — a window accumulator that
+* hard-codes 4 reports a quarter of the audio it actually holds and flushes
+* four-second windows to a classifier expecting one.
+*/
+function audioChunkBytesPerSample(format) {
+	return format === "f32le" ? 4 : 1;
+}
+/**
+* Expand a CODED audio window to freshly-owned f32le bytes, 4-byte aligned at
+* offset 0, so a caller can build a `Float32Array` view over them directly.
+* The input may be a msgpack subview at any offset; nothing here reads it as
+* anything but bytes.
+*
+* `f32le` is accepted and returns a copy, but a caller that already knows the
+* format is `f32le` should not call this at all — it has the bytes. Both
+* callers branch on the format first for exactly that reason, and the copy
+* here exists so the return type is always owned rather than sometimes
+* aliasing the argument.
+*/
+function expandAudioChunkToF32le(data, format) {
+	if (format === "f32le") {
+		const copy = new Uint8Array(data.byteLength);
+		copy.set(data);
+		return copy;
+	}
+	const table = format === "pcmu" ? ULAW_TABLE : ALAW_TABLE;
+	const out = new Float32Array(data.length);
+	for (let i = 0; i < data.length; i++) out[i] = table[data[i]];
+	return new Uint8Array(out.buffer);
+}
+/**
+* Build the μ-law decode table (ITU-T G.711). Each of the 256 byte values maps
+* to a 16-bit PCM sample, normalised to [-1.0, 1.0] for f32le output.
+*
+* Moved here verbatim from `audio-rtp-decoder.ts`, which no longer decodes:
+* it buffers the coded bytes and the plane's consumers expand.
+*/
+function buildUlawTable() {
+	const table = new Float32Array(256);
+	for (let i = 0; i < 256; i++) {
+		const complemented = ~i & 255;
+		const sign = (complemented & 128) !== 0 ? -1 : 1;
+		const exponent = complemented >> 4 & 7;
+		table[i] = sign * ((8 * (complemented & 15) + 132 << exponent) - 132) / 32768;
+	}
+	return table;
+}
+/** Build the A-law decode table (ITU-T G.711). */
+function buildAlawTable() {
+	const table = new Float32Array(256);
+	for (let i = 0; i < 256; i++) {
+		const xored = i ^ 85;
+		const sign = (xored & 128) !== 0 ? 1 : -1;
+		const exponent = xored >> 4 & 7;
+		const mantissa = xored & 15;
+		table[i] = sign * (exponent === 0 ? 16 * mantissa + 8 : 16 * mantissa + 264 << exponent - 1) / 32768;
+	}
+	return table;
+}
+var ULAW_TABLE = buildUlawTable();
+var ALAW_TABLE = buildAlawTable();
 Object.fromEntries([
 	{
 		id: "overview",
@@ -6717,11 +6829,20 @@ var SubscribeFramesResultSchema = object({
 * (the wire-serialisable supertype of `Buffer`) to match `DecodedFrameSchema`
 * / `EncodedPacketSchema`'s precedent; a `Buffer` is assignable to it.
 */
+var AudioChunkFormatSchema = _enum(AUDIO_CHUNK_FORMATS);
 var DecodedAudioChunkSchema = object({
 	data: _instanceof(Uint8Array),
 	sampleRate: number().int().positive(),
 	channels: number().int().positive(),
-	timestamp: number()
+	timestamp: number(),
+	/**
+	* Byte format of `data`. ABSENT MEANS `f32le` — today's bytes, byte for
+	* byte, for any peer that never heard of this field. A coded window
+	* (`pcmu` / `pcma`, one byte per sample) is only ever emitted to a
+	* subscription that DECLARED it accepts one, so absence can never mean
+	* "coded bytes a consumer will read as floats" (D455).
+	*/
+	format: AudioChunkFormatSchema.optional()
 });
 /**
 * Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9). The
@@ -6733,7 +6854,18 @@ var DecodedAudioChunkSchema = object({
 var SubscribeAudioChunksInputSchema = object({
 	brokerId: string(),
 	/** Short caller-identity tag (`audio-analyzer`, …) for `listClients`. */
-	tag: string().optional()
+	tag: string().optional(),
+	/**
+	* Byte formats this subscriber can READ, best first. The broker serves the
+	* chunk's own format when it is in this list and expands to `f32le`
+	* otherwise, so a subscriber is never handed bytes it cannot interpret.
+	*
+	* Absent (or without the source format) means `f32le` — the behaviour every
+	* subscriber had before D455, unchanged. This is the negotiation half of
+	* the source-bytes lever: it is what lets the broker and its consumers
+	* deploy one at a time across three nodes.
+	*/
+	accept: array(AudioChunkFormatSchema).readonly().optional()
 });
 /** Result of `stream-broker.subscribeAudioChunks`. */
 var SubscribeAudioChunksResultSchema = object({ 
@@ -12340,6 +12472,51 @@ var AudioAnalysisSettingsSchema = object({
 	minConfidence: number().min(0).max(1).default(.3),
 	allowedClasses: array(string()).default([])
 });
+/**
+* `attachDevice` — the analyzer PULLS a camera's audio from the broker (D461).
+*
+* Until D461 the orchestrator drained the broker's chunk plane, accumulated
+* ~1 s windows and pushed them back out as `analyseChunk`. It neither produced
+* nor consumed the audio: the PCM crossed hub-main twice for a process that
+* only buffered it. `attachDevice` inverts the direction — the analyzer opens
+* its own `subscribeAudioChunks` against the broker and the subscriber IS the
+* decoder, so the coded G.711 bytes D455 put on the plane stay coded all the
+* way to the one expansion that feeds the model.
+*
+* The orchestrator still owns the POLICY (the `audioMode` gate, the on-motion
+* window, the per-device node assignment, the settings read) and therefore
+* still owns the attach/detach pair. It no longer owns the bytes.
+*/
+var AudioAttachDeviceInputSchema = object({
+	deviceId: number(),
+	/** Broker id (`<deviceId>/<camStreamId>`) carrying this camera's audio. */
+	brokerId: string(),
+	/**
+	* `clusterRoles.ingestNode` — the node whose broker owns the source dial.
+	* Every `streamBroker` call the attachment makes is pinned to it, exactly as
+	* the orchestrator's poller pinned them before the move.
+	*/
+	ingestNodeId: string(),
+	/**
+	* Resolved once by the orchestrator at attach time, exactly as it was read
+	* once per subscription before D461. The analyzer does NOT re-resolve per
+	* window: a settings change re-attaches, which is what always happened.
+	*/
+	settings: AudioAnalysisSettingsSchema
+});
+var AudioAttachDeviceResultSchema = object({
+	/** False only when the analyzer is shutting down and refused to attach. */
+	attached: boolean(),
+	/**
+	* True when the attachment replaced a live one for the same device. An
+	* attach is idempotent by REPLACEMENT — two pollers on one camera would
+	* double the broker's fanout and neither would know about the other.
+	*/
+	replaced: boolean()
+});
+var AudioDetachDeviceResultSchema = object({ 
+/** False when no attachment existed — detach is idempotent. */
+detached: boolean() });
 var AudioClassificationResultSchema = object({
 	labels: array(AudioClassificationLabelSchema).readonly(),
 	rawLabels: array(AudioClassificationLabelSchema).readonly().optional(),
@@ -12388,6 +12565,21 @@ var audioAnalyzerCapability = {
 			settings: AudioAnalysisSettingsSchema
 		}), AudioAnalysisResultSchema.nullable(), { kind: "mutation" }),
 		classify: method(AudioChunkInputSchema, AudioClassificationResultSchema, { timeoutMs: 3e4 }),
+		/**
+		* Start pulling this camera's audio from the broker, in THIS process.
+		* Returns as soon as the attachment exists — the first
+		* `subscribeAudioChunks` retries with backoff behind it, because the
+		* broker for a camStream may not be registered yet (that tolerance moved
+		* with the poller, D461). Replaces any live attachment for the device.
+		*/
+		attachDevice: method(AudioAttachDeviceInputSchema, AudioAttachDeviceResultSchema, { kind: "mutation" }),
+		/**
+		* Stop pulling this camera's audio and release the broker subscription.
+		* Idempotent. A detach that never arrives is the one failure mode this
+		* split adds, which is why `AudioChunkPlane` reaps a subscription nobody
+		* drains rather than trusting it (D461).
+		*/
+		detachDevice: method(object({ deviceId: number() }), AudioDetachDeviceResultSchema, { kind: "mutation" }),
 		isReady: method(_void(), boolean()),
 		dispose: method(_void(), _void(), { kind: "mutation" }),
 		/**
@@ -22899,6 +23091,14 @@ var NativeCropResultSchema = object({
 	* set `encodeJpeg: true`; `bytes` is then absent.
 	*/
 	jpeg: string().optional(),
+	/**
+	* The SAME compressed JPEG as `jpeg`, as bytes (D462). Present instead of
+	* `jpeg` when the request set `acceptJpegBytes`; a request that did not gets
+	* `jpeg` exactly as before. MsgPack and the mesh leg both carry binary —
+	* `bytes` above has crossed this boundary as a `Uint8Array` all along — so
+	* base64 was buying nothing but a multi-megabyte string in the relay's heap.
+	*/
+	jpegBytes: _instanceof(Uint8Array).optional(),
 	width: number().int().positive(),
 	height: number().int().positive(),
 	/**
@@ -22965,7 +23165,14 @@ var ParkTrackFrameResultSchema = discriminatedUnion("parked", [object({
 })]);
 /** A retrieved parcel — the runner's own JPEG, base64 for the wire. */
 var ParkedTrackFrameSchema = object({
-	jpeg: string(),
+	/**
+	* Base64 JPEG — the pre-D462 wire. OPTIONAL since D462: a request that set
+	* `acceptJpegBytes` is answered in `jpegBytes` and this is then absent.
+	* Exactly one of the two is present.
+	*/
+	jpeg: string().optional(),
+	/** The same JPEG as bytes, for a caller that declared it reads them (D462). */
+	jpegBytes: _instanceof(Uint8Array).optional(),
 	width: number().int().positive(),
 	height: number().int().positive(),
 	/** The frame instant the parcel shows (the caller's clock, echoed back). */
@@ -23616,6 +23823,13 @@ var pipelineRunnerCapability = {
 			bbox: NativeCropBboxSchema,
 			maxWidth: number().int().positive().optional(),
 			/**
+			* The caller reads a `Uint8Array` (D462). When set, a JPEG answer comes
+			* back in `jpegBytes` instead of base64 `jpeg`. Absent means the old
+			* wire — never assume consent: a pre-D462 caller parses the field as
+			* base64 and bytes would decode to garbage rather than fail.
+			*/
+			acceptJpegBytes: boolean().optional(),
+			/**
 			* When `true`, the runner encodes the resolved crop to JPEG ON THE
 			* OWNING NODE and returns it in `jpeg` (base64) INSTEAD of raw `bytes`.
 			* Callers set this for CROSS-NODE fetches (`handle.nodeId` is a remote
@@ -23788,7 +24002,14 @@ var pipelineRunnerCapability = {
 		getParkedTrackFrame: method(object({
 			deviceId: number(),
 			trackId: string(),
-			kind: ParkedFrameKindSchema
+			kind: ParkedFrameKindSchema,
+			/**
+			* The caller reads a `Uint8Array` (D462). When set, a JPEG answer comes
+			* back in `jpegBytes` instead of base64 `jpeg`. Absent means the old
+			* wire — never assume consent: a pre-D462 caller parses the field as
+			* base64 and bytes would decode to garbage rather than fail.
+			*/
+			acceptJpegBytes: boolean().optional()
 		}), ParkedTrackFrameSchema.nullable()),
 		/**
 		* Drop every parcel of a track — the hub closed it. Idempotent. A track
@@ -34037,12 +34258,24 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"audioAnalyzer.attachDevice": {
+		capName: "audio-analyzer",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"audioAnalyzer.classify": {
 		capName: "audio-analyzer",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
+	"audioAnalyzer.detachDevice": {
+		capName: "audio-analyzer",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"audioAnalyzer.dispose": {
 		capName: "audio-analyzer",
 		capScope: "system",
@@ -39886,11 +40119,21 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"audioAnalyzer.attachDevice": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"audioAnalyzer.classify": [{
 		name: "deviceId",
 		form: "single",
 		optional: true
 	}],
+	"audioAnalyzer.detachDevice": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"audioMetrics.getCurrentSnapshot": [{
 		name: "deviceId",
 		form: "single",
@@ -41742,6 +41985,51 @@ Object.freeze({
 	"network-access": "ingress",
 	"smtp-provider": "email"
 });
+var G711_SCALE_CORRECTION_DB = {
+	PCMU: 20 * Math.log10(4),
+	PCMA: 20 * Math.log10(8)
+};
+/**
+* Restate a dBFS number that was MEASURED through the pre-epoch decoder as the
+* same intent on the ITU-T scale (D460).
+*
+* ## When this applies, and when it is the wrong thing to reach for
+*
+* An absolute-dBFS number in this repo is one of two things, and only one of
+* them converts:
+*
+*  - **A statement about the scale** — "-55 dBFS is near silence", "-25 dBFS
+*    is loud". It was true on the ITU-T scale before the epoch and it is true
+*    after. The defect was never in the number; it was that 19 of this hub's
+*    25 cameras did not obey it. Converting such a number takes something
+*    correct and makes it wrong, in order to preserve a bug.
+*  - **A measurement taken through the old decoder** — a value someone read
+*    off a meter that under-reported by exactly 4× (PCMU) or 8× (PCMA). It
+*    describes a sound that was really {@link G711_SCALE_CORRECTION_DB} dB
+*    louder. That is what this function is for.
+*
+* Telling the two apart is a question about PROVENANCE, not about arithmetic,
+* and it cannot be answered from the number. It is answered by the comment the
+* author left — which is why `scripts/check-dbfs-era.mts` makes leaving one
+* mandatory.
+*
+* ## Why a function and not a typed-in number
+*
+* `-55 + 12.04` written into a source file is, six months later, completely
+* indistinguishable from a threshold somebody simply preferred. Calling this
+* keeps the derivation, the law, and the original measurement all visible at
+* the call site, so a future reader can disagree with the *premise* instead of
+* having to reverse-engineer the sum.
+*
+* **This is not a runtime gain.** It converts an authored CONSTANT once, where
+* it is declared. It must never be applied to a live sample or a stored
+* `AudioEvent.dbfs`: the decoder is correct now, and a second authority
+* adjusting numbers the decoder already got right is the original defect with
+* an extra place to argue with (D459).
+*/
+function ituDbfsFromPreEpoch(law, authoredDbfs) {
+	return authoredDbfs + G711_SCALE_CORRECTION_DB[law];
+}
 /**
 * audio-condition — the authoring logic behind the sustained-sound condition
 * (`NcConditions.audio`), pure and UI-framework-free.
@@ -41792,6 +42080,7 @@ var AUDIO_KIND_PREFIX = "audio-";
 function audioKindId(macroId) {
 	return macroId.startsWith(AUDIO_KIND_PREFIX) ? macroId : `${AUDIO_KIND_PREFIX}${macroId}`;
 }
+Math.round(ituDbfsFromPreEpoch("PCMU", -55));
 /** Schema defaults — an untouched sub-field must author exactly these. */
 var NC_AUDIO_DEFAULTS = {
 	hitPercent: 60,
@@ -43325,4 +43614,4 @@ function enumerateInferenceDevices(hw) {
 	return out;
 }
 //#endregion
-export { failureContributionCapability as $, parseJsonUnknown as $t, addonWidgetsSourceCapability as A, storageEvictableCapability as At, defaultDeviceFor as B, invocationFromEncodeProfile as Bt, RATE_CONTROL_RELAXED as C, recordingSignalCapability as Ct, RecordingSignalStatusSchema as D, resolvePoolMemoryPolicy as Dt, RecordingConfigSchema as E, resolveLocationMode as Et, cameraStreamsCapability as F, webrtcSessionCapability as Ft, detectionPipelineCapability as G, DeviceFeature as Gt, deriveBatteryPresence as H, BOOT_RECOVERY_BACKOFF_MS as Ht, createHwAccelCache as I, errMsg as It, enumerateInferenceDevices as J, hydrateSchema as Jt, egressTranscodeSharingKey as K, DeviceType as Kt, createLogChannelsProvider as L, AUDIO_PRESETS as Lt, audioAnalyzerCapability as M, streamBrokerCapability as Mt, audioKindId as N, stripRetiredBandPreBufferSec as Nt, RingBuffer as O, resolveRecordingProfiles as Ot, batteryCapability as P, supportedRuntimes as Pt, evictionPolicyOfLocation as Q, nodePin as Qt, customAction as R, Fmp4BoxSplitter as Rt, PoolMemoryWatchdog as S, recordingExportCapability as St, RECORDING_EXPORT_MAX_READ_BYTES as T, resolveEgressDecodeHwAccel as Tt, deriveDetailCropRect as U, BaseAddon as Ut, defineCustomActions as V, isSoftwareDecode as Vt, deriveRecordingMode as W, CAM_PROFILE_ORDER as Wt, evaluateZoneRules as X, makeProfileBrokerId as Xt, evaluateSensorEdge as Y, isEvent as Yt, evictionPolicyForMode as Z, makeSourceBrokerId as Zt, FailureCounters as _, pickDetailCropConvention as _t, COCO_80_LABELS as a, boolean as an, logChannelsCapability as at, NativeLeaseSettingsSchema as b, pipelineRunnerCapability as bt, DEFAULT_CLUSTER_STEP_MODELS as c, literal as cn, mayReadLocation as ct, DEFAULT_EVENTS_BAND_BUFFER_SEC as d, preprocess as dn, modeMayWrite as dt, parseProfileBrokerId as en, gbToBytes as et, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as f, record as fn, motionDetectionCapability as ft, ExportRecordSchema as g, pickClusterStepSettings as gt, EncodeProfileSchema as h, EventCategory as hn, pickClusterStepModels as ht, BatteryStatusSchema as i, array as in, loadContributionCapability as it, audioAnalysisCapability as j, storageOccupancyCapability as jt, YAMNET_TO_MACRO as k, runtimeDevices as kt, DEFAULT_CLUSTER_STEP_SETTINGS as l, number as ln, mayWriteToLocation as lt, DEVICE_BACKEND_TO_FORMAT as m, union as mn, parseProcStatus as mt, AUDIO_BACKEND_CHOICES as n, sleep as nn, inferModelProvider as nt, COCO_TO_MACRO as o, discriminatedUnion as on, mapAudioLabelToMacro as ot, DEFAULT_NATIVE_LEASE_SETTINGS as p, string as pn, overlayClusterStepSettings as pt, egressTransportFromRequest as q, createEvent as qt, AUDIO_MACRO_LABELS as r, _enum as rn, isFirstLevelMacroClass as rt, DEFAULT_AUDIO_ANALYZER_CONFIG as s, lazy as sn, maskUrlCredentials as st, APPLE_SA_TO_MACRO as t, selectAssignedProfileSlots as tn, hfModelUrl as tt, DEFAULT_DETAIL_CROP_CONVENTION as u, object as un, migrateLegacyDeviceSignalConfig as ut, HF_BASE_URL as v, pickNativeLeaseOverride as vt, RATE_CONTROL_TIGHT as w, resolveClusterStepModelId as wt, OpsLogEntrySchema as x, recordingCapability as xt, NativeLeaseAdmissionSchema as y, pipelineExecutorCapability as yt, declareLogChannel as z, buildFfmpegArgs as zt };
+export { evictionPolicyOfLocation as $, makeProfileBrokerId as $t, YAMNET_TO_MACRO as A, runtimeDevices as At, declareLogChannel as B, buildFfmpegArgs as Bt, PoolMemoryWatchdog as C, recordingExportCapability as Ct, RecordingConfigSchema as D, resolveLocationMode as Dt, RECORDING_EXPORT_MAX_READ_BYTES as E, resolveEgressDecodeHwAccel as Et, batteryCapability as F, supportedRuntimes as Ft, deriveRecordingMode as G, CAM_PROFILE_ORDER as Gt, defineCustomActions as H, isSoftwareDecode as Ht, cameraStreamsCapability as I, webrtcSessionCapability as It, egressTransportFromRequest as J, audioChunkBytesPerSample as Jt, detectionPipelineCapability as K, DeviceFeature as Kt, createHwAccelCache as L, errMsg as Lt, audioAnalysisCapability as M, storageOccupancyCapability as Mt, audioAnalyzerCapability as N, streamBrokerCapability as Nt, RecordingSignalStatusSchema as O, resolvePoolMemoryPolicy as Ot, audioKindId as P, stripRetiredBandPreBufferSec as Pt, evictionPolicyForMode as Q, isEvent as Qt, createLogChannelsProvider as R, AUDIO_PRESETS as Rt, OpsLogEntrySchema as S, recordingCapability as St, RATE_CONTROL_TIGHT as T, resolveClusterStepModelId as Tt, deriveBatteryPresence as U, BOOT_RECOVERY_BACKOFF_MS as Ut, defaultDeviceFor as V, invocationFromEncodeProfile as Vt, deriveDetailCropRect as W, BaseAddon as Wt, evaluateSensorEdge as X, expandAudioChunkToF32le as Xt, enumerateInferenceDevices as Y, createEvent as Yt, evaluateZoneRules as Z, hydrateSchema as Zt, FailureCounters as _, union as _n, pickClusterStepSettings as _t, COCO_80_LABELS as a, sleep as an, loadContributionCapability as at, NativeLeaseAdmissionSchema as b, pipelineExecutorCapability as bt, DEFAULT_CLUSTER_STEP_MODELS as c, boolean as cn, maskUrlCredentials as ct, DEFAULT_EVENTS_BAND_BUFFER_SEC as d, literal as dn, migrateLegacyDeviceSignalConfig as dt, makeSourceBrokerId as en, failureContributionCapability as et, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as f, number as fn, modeMayWrite as ft, ExportRecordSchema as g, string as gn, pickClusterStepModels as gt, EncodeProfileSchema as h, record as hn, parseProcStatus as ht, BatteryStatusSchema as i, selectAssignedProfileSlots as in, isFirstLevelMacroClass as it, addonWidgetsSourceCapability as j, storageEvictableCapability as jt, RingBuffer as k, resolveRecordingProfiles as kt, DEFAULT_CLUSTER_STEP_SETTINGS as l, discriminatedUnion as ln, mayReadLocation as lt, DEVICE_BACKEND_TO_FORMAT as m, preprocess as mn, overlayClusterStepSettings as mt, AUDIO_BACKEND_CHOICES as n, parseJsonUnknown as nn, hfModelUrl as nt, COCO_TO_MACRO as o, _enum as on, logChannelsCapability as ot, DEFAULT_NATIVE_LEASE_SETTINGS as p, object as pn, motionDetectionCapability as pt, egressTranscodeSharingKey as q, DeviceType as qt, AUDIO_MACRO_LABELS as r, parseProfileBrokerId as rn, inferModelProvider as rt, DEFAULT_AUDIO_ANALYZER_CONFIG as s, array as sn, mapAudioLabelToMacro as st, APPLE_SA_TO_MACRO as t, nodePin as tn, gbToBytes as tt, DEFAULT_DETAIL_CROP_CONVENTION as u, lazy as un, mayWriteToLocation as ut, G711_SCALE_CORRECTION_DB as v, EventCategory as vn, pickDetailCropConvention as vt, RATE_CONTROL_RELAXED as w, recordingSignalCapability as wt, NativeLeaseSettingsSchema as x, pipelineRunnerCapability as xt, HF_BASE_URL as y, pickNativeLeaseOverride as yt, customAction as z, Fmp4BoxSplitter as zt };