@camstack/addon-pipeline 1.2.156 → 1.2.159

package/dist/recorder/index.mjs

@@ -1,5 +1,5 @@
-import { $ as isFirstLevelMacroClass, $t as record, B as defineCustomActions, Bt as nodePin, E as RecordingConfigSchema, It as hydrateSchema, J as evaluateSensorEdge, Kt as array, L as customAction, N as batteryCapability, Nt as DeviceFeature, Pt as DeviceType, Qt as object, T as RECORDING_EXPORT_MAX_READ_BYTES, U as deriveRecordingMode, Ut as selectAssignedProfileSlots, V as deriveBatteryPresence, Wt as sleep, Zt as number, bt as storageEvictableCapability, d as DEFAULT_EVENTS_BAND_BUFFER_SEC, en as string, et as loadContributionCapability, g as ExportRecordSchema, i as BatteryStatusSchema, jt as BaseAddon, mt as recordingExportCapability, nn as EventCategory, pt as recordingCapability, qt as boolean, vt as resolveRecordingProfiles, wt as errMsg, x as OpsLogEntrySchema } from "../dist-C9ohtgTQ.mjs";
-import { i as NO_COST_CLAIM, t as ChildCostRegistry } from "../node-CwIlVFyz.mjs";
+import { $ as isFirstLevelMacroClass, $t as record, B as defineCustomActions, Bt as nodePin, E as RecordingConfigSchema, Gt as _enum, It as hydrateSchema, J as evaluateSensorEdge, Kt as array, L as customAction, N as batteryCapability, Nt as DeviceFeature, Pt as DeviceType, Qt as object, T as RECORDING_EXPORT_MAX_READ_BYTES, U as deriveRecordingMode, Ut as selectAssignedProfileSlots, V as deriveBatteryPresence, Wt as sleep$1, Zt as number, bt as storageEvictableCapability, d as DEFAULT_EVENTS_BAND_BUFFER_SEC, en as string, et as loadContributionCapability, g as ExportRecordSchema, i as BatteryStatusSchema, jt as BaseAddon, mt as recordingExportCapability, nn as EventCategory, pt as recordingCapability, qt as boolean, vt as resolveRecordingProfiles, wt as errMsg, x as OpsLogEntrySchema } from "../dist-p8ruahJy.mjs";
+import { i as NO_COST_CLAIM, t as ChildCostRegistry } from "../node-kVYpLOax.mjs";
 import { t as resolveHubHostname } from "../hub-hostname-cCknRYKj.mjs";
 import { r as withRecordingIntent } from "../restream-intent-B4BXZra7.mjs";
 import { n as startEventLoopStallMonitor } from "../event-loop-stall-monitor-DXLNBMkY.mjs";
@@ -4209,6 +4209,377 @@ function sendDirectory(res, payload) {
 	res.end(Buffer.from(body));
 }
 //#endregion
