@camstack/system 1.2.238 → 1.2.240

package/dist/{manifest-system-deps-CrSP0Kkp.js → manifest-system-deps-CzyjTMcO.js}

@@ -6974,6 +6974,137 @@ function getCapUsageRegistry() {
 function __resetCapUsageRegistryForTests() {
 	singleton = null;
 }
+var MIRROR_REASON_BY_CATEGORY = new Map([
+	{
+		category: "device.state-changed",
+		reason: "Device runtime-state mirror, 69.1 % of fleet traffic. Each event is a snapshot of the slice AFTER the change; the superseded snapshot describes a state the device is no longer in, and every consumer (SystemMirror, DeviceStateHandle) reads the latest one only."
+	},
+	{
+		category: "camera-streams.onCamStreamsChanged",
+		reason: "Full stream-list snapshot per camera, 20.1 % of fleet traffic. The payload is the complete current list, not a delta, so an older list is strictly less true than the newer one."
+	},
+	{
+		category: "system.ready-state",
+		reason: "Readiness is a LEVEL, not an edge: the event reports whether a capability is ready right now. Declared for the case where it carries a deviceId; when it does not it stays in the global ring like any other unattributed event."
+	}
+].map((m) => [m.category, m.reason]));
+/**
+* Is this category declared a mirror? An unclassified category is NOT a mirror
+* — the safe default is to keep its history.
+*/
+function isMirrorCategory(category) {
+	return MIRROR_REASON_BY_CATEGORY.has(category);
+}
+/**
+* Non-mirror events retained per device. ~1.1 events/s fleet-wide after
+* coalescing ⇒ ~3 000/day/camera ⇒ 2 000 ≈ 16 h.
+*/
+var MAX_DEVICE_RING_EVENTS = 2e3;
+function serializePayload(data) {
+	try {
+		const json = JSON.stringify(data);
+		if (typeof json !== "string") return null;
+		return {
+			json,
+			bytes: Buffer.byteLength(json, "utf8")
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* The event as it should be RETAINED: unchanged when its payload is within the
+* cap, otherwise a NEW event whose `data` is the marked replacement. The
+* argument is never mutated — the same object is still live on the fan-out path
+* and in the global ring.
+*/
+function capEventData(event) {
+	const serialized = serializePayload(event.data);
+	if (serialized !== null && serialized.bytes <= 256) return event;
+	const truncated = {
+		__truncated: true,
+		__originalBytes: serialized?.bytes ?? null,
+		__preview: serialized === null ? "" : serialized.json.slice(0, 160)
+	};
+	return {
+		...event,
+		data: truncated
+	};
+}
+/**
+* The device this event is about, or `undefined` when it is about no device.
+*
+* Same rule as `matchesEventFilter` — `source.deviceId`, or `source.id` when
+* the source IS a device — so a read filtered by `deviceId` and a read served
+* from that device's ring agree on which events belong to it. A non-numeric
+* device source id yields `undefined` rather than `NaN`: an unattributable
+* event must never become a bucket of its own.
+*/
+function eventDeviceId(event) {
+	const explicit = event.source.deviceId;
+	if (explicit !== void 0) return Number.isFinite(explicit) ? explicit : void 0;
+	if (event.source.type !== "device") return void 0;
+	const asNumber = Number(event.source.id);
+	return Number.isFinite(asNumber) ? asNumber : void 0;
+}
+function createDeviceEventRings() {
+	return { byDevice: /* @__PURE__ */ new Map() };
+}
+function ringFor(rings, deviceId) {
+	const existing = rings.byDevice.get(deviceId);
+	if (existing !== void 0) {
+		rings.byDevice.delete(deviceId);
+		rings.byDevice.set(deviceId, existing);
+		return existing;
+	}
+	const created = {
+		history: [],
+		mirrors: /* @__PURE__ */ new Map()
+	};
+	rings.byDevice.set(deviceId, created);
+	while (rings.byDevice.size > 512) {
+		const oldest = rings.byDevice.keys().next();
+		if (oldest.done === true) break;
+		rings.byDevice.delete(oldest.value);
+	}
+	return created;
+}
+/**
+* Retain `event` in its device's ring, with its payload capped.
+*
+* Returns the device it was filed under, or `undefined` when the event names no
+* device — the caller has already retained it in the global ring and nothing
+* more happens here. No device is fabricated.
+*/
+function recordDeviceEvent(rings, event) {
+	const deviceId = eventDeviceId(event);
+	if (deviceId === void 0) return void 0;
+	const ring = ringFor(rings, deviceId);
+	const retained = capEventData(event);
+	if (isMirrorCategory(event.category)) {
+		ring.mirrors.set(event.category, retained);
+		return deviceId;
+	}
+	ring.history.push(retained);
+	if (ring.history.length > 2e3) ring.history.splice(0, ring.history.length - MAX_DEVICE_RING_EVENTS);
+	return deviceId;
+}
+/**
+* Everything retained for one device, oldest first — history merged with the
+* current value of each mirror, ordered by timestamp so the caller's `-limit`
+* slice means the same thing it means on the global ring.
+*
+* An unknown device yields `[]`: unknown is the truth about a camera that has
+* emitted nothing since this process started.
+*/
+function getDeviceRecent(rings, deviceId) {
+	const ring = rings.byDevice.get(deviceId);
+	if (ring === void 0) return [];
+	if (ring.mirrors.size === 0) return ring.history;
+	const merged = [...ring.history, ...ring.mirrors.values()];
+	merged.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+	return merged;
+}
 //#endregion
 //#region src/kernel/moleculer/event-bus-core.ts
 /**
@@ -6985,6 +7116,7 @@ function createSharedBusState(retainRecent = false) {
 	return {
 		handlers: /* @__PURE__ */ new Map(),
 		recent: [],
+		deviceRings: createDeviceEventRings(),
 		retainRecent
 	};
 }
@@ -7168,6 +7300,7 @@ function deliverShared(state, event) {
 	if (state.retainRecent && !isHighFrequencyCategory(event.category)) {
 		state.recent.push(event);
 		if (state.recent.length > 1e3) state.recent.splice(0, state.recent.length - MAX_RECENT_EVENTS);
+		recordDeviceEvent(state.deviceRings, event);
 	}
 	const delivered = /* @__PURE__ */ new Set();
 	for (const [pattern, set] of state.handlers) {
@@ -10133,14 +10266,15 @@ function getBrokerEventBus(broker, options) {
 			});
 		},
 		getRecent(filter, limit) {
-			const filtered = filter ? state.recent.filter((e) => {
+			const source = filter?.deviceId !== void 0 ? getDeviceRecent(state.deviceRings, filter.deviceId) : state.recent;
+			const filtered = filter ? source.filter((e) => {
 				const cat = filter.category;
 				if (cat) {
 					const categories = typeof cat === "string" ? [cat] : Array.isArray(cat) ? cat : [];
 					if (categories.length > 0 && !categories.some((c) => matchesPattern(String(c), e.category))) return false;
 				}
 				return matchesEventFilter(e, filter);
-			}) : state.recent;
+			}) : source;
 			return limit !== void 0 ? filtered.slice(-limit) : filtered;
 		}
 	};

package/dist/{retired-settings-keys-DRKmYztE.js → retired-settings-keys-1GWw9mup.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-CHclfj0J.js");
+const require_dist = require("./dist-Dze0l7UM.js");
 //#region src/builtins/sqlite-storage/retired-settings-keys.ts
 /**
 * Is THIS node the one whose settings store is the cluster's authority?

package/dist/{retired-settings-keys-bJE3qjAT.mjs → retired-settings-keys-Cbt4-K_M.mjs}

@@ -1,4 +1,4 @@
-import { in as asJsonObject } from "./dist-D5hpgLSL.mjs";
+import { in as asJsonObject } from "./dist-CDDG1zn3.mjs";
 //#region src/builtins/sqlite-storage/retired-settings-keys.ts
 /**
 * Is THIS node the one whose settings store is the cluster's authority?

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/system",
-  "version": "1.2.238",
+  "version": "1.2.240",
   "description": "Core addon for CamStack — builtins, pipeline, process management, auth, logging, events",
   "keywords": [
     "camstack",
@@ -352,7 +352,7 @@
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",
-    "publish": "npm publish --access public"
+    "publish:npm": "npm publish --access public"
   },
   "dependencies": {
     "@camstack/sdk": "*",