@camstack/addon-pipeline 1.2.326 → 1.2.328

package/dist/motion-wasm/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-BTBbIGSC.js");
+const require_dist = require("../dist-wJO7mXeO.js");
 const require_lazy_sharp = require("../lazy-sharp-BuwKlQLR.js");
 let node_fs = require("node:fs");
 let node_path = require("node:path");

package/dist/motion-wasm/index.mjs

@@ -1,4 +1,4 @@
-import { Sn as hydrateSchema, ct as evaluateZoneRules, dn as DeviceType, kt as motionDetectionCapability, mn as BaseAddon } from "../dist-BuU8Y4o1.mjs";
+import { An as hydrateSchema, It as motionDetectionCapability, Sn as BaseAddon, pt as evaluateZoneRules, yn as DeviceType } from "../dist-Bpub2VcJ.mjs";
 import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";

package/dist/{node-UK2v2ZSw.js → node-BCrqaejt.js}

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-emK7D4bc.js");
-const require_dist = require("./dist-BTBbIGSC.js");
+const require_dist = require("./dist-wJO7mXeO.js");
 let node_crypto = require("node:crypto");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs, 1);

package/dist/{node-inZFYgkm.mjs → node-BjCSgD4M.mjs}

@@ -1,4 +1,4 @@
-import { an as Fmp4BoxSplitter, fn as errMsg, ln as isSoftwareDecode, on as buildFfmpegArgs } from "./dist-BuU8Y4o1.mjs";
+import { _n as isSoftwareDecode, bn as errMsg, mn as buildFfmpegArgs, pn as Fmp4BoxSplitter } from "./dist-Bpub2VcJ.mjs";
 import { randomUUID } from "node:crypto";
 import { realpathSync } from "node:fs";
 import path from "node:path";

package/dist/pipeline-runner/index.js

@@ -3,9 +3,9 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-BTBbIGSC.js");
-const require_node = require("../node-UK2v2ZSw.js");
-const require_default_detection_model = require("../default-detection-model-WnGDQAQh.js");
+const require_dist = require("../dist-wJO7mXeO.js");
+const require_node = require("../node-BCrqaejt.js");
+const require_default_detection_model = require("../default-detection-model-1SadEKsW.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_lazy_sharp = require("../lazy-sharp-BuwKlQLR.js");
 const require_restream_intent = require("../restream-intent-7uDNqMKs.js");
@@ -903,10 +903,12 @@ function classifyNativeCropLeaseAge(ageMs, maxAgeMs = NATIVE_CROP_LEASE_MAX_AGE_
 }
 //#endregion
 //#region src/session-decode/native-crop-registry.ts
-var DEFAULT_NATIVE_CROP_REGISTRY_CAP = (() => {
-	const raw = Number(process.env["CAMSTACK_NATIVE_CROP_REGISTRY_CAP"]);
-	return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 4096;
-})();
+/**
+* Default max entries retained across all active decode sessions on a node
+* (64 → 256 → 4096; see the class doc for the two windows the cap has been
+* sized to).
+*/
+var DEFAULT_NATIVE_CROP_REGISTRY_CAP = 4096;
 /** Invoke a requester's best-effort `release()`, swallowing any transport error. */
 function safeRelease(request) {
 	try {
@@ -1173,20 +1175,6 @@ function createRetainedContentFallback(registry, ref) {
 		}
 	} };
 }
-//#endregion
-//#region src/session-decode/parked-frame-store.ts
-/** Per-camera parcel bound. 24 live tracks × two kinds on one camera is a
-*  crowd scene; past that the camera's oldest parcel leaves first. Read ONCE
-*  from `CAMSTACK_PARKED_FRAMES_PER_DEVICE`. */
-var PARKED_FRAMES_PER_DEVICE_MAX = (() => {
-	const raw = Number(process.env["CAMSTACK_PARKED_FRAMES_PER_DEVICE"]);
-	return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 48;
-})();
-/** {@link PARKED_FRAME_BUDGET_MB} in bytes. */
-var PARKED_FRAME_BUDGET_BYTES = (() => {
-	const raw = Number(process.env["CAMSTACK_PARKED_FRAME_MB"]);
-	return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 64;
-})() * 1024 * 1024;
 function keyOf$1(deviceId, trackId, kind) {
 	return `${deviceId}|${trackId}|${kind}`;
 }