+//#region src/recorder/addon/location-discard-actions.ts
+var DiscardStartInput = object({ locationId: string().min(1) });
+var DiscardStarted = object({
+	started: boolean(),
+	alreadyRunning: boolean(),
+	jobId: string().nullable()
+});
+var DiscardStatusSchema = object({
+	running: boolean(),
+	locationId: string().nullable(),
+	jobId: string().nullable(),
+	phase: _enum([
+		"idle",
+		"scanning",
+		"wiping-fs",
+		"wiping-db",
+		"cascading",
+		"complete",
+		"cancelled",
+		"error"
+	]),
+	camerasTotal: number(),
+	camerasDone: number(),
+	foldersRemoved: number(),
+	dbRowsDeleted: number(),
+	ownersCascaded: number(),
+	detail: string(),
+	startedAtMs: number().nullable(),
+	finishedAtMs: number().nullable(),
+	error: string().nullable()
+});
+var DiscardCancel = object({ requested: boolean() });
+var locationDiscardActions = defineCustomActions({
+	"storage.discardLocation": customAction(DiscardStartInput, DiscardStarted, { auth: "admin" }),
+	"storage.discardLocationStatus": customAction(object({}), DiscardStatusSchema, { auth: "admin" }),
+	"storage.discardLocationCancel": customAction(object({}), DiscardCancel, { auth: "admin" })
+});
+//#endregion
+//#region src/recorder/addon/location-class-wipe.ts
+/**
+* Class-subtree wipe — the filesystem half of discarding a frozen location
+* that SHARES its root with another class (today: Toshiba `/recordings`
+* holds events + low + high).
+*
+* The only directories this module will `rm` are
+* `<root>/<camera>/<subtree>` for `subtree` in the class map. It refuses
+* a path that is not exactly two levels under the root, a symlink, or a
+* subtree the class did not name. `rm` of the location root is not a
+* code path.
+*/
+var DISCARD_SUBTREES$1 = {
+	eventMedia: ["events"],
+	recordingsLow: ["low"],
+	recordings: ["high", "mid"]
+};
+function discardSubtreesForType(type) {
+	return DISCARD_SUBTREES$1[type] ?? null;
+}
+var DEFAULT_FS = {
+	readdir: (dir) => promises.readdir(dir, { withFileTypes: true }),
+	lstat: (target) => promises.lstat(target),
+	rm: (target) => promises.rm(target, {
+		recursive: true,
+		force: true
+	})
+};
+/**
+* Resolve `<root>/<camera>/<subtree>` and refuse anything that is not
+* exactly that shape under `root`. The check is lexical (after
+* `path.resolve`) so `../high` in a camera name cannot escape.
+*/
+function resolveClassDir(root, cameraId, subtree) {
+	if (cameraId.length === 0 || cameraId === "." || cameraId === "..") throw new Error(`discard: illegal camera id ${cameraId}`);
+	if (subtree.includes("/") || subtree.includes("\\") || subtree === ".." || subtree === ".") throw new Error(`discard: illegal subtree ${subtree}`);
+	const rootResolved = path.resolve(root);
+	const target = path.resolve(rootResolved, cameraId, subtree);
+	const rel = path.relative(rootResolved, target);
+	if (rel.startsWith("..") || path.isAbsolute(rel)) throw new Error(`discard: path escaped root: ${target}`);
+	const parts = rel.split(path.sep).filter((p) => p.length > 0);
+	if (parts.length !== 2 || parts[0] !== cameraId || parts[1] !== subtree) throw new Error(`discard: path is not a class subtree: ${target}`);
+	return target;
+}
+async function wipeClassSubtrees(input) {
+	const subtrees = discardSubtreesForType(input.type);
+	if (subtrees === null) throw new Error(`discard: unknown location type ${input.type}`);
+	const io = input.io ?? DEFAULT_FS;
+	const rootResolved = path.resolve(input.root);
+	let cameras;
+	try {
+		cameras = await io.readdir(rootResolved);
+	} catch (err) {
+		if (err.code === "ENOENT") return {
+			camerasDone: 0,
+			foldersRemoved: 0,
+			cancelled: false
+		};
+		throw err;
+	}
+	const dirs = cameras.filter((e) => e.isDirectory() && e.name !== "." && e.name !== "..");
+	let camerasDone = 0;
+	let foldersRemoved = 0;
+	for (const dir of dirs) {
+		if (input.stop()) return {
+			camerasDone,
+			foldersRemoved,
+			cancelled: true
+		};
+		for (const subtree of subtrees) {
+			const target = resolveClassDir(rootResolved, dir.name, subtree);
+			let st;
+			try {
+				st = await io.lstat(target);
+			} catch (err) {
+				if (err.code === "ENOENT") continue;
+				throw err;
+			}
+			if (st.isSymbolicLink()) throw new Error(`discard: refusing to wipe symlink ${target}`);
+			if (!st.isDirectory()) continue;
+			await io.rm(target);
+			foldersRemoved += 1;
+		}
+		camerasDone += 1;
+		input.onProgress({
+			camerasTotal: dirs.length,
+			camerasDone,
+			cameraId: dir.name,
+			foldersRemoved
+		});
+		if (input.pace) await input.pace();
+	}
+	return {
+		camerasDone,
+		foldersRemoved,
+		cancelled: false
+	};
+}
+//#endregion
+//#region src/recorder/addon/location-discard-policy.ts
+/**
+* Server-side eligibility for discarding a frozen location's leftover
+* class subtree. Same rules as the admin-ui card: frozen, known class,
+* writable sibling of the same type. The last writable of a type is
+* refused here even if the UI is bypassed.
+*/
+var DISCARD_SUBTREES = {
+	eventMedia: ["events"],
+	recordingsLow: ["low"],
+	recordings: ["high", "mid"]
+};
+function locationIsFrozen(location) {
+	const enabled = location.enabled !== false;
+	const readOnly = location.config["readOnly"] === true;
+	return !enabled || readOnly;
+}
+function discardEligible(location, siblings) {
+	if (!(location.type in DISCARD_SUBTREES)) return false;
+	if (!locationIsFrozen(location)) return false;
+	return siblings.some((s) => {
+		if (s.id === location.id) return false;
+		if (s.type !== location.type) return false;
+		const enabled = s.enabled !== false;
+		const readOnly = s.config["readOnly"] === true;
+		return enabled && !readOnly;
+	});
+}
+function assertDiscardAllowed(location, all, localNodeId) {
+	if (!discardEligible(location, all.filter((s) => s.type === location.type))) throw new Error(`discard refused: ${location.id} is not a frozen location with a writable sibling of type ${location.type}`);
+	const nodeId = location.nodeId ?? "hub";
+	if (nodeId !== localNodeId) throw new Error(`discard refused: ${location.id} lives on node ${nodeId}, this process is ${localNodeId}`);
+}
+function locationBasePath(location) {
+	const basePath = location.config["basePath"];
+	if (typeof basePath !== "string" || basePath.length === 0) throw new Error(`discard refused: ${location.id} has no basePath`);
+	return basePath;
+}
+//#endregion
+//#region src/recorder/addon/location-discard-job.ts
+/**
+* Footage discard job: wipe `<camera>/low/` (or `high/`+`mid/` for the
+* recordings class) on a frozen location, then forget the hour rows
+* stamped with that `locationId` and drop them from the RAM index.
+*
+* The class-subtree wipe is the load-bearing safety: `recordingsLow:default`
+* shares `/recordings` with `recordings:default`. This job never `rm`s the
+* location root. Profiles passed to the ledger forget are the class's own
+* (`low` vs `high`/`mid`) so a mis-stamped hour of the other class is not
+* dropped.
+*
+* Start returns immediately. Progress is the status snapshot.
+*/
+var IDLE_DISCARD = {
+	running: false,
+	locationId: null,
+	jobId: null,
+	phase: "idle",
+	camerasTotal: 0,
+	camerasDone: 0,
+	foldersRemoved: 0,
+	dbRowsDeleted: 0,
+	ownersCascaded: 0,
+	detail: "",
+	startedAtMs: null,
+	finishedAtMs: null,
+	error: null
+};
+var USB_PACE_MS = 80;
+var FOOTAGE_TYPES = new Set(["recordings", "recordingsLow"]);
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function profilesForType(type) {
+	return type === "recordingsLow" ? ["low"] : ["high", "mid"];
+}
+function createFootageDiscardJob(deps) {
+	let state = { ...IDLE_DISCARD };
+	let cancelRequested = false;
+	let inflight = null;
+	const report = (patch) => {
+		state = {
+			...state,
+			...patch
+		};
+	};
+	const status = () => ({ ...state });
+	const cancel = () => {
+		if (!state.running) return { requested: false };
+		cancelRequested = true;
+		report({ detail: "cancel requested — finishing current camera" });
+		return { requested: true };
+	};
+	const start = async (input) => {
+		if (state.running) return {
+			started: false,
+			alreadyRunning: true,
+			jobId: state.jobId
+		};
+		const jobId = randomUUID();
+		cancelRequested = false;
+		report({
+			...IDLE_DISCARD,
+			running: true,
+			locationId: input.locationId,
+			jobId,
+			phase: "scanning",
+			startedAtMs: deps.now(),
+			detail: "starting"
+		});
+		try {
+			const all = await deps.listLocations();
+			const location = all.find((row) => row.id === input.locationId);
+			if (!location) throw new Error(`discard refused: unknown location ${input.locationId}`);
+			if (!FOOTAGE_TYPES.has(location.type)) throw new Error(`discard refused: recorder handles footage, not ${location.type}`);
+			assertDiscardAllowed(location, all, deps.localNodeId);
+			const root = locationBasePath(location);
+			report({ detail: `scanning ${root}` });
+			inflight = run(location, root).finally(() => {
+				inflight = null;
+			});
+			return {
+				started: true,
+				alreadyRunning: false,
+				jobId
+			};
+		} catch (err) {
+			report({
+				...IDLE_DISCARD,
+				phase: "error",
+				error: err instanceof Error ? err.message : String(err),
+				finishedAtMs: deps.now()
+			});
+			throw err;
+		}
+	};
+	const run = async (location, root) => {
+		const wipe = deps.wipe ?? wipeClassSubtrees;
+		const paceMs = deps.paceMs ?? USB_PACE_MS;
+		try {
+			report({
+				phase: "wiping-fs",
+				detail: `wiping ${profilesForType(location.type).join("/")} under ${root}`
+			});
+			const fsResult = await wipe({
+				root,
+				type: location.type,
+				stop: () => cancelRequested,
+				onProgress: (p) => {
+					report({
+						phase: "wiping-fs",
+						camerasTotal: p.camerasTotal,
+						camerasDone: p.camerasDone,
+						foldersRemoved: p.foldersRemoved,
+						detail: `camera ${p.cameraId} (${p.camerasDone}/${p.camerasTotal})`
+					});
+				},
+				pace: () => sleep(paceMs)
+			});
+			if (fsResult.cancelled || cancelRequested) {
+				report({
+					running: false,
+					phase: "cancelled",
+					camerasDone: fsResult.camerasDone,
+					foldersRemoved: fsResult.foldersRemoved,
+					finishedAtMs: deps.now(),
+					detail: "cancelled"
+				});
+				return;
+			}
+			report({
+				phase: "wiping-db",
+				camerasDone: fsResult.camerasDone,
+				foldersRemoved: fsResult.foldersRemoved,
+				detail: "forgetting ledger hours"
+			});
+			const forgotten = await forgetLedger(location);
+			if (cancelRequested) {
+				report({
+					running: false,
+					phase: "cancelled",
+					dbRowsDeleted: forgotten,
+					finishedAtMs: deps.now(),
+					detail: "cancelled"
+				});
+				return;
+			}
+			report({
+				running: false,
+				phase: "complete",
+				dbRowsDeleted: forgotten,
+				finishedAtMs: deps.now(),
+				detail: `done — ${fsResult.foldersRemoved} folders, ${forgotten} ledger segments`,
+				error: null
+			});
+		} catch (err) {
+			report({
+				running: false,
+				phase: "error",
+				finishedAtMs: deps.now(),
+				error: err instanceof Error ? err.message : String(err),
+				detail: "failed"
+			});
+		}
+	};
+	const forgetLedger = async (location) => {
+		const ledger = deps.ledger;
+		if (ledger === null) return 0;
+		let forgotten = 0;
+		const profiles = profilesForType(location.type);
+		for await (const page of ledger.streamSegments({
+			locationId: location.id,
+			profiles
+		})) {
+			if (cancelRequested) return forgotten;
+			deps.index.removeSegments(page.map((row) => row.path));
+			await ledger.dropSegments(page);
+			forgotten += page.length;
+			report({
+				dbRowsDeleted: forgotten,
+				detail: `forgot ${forgotten} ledger segments`
+			});
+			await sleep(0);
+		}
+		return forgotten;
+	};
+	return {
+		start,
+		status,
+		cancel,
+		waitForIdle: () => inflight
+	};
+}
+//#endregion
 //#region src/recorder/addon/export-dense-map.ts
 /**
 * Shortest clip worth keeping, in ms.
@@ -6337,7 +6708,10 @@ function buildRecordingProvider(deps) {
 			}
 			const locationUsages = await Promise.all([...byPhysical.values()].map(async (group) => {
 				const first = group[0];
-				const cap = await deps.capacity(first.root);
+				const cap = group.some((l) => l.enabled !== false) ? await deps.capacity(first.root) : {
+					availableBytes: null,
+					totalBytes: null
+				};
 				const ids = group.map((l) => l.id);
 				if (cap.error !== void 0) deps.logger.warn("recorder: volume capacity unavailable (statfs failed)", { meta: {
 					locationId: first.id,
@@ -6740,6 +7114,15 @@ function buildRecordingProvider(deps) {
 		cancelRelocateJob: async ({ jobId }) => ({ cancelled: deps.relocate?.cancel(jobId) ?? false }),
 		planStorageRebalance: (input) => runRebalance(deps, input, false),
 		startStorageRebalance: (input) => runRebalance(deps, input, true),
+		getPlacement: async () => {
+			if (!deps.placementView) throw new Error("placement is not active on this node");
+			return deps.placementView();
+		},
+		setDevicePlacement: async ({ deviceId, locationId }) => {
+			if (!deps.setDevicePlacement) throw new Error("placement is not active on this node");
+			await deps.setDevicePlacement(deviceId, locationId);
+			return { ok: true };
+		},
 		getDeviceSettingsContribution: async ({ deviceId }) => {
 			if (deps.isCameraDevice && !await deps.isCameraDevice(deviceId)) return null;
 			return hydrateSchema(buildRecordingDeviceSchema(), {});
@@ -10701,6 +11084,11 @@ var RECORDING_PLACEMENT_KEY = "recordingPlacement";
 var RecordingPlacementBlobSchema = object({
 	/** `<deviceId>:<profile>` → locationId. */
 	assignments: record(string(), string()).default({}),
