@camstack/system 1.2.184 → 1.2.186

package/dist/builtins/device-manager/device-manager.addon.mjs

@@ -1,5 +1,5 @@
-import { $t as isDeviceConfigCap, Bt as DeviceRole, Ft as BaseAddon, H as deviceManagerCapability, J as enumerateSchemaFields, P as buildStreamParamsConfigSchema, Pt as errMsg, U as deviceStateCapability, Vt as DeviceType, W as deviceStatusCapability, Wt as WELL_KNOWN_TAB_MAP, a as CAMERA_SWITCH_ORDER, b as STREAM_PROFILE_META, f as DeviceStatusSchema, ft as normalizeUnit, mt as parseStreamParamsFormPatch, o as CAP_NAMES_WITH_STATUS, on as sleep, q as enumerateItemArrayFields, sn as EventCategory, t as ALL_CAPABILITY_DEFINITIONS, xt as runtimeStatePolicyFor, yt as resolveContainerPrimaryChild, zt as DeviceFeature } from "../../dist-CCMYMmkQ.mjs";
-import { n as purgeRetiredSettingsRows } from "../../retired-settings-keys-C0uslzAd.mjs";
+import { $t as isDeviceConfigCap, Bt as DeviceRole, Ft as BaseAddon, H as deviceManagerCapability, J as enumerateSchemaFields, P as buildStreamParamsConfigSchema, Pt as errMsg, U as deviceStateCapability, Vt as DeviceType, W as deviceStatusCapability, Wt as WELL_KNOWN_TAB_MAP, a as CAMERA_SWITCH_ORDER, b as STREAM_PROFILE_META, f as DeviceStatusSchema, ft as normalizeUnit, mt as parseStreamParamsFormPatch, o as CAP_NAMES_WITH_STATUS, on as sleep, q as enumerateItemArrayFields, sn as EventCategory, t as ALL_CAPABILITY_DEFINITIONS, xt as runtimeStatePolicyFor, yt as resolveContainerPrimaryChild, zt as DeviceFeature } from "../../dist-BLU9Dol1.mjs";
+import { n as purgeRetiredSettingsRows } from "../../retired-settings-keys-rIzS2f51.mjs";
 import { randomUUID } from "node:crypto";
 import { canonicalDeviceFingerprint } from "@camstack/types/node";
 //#region src/builtins/device-manager/adoption-job-engine.ts
