@camstack/system 1.2.184 → 1.2.186

package/dist/addon-runner.js

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-Cek0wNdY.js");
-const require_manifest_system_deps = require("./manifest-system-deps-DMWd5Ygf.js");
+const require_manifest_system_deps = require("./manifest-system-deps-KBuTXH-y.js");
 const require_custom_action_registry = require("./custom-action-registry-jY0NOZK8.js");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);

package/dist/addon-runner.mjs

@@ -1,4 +1,4 @@
-import { A as createUdsLoggerWithControl, Ft as RUNNER_RSS_BUDGET_ENV, Jt as startRunnerHeapWatch, Qt as emitHeapDiagnosticReport, a as createUdsAddonContext, bt as resolveAddonClass, it as setWorkerNativeCapsChangeListener, j as LocalChildClient, n as installManifestPythonDeps, nt as getWorkerNativeCapSnapshot, ot as validateProviderRegistrations, t as installManifestSystemDeps, tt as getWorkerNativeCapProvider, yt as installManifestNativeDeps } from "./manifest-system-deps-BmXFnBQZ.mjs";
+import { A as createUdsLoggerWithControl, Ft as RUNNER_RSS_BUDGET_ENV, Jt as startRunnerHeapWatch, Qt as emitHeapDiagnosticReport, a as createUdsAddonContext, bt as resolveAddonClass, it as setWorkerNativeCapsChangeListener, j as LocalChildClient, n as installManifestPythonDeps, nt as getWorkerNativeCapSnapshot, ot as validateProviderRegistrations, t as installManifestSystemDeps, tt as getWorkerNativeCapProvider, yt as installManifestNativeDeps } from "./manifest-system-deps-BF-C5NDL.mjs";
 import { t as CustomActionRegistry } from "./custom-action-registry-F__gp_VX.mjs";
 import { register } from "node:module";
 import * as path$1 from "node:path";

package/dist/builtins/addon-pages-aggregator/addon-pages-aggregator.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");
 const require_settle_sources = require("../../settle-sources-Bhsy57y-.js");
 let node_crypto = require("node:crypto");
 let node_path = require("node:path");

package/dist/builtins/addon-pages-aggregator/addon-pages-aggregator.addon.mjs

@@ -1,4 +1,4 @@
-import { E as addonPagesCapability, Ft as BaseAddon, Pt as errMsg, sn as EventCategory } from "../../dist-CCMYMmkQ.mjs";
+import { E as addonPagesCapability, Ft as BaseAddon, Pt as errMsg, sn as EventCategory } from "../../dist-BLU9Dol1.mjs";
 import { t as settleSourcesWithTimeout } from "../../settle-sources-CDtNC8ub.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import * as path$1 from "node:path";

package/dist/builtins/addon-widgets-aggregator/addon-widgets-aggregator.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");
 const require_settle_sources = require("../../settle-sources-Bhsy57y-.js");
 let node_crypto = require("node:crypto");
 let node_path = require("node:path");

package/dist/builtins/addon-widgets-aggregator/addon-widgets-aggregator.addon.mjs

@@ -1,4 +1,4 @@
-import { Ft as BaseAddon, O as addonWidgetsCapability, Pt as errMsg, sn as EventCategory } from "../../dist-CCMYMmkQ.mjs";
+import { Ft as BaseAddon, O as addonWidgetsCapability, Pt as errMsg, sn as EventCategory } from "../../dist-BLU9Dol1.mjs";
 import { t as settleSourcesWithTimeout } from "../../settle-sources-CDtNC8ub.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import * as path$1 from "node:path";

