@camstack/system 1.1.51 → 1.1.53

package/dist/{dist-BWQX9yUj.mjs → dist-D7_69kDt.mjs}

@@ -1,5 +1,5 @@
 import { z } from "zod";
-//#region ../types/dist/event-category-CFZs3jI4.mjs
+//#region ../types/dist/event-category-H4AVePnn.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -149,6 +149,9 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["RecordingSegmentWritten"] = "recording.segment.written";
 	EventCategory["RecordingPolicyFallback"] = "recording.policy.fallback";
 	EventCategory["RecordingRetentionCompleted"] = "recording.retention.completed";
+	/** Runner-sampled scrub thumbnail (~1/5 s/camera). Telemetry (D8): a lost
+	*  thumb is a scrub gap the recorder's keyframe backfill covers. */
+	EventCategory["RecordingThumbSampled"] = "recording.thumb-sampled";
 	EventCategory["DetectionEvent"] = "detection.event";
 	EventCategory["SessionTrackNew"] = "session.track.new";
 	EventCategory["SessionTrackExpired"] = "session.track.expired";
@@ -1799,6 +1802,19 @@ function scopeKey(scope) {
 		case "device": return `device:${scope.deviceId}`;
 	}
 }
+/**
+* Producer transition order within ONE generation: `starting → ready →
+* down`. Used by `hydrate` to accept only forward moves for
+* same-generation snapshot records (a snapshot can be ahead of a lost
+* delta, never behind it, within one producer generation).
+*/
+function stateRank(state) {
+	switch (state) {
+		case "starting": return 0;
+		case "ready": return 1;
+		case "down": return 2;
+	}
+}
 function scopesEqual(a, b) {
 	if (a.type !== b.type) return false;
 	if (a.type === "global" || b.type === "global") return true;
@@ -1849,43 +1865,70 @@ var ReadinessRegistry = class {
 		return Array.from(this.snapshot.values());
 	}
 	/**
-	* Hydrate the snapshot from an authoritative source. Entries already
-	* present locally are skipped — live deltas (received via the event
-	* bus subscription) always take precedence over the snapshot. For
-	* each newly hydrated entry, a one-shot transition is dispatched to
-	* matching subscriptions so pending `awaitReady` callers unblock
-	* without having to wait for a fresh event.
+	* Hydrate the snapshot from an authoritative source — a RECONCILE, not
+	* an add-only merge (D8: readiness events are telemetry and may be
+	* lost; the on-reconnect/periodic snapshot re-pull is the repair path,
+	* so it MUST be able to advance a stale record — the 2026-07-17
+	* "still awaiting platform-probe forever" wedge was this method
+	* skipping every already-seen key).
+	*
+	*  - **Unseen keys** are added (epoch 1 — mirrors the value the
+	*    consumer would have derived from the first observed `ready`).
+	*  - **Existing keys** are UPDATED when the authoritative record
+	*    carries a different generation (producer restart / synthetic-down
+	*    superseded — epoch bumps on a new-generation `ready`, mirroring
+	*    `ingest`), or a FORWARD state move within the same generation
+	*    (`starting → ready → down`; within one producer generation a
+	*    snapshot can only be ahead of a lost delta, never behind it).
+	*  - **Never a same-generation regress** — a snapshot pulled just
+	*    before a live delta landed must not un-ready a record (the next
+	*    reconcile round converges it anyway).
+	*  - **Never a record this process is authoritative for** — node-scoped
+	*    records for our own nodeId, and device/global records we emitted,
+	*    keep local truth (an authority's stale copy of OUR record must
+	*    not regress us).
 	*
-	* Local `epoch` is reset to 1 per entry — consumer-side epoch is
-	* derived from observed generation transitions, so this mirrors the
-	* value that would have been assigned had the consumer observed the
-	* first `ready` event directly.
+	* Every applied entry dispatches a one-shot transition to matching
+	* subscriptions so pending `awaitReady` callers unblock without having
+	* to wait for a fresh event.
 	*/
 	hydrate(records) {
 		const now = this.now();
 		for (const record of records) {
 			const key = readinessKey(record.capName, record.scope);
-			if (this.snapshot.has(key)) continue;
+			const prev = this.snapshot.get(key) ?? null;
+			let epoch;
+			let durationInPrevState;
+			if (prev !== null) {
+				if (this.isLocallyAuthoritative(prev)) continue;
+				const sameGeneration = prev.generation === record.generation;
+				if (sameGeneration && stateRank(record.state) <= stateRank(prev.state)) continue;
+				epoch = !sameGeneration && record.state === "ready" ? prev.epoch + 1 : prev.epoch;
+				durationInPrevState = Math.max(0, now - prev.lastChange);
+			} else {
+				epoch = 1;
+				durationInPrevState = 0;
+			}
 			const hydrated = {
 				capName: record.capName,
 				scope: record.scope,
 				state: record.state,
 				generation: record.generation,
-				epoch: 1,
+				epoch,
 				lastChange: now,
 				sourceNodeId: record.sourceNodeId
 			};
 			this.snapshot.set(key, hydrated);
-			if (this.logger) this.logger.debug(`readiness: ${record.capName} (${scopeKey(record.scope)}) → ${record.state} (hydrated, gen=${record.generation.slice(0, 6)})`);
+			if (this.logger) this.logger.debug(`readiness: ${record.capName} (${scopeKey(record.scope)}) → ${record.state} (hydrated${prev !== null ? " update" : ""}, gen=${record.generation.slice(0, 6)})`);
 			const transition = {
 				capName: record.capName,
 				scope: record.scope,
 				state: record.state,
-				epoch: 1,
+				epoch,
 				generation: record.generation,
 				sourceNodeId: "hydrated",
 				ts: now,
-				durationInPrevState: 0
+				durationInPrevState
 			};
 			for (const sub of this.subscriptions) {
 				if (sub.capName !== record.capName) continue;
@@ -1898,6 +1941,17 @@ var ReadinessRegistry = class {
 			}
 		}
 	}
+	/**
+	* True when THIS process is the origin authority for `record` — a
+	* snapshot pulled from elsewhere must never overwrite it:
+	*  - node-scoped records whose `scope.nodeId` is our own node id
+	*    (this process — or a child bridged onto our bus — emits them);
+	*  - device/global-scoped records whose latest transition WE emitted.
+	*/
+	isLocallyAuthoritative(record) {
+		if (record.scope.type === "node") return record.scope.nodeId === this.sourceNodeId;
+		return record.sourceNodeId === this.sourceNodeId;
+	}
 	/** Shallow copy of the full snapshot — mainly for diagnostics/tests. */
 	getAll() {
 		return new Map(this.snapshot);
@@ -3201,6 +3255,24 @@ var RecordingRetentionSchema = z.object({
 	maxSizeGb: z.number().min(0).optional()
 });
 /**
+* Scrub-thumbnail fidelity preset — the single per-camera selector bundling the
+* sprite tile RESOLUTION + JPEG QUALITY the recorder packs timeline-scrub
+* previews at. Five graduated steps; absent on a config = `standard` (the
+* shipped default, matching `sheet-geometry`/`sheet-composer`).
+*
+* Existing sheets are IMMUTABLE — a changed preset applies to NEW windows only.
+* Each window's index sidecar carries its own tile dims, so a camera whose
+* preset changed over time renders every historical window at the dims it was
+* written with.
+*/
+var ScrubThumbnailPresetSchema = z.enum([
+	"minimal",
+	"low",
+	"standard",
+	"high",
+	"max"
+]);
+/**
 * The full per-camera recording intent — the wire shape of a RecordingTarget.
 *
 * `mode` is the authoritative storage choice; `schedule`/`triggers`/`pre`/`post`
@@ -3237,7 +3309,14 @@ var RecordingConfigSchema = z.object({
 	* derived into bands once via `migrateConfigToBands`.
 	*/
 	bands: z.array(RecordingBandSchema).optional(),
-	retention: RecordingRetentionSchema.optional()
+	retention: RecordingRetentionSchema.optional(),
+	/**
+	* Per-camera scrub-thumbnail fidelity preset (resolution + JPEG quality for
+	* timeline-scrub sprite previews). Absent = `standard`. Applies to NEW
+	* windows only — existing sheets are immutable, and each window's index
+	* carries its own tile dims so mixed-preset history renders correctly.
+	*/
+	scrubThumbnails: ScrubThumbnailPresetSchema.optional()
 });
 /**
 * `StorageLocationType` — an addon-declared id that identifies the *kind* of
@@ -6903,10 +6982,23 @@ var deviceDiscoveryCapability = {
 	}
 };
 /**
-* Doorbell button cap. Installed on a `DeviceType.Button` accessory
-* with `role: DeviceRole.Doorbell`. Emits an `onPressed` event every
-* time the firmware pushes a ring; status tracks the last press and
-* a pressCount since start (diagnostic).
+* Doorbell button cap. Two kinds of providers coexist behind this cap
+* name (same pattern as `snapshot`):
+*
+*   - **Native** providers: registered per-device by device-driver
+*     addons via `ctx.registerNativeCap` — either on a
+*     `DeviceType.Button` accessory with `role: DeviceRole.Doorbell`,
+*     or directly on the camera (Reolink registers at camera level).
+*     Emits an `onPressed` event every time the firmware pushes a
+*     ring; status tracks the last press and a pressCount since start
+*     (diagnostic).
+*
+*   - **Wrapper** provider: the `virtual-doorbell` system builtin
+*     (`@camstack/system/builtins/doorbell`). Turns ANY binary-ish
+*     device (contact / switch / event-emitter …) into a doorbell for
+*     a camera. `defaultActive: false` — the operator explicitly binds
+*     it per camera in the device-bindings UI, then picks the source
+*     device + trigger in the per-device settings.
 *
 * The DeviceEventPropagator re-emits `onPressed` on the camera parent
 * — subscribers listening at the camera level receive ring events
@@ -6927,7 +7019,10 @@ var doorbellCapability = {
 	scope: "device",
 	deviceNative: true,
 	mode: "singleton",
-	deviceTypes: [DeviceType.Button],
+	kind: "wrapper",
+	defaultActive: false,
+	deviceTypes: [DeviceType.Button, DeviceType.Camera],
+	exposesDeviceSettings: true,
 	methods: {},
 	events: { 
 	/**
@@ -13565,6 +13660,14 @@ var ConfigEntrySchema = z.object({
 	value: z.unknown(),
 	description: z.string().optional()
 });
+var DeviceLinkModeSchema = z.enum(["auto", "manual"]);
+/** One resolved linked device — the compact projection consumers need. */
+var LinkedDeviceSchema = z.object({
+	deviceId: z.number(),
+	name: z.string(),
+	location: z.string().nullable(),
+	features: z.array(z.string())
+});
 var SavedDeviceRowSchema = z.object({
 	/** Numeric id reserved at allocateDeviceId time. */
 	id: z.number(),
@@ -13672,6 +13775,7 @@ var deviceManagerCapability = {
 	name: "device-manager",
 	scope: "system",
 	mode: "singleton",
+	exposesDeviceSettings: true,
 	methods: {
 		/** Reserve (or re-resolve) a progressive numeric id for `(addonId, stableId)`.
 		*  Idempotent: returns the existing id if one is already persisted for the
@@ -13922,6 +14026,19 @@ var deviceManagerCapability = {
 		getDevice: method(z.object({ deviceId: z.number() }), DeviceInfoSchema.nullable()),
 		/** List children of a parent device (by parent numeric id). */
 		getChildren: method(z.object({ parentDeviceId: z.number() }), z.array(DeviceInfoSchema)),
+		/**
+		* Resolve the devices LINKED to a camera — the single policy authority
+		* both consumers call (viewer devices panel + pipeline-analytics event
+		* kinds/ingest). Device-tree children are ALWAYS included; mode 'auto'
+		* (default) adds every device sharing the camera's non-null `location`,
+		* mode 'manual' adds the persisted manual list instead. Excludes the
+		* camera itself; deduped. Configuration is standard per-device settings
+		* (see the module docblock) — there are no bespoke link mutations.
+		*/
+		getLinkedDevices: method(z.object({ deviceId: z.number() }), z.object({
+			mode: DeviceLinkModeSchema,
+			devices: z.array(LinkedDeviceSchema)
+		})),
 		/** Get stream sources for a camera device. */
 		getStreamSources: method(z.object({ deviceId: z.number() }), z.array(StreamSourceEntrySchema$1)),
 		/** Get config entries (key + value + description) for a device. */
@@ -15640,6 +15757,61 @@ var EventKindSchema = z.enum([
 	"object",
 	"audio"
 ]);
+/**
+* Spatial filter for `listTracks` — the rect + polygon variants of the shared
+* MaskShape vocabulary (see `mask-shape.ts`). Coordinates are NORMALIZED 0..1
+* of the camera frame (top-left origin), matching the drawing-plane editor.
+*/
+var TrackZoneFilterSchema = z.discriminatedUnion("kind", [MaskRectShapeSchema, MaskPolygonShapeSchema]);
+/** Closed icon vocabulary so clients render a known glyph per kind. */
+var EventKindIconSchema = z.enum([
+	"motion",
+	"audio",
+	"person",
+	"vehicle",
+	"animal",
+	"door",
+	"pir",
+	"smoke",
+	"water",
+	"button",
+	"generic"
+]);
+var EventKindCategorySchema = z.enum([
+	"motion",
+	"audio",
+	"detection",
+	"sensor",
+	"custom"
+]);
+var EventKindDescriptorSchema = z.object({
+	/** Stable kind id (e.g. 'motion', 'person', 'contact'). */
+	kind: z.string(),
+	label: z.string(),
+	/** Hex color for timeline/legend rendering. */
+	color: z.string(),
+	icon: EventKindIconSchema,
+	category: EventKindCategorySchema,
+	/** Which cap + device contributes this kind. For built-ins the camera
+	*  itself; for sensor kinds the LINKED source device. */
+	source: z.object({
+		capName: z.string(),
+		deviceId: z.number()
+	})
+});
+var SensorEventSchema = z.object({
+	id: z.string(),
+	/** The CAMERA the event is attributed to (a sensor linked to N cameras
+	*  yields N rows, one per camera). */
+	deviceId: z.number(),
+	/** The linked sensor device whose state changed. */
+	sourceDeviceId: z.number(),
+	/** Event kind id — matches an `EventKindDescriptor.kind`. */
+	kind: z.string(),
+	/** Snapshot of the sensor cap's runtime-state slice at the change. */
+	value: z.record(z.string(), z.unknown()).nullable(),
+	timestamp: z.number()
+});
 var TrackPositionSchema = z.object({
 	x: z.number(),
 	y: z.number(),
@@ -15653,6 +15825,30 @@ var TrackSnapshotSchema = z.object({
 	mediaKey: z.string()
 });
 /**
+* Normalized 0..1 trajectory envelope (min/max over every position bbox,
+* divided by the track's detection-frame dims), computed at persist time.
+* Absent when the frame dims were unknown when the track was persisted
+* (legacy rows / dims-less sources) and on active (in-RAM) tracks.
+*/
+var TrackEnvelopeSchema = z.object({
+	minX: z.number(),
+	minY: z.number(),
+	maxX: z.number(),
+	maxY: z.number()
+});
+/**
+* Row projection for track list queries. `full` (default) returns the
+* complete Track including the frame-rate `positions[]` history and the
+* `snapshots[]` references — megabytes across a page of tracks. `slim`
+* keeps every scalar the list surfaces actually render (ids, class(es),
+* label / audioLabels / importance enrichment, firstSeen/lastSeen, state,
+* zonesVisited, bestEventId, envelope) and returns `positions` /
+* `snapshots` as EMPTY arrays — detail views re-fetch the full row via
+* `getTrack`. Mirrors the event-store `projection` convention
+* (`getObjectEvents` et al.).
+*/
+var TrackProjectionSchema = z.enum(["full", "slim"]);
+/**
 * One audio-classification label heard on the track's camera while the
 * track was alive, aggregated per label. An "episode" is one persisted
 * audio event (the confident-classification path: score ≥ the device's
@@ -15703,7 +15899,11 @@ var TrackSchema = z.object({
 	/** Audio-classification labels heard on the camera during the track's
 	*  life (score ≥ device `classificationMinScore`), aggregated per label.
 	*  Absent on legacy rows / tracks with no confident audio. */
-	audioLabels: z.array(TrackAudioLabelSchema).readonly().optional()
+	audioLabels: z.array(TrackAudioLabelSchema).readonly().optional(),
+	/** Normalized 0..1 trajectory envelope (see {@link TrackEnvelopeSchema}).
+	*  Populated from the persisted envelope columns on historical reads;
+	*  absent on legacy rows, dims-less tracks and active (in-RAM) tracks. */
+	envelope: TrackEnvelopeSchema.optional()
 });
 var BaseEventFields = {
 	id: z.string(),
@@ -15813,11 +16013,13 @@ var MediaFileSchema = z.object({
 	sizeBytes: z.number(),
 	timestamp: z.number()
 });
+var DEFAULT_EVENT_QUERY_LIMIT = 1e3;
+var MAX_EVENT_QUERY_LIMIT = 5e3;
 var DeviceEventQueryInput = z.object({
 	deviceId: z.number(),
 	since: z.number().optional(),
 	until: z.number().optional(),
-	limit: z.number().int().min(1).max(5e3).default(1e3),
+	limit: z.number().int().min(1).max(MAX_EVENT_QUERY_LIMIT).default(DEFAULT_EVENT_QUERY_LIMIT),
 	/** `slim` drops heavy JSON fields (regions/bbox/zones) and carries an
 	*  optional `mediaUrl` (populated by B5). `full` (default) keeps today's
 	*  exact behaviour. Callers may omit this field — the store defaults to
@@ -15825,6 +16027,27 @@ var DeviceEventQueryInput = z.object({
 	projection: z.enum(["full", "slim"]).optional()
 });
 var ObjectEventQueryInput = DeviceEventQueryInput.extend({ classFilter: z.string().optional() });
+var RecentTracksQueryInput = z.object({
+	/** Devices to merge. An empty array yields `{ tracks: [], nextCursor: null }`. */
+	deviceIds: z.array(z.number()),
+	/** Window lower bound on `lastSeen` (inclusive). */
+	since: z.number().optional(),
+	/** Window upper bound on `lastSeen` (inclusive). */
+	until: z.number().optional(),
+	/** Page size. Default 200, max 1000. */
+	limit: z.number().int().min(1).max(1e3).default(200),
+	/** Opaque continuation cursor from a previous page's `nextCursor`.
+	*  Encodes the (lastSeen, trackId) sort position — treat as opaque. */
+	cursor: z.string().optional(),
+	/** See {@link TrackProjectionSchema}. Default `full`. */
+	projection: TrackProjectionSchema.optional()
+});
+var RecentTracksPageSchema = z.object({
+	/** Merged page, ordered by (`lastSeen` DESC, `trackId` DESC). */
+	tracks: z.array(TrackSchema).readonly(),
+	/** Cursor for the next page, or null when this page is the last. */
+	nextCursor: z.string().nullable()
+});
 var KeyEventQueryInput = z.object({
 	deviceId: z.number(),
 	/** Window lower bound (track firstSeen ≥ since). */
@@ -15921,8 +16144,27 @@ var pipelineAnalyticsCapability = {
 			deviceId: z.number(),
 			since: z.number().optional(),
 			until: z.number().optional(),
-			limit: z.number().optional()
+			limit: z.number().optional(),
+			/** Spatial filter — only tracks whose trajectory intersects the zone
+			*  (normalized 0..1 rect or polygon). SQL-prefiltered on the persisted
+			*  envelope columns, then precisely tested per position. Tracks with
+			*  an unknown envelope (no frame dims at persist time) always match. */
+			zone: TrackZoneFilterSchema.optional(),
+			/** See {@link TrackProjectionSchema}. Default `full` (backward
+			*  compatible — omitting the field keeps today's exact behaviour). */
+			projection: TrackProjectionSchema.optional()
 		}), z.array(TrackSchema).readonly()),
+		/**
+		* Batched cluster-wide track listing — ONE call for the events page /
+		* reel first paint instead of a per-camera `listTracks` fan-out. Merges
+		* the persisted completed tracks of every requested device, sorted by
+		* `lastSeen` DESC with a stable (lastSeen, trackId) cursor. Per-device
+		* indexed pages (`idx_tracks_device_lastSeen`) are k-way merged
+		* provider-side; `projection: 'slim'` drops the heavy `positions[]` /
+		* `snapshots[]` JSON (returned as empty arrays). Active in-RAM tracks
+		* are not included (same contract as `listTracks`).
+		*/
+		listRecentTracks: method(RecentTracksQueryInput, RecentTracksPageSchema),
 		clearTracks: method(z.object({ deviceId: z.number() }), z.void(), {
 			kind: "mutation",
 			auth: "admin"
@@ -15931,6 +16173,26 @@ var pipelineAnalyticsCapability = {
 		getObjectEvents: method(ObjectEventQueryInput, z.array(ObjectEventSchema).readonly()),
 		getAudioEvents: method(DeviceEventQueryInput, z.array(AudioEventSchema).readonly()),
 		/**
+		* Every event kind the device can produce: built-ins (motion + audio),
+		* detection classes actually observed for the device (from the track
+		* history), and sensor kinds contributed by LINKED devices (resolved via
+		* `device-manager.getLinkedDevices`, mapped through `EVENT_KIND_BY_CAP`).
+		*/
+		listEventKinds: method(z.object({ deviceId: z.number() }), z.array(EventKindDescriptorSchema).readonly()),
+		/**
+		* Sensor-event history for a camera: state changes of LINKED sensor
+		* devices, attributed to the camera at ingest time (one row per linked
+		* camera). Mirrors `getAudioEvents` query semantics; `kinds` narrows to
+		* a kind subset.
+		*/
+		getSensorEvents: method(z.object({
+			deviceId: z.number(),
+			since: z.number().optional(),
+			until: z.number().optional(),
+			kinds: z.array(z.string()).optional(),
+			limit: z.number().int().min(1).max(MAX_EVENT_QUERY_LIMIT).default(DEFAULT_EVENT_QUERY_LIMIT)
+		}), z.array(SensorEventSchema).readonly()),
+		/**
 		* Importance-ranked highlights for a device+window. Queries completed
 		* tracks by (deviceId, firstSeen ∈ [since,until]), scores each (or reuses
 		* the persisted score), filters by minImportance/classFilter, orders by
@@ -20545,7 +20807,12 @@ var RecordingStorageUsageSchema = z.object({
 /**
 * Result of locating footage at a wall-clock instant for one device/profile.
 * `segment` carries the covering segment's window; `gap` reports the forward
-* nearest covered edge (`null` past the end of footage / when none exists).
+* nearest covered edge (`null` past the end of footage / when none exists)
+* and the backward covered edge `prevEndMs` (exclusive end of the nearest
+* footage behind the epoch; `null` when none — optional so older providers
+* that omit it stay valid). `prevEndMs` lets a backward frame-step hop the
+* small inter-segment cracks (durMs under-covers the span to the next
+* startMs by ~11-17 ms) instead of no-opping at a segment head.
 */
 var LocateSegmentResultSchema = z.discriminatedUnion("kind", [z.object({
 	kind: z.literal("segment"),
@@ -20554,7 +20821,8 @@ var LocateSegmentResultSchema = z.discriminatedUnion("kind", [z.object({
 	bytes: z.number()
 }), z.object({
 	kind: z.literal("gap"),
-	nearestEdgeMs: z.number().nullable()
+	nearestEdgeMs: z.number().nullable(),
+	prevEndMs: z.number().nullable().optional()
 })]);
 /** Raw bytes of one finalized footage segment (read off disk on the recording node). */
 var ReadSegmentBytesResultSchema = z.object({ data: z.instanceof(Uint8Array) });
@@ -22717,6 +22985,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"deviceManager.getLinkedDevices": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceManager.getRoleDisplayDefaults": {
 		capName: "device-manager",
 		capScope: "system",
@@ -24271,6 +24545,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getSensorEvents": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getTrack": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -24283,6 +24563,18 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.listEventKinds": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"pipelineAnalytics.listRecentTracks": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.listTracks": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -26326,4 +26618,4 @@ function scoreRuntimes(hw) {
 	};
 }
 //#endregion
-export { toExpressionValue as $, isCollectionArrayMethod as A, normalizeUnit as B, enumerateItemArrayFields as C, parseJsonUnknown as Ct, filesystemBrowseCapability as D, sleep as Dt, extractNestedAddonId as E, scopeKey as Et, localNetworkCapability as F, readNodePin as G, parseStreamParamsFormPatch as H, logDestinationCapability as I, settingsStoreCapability as J, scoreRuntimes as K, looseSchema as L, isVoidInput as M, kebabToCamel as N, getByPath as O, EventCategory as Ot, lifecycleJobSchema as P, streamQualityLabel as Q, metricsProviderCapability as R, deviceStatusCapability as S, parseJsonObject as St, evaluateLinkExpression as T, resolveCapMount as Tt, platformProbeCapability as U, objectInputDeclaresAddonId as V, procedureAuthKey as W, storageCapability as X, snapshotCapability as Y, storageProviderCapability as Z, authProviderCapability as _, emitDownForOwnedCaps as _t, DeviceStatusSchema as a, DEVICE_SETTINGS_CONTRIBUTION_METHODS as at, deviceManagerCapability as b, hydrateSchema as bt, STREAM_PROFILE_META as c, DeviceRole as ct, UserRecordSchema as d, ReadinessTimeoutError as dt, userManagementCapability as et, addonPagesCapability as f, WELL_KNOWN_TAB_MAP as ft, applyTransform as g, createEvent as gt, alertsCapability as h, asString as ht, CAP_NAMES_WITH_STATUS as i, DATAPLANE_SECRET_HEADER as it, isObjectInput as j, isArrayOutputSchema as k, ScopedTokenSchema as l, DeviceType as lt, addonWidgetsCapability as m, asNumber as mt, AlertSchema as n, errMsg as nt, METHOD_ACCESS_MAP as o, DEVICE_STATUS_METHOD as ot, addonSettingsCapability as p, asJsonObject as pt, setByPath as q, ApiKeyRecordSchema as r, BaseAddon as rt, RUNTIME_DEFAULTS as s, DeviceFeature as st, ALL_CAPABILITY_DEFINITIONS as t, validateExpressionSource as tt, StorageLocationTypeSchema as u, ReadinessRegistry as ut, backupCapability as v, emitReadiness as vt, enumerateSchemaFields as w, readinessKey as wt, deviceStateCapability as x, isDeviceConfigCap as xt, buildStreamParamsConfigSchema as y, expandCapMethods as yt, nodePin as z };
+export { streamQualityLabel as $, isArrayOutputSchema as A, nodePin as B, doorbellCapability as C, parseJsonObject as Ct, extractNestedAddonId as D, scopeKey as Dt, evaluateLinkExpression as E, resolveCapMount as Et, lifecycleJobSchema as F, procedureAuthKey as G, objectInputDeclaresAddonId as H, localNetworkCapability as I, setByPath as J, readNodePin as K, logDestinationCapability as L, isObjectInput as M, isVoidInput as N, filesystemBrowseCapability as O, sleep as Ot, kebabToCamel as P, storageProviderCapability as Q, looseSchema as R, deviceStatusCapability as S, isDeviceConfigCap as St, enumerateSchemaFields as T, readinessKey as Tt, parseStreamParamsFormPatch as U, normalizeUnit as V, platformProbeCapability as W, snapshotCapability as X, settingsStoreCapability as Y, storageCapability as Z, authProviderCapability as _, createEvent as _t, DeviceStatusSchema as a, DATAPLANE_SECRET_HEADER as at, deviceManagerCapability as b, expandCapMethods as bt, STREAM_PROFILE_META as c, DeviceFeature as ct, UserRecordSchema as d, ReadinessRegistry as dt, toExpressionValue as et, addonPagesCapability as f, ReadinessTimeoutError as ft, applyTransform as g, asString as gt, alertsCapability as h, asNumber as ht, CAP_NAMES_WITH_STATUS as i, BaseAddon as it, isCollectionArrayMethod as j, getByPath as k, EventCategory as kt, ScopedTokenSchema as l, DeviceRole as lt, addonWidgetsCapability as m, asJsonObject as mt, AlertSchema as n, validateExpressionSource as nt, METHOD_ACCESS_MAP as o, DEVICE_SETTINGS_CONTRIBUTION_METHODS as ot, addonSettingsCapability as p, WELL_KNOWN_TAB_MAP as pt, scoreRuntimes as q, ApiKeyRecordSchema as r, errMsg as rt, RUNTIME_DEFAULTS as s, DEVICE_STATUS_METHOD as st, ALL_CAPABILITY_DEFINITIONS as t, userManagementCapability as tt, StorageLocationTypeSchema as u, DeviceType as ut, backupCapability as v, emitDownForOwnedCaps as vt, enumerateItemArrayFields as w, parseJsonUnknown as wt, deviceStateCapability as x, hydrateSchema as xt, buildStreamParamsConfigSchema as y, emitReadiness as yt, metricsProviderCapability as z };

package/dist/http/file-data-plane.d.ts

@@ -5,6 +5,14 @@ export interface FileDataPlaneOptions {
     readonly getRoots: () => readonly string[];
     /** Optional extension→content-type overrides merged over the media defaults. */
     readonly contentTypes?: Readonly<Record<string, string>>;
+    /**
+     * Optional per-path Cache-Control resolver. Return a header value to use for
+     * this rel path, or undefined for the default (`no-cache`). Lets a caller
+     * serve content-hashed bundle assets as `public, max-age=…, immutable`
+     * (re-downloading a 1MB SPA bundle on every open is a real cold-start cost)
+     * while entry HTML stays revalidated.
+     */
+    readonly cacheControl?: (rel: string) => string | undefined;
 }
 /** Build a `(req, res)` handler that serves `getRoots()` files with Range. */
 export declare function createFileDataPlaneHandler(opts: FileDataPlaneOptions): (req: IncomingMessage, res: ServerResponse) => Promise<void>;

package/dist/index.js

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk-Cek0wNdY.js");
-const require_dist = require("./dist-C3uHEBtP.js");
-const require_model_download_service = require("./model-download-service-D-Umz4-L.js");
-const require_manifest_python_deps = require("./manifest-python-deps-CVcJ9hDX.js");
+const require_dist = require("./dist-BNro5CRu.js");
+const require_model_download_service = require("./model-download-service-hf0ookyy.js");
+const require_manifest_python_deps = require("./manifest-python-deps-DszE7bYn.js");
 const require_resource_monitor = require("./resource-monitor-DNNomR-i.js");
 const require_builtins_sqlite_storage_filesystem_storage_addon = require("./builtins/sqlite-storage/filesystem-storage.addon.js");
 const require_builtins_sqlite_storage_sqlite_settings_addon = require("./builtins/sqlite-storage/sqlite-settings.addon.js");
@@ -92047,16 +92047,32 @@ async function callRegisterNodeWithRetry(broker, params, opts) {
 }
 //#endregion
 //#region src/kernel/moleculer/readiness-service.ts
+/**
+* Service name AGENTS register their own readiness snapshot under.
+*
+* Deliberately NOT `$readiness`: agents call `$readiness.getSnapshot`
+* UNQUALIFIED to reach the hub's authoritative registry, and Moleculer
+* prefers a local service for an unqualified call — an agent registering
+* `$readiness` would shadow the hub and hydrate from itself. The hub
+* pulls `$agent-readiness.getSnapshot` with an explicit `{ nodeID }` on
+* every agent (re)connect + periodically, closing the reverse leg of the
+* D8 snapshot-reconcile (the hub otherwise learns agent readiness only
+* from lossy cross-node event broadcasts).
+*/
+var AGENT_READINESS_SERVICE_NAME = "$agent-readiness";
 function createReadinessService(deps) {
 	return {
-		name: "$readiness",
+		name: deps.name ?? "$readiness",
 		actions: { getSnapshot: { handler() {
 			return deps.getSnapshot();
 		} } }
 	};
 }
-function createReadinessServiceForRegistry(registry) {
-	return createReadinessService({ getSnapshot: () => registry.getSnapshotForTransport() });
+function createReadinessServiceForRegistry(registry, name) {
+	return createReadinessService({
+		getSnapshot: () => registry.getSnapshotForTransport(),
+		...name !== void 0 ? { name } : {}
+	});
 }
 //#endregion
 //#region src/kernel/moleculer/stream-probe-service.ts
@@ -93391,6 +93407,7 @@ async function stageFrameworkLockstep(input) {
 //#endregion
 exports.AGENT_CAP_FWD_ACTION = require_manifest_python_deps.AGENT_CAP_FWD_ACTION;
 exports.AGENT_CAP_FWD_SERVICE = require_manifest_python_deps.AGENT_CAP_FWD_SERVICE;
+exports.AGENT_READINESS_SERVICE_NAME = AGENT_READINESS_SERVICE_NAME;
 exports.ALL_CAPABILITY_DEFINITIONS = require_dist.ALL_CAPABILITY_DEFINITIONS;
 exports.AddonApiFactory = AddonApiFactory;
 exports.AddonDepsManager = require_manifest_python_deps.AddonDepsManager;