@camstack/addon-pipeline 1.2.101 → 1.2.103

package/dist/detection-pipeline/index.mjs

@@ -1,8 +1,8 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
-import { Ct as nodePin, Dt as sleep, Ft as object, H as evaluateZoneRules, Lt as string, N as defaultDeviceFor$1, R as detectionPipelineCapability, Rt as union, T as YAMNET_TO_MACRO, V as enumerateInferenceDevices, X as pipelineExecutorCapability, ct as errMsg, d as DEVICE_BACKEND_TO_FORMAT, kt as array, mt as BaseAddon, ot as supportedRuntimes$1, rt as runtimeDevices$1, t as APPLE_SA_TO_MACRO, tt as resolvePoolMemoryPolicy, vt as createEvent, wt as parseJsonUnknown, y as PoolMemoryWatchdog, yt as hydrateSchema, zt as EventCategory } from "../dist-gXdWP96z.mjs";
-import { a as getDefaultModelForFormat, c as getStepDefinition, i as ALL_STEPS, l as resolveModelForFormat, n as startEventLoopStallMonitor, o as getDefaultModelForFormatFromDef, r as ALL_PIPELINE_STEPS, s as getStep } from "../event-loop-stall-monitor-TnQ21mu0.mjs";
+import { At as array, Bt as EventCategory, H as enumerateInferenceDevices, It as object, Ot as sleep, P as defaultDeviceFor$1, Rt as string, T as YAMNET_TO_MACRO, Tt as parseJsonUnknown, U as evaluateZoneRules, Z as pipelineExecutorCapability, bt as hydrateSchema, d as DEVICE_BACKEND_TO_FORMAT, ht as BaseAddon, it as runtimeDevices$1, lt as errMsg, nt as resolvePoolMemoryPolicy, st as supportedRuntimes$1, t as APPLE_SA_TO_MACRO, wt as nodePin, y as PoolMemoryWatchdog, yt as createEvent, z as detectionPipelineCapability, zt as union } from "../dist-Ccmt3fGJ.mjs";
+import { a as getDefaultModelForFormat, c as getStepDefinition, i as ALL_STEPS, l as resolveModelForFormat, n as startEventLoopStallMonitor, o as getDefaultModelForFormatFromDef, r as ALL_PIPELINE_STEPS, s as getStep, u as landmarkPrecisionVerdict } from "../event-loop-stall-monitor-OJrOMeuu.mjs";
 import { t as getSharp } from "../lazy-sharp-6oymT_yf.mjs";
-import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-CKWh609B.mjs";
+import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-D0zDmXLI.mjs";
 import { a as ensureModel, o as isModelDownloaded, r as deleteModelFromDisk } from "../addon-utils-A2S9D7pu.mjs";
 import sharp from "sharp";
 import { spawn } from "node:child_process";
@@ -3033,7 +3033,9 @@ async function nativeChildCrop(provider, bbox, imageWidth, imageHeight, maxWidth
 *      peaky (a few high rows) rather than smeared across many rows.
 *   3. pick the angle maximising the score (coarse 2° sweep + a 0.5° local
 *      refinement); apply it to the full-resolution RGB tile only when it is
-*      meaningfully non-zero.
+*      meaningfully non-zero AND the optimum was BRACKETED by the sweep — an
+*      argmax sitting on the boundary means the profile never turned over and
+*      the "angle" is an artefact of where the search stopped.
 *
 * All of the geometry is pure functions over raw buffers, so the estimator is
 * fully deterministic and unit-testable without any image I/O.
@@ -3212,22 +3214,28 @@ function scoreAngle(gradient, angleRad) {
 		height: rotated.height
 	});
 }
