@camstack/system 1.2.314 → 1.2.315

package/dist/builtins/doorbell/virtual-doorbell.addon.js

@@ -3,8 +3,9 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-BtNkk3Qz.js");
+const require_dist = require("../../dist-DVKv5i-e.js");
 const require_device_state_changed = require("../../device-state-changed-Bk7cvTnz.js");
+let zod = require("zod");
 //#region src/builtins/doorbell/trigger-engine.ts
 /**
 * Pure trigger logic for the virtual-doorbell builtin — edge detection over
@@ -242,7 +243,7 @@ function entriesBindWrapper(entries, capName, ownAddonId) {
 function summariseEntries(entries) {
 	return entries.map((entry) => `${entry.capName}:${entry.kind}:${entry.providerAddonId}`);
 }
-function isRecord$1(value) {
+function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
@@ -258,13 +259,13 @@ function isRecord$1(value) {
 * from an empty snapshot, whereas a genuine unbind leaves the key present.
 */
 function readDurableWrapperBinding(record, deviceId, capName, ownAddonId) {
-	if (!isRecord$1(record)) return "unreadable";
+	if (!isRecord$2(record)) return "unreadable";
 	const deviceBindings = record["deviceBindings"];
-	if (!isRecord$1(deviceBindings)) return "unreadable";
+	if (!isRecord$2(deviceBindings)) return "unreadable";
 	const perDevice = deviceBindings[String(deviceId)];
-	if (!isRecord$1(perDevice)) return "unbound";
+	if (!isRecord$2(perDevice)) return "unbound";
 	const activation = perDevice[capName];
-	if (!isRecord$1(activation)) return "unbound";
+	if (!isRecord$2(activation)) return "unbound";
 	const wrapperAddonId = activation["wrapperAddonId"];
 	if (typeof wrapperAddonId !== "string") return "unbound";
 	return require_dist.isSameAddonId(wrapperAddonId, ownAddonId) ? "bound" : "unbound";
@@ -319,7 +320,7 @@ var KEY_SOURCES = "doorbellSources";
 var LEGACY_KEY_SOURCE = "doorbellSourceDeviceId";
 var LEGACY_KEY_TRIGGER = "doorbellTrigger";
 var LEGACY_KEY_EVENT_TYPE = "doorbellEventType";
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /** Coerce a persisted / form-supplied id (number or numeric string) to a
@@ -337,7 +338,7 @@ function collectSources(items) {
 	const out = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const item of items) {
-		const id = isRecord(item) ? coerceDeviceId(item["deviceId"]) : coerceDeviceId(item);
+		const id = isRecord$1(item) ? coerceDeviceId(item["deviceId"]) : coerceDeviceId(item);
 		if (id !== null && !seen.has(id)) {
 			seen.add(id);
 			out.push({ deviceId: id });
@@ -579,6 +580,278 @@ function createDoorbellExtensionProvider(deps) {
 	});
 }
 //#endregion
+//#region src/builtins/doorbell/doorbell-composition-migration.ts
+var DOORBELL_COMPOSITION_MIGRATION_STATE_KEY = "doorbell-source-composition-migration-v1";
+var DOORBELL_COMPOSITION_MIGRATION_CALLER = {
+	userId: "system:doorbell-source-migration",
+	isAdmin: true
+};
+function buildDoorbellCompositionFeature(input) {
+	const sources = [...input.sources].toSorted((a, b) => `${a.source.addonId}/${a.source.stableId}#${a.cap}`.localeCompare(`${b.source.addonId}/${b.source.stableId}#${b.cap}`));
+	if (sources.length === 0) throw new Error("doorbell composition needs at least one source");
+	const edgeBindings = {};
+	sources.forEach((entry, index) => {
+		edgeBindings[`active${index}`] = {
+			kind: "from",
+			source: entry.source,
+			cap: entry.cap,
+			fieldPath: entry.activeField
+		};
+		edgeBindings[`changed${index}`] = {
+			kind: "from",
+			source: entry.source,
+			cap: entry.cap,
+			fieldPath: entry.changedAtField
+		};
+	});
+	return {
+		kind: "fields",
+		cap: "doorbell",
+		enabled: input.enabled,
+		fields: {
+			lastPressedAt: {
+				kind: "expression",
+				expr: `latest(${sources.map((_, index) => `rose(active${index}, changed${index}, 2000)`).join(", ")})`,
+				bindings: edgeBindings
+			},
+			pressCountSinceStart: {
+				kind: "expression",
+				expr: "count(lastPressedAt)",
+				bindings: { lastPressedAt: {
+					kind: "from",
+					source: {
+						addonId: input.camera.addonId,
+						stableId: input.camera.stableId
+					},
+					cap: "doorbell",
+					fieldPath: "lastPressedAt"
+				} }
+			}
+		}
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stableValue(value) {
+	if (Array.isArray(value)) return value.map(stableValue);
+	if (!isRecord(value)) return value;
+	return Object.fromEntries(Object.keys(value).toSorted().map((key) => [key, stableValue(value[key])]));
+}
+function sameJson(a, b) {
+	return JSON.stringify(stableValue(a)) === JSON.stringify(stableValue(b));
+}
+function withoutEnabled(feature) {
+	const { enabled: _enabled, ...rest } = feature;
+	return rest;
+}
+function bindingHasCap(entries, cap) {
+	return entries.some((entry) => entry.capName === cap);
+}
+function migrationSources(camera, configured, devicesById, bindingsById) {
+	const sources = [];
+	for (const configuredSource of configured) {
+		const device = devicesById.get(configuredSource.deviceId);
+		const entries = bindingsById.get(configuredSource.deviceId);
+		if (device === void 0 || entries === void 0) throw new Error(`source device ${configuredSource.deviceId} could not be resolved and read`);
+		const ref = {
+			addonId: device.addonId,
+			stableId: device.stableId
+		};
+		const supportedCaps = Object.keys(require_dist.SOURCE_CAP_ACTIVE_FIELD).filter((cap) => Object.hasOwn(require_dist.SOURCE_CAP_CHANGED_AT_FIELD, cap) && bindingHasCap(entries, cap)).toSorted();
+		if (supportedCaps.length === 0) throw new Error(`source device ${configuredSource.deviceId} has no supported source capability`);
+		for (const cap of supportedCaps) {
+			const activeField = require_dist.SOURCE_CAP_ACTIVE_FIELD[cap];
+			const changedAtField = require_dist.SOURCE_CAP_CHANGED_AT_FIELD[cap];
+			if (activeField === void 0 || changedAtField === void 0) throw new Error(`source capability ${cap} has no transition field mapping`);
+			sources.push({
+				source: ref,
+				cap,
+				activeField,
+				changedAtField
+			});
+		}
+	}
+	if (sources.length === 0) throw new Error(`camera ${camera.id} has no resolvable doorbell sources`);
+	return sources;
+}
+function wrapperIsActive(entries) {
+	return entries.some((entry) => entry.capName === "doorbell" && entry.kind === "wrapped" && entry.providerAddonId === "virtual-doorbell");
+}
+function composerIsBound(entries) {
+	return entries.some((entry) => entry.capName === "doorbell" && (entry.providerAddonId === "composer" || entry.nativeAddonId === "composer"));
+}
+var DoorbellCompositionMigration = class {
+	deps;
+	rerunRequested = false;
+	inFlight = null;
+	stopped = false;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	request(reason) {
+		if (this.stopped) return;
+		this.rerunRequested = true;
+		if (this.inFlight !== null) return;
+		this.inFlight = this.runUntilQuiet(reason).finally(() => {
+			this.inFlight = null;
+			if (this.rerunRequested && !this.stopped) this.request("coalesced lifecycle event");
+		});
+	}
+	async waitForIdle() {
+		while (this.inFlight !== null || this.rerunRequested) {
+			const current = this.inFlight;
+			if (current !== null) await current;
+			else await Promise.resolve();
+		}
+	}
+	shutdown() {
+		this.stopped = true;
+		this.rerunRequested = false;
+	}
+	async runUntilQuiet(reason) {
+		while (this.rerunRequested && !this.stopped) {
+			this.rerunRequested = false;
+			try {
+				await this.runAttempt(reason);
+			} catch (err) {
+				this.deps.logger.warn("doorbell-source migration: attempt failed", { meta: {
+					reason,
+					error: err instanceof Error ? err.message : String(err)
+				} });
+			}
+		}
+	}
+	async runAttempt(reason) {
+		if (await this.deps.isComplete()) return;
+		const cameras = await this.deps.listCameras();
+		const configuredByCamera = /* @__PURE__ */ new Map();
+		const failedReads = /* @__PURE__ */ new Set();
+		for (const camera of cameras) try {
+			const sources = await this.deps.readSources(camera.id);
+			if (sources.length > 0) configuredByCamera.set(camera.id, sources);
+		} catch (err) {
+			failedReads.add(camera.id);
+			this.warnCamera(camera.id, `could not read source settings (${errorText(err)})`);
+		}
+		if (failedReads.size > 0) return;
+		if (configuredByCamera.size === 0) {
+			await this.deps.markComplete();
+			return;
+		}
+		const camerasById = new Map(cameras.map((camera) => [camera.id, camera]));
+		const sourceIds = [...new Set([...configuredByCamera.values()].flatMap((sources) => sources.map((s) => s.deviceId)))].toSorted((a, b) => a - b);
+		const sourceDevices = await this.deps.listSourceDevices(sourceIds);
+		const devicesById = new Map(sourceDevices.map((device) => [device.id, device]));
+		const bindingIds = [...new Set([...configuredByCamera.keys(), ...sourceIds])].toSorted((a, b) => a - b);
+		const bindingRows = await this.deps.getBindingsBatch(bindingIds);
+		const bindingsById = new Map(bindingRows.map((row) => [row.deviceId, row.entries]));
+		const coreBlocks = this.deps.coreBlocks();
+		if (coreBlocks === null) {
+			for (const cameraId of configuredByCamera.keys()) this.warnCamera(cameraId, "core-blocks provider is not ready");
+			return;
+		}
+		let allSettled = true;
+		for (const [cameraId, configured] of configuredByCamera) {
+			const camera = camerasById.get(cameraId);
+			const entries = bindingsById.get(cameraId);
+			if (camera === void 0 || entries === void 0) {
+				allSettled = false;
+				this.warnCamera(cameraId, "camera or binding row could not be read");
+				continue;
+			}
+			try {
+				const sources = migrationSources(camera, configured, devicesById, bindingsById);
+				const cameraRef = {
+					addonId: camera.addonId,
+					stableId: camera.stableId
+				};
+				const read = await coreBlocks.getCustomization({ ...cameraRef });
+				if (read.state !== "loaded") throw new Error(`customizations are not loaded (${read.reason})`);
+				const view = read.view;
+				if (view !== null && !view.block.enabled) throw new Error(`customization block ${view.block.id} is disabled`);
+				const existingComposition = view?.block.source?.kind === "composition" ? view.block.source.composition : null;
+				if (view !== null && existingComposition === null) throw new Error(`customization block ${view.block.id} has no readable composition`);
+				const existingDoorbell = existingComposition?.features.find((feature) => feature.cap === "doorbell");
+				const wrapperActive = wrapperIsActive(entries);
+				const composerBound = composerIsBound(entries);
+				const crashRecovery = !wrapperActive && composerBound && existingDoorbell?.kind === "fields" && existingDoorbell.enabled === true;
+				const enabled = wrapperActive || crashRecovery;
+				const canonical = buildDoorbellCompositionFeature({
+					camera: cameraRef,
+					sources,
+					enabled
+				});
+				let needsSave = view === null;
+				let composition;
+				if (existingComposition === null) composition = {
+					target: {
+						kind: "existing",
+						device: cameraRef
+					},
+					features: [canonical]
+				};
+				else if (existingDoorbell === void 0) {
+					composition = {
+						...existingComposition,
+						features: [...existingComposition.features, canonical]
+					};
+					needsSave = true;
+				} else if (existingDoorbell.kind === "fields" && sameJson(withoutEnabled(existingDoorbell), withoutEnabled(canonical))) {
+					composition = {
+						...existingComposition,
+						features: existingComposition.features.map((feature) => feature.cap === "doorbell" ? canonical : feature)
+					};
+					needsSave ||= existingDoorbell.enabled !== canonical.enabled;
+				} else throw new Error("an existing doorbell feature is not owned by this migration");
+				if (needsSave) if (view === null) await coreBlocks.createComposition({
+					block: {
+						enabled: true,
+						composition
+					},
+					caller: DOORBELL_COMPOSITION_MIGRATION_CALLER
+				});
+				else await coreBlocks.updateComposition({
+					blockId: view.block.id,
+					expectedUpdatedAt: view.block.updatedAt,
+					block: { composition },
+					caller: DOORBELL_COMPOSITION_MIGRATION_CALLER
+				});
+				if (!enabled) continue;
+				if (!composerBound) {
+					allSettled = false;
+					continue;
+				}
+				if (wrapperActive) {
+					await this.deps.setWrapperActive({
+						deviceId: camera.id,
+						capName: "doorbell",
+						wrapperAddonId: "virtual-doorbell",
+						active: false
+					});
+					this.deps.logger.info("doorbell-source migration: composer owns doorbell; wrapper deactivated", {
+						tags: { deviceId: camera.id },
+						meta: { reason }
+					});
+				}
+			} catch (err) {
+				allSettled = false;
+				this.warnCamera(cameraId, errorText(err));
+			}
+		}
+		if (allSettled) await this.deps.markComplete();
+	}
+	warnCamera(cameraId, reason) {
+		this.deps.logger.warn("doorbell-source migration: camera not migrated", {
+			tags: { deviceId: cameraId },
+			meta: { reason }
+		});
+	}
+};
+function errorText(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
 //#region src/builtins/doorbell/virtual-doorbell.addon.ts
 /**
 * The addon whose store IS the durable authority on wrapper activations.
@@ -628,6 +901,8 @@ function parseDoorbellSlice(slice) {
 */
 var VirtualDoorbellAddon = class extends require_dist.BaseAddon {
 	engine;
+	compositionMigration = null;
+	providerRegisteredUnsubscribe = null;
 	/** Monotonic guard: assignments are reloaded lazily on trigger traffic. */
 	assignmentsLoadedAt = 0;
 	assignmentsLoading = null;
@@ -652,6 +927,32 @@ var VirtualDoorbellAddon = class extends require_dist.BaseAddon {
 			if (!data) return;
 			this.handleStateChanged(data);
 		});
+		const migrationState = this.state(DOORBELL_COMPOSITION_MIGRATION_STATE_KEY, zod.z.object({ complete: zod.z.boolean() }), { complete: false });
+		this.compositionMigration = new DoorbellCompositionMigration({
+			logger: this.ctx.logger.child("doorbell-source-migration"),
+			listCameras: async () => this.ctx.api.deviceManager.listAll.query({
+				isCamera: true,
+				projection: "slim"
+			}),
+			listSourceDevices: async (deviceIds) => this.ctx.api.deviceManager.listAll.query({
+				deviceIds: [...deviceIds],
+				projection: "slim"
+			}),
+			readSources: (cameraId) => this.readDeviceSources(cameraId),
+			getBindingsBatch: async (deviceIds) => this.ctx.api.deviceManager.getBindingsBatch.query({ deviceIds: [...deviceIds] }),
+			coreBlocks: () => this.ctx.capabilities?.get("core-blocks") ?? null,
+			setWrapperActive: (input) => this.ctx.api.deviceManager.setWrapperActive.mutate(input),
+			isComplete: async () => (await migrationState.get()).complete,
+			markComplete: async () => migrationState.set({ complete: true })
+		});
+		this.providerRegisteredUnsubscribe = this.ctx.eventBus.subscribe({ category: "capability:provider-registered" }, (event) => {
+			if (event.data["capability"] !== "core-blocks") return;
+			this.compositionMigration?.request("core-blocks registered");
+		});
+		this.subscribe({ category: require_dist.EventCategory.DeviceBindingsChanged }, () => {
+			this.compositionMigration?.request("device bindings changed");
+		});
+		this.compositionMigration.request("addon initialized");
 		return [{
 			capability: require_dist.doorbellCapability,
 			provider: { getStatus: (input) => this.getStatus(input.deviceId) }
@@ -660,6 +961,12 @@ var VirtualDoorbellAddon = class extends require_dist.BaseAddon {
 			provider: this.buildExtensionProvider()
 		}];
 	}
+	async onShutdown() {
+		this.providerRegisteredUnsubscribe?.();
+		this.providerRegisteredUnsubscribe = null;
+		this.compositionMigration?.shutdown();
+		this.compositionMigration = null;
+	}
 	/**
 	* The `device-extension` provider: the only editor of a camera's trigger
 	* devices since D655 (see `doorbell-extension-slot.ts`).