@camstack/system 1.2.219 → 1.2.221

package/dist/{dist-Cyz5_i7z.mjs → dist-T9GvfhgV.mjs}

@@ -675,6 +675,86 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["ModelConvertProgress"] = "model-convert.progress";
 	return EventCategory;
 }({});
+//#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"
+];
+/**
+* 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;
+}
+buildUlawTable();
+buildAlawTable();
 /** Lookup map for well-known tabs by ID. */
 var WELL_KNOWN_TAB_MAP = Object.fromEntries([
 	{
@@ -1975,11 +2055,20 @@ var SubscribeFramesResultSchema = z.object({
 * (the wire-serialisable supertype of `Buffer`) to match `DecodedFrameSchema`
 * / `EncodedPacketSchema`'s precedent; a `Buffer` is assignable to it.
 */
+var AudioChunkFormatSchema = z.enum(AUDIO_CHUNK_FORMATS);
 var DecodedAudioChunkSchema = z.object({
 	data: z.instanceof(Uint8Array),
 	sampleRate: z.number().int().positive(),
 	channels: z.number().int().positive(),
-	timestamp: z.number()
+	timestamp: z.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
@@ -1991,7 +2080,18 @@ var DecodedAudioChunkSchema = z.object({
 var SubscribeAudioChunksInputSchema = z.object({
 	brokerId: z.string(),
 	/** Short caller-identity tag (`audio-analyzer`, …) for `listClients`. */
-	tag: z.string().optional()
+	tag: z.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: z.array(AudioChunkFormatSchema).readonly().optional()
 });
 /** Result of `stream-broker.subscribeAudioChunks`. */
 var SubscribeAudioChunksResultSchema = z.object({ 
@@ -7366,6 +7466,51 @@ var AudioAnalysisSettingsSchema = z.object({
 	minConfidence: z.number().min(0).max(1).default(.3),
 	allowedClasses: z.array(z.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 = z.object({
+	deviceId: z.number(),
+	/** Broker id (`<deviceId>/<camStreamId>`) carrying this camera's audio. */
+	brokerId: z.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: z.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 = z.object({
+	/** False only when the analyzer is shutting down and refused to attach. */
+	attached: z.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: z.boolean()
+});
+var AudioDetachDeviceResultSchema = z.object({ 
+/** False when no attachment existed — detach is idempotent. */
+detached: z.boolean() });
 var AudioClassificationResultSchema = z.object({
 	labels: z.array(AudioClassificationLabelSchema).readonly(),
 	rawLabels: z.array(AudioClassificationLabelSchema).readonly().optional(),
@@ -7381,6 +7526,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(z.object({ deviceId: z.number() }), AudioDetachDeviceResultSchema, { kind: "mutation" }),
 		isReady: method(z.void(), z.boolean()),
 		dispose: method(z.void(), z.void(), { kind: "mutation" }),
 		/**
@@ -20206,6 +20366,14 @@ var NativeCropResultSchema = z.object({
 	* set `encodeJpeg: true`; `bytes` is then absent.
 	*/
 	jpeg: z.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: z.instanceof(Uint8Array).optional(),
 	width: z.number().int().positive(),
 	height: z.number().int().positive(),
 	/**
@@ -20272,7 +20440,14 @@ var ParkTrackFrameResultSchema = z.discriminatedUnion("parked", [z.object({
 })]);
 /** A retrieved parcel — the runner's own JPEG, base64 for the wire. */
 var ParkedTrackFrameSchema = z.object({
-	jpeg: z.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: z.string().optional(),
+	/** The same JPEG as bytes, for a caller that declared it reads them (D462). */
+	jpegBytes: z.instanceof(Uint8Array).optional(),
 	width: z.number().int().positive(),
 	height: z.number().int().positive(),
 	/** The frame instant the parcel shows (the caller's clock, echoed back). */
@@ -20923,6 +21098,13 @@ var pipelineRunnerCapability = {
 			bbox: NativeCropBboxSchema,
 			maxWidth: z.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: z.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
@@ -21095,7 +21277,14 @@ var pipelineRunnerCapability = {
 		getParkedTrackFrame: method(z.object({
 			deviceId: z.number(),
 			trackId: z.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: z.boolean().optional()
 		}), ParkedTrackFrameSchema.nullable()),
 		/**
 		* Drop every parcel of a track — the hub closed it. Idempotent. A track
@@ -36736,12 +36925,24 @@ var METHOD_ACCESS_MAP = 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",
@@ -42585,11 +42786,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",
@@ -44733,6 +44944,52 @@ var SESSION_ONLY_POLICY = {
 	durability: "session",
 	volatileFields: []
 };
+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];
+}
+Math.round(ituDbfsFromPreEpoch("PCMU", -55));
 /** Schema defaults — an untouched sub-field must author exactly these. */
 var NC_AUDIO_DEFAULTS = {
 	hitPercent: 60,

package/dist/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk-Cek0wNdY.js");
-const require_dist = require("./dist-B17W9ngu.js");
+const require_dist = require("./dist-0sWJNwme.js");
 const require_builtins_alerts_alerts_addon = require("./builtins/alerts/alerts.addon.js");
 require("./builtins/alerts/index.js");
 const require_formatter = require("./formatter-DqAKDlvN.js");
@@ -27,9 +27,9 @@ require("./builtins/system-config/index.js");
 const require_builtins_winston_logging_index = require("./builtins/winston-logging/index.js");
 const require_event_loop_stall_monitor = require("./event-loop-stall-monitor-CAsHdMwP.js");
 const require_tls$1 = require("./tls-BFs4PzoW.js");
-const require_manifest_system_deps = require("./manifest-system-deps-g_nK0xsF.js");
+const require_manifest_system_deps = require("./manifest-system-deps-DfpwaXkh.js");
 const require_resource_monitor = require("./resource-monitor-LVE1BoLs.js");
-const require_custom_action_registry = require("./custom-action-registry-DKWhaWL1.js");
+const require_custom_action_registry = require("./custom-action-registry-DvVMHLfJ.js");
 let zod = require("zod");
 let node_crypto = require("node:crypto");
 let _camstack_types_node = require("@camstack/types/node");
@@ -78885,16 +78885,36 @@ var require_udp_broadcaster = /* @__PURE__ */ require_chunk.__commonJSMin(((expo
 var require_parser = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
 	var Writable = require("stream").Writable;
 	var { resolvePacketType } = require_constants();
-	/**
-	* Import types
-	*
-	* @typedef {import("./parser")} ParserClass
-	*/
+	/** Moleculer TCP framing: CRC byte, 4-byte BE total length, type byte, payload. */
+	var HEADER_BYTES = 6;
 	/**
 	* TCP packet parser
 	* @class Parser
 	* @extends {Writable}
 	* @implements {ParserClass}
+	*
+	* ── CamStack patch (D457) — the accumulator is no longer quadratic ─────────
+	*
+	* The shipped `_write` did, ONCE PER SOCKET CHUNK that left a partial packet:
+	*
+	*     packet = Buffer.concat([this.buf, chunk]);   // copies the whole pending
+	*     this.buf = Buffer.from(packet);              // copies it AGAIN
+	*
+	* so a message of M bytes arriving in chunks of c copied ~2·M²/2c bytes on the
+	* receiving event loop — quadratic in the chunk COUNT. On CamStack's hub the
+	* mesh carries base64 JPEG cross-node (`pipelineRunner.getNativeCrop`
+	* with `encodeJpeg`, `pipelineRunner.runStatelessStep{frameJpeg}`) at
+	* `maxPacketSize: 10 MiB`, and a 50 s V8 profile of hub-main put **20.8 % of
+	* its busy main thread inside this one function**.
+	*
+	* The fix is the same one CamStack applied to its own UDS `FrameDecoder`:
+	* hold the pending chunks in a LIST, concatenate ONCE when a whole packet is
+	* available, and never at all while one is still incomplete. Everything else —
+	* the framing, the CRC check and its position, the `maxPacketSize` rule
+	* (accumulated bytes, not the declared length, exactly as before), the `data`
+	* event shape, the error text — is byte-for-byte the original behaviour, and
+	* `packages/system/src/kernel/__tests__/moleculer/mesh-tcp-parser.spec.ts`
+	* asserts each of those cases alongside the copy accounting.
 	*/
 	var Parser = class extends Writable {
 		/**
@@ -78905,32 +78925,44 @@ var require_parser = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, modu
 		constructor(options, maxPacketSize) {
 			super(options);
 			this.maxPacketSize = maxPacketSize;
-			this.buf = null;
+			/** Pending chunks, newest last. Never concatenated until a packet completes. */
+			this.bufs = [];
+			/** Total bytes across `bufs` — the old `this.buf.length`. */
+			this.bufLen = 0;
+		}
+		/** The first `HEADER_BYTES` pending bytes, without flattening the rest. */
+		_header() {
+			const first = this.bufs[0];
+			if (first.length >= HEADER_BYTES) return first;
+			const head = Buffer.allocUnsafe(HEADER_BYTES);
+			let written = 0;
+			for (let i = 0; i < this.bufs.length && written < HEADER_BYTES; i++) {
+				const b = this.bufs[i];
+				const take = Math.min(HEADER_BYTES - written, b.length);
+				b.copy(head, written, 0, take);
+				written += take;
+			}
+			return head;
 		}
 		_write(chunk, encoding, cb) {
-			let packet = chunk;
-			if (this.buf && this.buf.length > 0) {
-				packet = Buffer.concat([this.buf, chunk]);
-				this.buf = null;
-			}
-			while (packet.length > 0) {
-				if (packet.length < 6) {
-					this.buf = Buffer.from(packet);
-					return cb();
-				}
-				if (this.maxPacketSize && packet.length > this.maxPacketSize) return cb(/* @__PURE__ */ new Error(`Incoming packet is larger than the 'maxPacketSize' limit (${packet.length} > ${this.maxPacketSize})!`));
-				const crc = packet[1] ^ packet[2] ^ packet[3] ^ packet[4] ^ packet[5];
-				if (crc !== packet[0]) return cb(/* @__PURE__ */ new Error("Invalid packet CRC! " + crc));
-				const length = packet.readInt32BE(1);
-				if (packet.length >= length) {
-					const msg = packet.slice(6, length);
-					const type = resolvePacketType(packet[5]);
-					this.emit("data", type, msg);
-					packet = packet.slice(length);
-				} else {
-					this.buf = Buffer.from(packet);
-					return cb();
-				}
+			if (this.bufLen > 0) this.bufs.push(chunk);
+			else this.bufs = [chunk];
+			this.bufLen += chunk.length;
+			while (this.bufLen > 0) {
+				if (this.bufLen < HEADER_BYTES) return cb();
+				if (this.maxPacketSize && this.bufLen > this.maxPacketSize) return cb(/* @__PURE__ */ new Error(`Incoming packet is larger than the 'maxPacketSize' limit (${this.bufLen} > ${this.maxPacketSize})!`));
+				const header = this._header();
+				const crc = header[1] ^ header[2] ^ header[3] ^ header[4] ^ header[5];
+				if (crc !== header[0]) return cb(/* @__PURE__ */ new Error("Invalid packet CRC! " + crc));
+				const length = header.readInt32BE(1);
+				if (this.bufLen < length) return cb();
+				const packet = this.bufs.length === 1 ? this.bufs[0] : Buffer.concat(this.bufs, this.bufLen);
+				const msg = packet.slice(HEADER_BYTES, length);
+				const type = resolvePacketType(packet[5]);
+				this.emit("data", type, msg);
+				const rest = packet.slice(length);
+				this.bufs = rest.length > 0 ? [rest] : [];
+				this.bufLen = rest.length;
 			}
 			cb();
 		}
@@ -95777,6 +95809,8 @@ exports.AddonRouteRegistry = AddonRouteRegistry;
 exports.AlertCenterAddon = require_builtins_alerts_alerts_addon.AlertCenterAddon;
 exports.ApiKeyManager = require_builtins_local_auth_local_auth_addon.ApiKeyManager;
 exports.AuthManager = require_builtins_local_auth_local_auth_addon.AuthManager;
+exports.CAP_ACTION_OVERFLOW_LABEL = require_manifest_system_deps.CAP_ACTION_OVERFLOW_LABEL;
+exports.CAP_ACTION_UNLABELLED = require_manifest_system_deps.CAP_ACTION_UNLABELLED;
 exports.CA_COMMON_NAME = require_tls$1.CA_COMMON_NAME;
 exports.CA_VALIDITY_DAYS = require_tls$1.CA_VALIDITY_DAYS;
 exports.CLUSTER_SECRET_MISMATCH_TYPE = CLUSTER_SECRET_MISMATCH_TYPE;
@@ -95804,6 +95838,7 @@ exports.DataPlaneRegistry = DataPlaneRegistry;
 exports.DeviceManagerAddon = require_builtins_device_manager_device_manager_addon.DeviceManagerAddon;
 exports.DeviceRegistry = require_manifest_system_deps.DeviceRegistry;
 exports.DeviceStore = require_builtins_sqlite_storage_index.DeviceStore$1;
+exports.EMPTY_CAP_ACTION_READING = require_manifest_system_deps.EMPTY_CAP_ACTION_READING;
 exports.EMPTY_SOCKET_DIRECTION = require_manifest_system_deps.EMPTY_SOCKET_DIRECTION;
 exports.EMPTY_SOCKET_PLANE_BASELINE = require_manifest_system_deps.EMPTY_SOCKET_PLANE_BASELINE;
 exports.EVENT_PLANE_TOP_N = require_manifest_system_deps.EVENT_PLANE_TOP_N;
@@ -95848,6 +95883,7 @@ exports.LogRingBuffer = LogRingBuffer;
 exports.LoggingGate = LoggingGate;
 exports.LokiDestination = require_builtins_loki_logging_index.LokiDestination$1;
 exports.LokiLoggingAddon = require_builtins_loki_logging_index.LokiLoggingAddon$1;
+exports.MAX_CAP_ACTIONS_PER_PEER = require_manifest_system_deps.MAX_CAP_ACTIONS_PER_PEER;
 exports.MAX_LEAF_VALIDITY_DAYS = require_tls$1.MAX_LEAF_VALIDITY_DAYS;
 exports.MESH_QUEUE_TOP_N = require_manifest_system_deps.MESH_QUEUE_TOP_N;
 exports.METHOD_ACCESS_MAP = require_dist.METHOD_ACCESS_MAP;
@@ -95936,6 +95972,7 @@ exports.builderMountedCapNames = builderMountedCapNames;
 exports.callRegisterNodeWithRetry = callRegisterNodeWithRetry;
 exports.callWithServiceDiscovery = require_manifest_system_deps.callWithServiceDiscovery;
 exports.canServeDataPlane = canServeDataPlane;
+exports.capActionLabel = require_manifest_system_deps.capActionLabel;
 exports.capActionName = require_manifest_system_deps.capActionName;
 exports.capActionSuffix = require_manifest_system_deps.capActionSuffix;
 exports.capBareAction = require_manifest_system_deps.capBareAction;
@@ -95958,6 +95995,7 @@ exports.createArrayBufferCensusGate = require_manifest_system_deps.createArrayBu
 exports.createAuthenticatedFileServer = require_event_loop_stall_monitor.createAuthenticatedFileServer;
 exports.createBroker = createBroker;
 exports.createBrokerDeviceManagerApi = require_manifest_system_deps.createBrokerDeviceManagerApi;
+exports.createCapActionCensus = require_manifest_system_deps.createCapActionCensus;
 exports.createCoreCapService = createCoreCapService;
 exports.createDeferredHeapWatchSink = require_manifest_system_deps.createDeferredHeapWatchSink;
 exports.createDoorSettingsView = createDoorSettingsView;
@@ -95992,6 +96030,7 @@ exports.deriveAgentListenPort = deriveAgentListenPort;
 exports.describeProviderKindDrift = describeProviderKindDrift;
 exports.describeRss = require_manifest_system_deps.describeRss;
 exports.detectWorkspacePackagesDir = detectWorkspacePackagesDir;
+exports.diffCapActionCensus = require_manifest_system_deps.diffCapActionCensus;
 exports.diffEventPlane = require_manifest_system_deps.diffEventPlane;
 exports.diffSocketPlane = require_manifest_system_deps.diffSocketPlane;
 Object.defineProperty(exports, "downloadBinary", {