+var DEFAULT_COARSE_STEP_DEG = 2;
+var NO_SKEW = {
+	angleDeg: 0,
+	score: 0
+};
 /**
 * Estimate the dominant text-baseline skew of a grayscale plate crop and return
 * the CORRECTION angle (degrees) that levels it. A coarse sweep over
 * ±`maxAngleDeg` in `coarseStepDeg` steps finds the best bucket; a `fineStepDeg`
 * local search refines it. Returns `0` when the flat (no-rotation) profile is
-* already the strongest response.
+* already the strongest response, and — critically — also when the coarse
+* winner is not BRACKETED by the sweep (see {@link BOUNDARY_REJECT_DEG}): an
+* optimum sitting on the edge of the searched interval is not a measurement,
+* it is the place the search ran out of road.
 */
 function estimateSkewAngle(gray, opts = {}) {
-	const maxAngleDeg = opts.maxAngleDeg ?? 30;
-	const coarseStepDeg = opts.coarseStepDeg ?? 2;
+	const maxAngleDeg = opts.maxAngleDeg ?? 16;
+	const coarseStepDeg = opts.coarseStepDeg ?? DEFAULT_COARSE_STEP_DEG;
 	const fineStepDeg = opts.fineStepDeg ?? .5;
 	const scoreMaxDim = opts.scoreMaxDim ?? 480;
-	if (gray.width < 4 || gray.height < 4) return {
-		angleDeg: 0,
-		score: 0
-	};
+	const boundaryRejectDeg = Math.max(0, maxAngleDeg - coarseStepDeg);
+	if (gray.width < 4 || gray.height < 4) return NO_SKEW;
 	const gradient = sobelMagnitude(downscaleGray(gray, scoreMaxDim));
 	let bestAngle = 0;
 	let bestScore = scoreAngle(gradient, 0);
@@ -3239,6 +3247,7 @@ function estimateSkewAngle(gray, opts = {}) {
 			bestAngle = deg;
 		}
 	}
+	if (Math.abs(bestAngle) >= boundaryRejectDeg) return NO_SKEW;
 	const lo = bestAngle - coarseStepDeg;
 	const hi = bestAngle + coarseStepDeg;
 	for (let deg = lo; deg <= hi + 1e-9; deg += fineStepDeg) {
@@ -3254,6 +3263,50 @@ function estimateSkewAngle(gray, opts = {}) {
 		score: bestScore
 	};
 }
