@camstack/addon-pipeline 1.2.219 → 1.2.221

package/dist/pipeline-runner/index.js

@@ -2,19 +2,20 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-wtNhtVVo.js");
-const require_node = require("../node-BduNi21Z.js");
-const require_default_detection_model = require("../default-detection-model-d7-Q_LMo.js");
-const require_worker_protocol = require("../worker-protocol-iWTFnnUM.js");
+const require_chunk = require("../chunk-emK7D4bc.js");
+const require_dist = require("../dist-ATDfcxgL.js");
+const require_node = require("../node-C5jnTgpv.js");
+const require_default_detection_model = require("../default-detection-model-B1NT1A38.js");
+const require_worker_protocol = require("../worker-protocol-B2MfQLlu.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
-const require_lazy_sharp = require("../lazy-sharp-zoQ07I43.js");
+const require_lazy_sharp = require("../lazy-sharp-BuwKlQLR.js");
 const require_restream_intent = require("../restream-intent-B1Difcnq.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
 let node_os = require("node:os");
-node_os = require_dist.__toESM(node_os);
+node_os = require_chunk.__toESM(node_os);
 let node_child_process = require("node:child_process");
 let sharp = require("sharp");
-sharp = require_dist.__toESM(sharp);
+sharp = require_chunk.__toESM(sharp);
 let node_url = require("node:url");
 let node_perf_hooks = require("node:perf_hooks");
 let _camstack_system_addon_utils = require("@camstack/system/addon-utils");
@@ -73,26 +74,23 @@ function wrapChild(child, onExit) {
 * signature (it forwards the same source in the subsequent `start` message);
 * the child entry itself is source-independent, so it is not consumed here.
 *
-* `leaseOverride` carries the operator's cluster-wide native-lease settings
-* (`pipeline-orchestrator` globals, read by `native-lease-settings-source.ts`)
-* into the child as environment variables — the child constructs its lease
-* store and demand gate at module load, before the first `start` message, so
-* the values have to be present at spawn. Only the knobs the operator actually
-* SET are emitted, which is what keeps the pre-settings env override
-* (`CAMSTACK_SESSION_NATIVE_LEASE_*`) working for the untouched ones; see
-* `native-lease-config.ts` for the full precedence.
+* The fork carries NO configuration. Until D453 it spread a set of
+* `*_SETTING` env vars in, because the child resolved its native-lease knobs
+* at module load; the knobs now travel on the `start` message
+* (`WorkerRequest.lease`), resolved in this process. That is what makes a
+* decode worker forkable BEFORE anyone knows which camera it will serve — a
+* child configured at spawn is a child bound to the configuration it was born
+* with — and it is what let the child bundle drop the Zod schemas that cost
+* every fork ~170 ms and ~100 MB of heap (D453).
 *
 * The inherited environment is SPREAD, never replaced: this child resolves
 * node-av through `CAMSTACK_FRAMEWORK_DIR` / `CAMSTACK_BUNDLED_ADDONS_DIR` on
 * agents, so a replaced env would silently break decoding off the hub.
 */
-function forkDecodeWorker(source, leaseOverride = {}, costRegistry) {
+function forkDecodeWorker(source, costRegistry) {
 	const child = (0, node_child_process.fork)(CHILD_ENTRY_PATH, [], {
 		serialization: "advanced",
-		env: {
-			...process.env,
-			...require_worker_protocol.nativeLeaseSettingEnv(leaseOverride)
-		}
+		env: { ...process.env }
 	});
 	const costClaim = costRegistry?.claim({
 		role: "decode",
@@ -103,6 +101,145 @@ function forkDecodeWorker(source, leaseOverride = {}, costRegistry) {
 	return wrapChild(child, () => costClaim.release());
 }
 //#endregion
+//#region src/session-decode/native-lease-config.ts
+/**
+* Resolution of the native-frame hold / tile knobs for one decode session —
+* PARENT side. The result travels to the decode worker on its `start` message
+* (`native-lease-knobs.ts` is the wire half, and the only half the child sees).
+*
+* ## Where the values come from
+*
+* The knobs are cluster-wide `pipeline-orchestrator` settings
+* (`@camstack/types` → `pipeline/native-lease.ts`). The pipeline-runner reads
+* them over the hub-routed `addon-settings` cap
+* (`pipeline-runner/native-lease-settings-source.ts`) and resolves them HERE,
+* once per session, at the moment the session starts — so a changed setting
+* reaches the next session and leaves running ones alone, exactly as before.
+*
+* Until D453 the resolution ran inside the CHILD, from `*_SETTING` env vars the
+* parent wrote at fork time. That bound a worker to the knobs it was forked
+* with (a pre-forked worker cannot be), and it dragged the Zod schemas — the
+* whole `@camstack/types` index — into the child bundle: ~130 ms and ~140 MB
+* per fork, measured. Moving the resolution up one process removed both.
+*
+* ## Precedence — setting > env > default
+*
+* 1. **setting** — the operator set the knob in the orchestrator's global
+*    settings. Wins, because a value someone deliberately chose in the UI must
+*    not be silently overruled by a shell variable nobody can see from there.
+* 2. **env** — {@link NATIVE_LEASE_ENV_VARS}, the pre-settings mechanism, kept
+*    as an emergency / dev override. It applies only while the corresponding
+*    setting is UNSET. "Unset" includes a knob sitting AT its shipped default:
+*    `addon-settings.getGlobalSettings` hydrates an unstored field with the
+*    schema default and offers no way to tell the two apart, so treating the
+*    default as a choice would have retired every env var on the day this
+*    shipped. Move the slider off the default and the setting takes over; move
+*    it back and the env var returns. See `readNativeLeaseOverride`.
+* 3. **default** — {@link DEFAULT_NATIVE_LEASE_SETTINGS}, byte-for-byte the
+*    constants the worker shipped with.
+*
+* A value that fails its bounds at ANY level falls through to the next one
+* rather than being clamped: clamping turns a typo into a number nobody chose,
+* and this one governs how much RAM a busy camera holds.
+*
+* The GPU surface ring (`CAMSTACK_SESSION_NATIVE_CROP_RING`) is deliberately
+* NOT here — see its docblock in `decode-worker-child.ts` for why it stays
+* env-only.
+*/
+/** Emergency / dev override env vars (pre-settings; lowest precedence but the default). */
+var NATIVE_LEASE_ENV_VARS = {
+	holdFrames: "CAMSTACK_SESSION_NATIVE_LEASE_HOLD_FRAMES",
+	budgetMb: "CAMSTACK_SESSION_NATIVE_LEASE_BUDGET_MB",
+	activityMs: "CAMSTACK_SESSION_NATIVE_LEASE_ACTIVITY_MS",
+	admission: "CAMSTACK_SESSION_NATIVE_LEASE_ADMISSION",
+	tileBudgetMb: "CAMSTACK_SESSION_NATIVE_TILE_BUDGET_MB",
+	sceneBudgetMb: "CAMSTACK_SESSION_NATIVE_SCENE_BUDGET_MB"
+};
+/**
+* Validate one candidate through the knob's own Zod bound. `null` for absent,
+* non-numeric, or out-of-bounds input — the caller then falls through to the
+* next precedence level.
+*/
+function parseKnob(knob, raw) {
+	if (raw === void 0) return null;
+	if (typeof raw === "string" && raw.trim() === "") return null;
+	const parsed = require_dist.NativeLeaseSettingsSchema.shape[knob].safeParse(Number(raw));
+	return parsed.success ? parsed.data : null;
+}
+/** {@link parseKnob} for the one knob whose value is a word, not a number. */
+function parseAdmission(raw) {
+	if (raw === void 0) return null;
+	const parsed = require_dist.NativeLeaseAdmissionSchema.safeParse(raw.trim());
+	return parsed.success ? parsed.data : null;
+}
+/** Resolve one NUMERIC knob across the three precedence levels. */
+function resolveKnob(knob, env, override) {
+	const fromSetting = parseKnob(knob, override[knob]);
+	if (fromSetting !== null) return {
+		value: fromSetting,
+		source: "setting"
+	};
+	const fromEnv = parseKnob(knob, env[NATIVE_LEASE_ENV_VARS[knob]]);
+	if (fromEnv !== null) return {
+		value: fromEnv,
+		source: "env"
+	};
+	return {
+		value: require_dist.DEFAULT_NATIVE_LEASE_SETTINGS[knob],
+		source: "default"
+	};
+}
+/** {@link resolveKnob} for `admission`. Same precedence, different parser. */
+function resolveAdmission(env, override) {
+	const fromSetting = parseAdmission(override.admission);
+	if (fromSetting !== null) return {
+		value: fromSetting,
+		source: "setting"
+	};
+	const fromEnv = parseAdmission(env[NATIVE_LEASE_ENV_VARS.admission]);
+	if (fromEnv !== null) return {
+		value: fromEnv,
+		source: "env"
+	};
+	return {
+		value: require_dist.DEFAULT_NATIVE_LEASE_SETTINGS.admission,
+		source: "default"
+	};
+}
+/**
+* Resolve every lease knob for one session. Pure.
+*
+* `override` carries ONLY the knobs the operator actually SET (see
+* `native-lease-settings-source.ts`); an empty object leaves the env override
+* fully functional, which is the whole point of the distinction.
+*/
+function resolveNativeLeaseKnobs(env, override) {
+	const holdFrames = resolveKnob("holdFrames", env, override);
+	const budgetMb = resolveKnob("budgetMb", env, override);
+	const activityMs = resolveKnob("activityMs", env, override);
+	const admission = resolveAdmission(env, override);
+	const tileBudgetMb = resolveKnob("tileBudgetMb", env, override);
+	const sceneBudgetMb = resolveKnob("sceneBudgetMb", env, override);
+	return {
+		values: {
+			holdFrames: holdFrames.value,
+			budgetMb: budgetMb.value,
+			activityMs: activityMs.value,
+			admission: admission.value,
+			tileBudgetMb: tileBudgetMb.value,
+			sceneBudgetMb: sceneBudgetMb.value
+		},
+		sources: {
+			holdFrames: holdFrames.source,
+			budgetMb: budgetMb.source,
+			activityMs: activityMs.source,
+			admission: admission.source,
+			tileBudgetMb: tileBudgetMb.source,
+			sceneBudgetMb: sceneBudgetMb.source
+		}
+	};
+}
+//#endregion
 //#region src/session-decode/guarded-session-decode.ts
 /**
 * 2s → 5s → 15s → 30s, then 30s forever.
@@ -1349,11 +1486,12 @@ var SessionDecodeSession = class {
 		this.child.on("message", (m) => this.handleMessage(m));
 		this.child.on("exit", (m) => this.handleExit(toWorkerExitInfo(m)));
 	}
-	start(source, opts) {
+	start(source, opts, lease) {
 		this.trySend({
 			kind: "start",
 			source,
-			opts
+			opts,
+			lease
 		});
 	}
 	/**
@@ -1521,6 +1659,7 @@ var SessionDecodeSession = class {
 					...raw.reason !== void 0 ? { workerReason: raw.reason } : {}
 				});
 				return;
+			case "ready": return;
 			case "error":
 				this.settleError(raw.message, raw.frameId);
 				return;
@@ -1772,7 +1911,7 @@ function createSessionDecodeCoordinator(deps) {
 	const firstFrameMaxWaitMs = Math.max(deps.firstFrameMaxWaitMs ?? DEFAULT_FIRST_FRAME_MAX_WAIT_MS, firstFrameTimeoutMs);
 	return { async *generateVideoFrames(source, opts) {
 		const session = new SessionDecodeSession(deps.fork(source), deps.logger, source.deviceId, firstFrameTimeoutMs, frameTimeoutMs, firstFrameMaxWaitMs, deps.onDialTiming, deps.onPreRollReport);
-		session.start(source, opts);
+		session.start(source, opts, deps.lease());
 		try {
 			while (true) {
 				const outcome = await session.pullNext();
@@ -1839,6 +1978,7 @@ function startSessionDecodePump(deps) {
 	let dialTiming = null;
 	const iterator = createSessionDecodeCoordinator({
 		fork: deps.fork,
+		lease: deps.lease,
 		logger: deps.logger,
 		onDialTiming: (timing) => {
 			dialTiming = timing;
@@ -6555,7 +6695,6 @@ function writeRetainedDetectionFrame(store, deviceId, frame, retention) {
 	if (!isContinuousRetainEnabled()) return store.allocateHandle(deviceId, frame) ?? void 0;
 	return store.write(deviceId, frame, frame.frameRef ? createRetainedContentFallback(require_default_detection_model.localFrameRegistry, frame.frameRef) : void 0) ?? void 0;
 }
-var DETECTION_KEEPWARM_MS = 15e3;
 /**
 * Occupancy-burst safety timeout (both the dial path and the analyzer-tap
 * path — Task 10). Bounds worst-case burst latency when frames stop
@@ -6582,6 +6721,31 @@ var DETECTION_REDIAL_DELAY_MS = 2e3;
 */
 var DETECTION_REDIAL_GIVEUP_WINDOW_MS = 6e4;
 /**
+* ## There is no decode keep-warm any more — D453 removed it
+*
+* A `WarmDetachedDecode` used to hold a detection worker alive for 15 s across
+* a detach, hoping the next motion event would adopt it. It did not park: it
+* kept its broker restream lease and kept DECODING, because the child's loop is
+* `for await (... decoder.frames(demuxer.packets(...)))`, driven by the demuxer
+* and not by the parent's `pull` — `minIntervalMs` throttles only inside
+* `FrameSlot.publish`, after the decode. `framesDecoded` advanced in 122 of 122
+* park windows at full source rate, and a decode-worker child costs 40-80% of a
+* core.
+*
+* So the park cost about what running costs, and it bought a re-fork back in
+* 12% of cases: on this fleet, 272 of 440 park windows expired having adopted
+* nothing, while the two decode-worker children stood at 319% of the 522% of
+* CPU CamStack drew on the host. D282 put the arithmetic at ~25x net-negative
+* against the forks it avoided, and D453 made the fork itself ~150 ms and
+* ~100 MB cheaper, which only widens it.
+*
+* Do not reintroduce a keep-warm shaped like this one, and do not "fix" it with
+* a longer TTL: the measured p50 gap between two sessions of one camera is
+* 61 s, so a longer window scales the waste and not the hit rate. If a warm
+* process is wanted, it must be a process that holds NO stream and decodes
+* NOTHING — see D453 for what that costs and why it was not taken either.
+*/
+/**
 * Pure decision helper: returns `true` when a dynamic frame-diff analyzer
 * subscription should be opened for an onboard-motion camera.
 *
@@ -6907,12 +7071,6 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	retention = null;
 	attached = /* @__PURE__ */ new Map();
 	/**
-	* Detection decode workers parked across a detach, keyed by deviceId — see
-	* {@link WarmDetachedDecode}. Bounded by construction: at most one entry per
-	* camera, each self-expiring after {@link DETECTION_KEEPWARM_MS}.
-	*/
-	warmDetachedDetection = /* @__PURE__ */ new Map();
-	/**
 	* Detail step state parked across a SOFT detach, keyed by deviceId — see
 	* `detail-park.ts` for the fault this closes. Bounded by construction: at
 	* most one entry per camera, each self-expiring after
@@ -7271,14 +7429,9 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			this.runner = null;
 		}
 		for (const attachment of this.attached.values()) {
-			if (attachment.detectionKeepWarmTimer !== null) {
-				clearTimeout(attachment.detectionKeepWarmTimer);
-				attachment.detectionKeepWarmTimer = null;
-			}
 			attachment.motionUnsubscribe?.();
 			attachment.detectionUnsubscribe?.();
 		}
-		for (const deviceId of [...this.warmDetachedDetection.keys()]) this.dropWarmDetectionDecode(deviceId, "shutdown");
 		for (const deviceId of [...this.parkedDetail.keys()]) this.dropParkedDetail(deviceId);
 		this.attached.clear();
 		this.lastMotionFrameAt.clear();
@@ -7989,7 +8142,6 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			config,
 			motionUnsubscribe: null,
 			detectionUnsubscribe: null,
-			detectionKeepWarmTimer: null,
 			detailSteps: deriveDetailSteps(config.steps)
 		};
 		this.attached.set(config.deviceId, attachment);
@@ -8645,12 +8797,24 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		warn: (message, extras) => this.ctxIfReady?.logger.warn(message, extras)
 	} });
 	/**
-	* Fork a decode worker carrying the operator's lease knobs. Used in place of
-	* a bare `forkDecodeWorker` reference at every session-decode spawn site: the
-	* knobs are read at spawn, so a changed setting reaches NEW sessions and
+	* Fork a decode worker. Used in place of a bare `forkDecodeWorker` reference
+	* at every session-decode spawn site so the cost registry is never forgotten.
+	*
+	* The fork carries NO configuration: since D453 the lease knobs travel on the
+	* `start` message ({@link resolveSessionLeaseKnobs}), not in the child's
+	* environment. A worker is therefore forkable before anyone knows which
+	* camera it will serve.
+	*/
+	forkDecodeWorkerWithLease = (source) => forkDecodeWorker(source, this.costRegistry);
+	/**
+	* The lease knobs for the session that is about to start — `setting > env >
+	* default`, resolved HERE because this process is the one that carries the
+	* Zod schemas (the child no longer does; D453).
+	*
+	* Read per session, so a changed operator setting reaches NEW sessions and
 	* leaves running ones alone (a live session would have to be re-dialled).
 	*/
-	forkDecodeWorkerWithLease = (source) => forkDecodeWorker(source, this.nativeLease.current(), this.costRegistry);
+	resolveSessionLeaseKnobs = () => resolveNativeLeaseKnobs(process.env, this.nativeLease.current());
 	/**
 	* Refresh the lease knobs before a decode worker is spawned. Awaited on the
 	* `acquire` leg of `startGuardedSessionDecode` (which always completes before
@@ -8855,19 +9019,10 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	*/
 	handleDetectionDecodeEnded(deviceId) {
 		const attachment = this.attached.get(deviceId);
-		if (!attachment) {
-			this.dropWarmDetectionDecode(deviceId, "worker-died-while-parked");
-			return;
-		}
+		if (!attachment) return;
 		const log = this.ctx.logger.withTags({ deviceId });
 		attachment.detectionUnsubscribe?.();
 		attachment.detectionUnsubscribe = null;
-		if (attachment.detectionKeepWarmTimer !== null) {
-			clearTimeout(attachment.detectionKeepWarmTimer);
-			attachment.detectionKeepWarmTimer = null;
-			log.warn("detection decode worker died while kept warm — next open re-forks cold");
-			return;
-		}
 		const now = Date.now();
 		const last = this.lastDecodeUnexpectedEndAt.get(deviceId) ?? 0;
 		this.lastDecodeUnexpectedEndAt.set(deviceId, now);
@@ -8892,13 +9047,14 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	/**
 	* Tear a camera down.
 	*
-	* `keepDecodeWarm` routes the DETECTION decode through the same keep-warm
-	* grace the phase gate uses instead of killing it — see
-	* {@link WarmDetachedDecode}. Set only by the {@link detachCamera} cap entry
-	* point (the orchestrator's motion-cooldown teardown); every internal detach
-	* — an attach replacing a stale config, a decode that died twice, shutdown —
-	* is a hard one, because in each of those cases the worker is either wrong or
-	* already gone.
+	* `softDetach` is the {@link detachCamera} cap entry point (the
+	* orchestrator's motion-cooldown teardown). It keeps the DETAIL step tree
+	* parked — a config slice, no process, no CPU — so a track outliving this
+	* session can still resolve its enrichment steps. It does NOT keep the decode
+	* worker: since D453 every detach releases it, because a held worker went on
+	* decoding at full rate for the whole window (see the note above
+	* {@link AttachedCamera}). Every internal detach — an attach replacing a
+	* stale config, a decode that died twice, shutdown — is hard on both counts.
 	*/
 	/**
 	* Park the detaching camera's detail-relevant config slice for the grace
@@ -8945,18 +9101,13 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		}
 		return parked.state;
 	}
-	detachInternal(deviceId, keepDecodeWarm = false) {
+	detachInternal(deviceId, softDetach = false) {
 		const attachment = this.attached.get(deviceId);
 		if (!attachment) return;
 		this.clearOnboardAnalyzer(deviceId);
-		if (attachment.detectionKeepWarmTimer !== null) {
-			clearTimeout(attachment.detectionKeepWarmTimer);
-			attachment.detectionKeepWarmTimer = null;
-		}
 		attachment.motionUnsubscribe?.();
-		if (keepDecodeWarm && attachment.detectionUnsubscribe !== null) this.parkWarmDetectionDecode(deviceId, attachment.config, attachment.detectionUnsubscribe);
-		else attachment.detectionUnsubscribe?.();
-		if (keepDecodeWarm) this.parkDetailState(deviceId, attachment.config);
+		attachment.detectionUnsubscribe?.();
+		if (softDetach) this.parkDetailState(deviceId, attachment.config);
 		else this.dropParkedDetail(deviceId);
 		this.lastMotionFrameAt.delete(deviceId);
 		this.lastDecodeUnexpectedEndAt.delete(deviceId);
@@ -8981,83 +9132,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		this.runner?.unregisterCamera(deviceId);
 		this.ctx?.logger.info("detachCamera", {
 			tags: { deviceId },
-			meta: { decodeKeptWarm: this.warmDetachedDetection.has(deviceId) }
-		});
-	}
-	/**
-	* The decode-relevant identity of a camera's detection decode. Two configs
-	* that agree on all of it can share one worker; anything else must re-fork.
-	* Kept in ONE place so a future decode-shaping option cannot be added to the
-	* pump without the adoption check noticing.
-	*/
-	detectionDecodeIdentity(config) {
-		return {
-			streamId: config.detectionStreamId,
-			fps: config.detectionFps,
-			hostname: resolveSessionDecodeHostname(config, process.env["CAMSTACK_HUB_URL"]),
-			ownerNodeId: resolveSessionDecodeOwnerNodeId(config)
-		};
-	}
-	/**
-	* Hold a detached camera's detection decode worker for
-	* {@link DETECTION_KEEPWARM_MS} so the next motion event reuses it.
-	* Replacing an existing park releases the older worker first — two parked
-	* workers for one camera would be two live decodes and two broker leases.
-	*/
-	parkWarmDetectionDecode(deviceId, config, unsubscribe) {
-		this.dropWarmDetectionDecode(deviceId, "replaced");
-		const timer = setTimeout(() => {
-			this.warmDetachedDetection.delete(deviceId);
-			unsubscribe();
-			this.ctx?.logger.info("session-decode: warm detection decode expired — worker released", {
-				tags: { deviceId },
-				meta: { keepWarmMs: DETECTION_KEEPWARM_MS }
-			});
-		}, DETECTION_KEEPWARM_MS);
-		timer.unref?.();
-		this.warmDetachedDetection.set(deviceId, {
-			unsubscribe,
-			timer,
-			...this.detectionDecodeIdentity(config)
-		});
-	}
-	/**
-	* Adopt a parked decode worker for a camera that is attaching again, or
-	* `null` when there is nothing to adopt.
-	*
-	* A parked worker whose identity no longer matches is DROPPED here rather
-	* than left to expire: the caller is about to fork a replacement, and letting
-	* both run would double this camera's decode cost for the rest of the window.
-	*/
-	adoptWarmDetectionDecode(deviceId, config) {
-		const warm = this.warmDetachedDetection.get(deviceId);
-		if (!warm) return null;
-		const wanted = this.detectionDecodeIdentity(config);
-		if (warm.streamId !== wanted.streamId || warm.fps !== wanted.fps || warm.hostname !== wanted.hostname || warm.ownerNodeId !== wanted.ownerNodeId) {
-			this.dropWarmDetectionDecode(deviceId, "config-changed");
-			return null;
-		}
-		clearTimeout(warm.timer);
-		this.warmDetachedDetection.delete(deviceId);
-		this.ctx?.logger.info("session-decode: reusing the warm detection decode worker (no re-fork)", {
-			tags: { deviceId },
-			meta: {
-				streamId: warm.streamId,
-				fps: warm.fps
-			}
-		});
-		return warm.unsubscribe;
-	}
-	/** Release a parked worker now. `reason` names why in the log. */
-	dropWarmDetectionDecode(deviceId, reason) {
-		const warm = this.warmDetachedDetection.get(deviceId);
-		if (!warm) return;
-		clearTimeout(warm.timer);
-		this.warmDetachedDetection.delete(deviceId);
-		warm.unsubscribe();
-		this.ctx?.logger.info("session-decode: warm detection decode released", {
-			tags: { deviceId },
-			meta: { reason }
+			meta: { detailParked: this.parkedDetail.has(deviceId) }
 		});
 	}
 	/**
@@ -9368,6 +9443,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				let reservation = null;
 				return startSessionDecodePump({
 					fork: this.forkDecodeWorkerWithLease,
+					lease: this.resolveSessionLeaseKnobs,
 					logger: log,
 					source,
 					opts: {
@@ -9526,6 +9602,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				} });
 				return startSessionDecodePump({
 					fork: this.forkDecodeWorkerWithLease,
+					lease: this.resolveSessionLeaseKnobs,
 					logger: log,
 					source,
 					opts: {
@@ -9572,16 +9649,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		const attachment = this.attached.get(deviceId);
 		if (!attachment) return;
 		if (action === "subscribe") {
-			if (attachment.detectionKeepWarmTimer !== null) {
-				clearTimeout(attachment.detectionKeepWarmTimer);
-				attachment.detectionKeepWarmTimer = null;
-			}
 			if (attachment.detectionUnsubscribe !== null) return;
-			const adopted = this.adoptWarmDetectionDecode(deviceId, attachment.config);
-			if (adopted) {
-				attachment.detectionUnsubscribe = adopted;
-				return;
-			}
 			this.subscribeDetectionFrames(attachment.config).then((unsub) => {
 				if (!this.attached.has(deviceId)) {
 					unsub?.();
@@ -9590,13 +9658,9 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				attachment.detectionUnsubscribe = unsub;
 			});
 		} else {
-			if (attachment.detectionKeepWarmTimer !== null) return;
 			if (attachment.detectionUnsubscribe === null) return;
-			attachment.detectionKeepWarmTimer = setTimeout(() => {
-				attachment.detectionKeepWarmTimer = null;
-				attachment.detectionUnsubscribe?.();
-				attachment.detectionUnsubscribe = null;
-			}, DETECTION_KEEPWARM_MS);
+			attachment.detectionUnsubscribe();
+			attachment.detectionUnsubscribe = null;
 		}
 	}
 	/**
@@ -10348,6 +10412,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				const useLocalFrameRef = this.executorCoLocated() && process.env["CAMSTACK_DISABLE_LOCAL_FRAME_REF"] !== "1";
 				return startSessionDecodePump({
 					fork: this.forkDecodeWorkerWithLease,
+					lease: this.resolveSessionLeaseKnobs,
 					logger: log,
 					source,
 					opts: {