@@ -2167,6 +2167,91 @@ function resolveTrackedEventDeviceIds(config, linkedIds) {
 */
 var LINK_CANDIDATE_PROJECTION = { projection: "slim" };
 /**
+* The broken state the 2026-08-26 design leaves possible, made DETECTABLE: a
+* container whose OWN location matches the camera's while its descendants
+* carry `location: null` (a location that predates the cascade, or a cascade
+* write that failed) is skipped by the container rule AND matched by nobody —
+* the whole appliance silently vanishes from auto-link. Measured live
+* 2026-09-05: 40 containers, 373 children, zero log lines.
+*
+* A container qualifies when it matches the camera's location, has at least
+* one descendant, contributed NONE of them to the resolved set, and at least
+* one descendant is location-less. A subtree whose members all carry a
+* DIFFERENT explicit location is excluded on purpose — that is an operator's
+* deliberate split, not the broken state.
+*/
+function findLocationInvisibleContainers(params) {
+	const { selfId, selfLocation, resolvedIds, candidates } = params;
+	if (selfLocation === null || selfLocation.length === 0) return [];
+	const byParent = /* @__PURE__ */ new Map();
+	for (const c of candidates) {
+		if (c.parentDeviceId === null) continue;
+		const bucket = byParent.get(c.parentDeviceId);
+		if (bucket) bucket.push(c);
+		else byParent.set(c.parentDeviceId, [c]);
+	}
+	const out = [];
+	for (const c of candidates) {
+		if (c.type !== DeviceType.Container) continue;
+		if (c.id === selfId) continue;
+		if (c.location !== selfLocation) continue;
+		let anyResolved = false;
+		let anyNullLocation = false;
+		let descendantCount = 0;
+		const visited = new Set([c.id]);
+		let frontier = [c.id];
+		while (frontier.length > 0) {
+			const next = [];
+			for (const parentId of frontier) for (const child of byParent.get(parentId) ?? []) {
+				if (visited.has(child.id)) continue;
+				visited.add(child.id);
+				descendantCount += 1;
+				if (resolvedIds.has(child.id)) anyResolved = true;
+				if (child.location === null) anyNullLocation = true;
+				next.push(child.id);
+			}
+			frontier = next;
+		}
+		if (descendantCount > 0 && !anyResolved && anyNullLocation) out.push(c.id);
+	}
+	return out;
+}
+/**
+* Per-process warn dedupe for {@link findLocationInvisibleContainers}. This
+* read path runs continuously (the analytics reverse index resolves linked
+* devices for every camera on a timer), so an undeduped warn would be a log
+* flood about a state that only an operator action (or the boot backfill)
+* changes. One line per (camera, container) pair per process is exactly as
+* loud as the fact is. Bounded so pathological id churn cannot grow it
+* forever; once full it stops ADDING, never stops the resolver.
+*/
+var INVISIBLE_CONTAINER_WARN_CAP = 4096;
+var warnedInvisibleContainers = /* @__PURE__ */ new Set();
+function warnLocationInvisibleContainers(pctx, cameraId, byId, all, resolved) {
+	if (resolved.mode !== "auto") return;
+	const selfLocation = byId.get(cameraId)?.location ?? null;
+	if (selfLocation === null || selfLocation.length === 0) return;
+	const invisible = findLocationInvisibleContainers({
+		selfId: cameraId,
+		selfLocation,
+		resolvedIds: new Set(resolved.devices.map((d) => d.deviceId)),
+		candidates: all
+	});
+	for (const containerId of invisible) {
+		const key = `${cameraId}:${containerId}`;
+		if (warnedInvisibleContainers.has(key)) continue;
+		if (warnedInvisibleContainers.size >= INVISIBLE_CONTAINER_WARN_CAP) return;
+		warnedInvisibleContainers.add(key);
+		pctx.host.ctx.logger.warn("getLinkedDevices: container matches the camera location but is invisible to auto-link — its children carry no location; re-save the container location to realign", {
+			tags: { deviceId: containerId },
+			meta: {
+				cameraId,
+				location: selfLocation
+			}
+		});
+	}
+}
+/**
 * Resolve ONE camera's linked set against an ALREADY-FETCHED fleet.
 *
 * The fleet is a parameter, not a fetch, because it is the entire cost of this
@@ -2204,7 +2289,10 @@ function resolveFor(deviceId, all, byId, blob) {
 async function getLinkedDevices(pctx, input) {
 	const { deviceId } = input;
 	const [all, blob] = await Promise.all([listAll(pctx, LINK_CANDIDATE_PROJECTION), pctx.settings.readDeviceStore(deviceId)]);
-	return resolveFor(deviceId, all, new Map(all.map((d) => [d.id, d])), blob);
+	const byId = new Map(all.map((d) => [d.id, d]));
+	const resolved = resolveFor(deviceId, all, byId, blob);
+	warnLocationInvisibleContainers(pctx, deviceId, byId, all, resolved);
+	return resolved;
 }
 /**
 * Cap implementation of `getLinkedDevicesBatch` — ONE fleet listing for the
@@ -2230,10 +2318,14 @@ async function getLinkedDevicesBatch(pctx, input) {
 		return {};
 	})))]);
 	const byId = new Map(all.map((d) => [d.id, d]));
-	return deviceIds.map((deviceId, index) => ({
-		deviceId,
-		...resolveFor(deviceId, all, byId, blobs[index] ?? {})
-	}));
+	return deviceIds.map((deviceId, index) => {
+		const resolved = resolveFor(deviceId, all, byId, blobs[index] ?? {});
+		warnLocationInvisibleContainers(pctx, deviceId, byId, all, resolved);
+		return {
+			deviceId,
+			...resolved
+		};
+	});
 }
 /**
 * "Linked devices" settings section for a CAMERA (null for every other
@@ -3520,6 +3612,215 @@ async function swapHardwareState(settings, sourceId, targetId) {
 	};
 }
 //#endregion
+//#region src/builtins/device-manager/location-alignment.ts
+/**
+* Location alignment — closes the RETROACTIVITY hole D252/D329 left open, and
+* makes the broken state LOUD wherever it survives.
+*
+* The cascade (`setLocation` → every descendant's own `location` column,
+* device-meta-actions.ts) runs only when `setLocation` is CALLED. Both records
+* said so out loud ("Nothing retroactive") and the fleet paid for it: measured
+* on the live hub 2026-09-04, 40 containers whose location predated the
+* cascade carried 373 children at `location: null` — every one of those
+* containers invisible to auto-mode linking-by-location (the container itself
+* is deliberately never a link; its children never matched), and not one log
+* line said so. Camera 615 showed one siren where four appliances belonged.
+*
+* Two mechanisms close it, both WRITE-time — read-time inheritance stays
+* rejected (D252's context: a live-resolved location is invisible everywhere
+* except the one call site that resolves it):
+*
+*  1. **A one-shot boot backfill** (`runLocationBackfillAtBoot`). For every
+*     device whose `location` is null and whose parent chain reaches a located
+*     CONTAINER ancestor (container-only — see `planNullLocationFills` for
+*     why a camera's subtree is deliberately left alone), the NEAREST located
+*     ancestor's location is written onto the
+*     row — once per install, marker-guarded. It fills NULL ONLY: an automated
+*     pass carries no operator intent, so it must never overwrite an explicit
+*     different location the way an operator's `setLocation` deliberately
+*     does. Runs under `withMetaWriteLock` and re-verifies each row is still
+*     null before patching, so it cannot fight a concurrent edit. The marker
+*     is only advanced when every planned write LANDED — a partial repair
+*     retries next boot (bounded: once per boot), never silently half-done.
+*
+*  2. **Registration-time inheritance** (`resolveInheritedLocation`, consumed
+*     by `registerDevice` in device-meta-actions.ts). A child adopted AFTER
+*     its parent's location was set is the same hole reopened — the cascade
+*     only fires on `setLocation`, and nobody re-saves a container because HA
+*     grew an entity. So a newly-registered (or re-parented) row whose own
+*     location is null inherits the nearest located CONTAINER ancestor's
+*     location the instant it registers, and pulls it down onto its own
+*     null-location descendants (out-of-order adoption registers children
+*     before parents).
+*
+* And one detection: every boot, read-only, the fleet is checked for the
+* broken state and each misaligned ancestor is WARNED about, device-tagged —
+* the state can re-enter (a partially-failed cascade, a hand-edited ledger)
+* and a branch that drops work must say so.
+*/
+/** Addon-store key of the one-shot marker. A number: the highest backfill
+*  version that COMPLETED (every planned write landed). */
+var LOCATION_BACKFILL_MARKER_KEY = "locationBackfillVersion";
+/** Walk the parent chain of `startParentId` over an in-memory fleet snapshot
+*  and return the nearest ancestor carrying a non-null location. Cycle-guarded:
+*  a chain that revisits a node answers null rather than spinning. */
+function nearestLocatedAncestor(byId, startParentId) {
+	const visited = /* @__PURE__ */ new Set();
+	let cursor = startParentId;
+	while (cursor !== null && !visited.has(cursor)) {
+		visited.add(cursor);
+		const ancestor = byId.get(cursor);
+		if (!ancestor) return null;
+		if (ancestor.location !== null) return ancestor;
+		cursor = ancestor.parentDeviceId;
+	}
+	return null;
+}
+/**
+* Pure planning core of the backfill: every row whose own `location` is null
+* and whose parent chain reaches a located CONTAINER ancestor gets that
+* ancestor's location. Nearest located ancestor wins — and DECIDES: a located
+* non-container between the row and a located container blocks the fill.
+*
+* The container-only predicate is an operator decision (2026-09-05), the
+* automated mirror of the structural-children rule: a non-container parent's
+* subtree (a camera and its siren/floodlight) is already fully reachable
+* through `resolveLinkedDeviceIds`' children-of-self rule, so a location buys
+* its own camera nothing — and COSTS cross-camera noise, verified against the
+* real fleet shape with the real resolver: a camera child that gains the room
+* matches every OTHER camera in that room individually (`ids.add`; only a
+* Container parent routes through `expand`), so camera B lists camera A's
+* siren as a companion. A container's descendants, by contrast, are reachable
+* by location ONLY through their own columns — the container itself is never
+* a link — which is the whole reason the cascade writes them (D252). Note the
+* asymmetry with the OPERATOR's cascade, which has no type predicate (D329):
+* an operator re-saving a camera accepts that trade explicitly; an automated
+* pass must not manufacture it.
+*/
+function planNullLocationFills(rows) {
+	const byId = new Map(rows.map((r) => [r.id, r]));
+	const plan = [];
+	for (const row of rows) {
+		if (row.location !== null) continue;
+		if (row.parentDeviceId === null) continue;
+		const hit = nearestLocatedAncestor(byId, row.parentDeviceId);
+		if (hit === null) continue;
+		if (hit.type !== DeviceType.Container) continue;
+		if (hit.location === null) continue;
+		plan.push({
+			id: row.id,
+			location: hit.location,
+			ancestorId: hit.id
+		});
+	}
+	return plan;
+}
+/**
+* Async ancestor walk for `registerDevice`: the nearest located CONTAINER
+* ancestor's location, read row by row (registration has no fleet snapshot in
+* hand and must not pay for one). Same container-only predicate as
+* {@link planNullLocationFills}, and for the same reason — a child adopted
+* under a located CAMERA is already linked structurally to that camera, and a
+* location on its own column would make it a companion of every other camera
+* in the room. The nearest located ancestor decides: a located non-container
+* on the way up answers null. Cycle-guarded like the pure walk; a missing row
+* — a parent registered out of order — answers null, and the parent's own
+* later registration pulls the location down instead (see `registerDevice`).
+*/
+async function resolveInheritedLocation(rows, parentDeviceId) {
+	const visited = /* @__PURE__ */ new Set();
+	let cursor = parentDeviceId;
+	while (cursor !== null && !visited.has(cursor)) {
+		visited.add(cursor);
+		const ancestor = await rows.get(cursor);
+		if (ancestor === null) return null;
+		if (ancestor.meta.location !== null) return ancestor.meta.type === DeviceType.Container ? ancestor.meta.location : null;
+		cursor = ancestor.meta.parentDeviceId;
+	}
+	return null;
+}
+/** `fills` grouped by the ancestor whose location they inherit — the unit the
+*  logs speak in, because the ancestor is the device an operator would act on. */
+function groupByAncestor(fills) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const fill of fills) {
+		const bucket = grouped.get(fill.ancestorId);
+		if (bucket) bucket.push(fill);
+		else grouped.set(fill.ancestorId, [fill]);
+	}
+	return grouped;
+}
+/**
+* Boot entrypoint: the one-shot repair (marker-guarded) plus the every-boot
+* detection. `bootRows` is the fleet listing the addon's warm-boot pass
+* already paid for — reused for the detection so a clean boot costs no extra
+* fleet read; ignored by the repair, which takes its own listing UNDER the
+* meta write lock (the snapshot must not predate the lock).
+*/
+async function runLocationBackfillAtBoot(pctx, bootRows) {
+	const logger = pctx.host.ctx.logger;
+	const markerRaw = (await pctx.settings.readAddonStore())[LOCATION_BACKFILL_MARKER_KEY];
+	const completedVersion = typeof markerRaw === "number" ? markerRaw : 0;
+	let repaired = false;
+	if (completedVersion < 1) {
+		const patched = [];
+		const failed = [];
+		await pctx.metaStore.withMetaWriteLock(async () => {
+			const plan = planNullLocationFills((await pctx.metaStore.rows.listAll()).map((r) => r.meta));
+			for (const fill of plan) try {
+				const current = await pctx.metaStore.rows.get(fill.id);
+				if (current === null || current.meta.location !== null) continue;
+				await pctx.metaStore.rows.patch(fill.id, { location: fill.location });
+				patched.push(fill);
+			} catch (err) {
+				failed.push({
+					id: fill.id,
+					error: err
+				});
+			}
+		});
+		repaired = true;
+		for (const [ancestorId, fills] of groupByAncestor(patched)) {
+			pctx.host.ctx.eventBus.emit({
+				id: randomUUID(),
+				timestamp: /* @__PURE__ */ new Date(),
+				source: {
+					type: "device",
+					id: ancestorId
+				},
+				category: EventCategory.DeviceMetaChanged,
+				data: {
+					deviceId: ancestorId,
+					field: "location",
+					value: fills[0]?.location ?? null
+				}
+			});
+			logger.info("location backfill: aligned location-less descendants to their ancestor", {
+				tags: { deviceId: ancestorId },
+				meta: {
+					location: fills[0]?.location,
+					updatedIds: fills.map((f) => f.id)
+				}
+			});
+		}
+		if (failed.length > 0) logger.error("location backfill partially failed — retrying on the next boot", { meta: {
+			failedIds: failed.map((f) => f.id),
+			errors: failed.map((f) => f.error instanceof Error ? f.error.message : String(f.error))
+		} });
+		else await pctx.metaStore.withAddonStoreWriteLock(async () => {
+			await pctx.settings.writeAddonStore({ [LOCATION_BACKFILL_MARKER_KEY]: 1 });
+		});
+	}
+	const residual = planNullLocationFills((!repaired && bootRows !== void 0 ? bootRows : await pctx.metaStore.rows.listAll()).map((r) => r.meta));
+	for (const [ancestorId, fills] of groupByAncestor(residual)) logger.warn("location cascade misaligned — location-less descendants under a located ancestor never match location auto-link; re-save the ancestor location to realign", {
+		tags: { deviceId: ancestorId },
+		meta: {
+			location: fills[0]?.location,
+			misalignedDescendantIds: fills.map((f) => f.id)
+		}
+	});
+}
+//#endregion
 //#region src/builtins/device-manager/device-meta-actions.ts
 /**
 * Device meta-mutation + persistence actions for the device-manager addon —
@@ -3723,7 +4024,7 @@ async function migrateDevice(pctx, input) {
 async function registerDevice(pctx, input) {
 	const { addonId, stableId, id, type, name, parentDeviceId, features, config } = input;
 	const featuresArr = Array.isArray(features) ? [...features] : [];
-	const { isFirstRegistration, exportFingerprint, fingerprintChanged } = await pctx.metaStore.withMetaWriteLock(async () => {
+	const { isFirstRegistration, exportFingerprint, fingerprintChanged, inheritedLocation, inheritedDescendantIds, inheritFailed } = await pctx.metaStore.withMetaWriteLock(async () => {
 		const existingRow = await pctx.metaStore.rows.get(id);
 		const existingMeta = existingRow?.meta;
 		const wasRegistered = existingRow?.registered ?? false;
@@ -3735,6 +4036,10 @@ async function registerDevice(pctx, input) {
 			deviceType: type,
 			features: featuresArr
 		});
+		const priorLocation = existingMeta?.location ?? null;
+		const resolvedParentId = parentDeviceId ?? null;
+		const parentChanged = existingMeta !== void 0 && (existingMeta.parentDeviceId ?? null) !== resolvedParentId;
+		const inherited = priorLocation === null && resolvedParentId !== null && (isFirst || parentChanged) ? await resolveInheritedLocation(pctx.metaStore.rows, resolvedParentId) : null;
 		await pctx.metaStore.rows.upsertRegistration({
 			deviceId: id,
 			addonId,
@@ -3742,21 +4047,69 @@ async function registerDevice(pctx, input) {
 			type,
 			name: resolvedName,
 			userNamed: wasUserNamed,
-			location: existingMeta?.location ?? null,
+			location: priorLocation ?? inherited,
 			disabled: existingMeta?.disabled ?? false,
-			parentDeviceId: parentDeviceId ?? null,
+			parentDeviceId: resolvedParentId,
 			registered: true,
 			features: featuresArr,
 			exportFingerprint: fingerprint
 		});
+		const descendantsFilled = [];
+		const descendantsFailed = [];
+		if (inherited !== null) for (const descendant of await collectDescendants(pctx.metaStore, id)) {
+			if (descendant.location !== null) continue;
+			try {
+				await pctx.metaStore.rows.patch(descendant.id, { location: inherited });
+				descendantsFilled.push(descendant.id);
+			} catch (err) {
+				descendantsFailed.push({
+					id: descendant.id,
+					error: err
+				});
+			}
+		}
 		return {
 			isFirstRegistration: isFirst,
 			exportFingerprint: fingerprint,
-			fingerprintChanged: existingMeta?.exportFingerprint !== fingerprint
+			fingerprintChanged: existingMeta?.exportFingerprint !== fingerprint,
+			inheritedLocation: inherited,
+			inheritedDescendantIds: descendantsFilled,
+			inheritFailed: descendantsFailed
 		};
 	});
 	if (Object.keys(config).length > 0) await pctx.settings.writeDeviceStore(id, config);
 	pctx.metaStore.idToAddonId.set(id, addonId);
+	if (inheritedLocation !== null) {
+		for (const changedId of [id, ...inheritedDescendantIds]) pctx.host.ctx.eventBus.emit({
+			id: randomUUID(),
+			timestamp: /* @__PURE__ */ new Date(),
+			source: {
+				type: "device",
+				id: changedId
+			},
+			category: EventCategory.DeviceMetaChanged,
+			data: {
+				deviceId: changedId,
+				field: "location",
+				value: inheritedLocation
+			}
+		});
+		pctx.host.ctx.logger.info("registerDevice: inherited located-ancestor location", {
+			tags: { deviceId: id },
+			meta: {
+				location: inheritedLocation,
+				descendantsFilled: inheritedDescendantIds.length
+			}
+		});
+		if (inheritFailed.length > 0) pctx.host.ctx.logger.error("registerDevice: inherited-location fill partially failed — some descendants NOT aligned", {
+			tags: { deviceId: id },
+			meta: {
+				location: inheritedLocation,
+				failedIds: inheritFailed.map((f) => f.id),
+				errors: inheritFailed.map((f) => f.error instanceof Error ? f.error.message : String(f.error))
+			}
+		});
+	}
 	if (isFirstRegistration) pctx.host.ctx.eventBus.emit({
 		id: randomUUID(),
 		timestamp: /* @__PURE__ */ new Date(),
@@ -6348,7 +6701,8 @@ var DeviceManagerAddon = class extends BaseAddon {
 		const stateMirror = this.stateMirrorImpl;
 		const resolvePersistedById = metaStore.resolvePersistedById;
 		const idToAddonId = metaStore.idToAddonId;
-		for (const row of await deviceRows.listAll()) idToAddonId.set(row.meta.id, row.meta.addonId);
+		const bootRows = await deviceRows.listAll();
+		for (const row of bootRows) idToAddonId.set(row.meta.id, row.meta.addonId);
 		const stampIntegrationId$1 = (deviceId, integrationId) => stampIntegrationId(metaStore, this.ctx, deviceId, integrationId);
 		const pctx = {
 			host: this.providerHost,
@@ -6363,6 +6717,11 @@ var DeviceManagerAddon = class extends BaseAddon {
 				return provider;
 			}
 		};
+		try {
+			await runLocationBackfillAtBoot(pctx, bootRows);
+		} catch (err) {
+			this.ctx.logger.warn("location backfill failed — fleet boots without it", { meta: { error: errMsg(err) } });
+		}
 		const provider = {
 			resolveDeviceOwnerSync: (deviceId) => resolveDeviceOwnerSync(pctx, deviceId),
 			resolveNativeCapOwnerSync: (capName, deviceId) => resolveNativeCapOwnerSync(pctx, capName, deviceId),

package/dist/builtins/device-manager/location-alignment.d.ts

@@ -0,0 +1,61 @@
+import { PersistedDeviceMeta } from './device-meta-types.js';
+import { ProviderContext } from './device-provider-context.js';
+import { DeviceRow } from './device-row-store.js';
+/** Addon-store key of the one-shot marker. A number: the highest backfill
+ *  version that COMPLETED (every planned write landed). */
+export declare const LOCATION_BACKFILL_MARKER_KEY = "locationBackfillVersion";
+export declare const LOCATION_BACKFILL_VERSION = 1;
+/** One planned repair: write `location` onto row `id`, inherited from the
+ *  nearest located ancestor `ancestorId`. */
+export interface NullLocationFill {
+    readonly id: number;
+    readonly location: string;
+    readonly ancestorId: number;
+}
+/**
+ * Pure planning core of the backfill: every row whose own `location` is null
+ * and whose parent chain reaches a located CONTAINER ancestor gets that
+ * ancestor's location. Nearest located ancestor wins — and DECIDES: a located
+ * non-container between the row and a located container blocks the fill.
+ *
+ * The container-only predicate is an operator decision (2026-09-05), the
+ * automated mirror of the structural-children rule: a non-container parent's
+ * subtree (a camera and its siren/floodlight) is already fully reachable
+ * through `resolveLinkedDeviceIds`' children-of-self rule, so a location buys
+ * its own camera nothing — and COSTS cross-camera noise, verified against the
+ * real fleet shape with the real resolver: a camera child that gains the room
+ * matches every OTHER camera in that room individually (`ids.add`; only a
+ * Container parent routes through `expand`), so camera B lists camera A's
+ * siren as a companion. A container's descendants, by contrast, are reachable
+ * by location ONLY through their own columns — the container itself is never
+ * a link — which is the whole reason the cascade writes them (D252). Note the
+ * asymmetry with the OPERATOR's cascade, which has no type predicate (D329):
+ * an operator re-saving a camera accepts that trade explicitly; an automated
+ * pass must not manufacture it.
+ */
+export declare function planNullLocationFills(rows: readonly PersistedDeviceMeta[]): readonly NullLocationFill[];
+/** The one row-store method the async ancestor walk needs. */
+export interface RowReader {
+    get(deviceId: number): Promise<DeviceRow | null>;
+}
+/**
+ * Async ancestor walk for `registerDevice`: the nearest located CONTAINER
+ * ancestor's location, read row by row (registration has no fleet snapshot in
+ * hand and must not pay for one). Same container-only predicate as
+ * {@link planNullLocationFills}, and for the same reason — a child adopted
+ * under a located CAMERA is already linked structurally to that camera, and a
+ * location on its own column would make it a companion of every other camera
+ * in the room. The nearest located ancestor decides: a located non-container
+ * on the way up answers null. Cycle-guarded like the pure walk; a missing row
+ * — a parent registered out of order — answers null, and the parent's own
+ * later registration pulls the location down instead (see `registerDevice`).
+ */
+export declare function resolveInheritedLocation(rows: RowReader, parentDeviceId: number | null): Promise<string | null>;
+/**
+ * Boot entrypoint: the one-shot repair (marker-guarded) plus the every-boot
+ * detection. `bootRows` is the fleet listing the addon's warm-boot pass
+ * already paid for — reused for the detection so a clean boot costs no extra
+ * fleet read; ignored by the repair, which takes its own listing UNDER the
+ * meta write lock (the snapshot must not predate the lock).
+ */
+export declare function runLocationBackfillAtBoot(pctx: ProviderContext, bootRows?: readonly DeviceRow[]): Promise<void>;

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

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DE3OH-FG.js");
+const require_dist = require("../../dist-0fjBDzUu.js");
 //#region src/builtins/doorbell/trigger-engine.ts
 /**
 * Pure trigger logic for the virtual-doorbell builtin — edge detection over

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

@@ -1,4 +1,4 @@
-import { Ft as BaseAddon, G as doorbellCapability, Jt as createEvent, M as bareAddonId, Pt as errMsg, Vt as DeviceType, Y as evaluateSensorEdge, _ as SOURCE_CAPS, nt as isSameAddonId, rt as isSourceCap, sn as EventCategory, v as SOURCE_DEVICE_TYPES } from "../../dist-CCMYMmkQ.mjs";
+import { Ft as BaseAddon, G as doorbellCapability, Jt as createEvent, M as bareAddonId, Pt as errMsg, Vt as DeviceType, Y as evaluateSensorEdge, _ as SOURCE_CAPS, nt as isSameAddonId, rt as isSourceCap, sn as EventCategory, v as SOURCE_DEVICE_TYPES } from "../../dist-BLU9Dol1.mjs";
 //#region src/builtins/doorbell/trigger-engine.ts
 /**
 * Pure trigger logic for the virtual-doorbell builtin — edge detection over

package/dist/builtins/hub-forwarder/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DE3OH-FG.js");
+const require_dist = require("../../dist-0fjBDzUu.js");
 const require_formatter = require("../../formatter-DqAKDlvN.js");
 //#region src/builtins/hub-forwarder/hub-forwarder-destination.ts
 var DEFAULT_OUTBOUND_BUFFER_SIZE = 500;

package/dist/builtins/hub-forwarder/index.mjs

@@ -1,4 +1,4 @@
-import { Ft as BaseAddon, ct as logDestinationCapability } from "../../dist-CCMYMmkQ.mjs";
+import { Ft as BaseAddon, ct as logDestinationCapability } from "../../dist-BLU9Dol1.mjs";
 import { t as formatLogLine } from "../../formatter-B7qW8bPJ.mjs";
 //#region src/builtins/hub-forwarder/hub-forwarder-destination.ts
 var DEFAULT_OUTBOUND_BUFFER_SIZE = 500;

package/dist/builtins/liveness-monitor/liveness-monitor.addon.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DE3OH-FG.js");
+const require_dist = require("../../dist-0fjBDzUu.js");
 //#region src/builtins/liveness-monitor/liveness-checks.ts
 var NO_DEVICES = "liveness:no-devices";
 var ALL_OFFLINE = "liveness:all-devices-offline";

package/dist/builtins/liveness-monitor/liveness-monitor.addon.mjs

@@ -1,4 +1,4 @@
-import { Ft as BaseAddon, Jt as createEvent, Pt as errMsg, sn as EventCategory } from "../../dist-CCMYMmkQ.mjs";
+import { Ft as BaseAddon, Jt as createEvent, Pt as errMsg, sn as EventCategory } from "../../dist-BLU9Dol1.mjs";
 //#region src/builtins/liveness-monitor/liveness-checks.ts
 var NO_DEVICES = "liveness:no-devices";
 var ALL_OFFLINE = "liveness:all-devices-offline";

package/dist/builtins/local-auth/local-auth.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DE3OH-FG.js");
+const require_dist = require("../../dist-0fjBDzUu.js");
 let node_crypto = require("node:crypto");
 node_crypto = require_chunk.__toESM(node_crypto);
 let crypto$1 = require("crypto");

package/dist/builtins/local-auth/local-auth.addon.mjs

@@ -1,5 +1,5 @@
 import { i as __require, o as __toESM, t as __commonJSMin } from "../../chunk-CNf5ZN-e.mjs";
-import { A as authProviderCapability, Ft as BaseAddon, T as UserRecordSchema, jt as userManagementCapability, r as ApiKeyRecordSchema, x as ScopedTokenSchema } from "../../dist-CCMYMmkQ.mjs";
+import { A as authProviderCapability, Ft as BaseAddon, T as UserRecordSchema, jt as userManagementCapability, r as ApiKeyRecordSchema, x as ScopedTokenSchema } from "../../dist-BLU9Dol1.mjs";
 import * as crypto$2 from "node:crypto";
 import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
 import nodeCrypto from "crypto";

package/dist/builtins/local-network/local-network.addon.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DE3OH-FG.js");
+const require_dist = require("../../dist-0fjBDzUu.js");
 const require_tls = require("../../tls-BxQlomxd.js");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");

package/dist/builtins/local-network/local-network.addon.mjs

@@ -1,4 +1,4 @@
-import { Ft as BaseAddon, sn as EventCategory, st as localNetworkCapability } from "../../dist-CCMYMmkQ.mjs";
+import { Ft as BaseAddon, sn as EventCategory, st as localNetworkCapability } from "../../dist-BLU9Dol1.mjs";
 import { S as readLanHttpState, _ as DEFAULT_LAN_HTTP_PORT, a as writeTlsMode, i as writeExtraSans, l as reissueTlsLeaf, n as readTlsAccessStatus, o as validateUploadedTls, r as readTlsMode, s as ensureTlsCert, t as readExtraSans, y as applyLanHttp } from "../../tls-DOTmtLCW.mjs";
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";

package/dist/builtins/loki-logging/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DE3OH-FG.js");
+const require_dist = require("../../dist-0fjBDzUu.js");
 //#region src/builtins/loki-logging/loki-payload.ts
 /**
 * Loki rejects a label name that is not a valid Prometheus label

package/dist/builtins/loki-logging/index.mjs

@@ -1,4 +1,4 @@
-import { Ft as BaseAddon, ct as logDestinationCapability } from "../../dist-CCMYMmkQ.mjs";
+import { Ft as BaseAddon, ct as logDestinationCapability } from "../../dist-BLU9Dol1.mjs";
 //#region src/builtins/loki-logging/loki-payload.ts
 /**
 * Loki rejects a label name that is not a valid Prometheus label

package/dist/builtins/native-metrics/native-metrics.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DE3OH-FG.js");
+const require_dist = require("../../dist-0fjBDzUu.js");
 let node_fs_promises = require("node:fs/promises");
 let node_child_process = require("node:child_process");
 let node_util = require("node:util");

package/dist/builtins/native-metrics/native-metrics.addon.mjs

@@ -1,4 +1,4 @@
-import { Ft as BaseAddon, Jt as createEvent, Pt as errMsg, Q as foldSnapshotByFunction, _t as reducePoints, dt as metricsProviderCapability, sn as EventCategory, vt as resolveBucketMs } from "../../dist-CCMYMmkQ.mjs";
+import { Ft as BaseAddon, Jt as createEvent, Pt as errMsg, Q as foldSnapshotByFunction, _t as reducePoints, dt as metricsProviderCapability, sn as EventCategory, vt as resolveBucketMs } from "../../dist-BLU9Dol1.mjs";
 import { readFile, readdir } from "node:fs/promises";
 import { execFile, execFileSync } from "node:child_process";
 import { promisify } from "node:util";

package/dist/builtins/platform-probe/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DE3OH-FG.js");
+const require_dist = require("../../dist-0fjBDzUu.js");
 let node_child_process = require("node:child_process");
 let node_util = require("node:util");
 let node_fs = require("node:fs");