+function toSharpChannels(channels) {
+	switch (channels) {
+		case 1: return 1;
+		case 2: return 2;
+		case 4: return 4;
+		default: return 3;
+	}
+}
+/**
+* Cut an expand-rotated canvas back to the LEVELLED SOURCE BAND.
+*
+* `rotateRaw(expand: true)` grows the canvas to `w·|cos| + h·|sin|` ×
+* `w·|sin| + h·|cos|` so no corner is clipped — but the `|sin|` terms are pure
+* corner spread: flat fill above/below (and left/right of) the plate. Handing
+* that to OCR is not free. The recognizer letterboxes the whole tile into a
+* fixed 64px-tall input, so a 155px crop returned at 194px shrinks every glyph
+* by ~20% before a single character is read — the warp paying back part of what
+* it just won.
+*
+* The band kept is the source rectangle scaled by `|cos angle|`, centred: a
+* source edge of length L, once levelled, spans `L·|cos|` along its own axis.
+* Everything outside is the fill the rotation introduced.
+*/
+function cropLevelledBand(rotated, srcWidth, srcHeight, angleRad) {
+	const c = Math.abs(Math.cos(angleRad));
+	const bw = Math.max(1, Math.min(rotated.width, Math.round(srcWidth * c)));
+	const bh = Math.max(1, Math.min(rotated.height, Math.round(srcHeight * c)));
+	if (bw === rotated.width && bh === rotated.height) return rotated;
+	const ch = rotated.channels;
+	const x0 = Math.max(0, Math.floor((rotated.width - bw) / 2));
+	const y0 = Math.max(0, Math.floor((rotated.height - bh) / 2));
+	const out = new Uint8Array(bw * bh * ch);
+	const rowBytes = bw * ch;
+	for (let y = 0; y < bh; y++) {
+		const srcOff = ((y0 + y) * rotated.width + x0) * ch;
+		out.set(rotated.data.subarray(srcOff, srcOff + rowBytes), y * rowBytes);
+	}
+	return {
+		data: out,
+		width: bw,
+		height: bh,
+		channels: ch
+	};
+}
 /**
 * Rectify an oblique plate crop: decode the JPEG, estimate the baseline skew,
 * and — only when it exceeds {@link MIN_RECTIFY_ANGLE_DEG} — rotate the
@@ -3281,19 +3334,20 @@ async function rectifyPlateJpeg(jpeg, opts = {}) {
 	let mean = 0;
 	for (let i = 0; i < gray.data.length; i++) mean += gray.data[i];
 	const fill = gray.data.length > 0 ? mean / gray.data.length | 0 : 0;
-	const rotated = rotateRaw(rgb, angleDeg * DEG2RAD, {
+	const angleRad = angleDeg * DEG2RAD;
+	const band = cropLevelledBand(rotateRaw(rgb, angleRad, {
 		expand: true,
 		fill
-	});
+	}), rgb.width, rgb.height, angleRad);
 	try {
 		return {
-			jpeg: await sharp(Buffer.from(rotated.data), { raw: {
-				width: rotated.width,
-				height: rotated.height,
-				channels: rotated.channels
+			jpeg: await sharp(Buffer.from(band.data), { raw: {
+				width: band.width,
+				height: band.height,
+				channels: toSharpChannels(band.channels)
 			} }).jpeg({ quality: opts.quality ?? 90 }).toBuffer(),
-			width: rotated.width,
-			height: rotated.height,
+			width: band.width,
+			height: band.height,
 			angleDeg
 		};
 	} catch {
@@ -3302,6 +3356,12 @@ async function rectifyPlateJpeg(jpeg, opts = {}) {
 }
 //#endregion
 //#region src/detection-pipeline/pipeline/result-assembler.ts
+/** L2 norm of a raw embedding vector. */
+function vectorMagnitude(v) {
+	let sum = 0;
+	for (const x of v) sum += x * x;
+	return Math.sqrt(sum);
+}
 /**
 * Small deterministic id generator scoped to a single frame. Each call
 * returns the next `d{n}` id so detail parentId references can be set
@@ -3395,6 +3455,7 @@ function applyChildOutput(parent, childStep, output, stepLatencyMs, ctx) {
 		case "embedding":
 			parent.embedding = output.embeddingNorm;
 			parent.embeddingModelId = childStep.modelId;
+			parent.embeddingMagnitude = vectorMagnitude(output.embedding);
 			parent.ownLabels.push({
 				label: `embedding:${output.embedding.length}d`,
 				score: 1
@@ -3617,20 +3678,50 @@ var MIN_FACE_DETECTION_FLOOR_PX = 6;
 */
 var NATIVE_FACE_CROP_MAX_WIDTH = 320;
 /**
-* Minimum short side (px) of the ACTUAL crop fed to the plate-OCR (`ctc`) leaf
-* — the plate analogue of the face path's min-face-size gate. Below ~20px the
-* CTC logit map collapses toward the blank and the surviving timesteps emit
-* symbol junk ("[miv4o)", "6ou.2" — live-observed 2026-07-22). Measured on the
-* NATIVE crop when the native ROI fetch succeeded (its dimensions ARE the
-* plate's real native size — `nativeChildCrop`'s 1920 cap never binds for a
-* plate), else on the fallback detection-space tile — which IS the input OCR
-* would read, so the same floor applies honestly in both cases.
+* Minimum LONG side (px) of the ACTUAL crop fed to the plate-OCR (`ctc`) leaf —
+* the plate analogue of the face path's min-face-size gate.
+*
+* The long side, not the short one. A plate's information lives along its text
+* run: the recognizer resizes the tile to a fixed 64px height and reads left to
+* right, so what decides whether a glyph survives is how many horizontal pixels
+* each character got. The previous 20px SHORT-side floor measured the wrong
+* axis and passed essentially everything.
+*
+* The number comes from the 2026-08 audit of 11 cam-617 plate tracks with
+* ground truth. Native long side vs read:
+*
+*   117px → "DNRO3O9"  (truth DNRO309 — one glyph out, the only near-miss)
+*    82px → "VONND9592" (truth DNDS597)
+*    77px → "DEPNOQ1"   (truth DNP1091)
+*    76px → "VDHPXOE8"  (truth DNPK838)
+*    73px → "DAEOR2D8"  (truth DNDR298)
+*    ≤62px → "I0IAZ", "EUSM9", "0IA3", "DYAGI2", "I0AA", "IC1E"
+*
+* Not one read under 100px resembled its plate, and the gap between 82 and 117
+* is empty — 100 sits in it. Below this floor the OCR call is pure cost: it
+* produces a label that is wrong, and a wrong plate label is worse than none.
+*
+* Measured on the NATIVE crop when the native ROI fetch succeeded (its
+* dimensions ARE the plate's real native size — `nativeChildCrop`'s 1920 cap
+* never binds for a plate), else on the fallback detection-space tile — which
+* IS the input OCR would read, so the same floor applies honestly in both cases.
 */