package/dist/builtins/alerts/alerts.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/alerts/prune-policy.ts
 /**
 * Ids older than `cutoffMs`, oldest first.

package/dist/builtins/alerts/alerts.addon.mjs

@@ -1,4 +1,4 @@
-import { Ft as BaseAddon, Jt as createEvent, Pt as errMsg, k as alertsCapability, n as AlertSchema, sn as EventCategory } from "../../dist-CCMYMmkQ.mjs";
+import { Ft as BaseAddon, Jt as createEvent, Pt as errMsg, k as alertsCapability, n as AlertSchema, sn as EventCategory } from "../../dist-BLU9Dol1.mjs";
 //#region src/builtins/alerts/prune-policy.ts
 /**
 * Ids older than `cutoffMs`, oldest first.

package/dist/builtins/backup-orchestrator/backup-orchestrator.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");
 let buffer = require("buffer");
 let node_fs_promises = require("node:fs/promises");

package/dist/builtins/backup-orchestrator/backup-orchestrator.addon.mjs

@@ -1,4 +1,4 @@
-import { Ft as BaseAddon, j as backupCapability, sn as EventCategory } from "../../dist-CCMYMmkQ.mjs";
+import { Ft as BaseAddon, j as backupCapability, sn as EventCategory } from "../../dist-BLU9Dol1.mjs";
 import { randomBytes, randomUUID } from "node:crypto";
 import { Buffer as Buffer$1 } from "buffer";
 import * as fsp from "node:fs/promises";

package/dist/builtins/console-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");
 const require_formatter = require("../../formatter-DqAKDlvN.js");
 //#region src/builtins/console-logging/console-destination.ts
 var LEVEL_RANK = {

package/dist/builtins/console-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";
 import { t as formatLogLine } from "../../formatter-B7qW8bPJ.mjs";
 //#region src/builtins/console-logging/console-destination.ts
 var LEVEL_RANK = {

package/dist/builtins/core-blocks/core-blocks.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");
 let node_crypto = require("node:crypto");
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = require_chunk.__toESM(node_fs_promises);

package/dist/builtins/core-blocks/core-blocks.addon.mjs

@@ -1,4 +1,4 @@
-import { Ft as BaseAddon, I as coreBlockAddonId, L as coreBlockIdFromAddonId, Pt as errMsg, R as coreBlocksCapability, c as CORE_BLOCK_ADDON_PREFIX, d as DeclaredDevices, l as CoreBlockSchema, s as CORE_BLOCKS_ADDON_ID } from "../../dist-CCMYMmkQ.mjs";
+import { Ft as BaseAddon, I as coreBlockAddonId, L as coreBlockIdFromAddonId, Pt as errMsg, R as coreBlocksCapability, c as CORE_BLOCK_ADDON_PREFIX, d as DeclaredDevices, l as CoreBlockSchema, s as CORE_BLOCKS_ADDON_ID } from "../../dist-BLU9Dol1.mjs";
 import { randomUUID } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path$1 from "node:path";

package/dist/builtins/device-manager/device-linked-devices.d.ts

@@ -64,6 +64,26 @@ export declare function resolveLinkedDeviceIds(params: {
 export declare function resolveTrackedEventDeviceIds(config: Record<string, unknown>, linkedIds: readonly number[]): readonly number[];
 /** The single resolved answer, before it is tagged with its camera. */
 export type ResolvedLinkedDevices = Awaited<ReturnType<IDeviceManagerProvider['getLinkedDevices']>>;
+/**
+ * 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.
+ */
+export declare function findLocationInvisibleContainers(params: {
+    readonly selfId: number;
+    readonly selfLocation: string | null;
+    readonly resolvedIds: ReadonlySet<number>;
+    readonly candidates: readonly LinkCandidate[];
+}): readonly number[];
 /** Cap implementation of `getLinkedDevices`. */
 export declare function getLinkedDevices(pctx: ProviderContext, input: Parameters<IDeviceManagerProvider['getLinkedDevices']>[0]): ReturnType<IDeviceManagerProvider['getLinkedDevices']>;
 /**

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

@@ -3,8 +3,8 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DE3OH-FG.js");
-const require_retired_settings_keys = require("../../retired-settings-keys-BgUS9Rr3.js");
+const require_dist = require("../../dist-0fjBDzUu.js");
+const require_retired_settings_keys = require("../../retired-settings-keys-pL2Nq6KT.js");
 let node_crypto = require("node:crypto");
 let _camstack_types_node = require("@camstack/types/node");
 //#region src/builtins/device-manager/adoption-job-engine.ts
@@ -2172,6 +2172,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 !== require_dist.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
@@ -2209,7 +2294,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
@@ -2235,10 +2323,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
@@ -3525,6 +3617,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 !== require_dist.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 === require_dist.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: (0, node_crypto.randomUUID)(),
+				timestamp: /* @__PURE__ */ new Date(),
+				source: {
+					type: "device",
+					id: ancestorId
+				},
+				category: require_dist.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 —
@@ -3728,7 +4029,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;
@@ -3740,6 +4041,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,
@@ -3747,21 +4052,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: (0, node_crypto.randomUUID)(),
+			timestamp: /* @__PURE__ */ new Date(),
+			source: {
+				type: "device",
+				id: changedId
+			},
+			category: require_dist.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: (0, node_crypto.randomUUID)(),
 		timestamp: /* @__PURE__ */ new Date(),
@@ -6353,7 +6706,8 @@ var DeviceManagerAddon = class extends require_dist.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,
@@ -6368,6 +6722,11 @@ var DeviceManagerAddon = class extends require_dist.BaseAddon {
 				return provider;
 			}
 		};
+		try {
+			await runLocationBackfillAtBoot(pctx, bootRows);
+		} catch (err) {
+			this.ctx.logger.warn("location backfill failed — fleet boots without it", { meta: { error: require_dist.errMsg(err) } });
+		}
 		const provider = {
 			resolveDeviceOwnerSync: (deviceId) => resolveDeviceOwnerSync(pctx, deviceId),
 			resolveNativeCapOwnerSync: (capName, deviceId) => resolveNativeCapOwnerSync(pctx, capName, deviceId),