+	/**
+	* Operator pin: `String(deviceId)` → a `recordings:*` location id.
+	* Absent = Auto. High and mid follow the pin; low is not pinned here.
+	*/
+	pins: record(string(), string()).default({}),
 	/** locationId → the volume id last verified at that location's root. */
 	volumeIds: record(string(), string()).default({}),
 	/**
@@ -10719,6 +11107,7 @@ var RecordingPlacementBlobSchema = object({
 /** Cold-start value: nothing assigned, nothing claimed, no authority recorded. */
 var EMPTY_PLACEMENT = {
 	assignments: {},
+	pins: {},
 	volumeIds: {},
 	defaultLocations: {}
 };
@@ -10804,6 +11193,25 @@ async function rememberVolumeId(state, locationId, volumeId) {
 		updatedAt: Date.now()
 	});
 }
+/** Operator pin: `locationId` null clears Auto. High/mid assignment keys follow. */
+async function writeDevicePin(state, deviceId, locationId) {
+	const blob = await state.get();
+	const pins = { ...blob.pins };
+	const assignments = { ...blob.assignments };
+	const key = String(deviceId);
+	if (locationId === null) delete pins[key];
+	else {
+		pins[key] = locationId;
+		assignments[assignmentKey(deviceId, "high")] = locationId;
+		assignments[assignmentKey(deviceId, "mid")] = locationId;
+	}
+	await state.set({
+		...blob,
+		pins,
+		assignments,
+		updatedAt: Date.now()
+	});
+}
 //#endregion
 //#region src/recorder/addon/placement-volume.ts
 /**
@@ -11026,6 +11434,17 @@ function sameStamp(stamped, authority) {
 	for (const [type, locationId] of authority) if (stamped.get(type) !== locationId) return false;
 	return true;
 }
+/** Operator pins win over the planner for high/mid of the pinned camera. */
+function overlayPins(planned, pins) {
+	const next = new Map(planned);
+	for (const [id, locationId] of Object.entries(pins)) {
+		const deviceId = Number(id);
+		if (!Number.isFinite(deviceId)) continue;
+		next.set(assignmentKey(deviceId, "high"), locationId);
+		next.set(assignmentKey(deviceId, "mid"), locationId);
+	}
+	return next;
+}
 var PlacementService = class {
 	deps;
 	/** Locations whose volume has been probed since the last location change. */
@@ -11219,6 +11638,11 @@ var PlacementService = class {
 			return null;
 		}
 		const assignedId = blob.assignments[assignmentKey(deviceId, profile)];
+		const pinId = blob.pins[String(deviceId)];
+		if (pinId !== void 0 && (profile === "high" || profile === "mid")) {
+			const pinned = pool.find((l) => l.id === pinId && !l.readOnly) ?? null;
+			if (pinned !== null) return pinned;
+		}
 		if (assignedId === void 0) return null;
 		const location = pool.find((l) => l.id === assignedId && !l.readOnly) ?? null;
 		if (location === null) return null;
@@ -11277,7 +11701,7 @@ var PlacementService = class {
 			return NO_PLAN;
 		}
 		const stamped = new Map(Object.entries(blob.defaultLocations));
-		const repoints = this.detectRepoints(blob.assignments, stamped, authority);
+		const repoints = this.detectRepoints(blob.assignments, stamped, authority, blob.pins);
 		if (repoints.length === 0) this.repointAnnounced.clear();
 		for (const repoint of repoints) this.announceRepoint(repoint);
 		const repointed = /* @__PURE__ */ new Map();
@@ -11298,7 +11722,7 @@ var PlacementService = class {
 		});
 		const pass = {
 			repointed,
-			planned: plan.assignments,
+			planned: overlayPins(plan.assignments, blob.pins),
 			defaultLocations: authority
 		};
 		this.reportDivergence(applyPlacementPass(blob.assignments, pass), authority);