-var MIN_PLATE_OCR_SHORT_SIDE_PX = 20;
+var MIN_PLATE_OCR_LONG_SIDE_PX = 100;
 function isEnrichmentOutput(output) {
 	return output.kind === "classifications" || output.kind === "embedding" || output.kind === "text";
 }
 /**
+* Read a numeric step setting, falling back to `fallback` when the key is
+* absent or not a finite number. A type guard rather than a cast — a step's
+* `settings` bag is `Record<string, unknown>` because it is operator data, and
+* asserting `as number` over it is how a string from a form becomes a silent
+* NaN comparison that admits everything.
+*/
+function numericSetting(settings, key, fallback) {
+	const raw = settings?.[key];
+	return typeof raw === "number" && Number.isFinite(raw) ? raw : fallback;
+}
+/**
 * Stamp the camera onto an inference input so a failure inside the SHARED pool
 * can name it (`InferenceInput.deviceId` — diagnostic only, it selects
 * nothing). Immutable, and a no-op for a caller with no real camera: the
@@ -4071,12 +4162,27 @@ var PipelineExecutor = class {
 				let cropW;
 				let cropH;
 				if (modelEntry?.faceAlignment) {
-					const minFaceSize = typeof child.settings?.["minFaceSize"] === "number" ? child.settings["minFaceSize"] : DEFAULT_MIN_FACE_SIZE_PX;
+					const minFaceSize = numericSetting(child.settings, "minFaceSize", DEFAULT_MIN_FACE_SIZE_PX);
 					const detShortSide = bboxShortSide(parentDetection.bbox);
 					if (detShortSide < MIN_FACE_DETECTION_FLOOR_PX) {
 						this.warnFaceTooSmall(child, detShortSide, minFaceSize, void 0, deviceId);
 						continue;
 					}
+					const precision = landmarkPrecisionVerdict({
+						detectionShortSidePx: detShortSide,
+						floorPx: numericSetting(child.settings, "minLandmarkFaceSize", 24)
+					});
+					if (precision !== null) {
+						this.throttledWarn(`face-landmark-floor:${child.stepId}:${deviceId}`, 3e4, "face detected but its landmarks are below the precision floor — no embedding", {
+							step: child.stepId,
+							model: child.modelId,
+							detectionShortSidePx: Math.round(precision.detectionShortSidePx),
+							minLandmarkFaceSizePx: precision.floorPx,
+							tileW: imageWidth,
+							tileH: imageHeight
+						}, deviceId);
+						continue;
+					}
 					const lms = parentDetection.landmarks;
 					if (lms && lms.length >= 5) {
 						if (!nativeCropProvider && detShortSide < minFaceSize) {
@@ -4140,15 +4246,16 @@ var PipelineExecutor = class {
 						cropH = crop.height;
 					}
 					if (child.definition.postprocessor === "ctc") {
-						const plateShortSidePx = Math.min(cropW, cropH);
-						if (plateShortSidePx < MIN_PLATE_OCR_SHORT_SIDE_PX) {
-							this.opts.logger?.debug("plate ROI too small for OCR — skipping", {
+						const plateLongSidePx = Math.max(cropW, cropH);
+						if (plateLongSidePx < MIN_PLATE_OCR_LONG_SIDE_PX) {
+							this.opts.logger?.info("plate ROI too small for OCR — skipping", {
 								tags: { deviceId },
 								meta: {
 									step: child.stepId,
 									model: child.modelId,
-									plateShortSidePx: Math.round(plateShortSidePx),
-									minPlateShortSidePx: MIN_PLATE_OCR_SHORT_SIDE_PX,
+									plateLongSidePx: Math.round(plateLongSidePx),
+									plateShortSidePx: Math.round(Math.min(cropW, cropH)),
+									minPlateLongSidePx: MIN_PLATE_OCR_LONG_SIDE_PX,
 									source: nativeChild ? "native" : "detection-tile"
 								}
 							});
@@ -4161,12 +4268,15 @@ var PipelineExecutor = class {
 							cropJpegBuf = rectified.jpeg;
 							cropW = rectified.width;
 							cropH = rectified.height;
-							this.opts.logger?.debug("Plate crop deskewed before OCR", { meta: {
-								stepId: child.definition.id,
-								angleDeg: Number(rectified.angleDeg.toFixed(2)),
-								width: cropW,
-								height: cropH
-							} });
+							this.opts.logger?.info("plate crop deskewed before OCR", {
+								tags: { deviceId },
+								meta: {
+									step: child.stepId,
+									angleDeg: Number(rectified.angleDeg.toFixed(2)),
+									width: cropW,
+									height: cropH
+								}
+							});
 						}
 					} catch {}
 				}
@@ -4176,6 +4286,17 @@ var PipelineExecutor = class {
 				}, deviceId), cropW, cropH, "crop-roi", parentDetection.bbox, parentDetection.macroClass, traceBuilder, stepTimings, poolAgg);
 				const childMs = Date.now() - childStart;
 				if (childOutput === null) continue;
+				if (child.definition.postprocessor === "ctc" && childOutput.kind === "text") this.opts.logger?.info("plate OCR read", {
+					tags: { deviceId },
+					meta: {
+						step: child.stepId,
+						model: child.modelId,
+						text: childOutput.text,
+						confidence: Number(childOutput.confidence.toFixed(3)),
+						formatValid: childOutput.formatValid ?? null,
+						tilePx: `${cropW}x${cropH}`
+					}
+				});
 				const detailsBefore = ctx.details.length;
 				applyChildOutput(parentDetection, child, childOutput, childMs, ctx);
 				if (childOutput.kind === "detections" && child.children.length > 0) {

package/dist/{dist-dm3t4BOt.js → dist-C11WuNUP.js}

@@ -15342,128 +15342,103 @@ var COCO_TO_MACRO = {
 var AUDIO_MACRO_LABELS = [
 	{
 		id: "speech",
-		name: "Speech",
-		icon: "🗣️"
+		name: "Speech"
 	},
 	{
 		id: "scream",
-		name: "Scream / Shout",
-		icon: "😱"
+		name: "Scream / Shout"
 	},
 	{
 		id: "crying",
-		name: "Crying / Baby",
-		icon: "😢"
+		name: "Crying / Baby"
 	},
 	{
 		id: "laughter",
-		name: "Laughter",
-		icon: "😂"
+		name: "Laughter"
 	},
 	{
 		id: "music",
-		name: "Music",
-		icon: "🎵"
+		name: "Music"
 	},
 	{
 		id: "dog",
-		name: "Dog",
-		icon: "🐕"
+		name: "Dog"
 	},
 	{
 		id: "cat",
-		name: "Cat",
-		icon: "🐈"
+		name: "Cat"
 	},
 	{
 		id: "bird",
-		name: "Bird",
-		icon: "🐦"
+		name: "Bird"
 	},
 	{
 		id: "animal",
-		name: "Animal (other)",
-		icon: "🐾"
+		name: "Animal (other)"
 	},
 	{
 		id: "alarm",
-		name: "Alarm / Siren",
-		icon: "🚨"
+		name: "Alarm / Siren"
 	},
 	{
 		id: "doorbell",
-		name: "Doorbell / Knock",
-		icon: "🔔"
+		name: "Doorbell / Knock"
 	},
 	{
 		id: "glass_breaking",
-		name: "Glass Breaking",
-		icon: "💥"
+		name: "Glass Breaking"
 	},
 	{
 		id: "gunshot",
-		name: "Gunshot / Explosion",
-		icon: "💣"
+		name: "Gunshot / Explosion"
 	},
 	{
 		id: "vehicle",
-		name: "Vehicle",
-		icon: "🚗"
+		name: "Vehicle"
 	},
 	{
 		id: "siren",
-		name: "Emergency Siren",
-		icon: "🚑"
+		name: "Emergency Siren"
 	},
 	{
 		id: "fire",
-		name: "Fire / Smoke",
-		icon: "🔥"
+		name: "Fire / Smoke"
 	},
 	{
 		id: "water",
-		name: "Water",
-		icon: "💧"
+		name: "Water"
 	},
 	{
 		id: "wind",
-		name: "Wind / Weather",
-		icon: "🌬️"
+		name: "Wind / Weather"
 	},
 	{
 		id: "door",
-		name: "Door",
-		icon: "🚪"
+		name: "Door"
 	},
 	{
 		id: "footsteps",
-		name: "Footsteps",
-		icon: "👣"
+		name: "Footsteps"
 	},
 	{
 		id: "crowd",
-		name: "Crowd / Chatter",
-		icon: "👥"
+		name: "Crowd / Chatter"
 	},
 	{
 		id: "telephone",
-		name: "Telephone",
-		icon: "📞"
+		name: "Telephone"
 	},
 	{
 		id: "engine",
-		name: "Engine / Motor",
-		icon: "⚙️"
+		name: "Engine / Motor"
 	},
 	{
 		id: "tools",
-		name: "Tools / Construction",
-		icon: "🔨"
+		name: "Tools / Construction"
 	},
 	{
 		id: "silence",
-		name: "Silence",
-		icon: "🤫"
+		name: "Silence"
 	}
 ];
 var YAMNET_TO_MACRO = {
@@ -19727,6 +19702,12 @@ var DetailResultSchema = object({
 	/** FRAME-space bbox (already mapped back from crop space). */
 	bbox: NativeCropBboxSchema.optional(),
 	embedding: string().optional(),