@@ -1203,8 +1191,8 @@ var ParkedFrameStore = class {
 	perDeviceKeys = /* @__PURE__ */ new Map();
 	totalBytes = 0;
 	constructor(options = {}) {
-		this.budgetBytes = options.budgetBytes ?? PARKED_FRAME_BUDGET_BYTES;
-		this.perDeviceMax = options.perDeviceMax ?? PARKED_FRAMES_PER_DEVICE_MAX;
+		this.budgetBytes = options.budgetBytes ?? 67108864;
+		this.perDeviceMax = options.perDeviceMax ?? 48;
 		this.maxAgeMs = options.maxAgeMs ?? 6e5;
 		this.now = options.now ?? Date.now;
 		this.onEvict = options.onEvict;
@@ -1389,47 +1377,6 @@ var PartitionedParkedFrameStore = class {
 		this.faceSource.clear();
 	}
 };
-/** {@link RETAINED_FRAME_BUDGET_MB} in bytes. */
-var RETAINED_FRAME_BUDGET_BYTES = (() => {
-	const raw = Number(process.env["CAMSTACK_SESSION_RETAIN_MB"]);
-	return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 160;
-})() * 1024 * 1024;
-/**
-* How many of each device's MOST RECENT frames are protected from a busy
-* neighbour's budget eviction. Sized to cover the late two-plane / cross-process
-* enrichment horizon (~150-500 ms) at the REAL delivered rate: the store writes
-* every DELIVERED rgb frame, and a high-fps camera delivers ~25 fps (observed on
-* the 4K outdoor cams), so the old floor of 6 protected only ~240 ms there and
-* its late captures hit "frame recycled before resolve" (2026-07-22 triage —
-* missing thumbnails/firstFrames concentrated on exactly those cameras).
-* 16 frames ≈ 0.64 s @25 fps (1.6 s @10 fps). Only ACTIVE cameras hold frames,
-* so the worst-case protected footprint stays well inside the byte budget for
-* realistic concurrency (4 active cams ≈ 44 MB of 160); the hard ceiling always
-* overrides the floor regardless. Read ONCE from `CAMSTACK_SESSION_RETAIN_FLOOR`;
-* `0` disables the floor (pure global FIFO — the pre-2026-07-19 behaviour).
-*/
-var RETAINED_FRAME_PER_DEVICE_FLOOR = (() => {
-	const raw = Number(process.env["CAMSTACK_SESSION_RETAIN_FLOOR"]);
-	return Number.isFinite(raw) && raw >= 0 ? Math.floor(raw) : 16;
-})();
-/**
-* TIME-based per-device protection (2026-07-23 cold-window fix): a frame
-* YOUNGER than this survives budget eviction regardless of how many frames
-* its device holds. The COUNT floor above protects a fixed number of frames —
-* but the wall-clock window that buys depends on the delivered fps (16 frames
-* = 1.6 s @10 fps but only 0.64 s @25 fps, and the 4K street cams deliver
-* ~25). The late-capture horizon is TIME (session attach + enrichment +
-* round-trip ≈ 0.5–1.5 s, worst on cold on-motion dials), so the guarantee
-* must be time-denominated: 12/13 of the zero-media/missing-firstFrame tracks
-* in the 2026-07-23 audit were ≤6 s cold-session subjects whose handles were
-* recycled before their first captures ran. Bounded by the hard byte ceiling
-* (pass 2) exactly like the count floor — worst case ~26 MB per ACTIVE camera
-* @25 fps. `CAMSTACK_SESSION_RETAIN_FLOOR_MS`; `0` disables (count floor only).
-*/
-var RETAINED_FRAME_TIME_FLOOR_MS = (() => {
-	const raw = Number(process.env["CAMSTACK_SESSION_RETAIN_FLOOR_MS"]);
-	return Number.isFinite(raw) && raw >= 0 ? Math.floor(raw) : 3e3;
-})();
 /** Opaque RAM-key prefix stamped into a retained frame's `FrameHandle.shmId`. */
 var RETAINED_FRAME_KEY_PREFIX = "ram:";
 /** A retention frame is uniquely identified by its key + slot + committed seq. */
@@ -1468,9 +1415,9 @@ var RetainedFrameStore = class RetainedFrameStore {
 	static SLOT_SPREAD = 1024;
 	constructor(options) {
 		this.nodeId = options.nodeId;
-		this.budgetBytes = options.budgetBytes ?? RETAINED_FRAME_BUDGET_BYTES;
-		this.perDeviceFloor = options.perDeviceFloor ?? RETAINED_FRAME_PER_DEVICE_FLOOR;
-		this.timeFloorMs = options.timeFloorMs ?? RETAINED_FRAME_TIME_FLOOR_MS;
+		this.budgetBytes = options.budgetBytes ?? 167772160;
+		this.perDeviceFloor = options.perDeviceFloor ?? 16;
+		this.timeFloorMs = options.timeFloorMs ?? 3e3;
 		this.now = options.now ?? Date.now;
 		this.onEvict = options.onEvict;
 	}
@@ -2029,6 +1976,154 @@ function onboardRootDetections(slot, frame, gate) {
 	};
 }
 //#endregion
+//#region src/pipeline-runner/label-link.ts
+/**
+* The runner's half of the detector ↔ step label link (D715).
+*
+* The runner holds the camera's WHOLE step tree (the attach config), so it is
+* the one place that can answer "who writes this effect?" for a camera: the
+* root model's declaration (`fillsClassifierEffects`) against the filled
+* step's own `labelLink` policy and class list (`resolveLabelLink`). Three
+* consumers read that one answer:
+*
+*  - the frame result — a linked label the executor wrote at score 0 is raised
+*    to the detection's score when the detector is authoritative;
+*  - the `detailSteps` announce — a skipped classifier is announced with
+*    `filledBy`, so post-analysis does not dispatch it for a subject the
+*    detector already named;
+*  - `package-detection` — when the root fills it, the package root is not
+*    dispatched at all and the root's own `package` boxes ARE the package
+*    result (the operator's package threshold moves onto the root's gate, and
+*    the frame says it looked).
+*
+* Pure: the caller passes the model resolver; no I/O, no clock.
+*/
+/** The root step the fills are read from — the always-on camera root. */
+var LABEL_LINK_ROOT_STEP_ID = "object-detection";
+var PACKAGE_STEP_ID = "package-detection";
+var PACKAGE_THRESHOLD_KEY = "minConfidencePackage";
+var EMPTY_LABEL_LINK_PLAN = { decisions: /* @__PURE__ */ new Map() };
+function findStep(steps, addonId) {
+	for (const step of steps) {
+		if (step.addonId === addonId) return step;
+		const nested = step.children !== void 0 ? findStep(step.children, addonId) : void 0;
+		if (nested !== void 0) return nested;
+	}
+}
+/**
+* Plan a camera's label links from its configured tree. A root with no pinned
+* model runs the static default — a COCO model, which fills nothing.
+*/
+function planLabelLinks(steps, resolveModel) {
+	if (steps === void 0) return EMPTY_LABEL_LINK_PLAN;
+	const root = steps.find((s) => s.addonId === "object-detection" && s.enabled !== false);
+	if (root?.modelId === void 0) return EMPTY_LABEL_LINK_PLAN;
+	const fills = resolveModel("object-detection", root.modelId)?.fillsClassifierEffects ?? [];
+	if (fills.length === 0) return {
+		rootModelId: root.modelId,
+		decisions: /* @__PURE__ */ new Map()
+	};
+	const decisions = /* @__PURE__ */ new Map();
+	for (const fill of fills) {
+		const step = findStep(steps, fill.stepId);
+		decisions.set(fill.stepId, require_dist.resolveLabelLink(fill, step === void 0 ? void 0 : {
+			enabled: step.enabled !== false,
+			...step.settings !== void 0 ? { settings: step.settings } : {}
+		}));
+	}
+	return {
+		rootModelId: root.modelId,
+		decisions
+	};
+}
+/** Steps this plan says must not be dispatched, with the model that fills them. */
+function filledStepIds(plan) {
+	const out = /* @__PURE__ */ new Map();
+	if (plan.rootModelId === void 0) return out;
+	for (const [stepId, decision] of plan.decisions) if (decision.skip) out.set(stepId, plan.rootModelId);
+	return out;
+}
+function raiseLinkedLabels(detection, plan) {
+	let changed = false;
+	const labels = detection.labels.map((label) => {
+		const stepId = require_dist.linkedStepOf(label.stepId);
+		if (stepId === void 0 || plan.decisions.get(stepId)?.authoritative !== true) return label;
+		if (label.score === detection.score) return label;
+		changed = true;
+		return {
+			...label,
+			score: detection.score
+		};
+	});
+	return changed ? labels : void 0;
+}
+/**
+* Raise each linked label to its detection's score where the detector is the
+* authoritative writer of that effect. Every other linked label stays the
+* score-0 fallback the executor wrote. Never mutates; returns the input when
+* nothing changes.
+*/
+function applyLabelLinkAuthority(result, plan) {
+	if (plan.decisions.size === 0) return result;
+	let changed = false;
+	const detections = result.detections.map((d) => {
+		const labels = raiseLinkedLabels(d, plan);
+		if (labels === void 0) return d;
+		changed = true;
+		return {
+			...d,
+			labels
+		};
+	});
+	return changed ? {
+		...result,
+		detections
+	} : result;
+}
+/** The root step's schema default for its class allow-list. */
+function rootDefaultMacroClasses() {
+	const field = require_default_detection_model.getStep(LABEL_LINK_ROOT_STEP_ID).getConfigSchema().find((f) => "key" in f && f.key === "enabledMacroClasses");
+	const value = field !== void 0 && "default" in field ? field.default : void 0;
+	return Array.isArray(value) ? value : [];
+}
+function withPackageAdmitted(root, packageStep) {
+	const settings = root.settings ?? {};
+	const stored = settings["enabledMacroClasses"];
+	const enabled = Array.isArray(stored) ? stored : rootDefaultMacroClasses();
+	const admitted = enabled.length > 0 && !enabled.includes("package") ? { enabledMacroClasses: [...enabled, "package"] } : {};
+	const threshold = packageStep.settings?.[PACKAGE_THRESHOLD_KEY];
+	const gate = typeof threshold === "number" ? { [PACKAGE_THRESHOLD_KEY]: threshold } : {};
+	return {
+		...root,
+		settings: {
+			...settings,
+			...admitted,
+			...gate
+		}
+	};
+}
+/**
+* When the root fills `package-detection` and that step's policy lets it be
+* skipped, drop the package root from the dispatch and let the camera root
+* report packages: its gate admits `package` at the package step's threshold.
+* Otherwise the tree is returned untouched.
+*/
+function applyPackageFill(steps, plan) {
+	if (plan.decisions.get(PACKAGE_STEP_ID)?.skip !== true) return {
+		steps,
+		filledByRoot: false
+	};
+	const packageStep = steps.find((s) => s.addonId === PACKAGE_STEP_ID);
+	if (packageStep === void 0) return {
+		steps,
+		filledByRoot: false
+	};
+	return {
+		steps: steps.filter((s) => s.addonId !== PACKAGE_STEP_ID).map((s) => s.addonId === "object-detection" && s.enabled !== false ? withPackageAdmitted(s, packageStep) : s),
+		filledByRoot: true
+	};
+}
+//#endregion
 //#region src/pipeline-runner/bench-step-schema.ts
 /**
 * Shared bench-facing schemas: the minimal recursive step tree. Extracted from
@@ -4545,9 +4640,9 @@ var PACKAGE_DETECTION_STEP_ID = "package-detection";
 * through) and the frame was not shed. Post-analysis reads it as "an empty
 * doormat on this frame is an ABSENCE, not silence" (D687). Never mutates.
 */
-function withPackageLook(result, dispatched) {
+function withPackageLook(result, dispatched, filledByRoot = false) {
 	if (result.shed === true) return result;
-	return dispatched.some((s) => s.addonId === "package-detection" && s.enabled !== false) ? {
+	return filledByRoot || dispatched.some((s) => s.addonId === "package-detection" && s.enabled !== false) ? {
 		...result,
 		packageLooked: true
 	} : result;
@@ -5933,12 +6028,10 @@ var PipelineRunner = class {
 		}, (registration.occupancyRecheckSec ?? 0) * 1e3);
 		if (initialPhase === "active") {
 			this.detectionStreamHandler?.(deviceId, "subscribe");
-			const cooldownMs = registration.motionCooldownMs ?? DEFAULT_MOTION_COOLDOWN_MS;
 			this.config.onPhaseChanged?.(deviceId, "active", {
-				source: "analyzer",
-				regions: void 0,
+				cause: "attach",
 				timestamp: Date.now(),
-				cooldownMs
+				...registration.sessionTrigger !== void 0 ? { trigger: registration.sessionTrigger } : {}
 			});
 		}
 	}
@@ -5953,7 +6046,13 @@ var PipelineRunner = class {
 			clearInterval(state.occupancyTimer);
 			state.occupancyTimer = null;
 		}
-		if (state.phase === "active") this.detectionStreamHandler?.(deviceId, "unsubscribe");
+		if (state.phase === "active") {
+			this.detectionStreamHandler?.(deviceId, "unsubscribe");
+			this.config.onPhaseChanged?.(deviceId, "watching", {
+				cause: "detach",
+				timestamp: Date.now()
+			});
+		}
 		state.motionQueue.clear();
 		this.discardQueuedDetectionFrames(deviceId, state, "detach");
 		this.timingSampler.clearDroppedFramesSource(deviceId);
@@ -6324,6 +6423,7 @@ var PipelineRunner = class {
 		});
 		this.detectionStreamHandler?.(deviceId, "subscribe");
 		this.config.onPhaseChanged?.(deviceId, "active", {
+			cause: "motion",
 			source,
 			regions,
 			timestamp: Date.now(),
@@ -6345,6 +6445,7 @@ var PipelineRunner = class {
 		this.detectionStreamHandler?.(deviceId, "unsubscribe");
 		const source = state.lastArmedSource ?? "analyzer";
 		this.config.onPhaseChanged?.(deviceId, "watching", {
+			cause: "motion",
 			source,
 			regions: void 0,
 			timestamp: Date.now(),
@@ -7159,6 +7260,25 @@ var DETECTION_REDIAL_GIVEUP_WINDOW_MS = 6e4;
 * NOTHING — see D453 for what that costs and why it was not taken either.
 */
 /**
+* The source fields a `DetectionPhaseTransition` carries, per cause. A motion
+* transition: its source and cooldown. A session attach: the motion that opened
+* it, as the orchestrator dispatched it — absent when it sent none. A detach:
+* nothing.
+*/
+function phaseTransitionSourceFields(meta) {
+	if (meta.cause === "motion") return {
+		source: meta.source,
+		cooldownMs: meta.cooldownMs
+	};
+	if (meta.cause === "detach" || meta.trigger === void 0) return {};
+	const { source, triggeredBy, sensorName } = meta.trigger;
+	return {
+		source,
+		triggeredBy,
+		...sensorName !== void 0 ? { sensorName } : {}
+	};
+}
+/**
 * Pure decision helper: returns `true` when a dynamic frame-diff analyzer
 * subscription should be opened for an onboard-motion camera.
 *
@@ -7222,20 +7342,23 @@ function isDetailPlaneStepId(stepId) {
 * Extracted as a pure function so the unit suite can exercise the
 * derivation without instantiating the full addon.
 */
-function deriveDetailSteps(steps) {
+function deriveDetailSteps(steps, plan = EMPTY_LABEL_LINK_PLAN) {
 	const stepIds = /* @__PURE__ */ new Set();
 	collectEnabledStepIds(steps, stepIds);
+	const filled = filledStepIds(plan);
 	const announces = [];
 	for (const stepId of stepIds) {
 		const def = tryGetStepDefinition(stepId);
 		if (!def || def.inputClasses === null) continue;
+		const filledBy = filled.get(def.id);
 		announces.push({
 			stepId: def.id,
 			inputClasses: def.inputClasses,
 			cadence: def.cadence ?? {
 				trigger: "once",
 				maxPerTrack: 3
-			}
+			},
+			...filledBy !== void 0 ? { filledBy } : {}
 		});
 	}
 	return announces;
@@ -8714,6 +8837,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		runner.registerCamera(config.deviceId, {
 			detectionMode: config.detectionMode,
 			...config.detectionSources !== void 0 ? { detectionSources: config.detectionSources } : {},
+			...config.sessionTrigger !== void 0 ? { sessionTrigger: config.sessionTrigger } : {},
 			...require_default_detection_model.rootObjectGate(config.steps) !== void 0 ? { objectGate: require_default_detection_model.rootObjectGate(config.steps) } : {},
 			fps: config.detectionFps,
 			motionCooldownMs: config.motionCooldownMs,
@@ -9550,6 +9674,42 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	* read synchronously by the placement.
 	*/
 	customModels = new require_default_detection_model.CustomModelCatalog({ warn: (message, extras) => this.ctxIfReady?.logger.warn(message, extras) });
+	/**
+	* Per camera, the label-link plan (D715) and the announce derived from it,
+	* keyed on the two inputs it reads: the attach tree and the custom-model
+	* snapshot (a Frigate+ root is a custom model). Recomputed when either
+	* changes identity — at most once per catalog refresh.
+	*/
+	labelLinkCache = /* @__PURE__ */ new Map();
+	/** The camera's label-link plan; logs once per change of what is filled. */
+	labelLinkPlanFor(deviceId, steps) {
+		const byStep = this.customModels.current();
+		const cached = this.labelLinkCache.get(deviceId);
+		if (cached !== void 0 && cached.steps === steps && cached.byStep === byStep) return cached.plan;
+		const plan = planLabelLinks(steps, (stepId, modelId) => this.customModels.stepDefinition(stepId)?.models.find((m) => m.id === modelId));
+		const announces = deriveDetailSteps(steps, plan);
+		this.labelLinkCache.set(deviceId, {
+			steps,
+			byStep,
+			plan,
+			announces
+		});
+		const describe = (p) => p === void 0 ? "" : [...p.decisions].map(([id, d]) => `${id}:${d.skip ? "skip" : d.authoritative ? "sole" : "fallback"}`).join(",");
+		if (describe(cached?.plan) !== describe(plan) && plan.decisions.size > 0) this.ctxIfReady?.logger.info("label link: the root model fills pipeline steps", {
+			tags: { deviceId },
+			meta: {
+				rootModelId: plan.rootModelId ?? null,
+				steps: [...plan.decisions].map(([stepId, d]) => ({
+					stepId,
+					policy: d.policy,
+					authoritative: d.authoritative,
+					skip: d.skip,
+					openGaps: d.openGaps
+				}))
+			}
+		});
+		return plan;
+	}
 	cropConvention = new CropConventionSource({ logger: {
 		info: (message, extras) => this.ctxIfReady?.logger.info(message, extras),
 		warn: (message, extras) => this.ctxIfReady?.logger.warn(message, extras)
@@ -9945,6 +10105,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		this.lastDecodeUnexpectedEndAt.delete(deviceId);
 		this.packageGovernor.forget(deviceId);
 		this.packageGateSkips.delete(deviceId);
+		this.labelLinkCache.delete(deviceId);
 		this.packageZoneUnionByDevice.delete(deviceId);
 		this.packageZoneUnionAt.delete(deviceId);
 		this.lastMotionNearPackageZone.delete(deviceId);
@@ -10341,7 +10502,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			acquire: () => this.acquireSessionDecodeRestream(api, config.deviceId, config.detectionStreamId, `session-decode:detect:${config.deviceId}`, resolveSessionDecodeHostname(config, process.env["CAMSTACK_HUB_URL"]), resolveSessionDecodeOwnerNodeId(config), true),
 			startPump: (source, hooks) => {
 				const dialMs = Date.now() - requestedAt;
-				const useLocalFrameRef = this.executorCoLocated() && process.env["CAMSTACK_DISABLE_LOCAL_FRAME_REF"] !== "1";
+				const useLocalFrameRef = this.executorCoLocated();
 				log.info("session-decode: detection routed through per-session decode worker (rgb)", { meta: {
 					streamId: config.detectionStreamId,
 					codec: source.codec,
@@ -10601,9 +10762,11 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	* The phase is NOT the camera's motion and writes no `motion` runtime slice
 	* (D696). Every on-motion detection session attaches `always-on`, so the
 	* phase reads `active` for a whole session, and an always-on camera is
-	* `active` for as long as it is attached; a detach writes nothing at all.
+	* `active` for as long as it is attached (`cause: 'attach'`), and returns to
+	* `watching` on detach (`cause: 'detach'`) — neither names a motion source.
 	* The slice it used to write was therefore "a session is attached", and was
-	* left `detected: true` after every session. The orchestrator is the only
+	* left `detected: true` after every session (the detach close of the EVENT
+	* did not exist either until 2026-10-06). The orchestrator is the only
 	* writer of that slice, with the EFFECTIVE motion, and this runner says so
 	* on `getLocalLoad().motionSliceWriter` so that it never writes the slice
 	* while a runner older than D696 still does.
@@ -10617,8 +10780,8 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				from: detected ? "watching" : "active",
 				to: detected ? "active" : "watching",
 				reason: detected ? "motion_detected" : "cooldown_expired",
-				source: meta.source,
-				cooldownMs: meta.cooldownMs,
+				cause: meta.cause,
+				...phaseTransitionSourceFields(meta),
 				timestamp: meta.timestamp
 			};
 			this.ctx.eventBus.emit(require_dist.createEvent(require_dist.EventCategory.DetectionPhaseTransition, {
@@ -10658,8 +10821,10 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			return null;
 		}
 		if (steps.length === 0) return null;
-		let dispatchSteps = steps;
-		if (steps.some((s) => s.addonId === "package-detection" && s.enabled !== false)) {
+		const labelLinkPlan = this.labelLinkPlanFor(deviceId, steps);
+		const packageFill = applyPackageFill(steps, labelLinkPlan);
+		let dispatchSteps = packageFill.steps;
+		if (dispatchSteps.some((s) => s.addonId === "package-detection" && s.enabled !== false)) {
 			this.refreshPackageZoneUnion(deviceId);
 			const motionInZone = this.lastMotionNearPackageZone.get(deviceId) ?? this.lastAnalyzerDetected.get(deviceId) ?? false;
 			const decision = this.packageGovernor.evaluate({
@@ -10669,7 +10834,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			});
 			const skipped = this.packageGateSkips.get(deviceId) ?? 0;
 			if (!decision.run) {
-				dispatchSteps = steps.filter((s) => s.addonId !== PACKAGE_DETECTION_STEP_ID);
+				dispatchSteps = dispatchSteps.filter((s) => s.addonId !== PACKAGE_DETECTION_STEP_ID);
 				if (skipped === 0) log.info("package-detection gated off by the motion-settle governor", {
 					tags: { deviceId },
 					meta: { motionInZone: this.lastAnalyzerDetected.get(deviceId) ?? false }
@@ -10746,7 +10911,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			return null;
 		}
 		if (result === null) return null;
-		const looked = withPackageLook(result, dispatchSteps);
+		const looked = withPackageLook(applyLabelLinkAuthority(result, labelLinkPlan), dispatchSteps, packageFill.filledByRoot);
 		return this.recoverSmallSubjects(deviceId, frame, looked, dispatchSteps, camConfig?.deviceKey);
 	}
 	/**
@@ -11393,7 +11558,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			...this.liveWorkerSlotWaiter(deviceId),
 			acquire: () => this.acquireSessionDecodeRestream(api, config.deviceId, config.detectionStreamId, `session-decode:occupancy:${config.deviceId}`, resolveSessionDecodeHostname(config, process.env["CAMSTACK_HUB_URL"]), resolveSessionDecodeOwnerNodeId(config)),
 			startPump: (source, hooks) => {
-				const useLocalFrameRef = this.executorCoLocated() && process.env["CAMSTACK_DISABLE_LOCAL_FRAME_REF"] !== "1";
+				const useLocalFrameRef = this.executorCoLocated();
 				return startSessionDecodePump({
 					fork: this.forkDecodeWorkerWithLease,
 					lease: this.resolveSessionLeaseKnobs,
@@ -11443,7 +11608,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	emitInferenceResult(deviceId, frame, result, handle, source, occasion) {
 		if (!this.ctx?.eventBus) return;
 		const capturedAt = frame.capturedAt;
-		const detailSteps = this.attached.get(deviceId)?.detailSteps;
+		const detailSteps = this.labelLinkCache.get(deviceId)?.announces ?? this.attached.get(deviceId)?.detailSteps;
 		const payload = {
 			deviceId,
 			frame: result,
@@ -11638,6 +11803,7 @@ exports.cameraOwnsMotionViaSensor = require_dist.cameraOwnsMotionViaSensor;
 exports.customActions = pipelineRunnerBenchActions;
 exports.default = PipelineRunnerAddon;
 exports.deriveDetailSteps = deriveDetailSteps;
+exports.phaseTransitionSourceFields = phaseTransitionSourceFields;
 exports.resolveMotionFrameSource = resolveMotionFrameSource;
 exports.resolveSessionDecodeHostname = resolveSessionDecodeHostname;
 exports.resolveSessionDecodeOwnerNodeId = resolveSessionDecodeOwnerNodeId;