@@ -11335,15 +11759,17 @@ var PlacementService = class {
 	* from an absent stamp would throw away every deliberate assignment on the
 	* first tick after a deploy.
 	*/
-	detectRepoints(stored, stamped, authority) {
+	detectRepoints(stored, stamped, authority, pins) {
 		const out = [];
 		for (const [type, to] of authority) {
 			const from = stamped.get(type);
 			if (from === void 0 || from === to) continue;
 			const keys = [];
 			for (const [key, locationId] of Object.entries(stored)) {
-				if (placementTypeForProfile(key.split(":")[1] ?? "") !== type) continue;
+				const [devicePart, profilePart] = key.split(":");
+				if (placementTypeForProfile(profilePart ?? "") !== type) continue;
 				if (locationId === to) continue;
+				if (type === "recordings" && devicePart !== void 0 && pins[devicePart] !== void 0) continue;
 				keys.push(key);
 			}
 			out.push({
@@ -11479,6 +11905,40 @@ var PlacementService = class {
 			return /* @__PURE__ */ new Map();
 		}
 	}
+	async placementView() {
+		const blob = await readPlacementState(this.deps.state);
+		return {
+			assignments: Object.entries(blob.assignments).flatMap(([key, locationId]) => {
+				const [idPart, profile] = key.split(":");
+				const deviceId = Number(idPart);
+				if (!Number.isFinite(deviceId) || profile === void 0) return [];
+				return [{
+					deviceId,
+					profile,
+					locationId
+				}];
+			}),
+			pins: Object.entries(blob.pins).flatMap(([id, locationId]) => {
+				const deviceId = Number(id);
+				if (!Number.isFinite(deviceId)) return [];
+				return [{
+					deviceId,
+					locationId
+				}];
+			}),
+			defaultLocations: blob.defaultLocations
+		};
+	}
+	async setDevicePin(deviceId, locationId) {
+		if (locationId !== null) {
+			if (!this.pool().find((l) => l.id === locationId && l.type === "recordings" && !l.readOnly)) throw new Error(`Cannot pin camera ${String(deviceId)} to "${locationId}" — it is not a writable recordings location`);
+		}
+		await writeDevicePin(this.deps.state, deviceId, locationId);
+		this.deps.logger.info("recorder placement: operator pin updated", {
+			tags: { deviceId },
+			meta: { locationId }
+		});
+	}
 	/**
 	* Turn each pool location into a planner candidate. Headroom is
 	* `min(free − minFree floor, maxUsedGb − used)`, clamped at zero: the first
@@ -15471,6 +15931,14 @@ function withDeviceTag(logger, deviceId) {
 * provider until the controller swaps the manifest entry in a later step — this
 * file ships dormant (separate tree, not wired into the manifest yet).
 */
+/**
+* Hub harvests this named export into CustomActionRegistry. Actions that
+* exist only on the onInitialize envelope stay invisible to `addons.custom`.
+*/
+var customActions = {
+	...recorderDebugActions,
+	...locationDiscardActions
+};
 /** Default designated recording node (`recordingNodeId` global setting). The
 *  stream-broker is hub-only and recording is a single-node global function, so
 *  the hub is the safe default — mirrors pipeline-analytics' post-processing
@@ -15638,6 +16106,8 @@ var RecorderV2Addon = class extends BaseAddon {
 	* deferred archive walk reconciles it against disk.
 	*/
 	segmentHours = null;
+	/** Frozen-location leftover wipe (`low/` or `high/`+`mid/`). Detached. */
+	footageDiscard = null;
 	/** Why the last placement pass planned nothing — latched so the line is one
 	*  per episode, not one per 30 s tick. `null` ⇒ the last pass had work. */
 	placementWorkGap = null;
@@ -16064,6 +16534,16 @@ var RecorderV2Addon = class extends BaseAddon {
 			refreshStorageLocationsForMigration: (leaseId) => this.refreshStorageLocationsForMigration(leaseId),
 			assertStorageMigrationLease: (leaseId) => this.assertStorageMigrationLease(leaseId),
 			placementSnapshot: () => this.placementSnapshot(),
+			placementView: () => {
+				const placement = this.placement;
+				if (!placement) throw new Error("placement is not active on this node");
+				return placement.placementView();
+			},
+			setDevicePlacement: (deviceId, locationId) => {
+				const placement = this.placement;
+				if (!placement) throw new Error("placement is not active on this node");
+				return placement.setDevicePin(deviceId, locationId);
+			},
 			dataDir: this.ctx.dataDir,
 			playbackBaseUrl: () => this.playbackBaseUrl,
 			isCameraDevice: async (deviceId) => {
@@ -16226,27 +16706,50 @@ var RecorderV2Addon = class extends BaseAddon {
 			}
 		});
 		warnLostBands(this.configStore(), this.ctx.logger);
+		const providers = [
+			{
+				capability: recordingCapability,
+				provider: recordingProvider
+			},
+			{
+				capability: storageEvictableCapability,
+				provider: evictableProvider
+			},
+			{
+				capability: recordingExportCapability,
+				provider: exportProvider
+			},
+			{
+				capability: loadContributionCapability,
+				provider: { list: () => this.costRegistry.contributions() }
+			}
+		];
+		this.footageDiscard = createFootageDiscardJob({
+			listLocations: async () => this.ctx.api.storage.listLocations.query({}),
+			localNodeId: this.nodeId,
+			index: this.index,
+			ledger: this.segmentHours === null ? null : {
+				streamSegments: (scope) => this.segmentHours.streamSegments(scope),
+				dropSegments: (rows) => this.segmentHours.dropSegments(rows)
+			},
+			now: () => Date.now()
+		});
 		return {
-			providers: [
-				{
-					capability: recordingCapability,
-					provider: recordingProvider
-				},
-				{
-					capability: storageEvictableCapability,
-					provider: evictableProvider
-				},
-				{
-					capability: recordingExportCapability,
-					provider: exportProvider
+			providers,
+			customActions: {
+				...recorderDebugActions,
+				...locationDiscardActions
+			},
+			actionHandlers: {
+				"debug.storeCensus": async (input) => handleStoreCensusAction(this.readCensus, this.ctx.logger.child("Census"), input),
+				"storage.discardLocation": async (input) => this.footageDiscard?.start(input) ?? {
+					started: false,
+					alreadyRunning: false,
+					jobId: null
 				},
-				{
-					capability: loadContributionCapability,
-					provider: { list: () => this.costRegistry.contributions() }
-				}
-			],
-			customActions: recorderDebugActions,
-			actionHandlers: { "debug.storeCensus": async (input) => handleStoreCensusAction(this.readCensus, this.ctx.logger.child("Census"), input) }
+				"storage.discardLocationStatus": async () => this.footageDiscard?.status() ?? IDLE_DISCARD,
+				"storage.discardLocationCancel": async () => this.footageDiscard?.cancel() ?? { requested: false }
+			}
 		};
 	}
 	async onShutdown() {
@@ -16330,7 +16833,7 @@ var RecorderV2Addon = class extends BaseAddon {
 			},
 			logger: this.ctx.logger,
 			now: () => Date.now(),
-			pace: () => sleep(LEDGER_WALK_PAUSE_MS)
+			pace: () => sleep$1(LEDGER_WALK_PAUSE_MS)
 		});
 	}
 	/**
@@ -16479,7 +16982,7 @@ var RecorderV2Addon = class extends BaseAddon {
 				},
 				logger: this.ctx.logger,
 				now: () => Date.now(),
-				pace: () => sleep(GHOST_LOCATION_PROBE_PAUSE_MS)
+				pace: () => sleep$1(GHOST_LOCATION_PROBE_PAUSE_MS)
 			});
 			this.ghostLocationPass = startPeriodicPass({
 				name: "ghost-location-reconcile",
@@ -17253,4 +17756,4 @@ var RecorderV2Addon = class extends BaseAddon {
 	}
 };
 //#endregion
-export { RecorderV2Addon as default };
+export { customActions, RecorderV2Addon as default };