+	/**
+	* L2 magnitude of the RAW pre-normalization embedding. Additive and optional
+	* so an older runner that does not send it degrades to "unmeasurable", which
+	* the consuming gate treats as accept — never as reject.
+	*/
+	embeddingMagnitude: number().optional(),
 	label: string().optional(),
 	/**
 	* The tier `label` occupies, copied VERBATIM from the producing step's
@@ -35841,12 +35822,61 @@ Object.freeze({
 	"network-access": "ingress",
 	"smtp-provider": "email"
 });
+/**
+* audio-condition — the authoring logic behind the sustained-sound condition
+* (`NcConditions.audio`), pure and UI-framework-free.
+*
+* WHY IT LIVES HERE
+* ─────────────────
+* Same reason as `condition-taxonomy.ts` next door: two editors author this
+* condition (the admin UI and the viewer), the vocabulary it offers is already
+* in this package (`AUDIO_MACRO_LABELS`), and a second copy of "what a cleared
+* threshold writes" is a mirror free to drift. The viewer keeps its own copy
+* because it is a separate app with its own toolchain; every surface that CAN
+* import `@camstack/types` uses this one.
+*
+* Four behaviours here are not cosmetic:
+*
+*  1. **dBFS is negative-going.** `0` is full scale; digital silence reads
+*     {@link NC_AUDIO_DBFS_FLOOR}. A control that let an operator author `60`
+*     meaning "loud" would write a threshold no sample can reach, and the rule
+*     would look broken rather than mis-configured. Every write is clamped.
+*  2. **Neither filter given = the engine REFUSES.** With no level floor and no
+*     labels every sample is trivially a hit, so the window would fire on
+*     silence. {@link audioIsFailClosed} is how an editor says that BEFORE the
+*     save instead of shipping a rule that never notifies and never says why.
+*  3. **Both label spellings are the same label.** The hub's taxonomy serves
+*     `audio-dog`; the macro catalog and an operator both say `dog`, and the
+*     matcher normalizes the prefix away on both sides. Selection therefore
+*     compares NORMALIZED ids — a rule authored in the admin UI must not read
+*     as "nothing selected" on the phone.
+*  4. **A stored label the build does not know stays visible.** It is offered
+*     as an explicitly-unknown, removable choice, never silently dropped:
+*     rewriting the rule the operator is looking at is worse than showing a
+*     stale id.
+*/
+/** The `audio-` namespace the NC taxonomy uses for these same macro ids. */
+var AUDIO_KIND_PREFIX = "audio-";
+/**
+* The inverse: a macro id in the taxonomy's namespace (`dog` → `audio-dog`),
+* which is the `iconId` every UI resolves to a glyph (`EVENT_KIND_ICONS` in
+* `@camstack/ui-library`, `event-kind-icons.ts` in the viewer). Idempotent, so
+* a value that already carries the namespace is passed through unchanged.
+*
+* This lives here — beside `normalizeAudioLabel` and next to the vocabulary
+* itself — rather than in a UI package, because the *id* is data and the *glyph*
+* is presentation: the server puts the id on a config option, and whichever
+* renderer picks it up (lucide-react on the web, lucide-react-native in the
+* viewer) supplies its own component for it.
+*/
+function audioKindId(macroId) {
+	return macroId.startsWith(AUDIO_KIND_PREFIX) ? macroId : `${AUDIO_KIND_PREFIX}${macroId}`;
+}
 /** Schema defaults — an untouched sub-field must author exactly these. */
 var NC_AUDIO_DEFAULTS = {
 	hitPercent: 60,
 	samplingSeconds: 10
 };
-new Map(AUDIO_MACRO_LABELS.flatMap((macro) => macro.icon === void 0 ? [] : [[macro.id, macro.icon]]));
 new Set(["devices", "classes"]);
 NC_AUDIO_DEFAULTS.hitPercent, NC_AUDIO_DEFAULTS.samplingSeconds;
 /**
@@ -37367,6 +37397,12 @@ Object.defineProperty(exports, "audioAnalyzerCapability", {
 		return audioAnalyzerCapability;
 	}
 });
+Object.defineProperty(exports, "audioKindId", {
+	enumerable: true,
+	get: function() {
+		return audioKindId;
+	}
+});
 Object.defineProperty(exports, "batteryCapability", {
 	enumerable: true,
 	get: function() {