@camstack/addon-post-analysis 1.2.63 → 1.2.65

package/dist/{dist-D4fGaA71.js → dist-DTClXZLm.js}

@@ -7421,8 +7421,31 @@ var AdoptionJobSchema = object({
 	error: string().nullable()
 });
 /**
-* Per-camera FUNCTION SWITCHES — the one coherent on/off surface over the
-* pipeline functions an operator thinks in terms of.
+* Per-camera FUNCTION SWITCHES.
+*
+* ## The aggregate group is being withdrawn — the BADGE is not (D113)
+*
+* This file shipped as "the one coherent on/off surface over the pipeline
+* functions an operator thinks in terms of". The operator's verdict on
+* 2026-08-12 was that the coherent surface bought complexity and no clarity:
+* every function already had a settings page of its own, and a second place to
+* turn it off is a second place to look. Each switch is going back to its own
+* component's original options — detection to the detection-pipeline wrapper
+* binding, audio analysis to its own, recording to `RecordingConfig.enabled`
+* (which was always first-class; the switch was a veneer over
+* `recording.setDeviceConfig`), notifications to a notification-center
+* per-device setting, the two camera planes to their own components.
+*
+* What survives is {@link composeSwitchedOff}: `CameraStatus.switchedOff`, the
+* thing that lets a status surface say DISABLED instead of BROKEN, recomposed
+* straight from the authorities with no group in the middle. That rule was
+* never about a control panel.
+*
+* Everything else here — {@link CAMERA_SWITCH_CATALOG}, {@link CameraSwitch},
+* {@link deriveCameraSwitches}, the `pipelineOrchestrator.getCameraSwitches` /
+* `setCameraSwitch` pair — is a COMPATIBILITY surface for as long as deployed
+* viewers (v1.0.305) and the admin UI still call it. It is deleted when they
+* stop; nothing new may be built on it.
 *
 * ## This file adds no state
 *
@@ -7784,14 +7807,29 @@ var RecordingConfigSchema = object({
 	scrubThumbnails: ScrubThumbnailPresetSchema.optional()
 }).strict();
 /**
+* Derive the {@link RecordingStorageModeSchema} summary from the authoritative
+* bands: `continuous` when any band records continuously, `events` when a band
+* exists at all, else `off`. Pure.
+*
+* THE one definition: the recorder stamps `config.mode` with it on save and
+* reports it as the cap's `activeMode`, and the settings UI reads it back to
+* decide which authoring tab a config opens in. Two copies would drift, and the
+* symptom (a status dot disagreeing with what is being recorded) is exactly the
+* bug this field was added to fix.
+*/
+function deriveRecordingMode(config) {
+	if (!config.enabled || config.bands.length === 0) return "off";
+	if (config.bands.some((band) => band.mode === "continuous")) return "continuous";
+	return "events";
+}
+/**
 * Entity-relocation job state (storage entity-routing spec, Phase 4).
 *
-* One shape shared by the recorder's `relocateFootage` (segments) and
-* pipeline-analytics' `relocateMedia` (event media blobs) so the admin Data
-* page renders both movers with one component. Jobs are in-RAM (a restart
-* forgets them — re-running is safe by construction: copy-if-absent, delete
-* after verify) and each completed/failed run also lands one durable ops-log
-* row on the owning addon's surface.
+* One shape shared by the recorder and pipeline-analytics internal movers.
+* The public admin surface is `storage-migration`; child jobs remain in RAM
+* because copy-if-absent, verify, delete and index/row repoint are resumable.
+* Each completed/failed run also lands one durable ops-log row on its owning
+* addon surface.
 */
 var RelocateJobStateSchema = _enum([
 	"running",
@@ -7818,19 +7856,100 @@ var RelocateJobSchema = object({
 	finishedAt: number().nullable(),
 	error: string().nullable()
 });
+/** Profile-derived footage selection used only by the migration coordinator:
+* `recordings` owns high+mid; `recordingsLow` owns low. */
+var RelocateFootageClassSchema = _enum(["recordings", "recordingsLow"]);
 var RelocateFootageInputSchema = object({
-	deviceId: number().optional(),
 	fromLocationId: string(),
 	toLocationId: string(),
 	entities: array(_enum(["segments"])).optional(),
+	/** Limits relocation to the logical profile class. Omit only for the
+	* pre-orchestration compatibility path. */
+	footageClass: RelocateFootageClassSchema.optional(),
 	/** Copy throttle in MB/s (default 40) — the drain is a background chore,
 	*  never allowed to starve live writers. */
 	throttleMbps: number().min(1).max(1e3).optional()
 });
-var RelocateMediaInputSchema = object({
-	deviceId: number().optional(),
+/** Internal, lease-scoped participant operation. It is intentionally separate
+* from persistent recording settings: a migration never changes
+* `RecordingConfig.enabled` or camera wrapper bindings. */
+var StorageMigrationLeaseInputSchema = object({ leaseId: string().min(1) });
+var StorageMigrationFootageMoveInputSchema = RelocateFootageInputSchema.extend({ leaseId: string().min(1) });
+var StorageMigrationMediaMoveInputSchema = object({
 	toLocationId: string(),
 	throttleMbps: number().min(1).max(1e3).optional()
+}).extend({ leaseId: string().min(1) });
+/** The independently selectable logical storage classes. `recordings`
+* encompasses the high and mid segment profiles; `recordingsLow` is low
+* segments; `eventMedia` is post-analysis blobs. */
+var StorageMigrationClassSchema = _enum([
+	"recordings",
+	"recordingsLow",
+	"eventMedia"
+]);
+/** A destination is always an existing, fully-qualified location id. The
+* migration API intentionally never changes a source location's `basePath`:
+* callers create a new `<type>:<slug>` location, then select it here. */
+var StorageMigrationDestinationsSchema = object({
+	recordings: string().min(1).optional(),
+	recordingsLow: string().min(1).optional(),
+	eventMedia: string().min(1).optional()
+}).refine((value) => Object.keys(value).length > 0, { message: "select at least one storage class" });
+/** Shared input for planning and starting an orchestrated storage migration. */
+var StorageMigrationInputSchema = object({
+	destinations: StorageMigrationDestinationsSchema,
+	throttleMbps: number().min(1).max(1e3).optional()
+});
+/** The durable coordinator state machine. The only phase that changes default
+* locations is `repointing`, after every selected mover has completed and been
+* verified. */
+var StorageMigrationPhaseSchema = _enum([
+	"planning",
+	"pausing",
+	"moving",
+	"verifying",
+	"repointing",
+	"refreshing",
+	"resuming",
+	"done",
+	"failed",
+	"cancelled"
+]);
+var StorageMigrationParticipantSchema = _enum([
+	"pipeline",
+	"recorder",
+	"analytics"
+]);
+var StorageMigrationMoveSchema = object({
+	storageClass: StorageMigrationClassSchema,
+	fromLocationId: string(),
+	toLocationId: string(),
+	moverJobId: string().nullable(),
+	state: RelocateJobStateSchema.nullable(),
+	error: string().nullable()
+});
+var StorageMigrationJobSchema = object({
+	jobId: string(),
+	phase: StorageMigrationPhaseSchema,
+	destinations: StorageMigrationDestinationsSchema,
+	throttleMbps: number(),
+	moves: array(StorageMigrationMoveSchema),
+	pauseLeaseId: string().nullable(),
+	pausedParticipants: array(StorageMigrationParticipantSchema),
+	repointed: boolean(),
+	cancelRequested: boolean(),
+	startedAt: number(),
+	updatedAt: number(),
+	finishedAt: number().nullable(),
+	error: string().nullable()
+});
+var StorageMigrationPlanSchema = object({
+	destinations: StorageMigrationDestinationsSchema,
+	moves: array(object({
+		storageClass: StorageMigrationClassSchema,
+		fromLocationId: string(),
+		toLocationId: string()
+	}))
 });
 /**
 * `StorageLocationType` — an addon-declared id that identifies the *kind* of
@@ -17149,20 +17268,28 @@ var pipelineAnalyticsCapability = {
 		}),
 		/** The events ops-log rows (newest-first), optionally scoped to one camera.
 		*  Backed by a declared pipeline-analytics SQLite collection. */
-		/**
-		* Move event-media blobs onto `toLocationId` (entity-routing spec Phase
-		* 4): per-row copy → stamp row.locationId → delete old blob. Rows already
-		* at the target are skipped, so a re-run resumes. Single-flight.
-		*/
-		relocateMedia: method(RelocateMediaInputSchema, object({ jobId: string() }), {
+		/** Internal migration-participant lease. It drains active MediaStore
+		* writes and refuses new ones without changing analytics bindings. */
+		pauseForStorageMigration: method(StorageMigrationLeaseInputSchema, object({ paused: literal(true) }), {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		getMediaRelocateStatus: method(object({}), array(RelocateJobSchema).readonly(), {
-			kind: "query",
+		resumeForStorageMigration: method(StorageMigrationLeaseInputSchema, object({ resumed: literal(true) }), {
+			kind: "mutation",
 			auth: "admin"
 		}),
-		cancelMediaRelocate: method(object({ jobId: string() }), object({ cancelled: boolean() }), {
+		/** Drops cached location roots after the storage coordinator repoints a
+		* default so future event-media writes use the new root. */
+		refreshStorageLocationsForMigration: method(StorageMigrationLeaseInputSchema, object({ refreshed: literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		startStorageMigrationMove: method(StorageMigrationMediaMoveInputSchema, object({ jobId: string() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getStorageMigrationMoveStatus: method(object({ jobId: string() }), RelocateJobSchema.nullable(), { auth: "admin" }),
+		cancelStorageMigrationMove: method(object({ jobId: string() }), object({ cancelled: boolean() }), {
 			kind: "mutation",
 			auth: "admin"
 		}),
@@ -18825,9 +18952,16 @@ var CameraStatusSchema = object({
 	audio: CameraAudioStatusSchema.nullable(),
 	recording: CameraRecordingStatusSchema.nullable(),
 	/**
-	* Per-camera function switches an OPERATOR has turned off
+	* Per-camera functions an OPERATOR has turned off
 	* ([D61](../../../../docs/decisions/adr-0067.md)).
 	*
+	* Composed from the AUTHORITIES themselves — the wrapper bindings,
+	* `RecordingConfig.enabled`, the notification mute, the broker's audio
+	* policy, the camera's own microphone — via `composeSwitchedOff`, not from
+	* the deprecated `getCameraSwitches` group ([D113](../../../../docs/decisions/adr-0113.md)).
+	* The badge outlives the control panel: the panel was a convenience, this is
+	* the difference between a camera being off and a camera being dead.
+	*
 	* This is the difference between DISABLED and BROKEN. A camera whose
 	* `detection` block reports zero fps and whose `switchedOff` contains
 	* `'object-detection'` was switched off by a person; the same camera with an
@@ -18898,7 +19032,13 @@ var NodeInferenceDevicesSchema = object({
 	reachable: boolean(),
 	devices: array(NodeInferenceDeviceSchema).readonly()
 });
-method(object({
+method(StorageMigrationLeaseInputSchema, object({ paused: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(StorageMigrationLeaseInputSchema, object({ resumed: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
 	deviceId: number(),
 	agentNodeId: string()
 }), object({ success: literal(true) }), {
@@ -19602,6 +19742,13 @@ method(object({ locationId: string() }), EvictableUsageSchema), method(object({
 	locationId: string(),
 	targetBytes: number().int().positive()
 }), EvictResultSchema, { kind: "mutation" });
+method(StorageMigrationInputSchema, StorageMigrationPlanSchema, { auth: "admin" }), method(StorageMigrationInputSchema, object({ jobId: string() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ jobId: string().optional() }), StorageMigrationJobSchema.nullable(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
+	kind: "mutation",
+	auth: "admin"
+});
 var ProviderInfoSchema = discriminatedUnion("shouldSaveDiskSpace", [object({
 	providerId: string().min(1),
 	displayName: string().min(1),
@@ -19705,6 +19852,28 @@ var TerminalProfileInfoSchema = object({
 	label: string(),
 	description: string().optional()
 });
+/**
+* A durable operator-created Terminal instance. Profiles are templates; only
+* an instance declares a camera.
+*/
+var TerminalInstanceInfoSchema = object({
+	instanceId: string(),
+	cameraStableId: string(),
+	nodeId: string(),
+	profileId: string(),
+	profileLabel: string(),
+	name: string(),
+	enabled: boolean()
+});
+var TerminalLegacyCameraSchema = object({
+	stableId: string(),
+	nodeId: string(),
+	profileId: string(),
+	profileLabel: string(),
+	name: string(),
+	/** Only legacy monitor cameras can retain their historic stable identity. */
+	adoptable: boolean()
+});
 var TerminalOutputEventSchema = discriminatedUnion("kind", [object({
 	seq: number().int().positive(),
 	kind: literal("data"),
@@ -19721,7 +19890,29 @@ var TerminalOutputBatchSchema = object({
 	snapshot: string().optional(),
 	events: array(TerminalOutputEventSchema).readonly()
 });
-method(_void(), array(TerminalProfileInfoSchema).readonly(), { auth: "admin" }), method(_void(), array(TerminalSessionInfoSchema).readonly(), { auth: "admin" }), method(object({
+method(_void(), array(TerminalProfileInfoSchema).readonly(), { auth: "admin" }), method(_void(), array(TerminalInstanceInfoSchema).readonly(), { auth: "admin" }), method(object({
+	targetNodeId: string().min(1),
+	profileId: string().min(1),
+	name: string().trim().min(1).max(160).optional()
+}), TerminalInstanceInfoSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ instanceId: string().min(1) }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	instanceId: string().min(1),
+	enabled: boolean()
+}), TerminalInstanceInfoSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(_void(), array(TerminalLegacyCameraSchema).readonly(), { auth: "admin" }), method(object({
+	stableId: string().min(1),
+	name: string().trim().min(1).max(160).optional()
+}), TerminalInstanceInfoSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(_void(), array(TerminalSessionInfoSchema).readonly(), { auth: "admin" }), method(object({
 	profileId: string(),
 	cols: number().int().positive(),
 	rows: number().int().positive()
@@ -19738,7 +19929,13 @@ method(_void(), array(TerminalProfileInfoSchema).readonly(), { auth: "admin" }),
 }), method(object({
 	sessionId: string(),
 	afterSeq: number().int().nonnegative(),
-	waitMs: number().int().min(0).max(2e3).default(0)
+	waitMs: number().int().min(0).max(2e3).default(0),
+	/**
+	* Wait when a just-opened session has no output yet. Kept opt-in so a
+	* browser's initial repaint remains immediate; the camera snapshot
+	* relay uses it to avoid encoding a blank startup frame.
+	*/
+	waitForOutput: boolean().optional()
 }), TerminalOutputBatchSchema, {
 	kind: "mutation",
 	auth: "admin",
@@ -25785,13 +25982,19 @@ method(object({
 }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(RelocateFootageInputSchema, object({ jobId: string() }), {
+}), method(StorageMigrationLeaseInputSchema, object({ paused: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({}), array(RelocateJobSchema).readonly(), {
-	kind: "query",
+}), method(StorageMigrationLeaseInputSchema, object({ resumed: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(StorageMigrationLeaseInputSchema, object({ refreshed: literal(true) }), {
+	kind: "mutation",
 	auth: "admin"
-}), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
+}), method(StorageMigrationFootageMoveInputSchema, object({ jobId: string() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ jobId: string() }), RelocateJobSchema.nullable(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
 	kind: "mutation",
 	auth: "admin"
 });
@@ -25811,10 +26014,42 @@ method(object({
 */
 /** Playback-speed multiplier for the render (1 = realtime). */
 var ExportSpeedSchema = number().min(.25).max(32);
+/**
+* One dense interval, in SECONDS FROM THE EXPORT'S OWN `fromMs`.
+*
+* Relative and not absolute epoch on purpose: the renderer's frame-select
+* expression sees ffmpeg's `t`, which starts at 0 for the export's source
+* playlist. Handing it absolute epochs would make every call site responsible
+* for the same subtraction, and the one that forgot would emit a filter that
+* selects nothing — silently, as a uniform timelapse.
+*/
+var ExportDenseRangeSchema = object({
+	fromSec: number().nonnegative(),
+	toSec: number().nonnegative()
+}).refine((r) => r.toSec > r.fromSec, { message: "dense range must have toSec > fromSec" });
+/**
+* Dense-interval overlay for a timelapse: sample at `dense.everyMs` INSIDE the
+* listed ranges and at the base `everyMs` everywhere else.
+*
+* `everyMs` must be strictly smaller than the base cadence — a dense rate that
+* is not denser renders a uniform timelapse the operator believes is two-rate.
+*/
+var ExportDenseSchema = object({
+	everyMs: number().int().positive(),
+	ranges: array(ExportDenseRangeSchema).min(1).max(200)
+});
 /** Timelapse cadence — sample one source frame per `everyMs`, output at `outputFps`. */
 var ExportTimelapseSchema = object({
 	everyMs: number().int().positive(),
-	outputFps: number().int().min(1).max(60).optional()
+	outputFps: number().int().min(1).max(60).optional(),
+	/** Optional second, FASTER rate over the intervals that matter. */
+	dense: ExportDenseSchema.optional()
+}).superRefine((v, ctx) => {
+	if (v.dense !== void 0 && v.dense.everyMs >= v.everyMs) ctx.addIssue({
+		code: ZodIssueCode.custom,
+		message: "dense.everyMs must be strictly smaller than the base everyMs",
+		path: ["dense", "everyMs"]
+	});
 });
 /**
 * Render options. `speed` and `timelapse` are mutually exclusive. `includeAudio`
@@ -25872,6 +26107,38 @@ var ExportDownloadSchema = object({
 	url: string(),
 	endpoints: array(string())
 });
+/**
+* Hard ceiling on ONE {@link recordingExportCapability} byte read — 50 MiB.
+*
+* Two independent reasons land on the same number, which is why it is this one
+* and not a rounder guess:
+*
+*  - **Nobody would accept more.** The roomiest byte cap any notifier backend
+*    declares is telegram's 50 MiB, and the degrade engine DROPS an over-cap
+*    attachment outright rather than degrading it to a link. Bytes above this
+*    are read, encoded and moved to be thrown away at the last step.
+*  - **The envelope is unary.** A base64 payload is held whole, ~1.33× its
+*    size, in the provider AND in the caller — on a hub this repo has already
+*    OOM'd once (D9/D18). A bounded on-demand read at human speed is the shape
+*    those records permit; an unbounded one is the shape they forbid.
+*
+* Above it the provider REFUSES with a log line rather than truncating: half a
+* video is worse than a notification that says there is no attachment.
+*/
+var RECORDING_EXPORT_MAX_READ_BYTES = 50 * 1024 * 1024;
+/**
+* A finished export's bytes, inline.
+*
+* `bytes` is the DECODED length — the number the caller bounds and logs
+* against, so nobody has to infer it from the base64 length.
+*/
+var ExportBytesSchema = object({
+	base64: string(),
+	contentType: string(),
+	/** Suggested filename, extension included. */
+	name: string(),
+	bytes: number().int().nonnegative()
+});
 method(object({
 	deviceId: number(),
 	profile: string(),
@@ -25896,6 +26163,9 @@ method(object({
 }), method(object({ exportId: string() }), ExportDownloadSchema, {
 	kind: "query",
 	auth: "protected"
+}), method(object({ exportId: string() }), ExportBytesSchema, {
+	kind: "query",
+	auth: "protected"
 });
 /**
 * scene-monitor — device-scoped reference-region state cap. An operator marks
@@ -28362,9 +28632,10 @@ var DeclaredDevices = class {
 		}
 		const integrationId = spec.integrationId ?? await this.ensureIntegration(spec.integrationName);
 		const index = await this.readIndex();
+		const live = await this.readLiveByStableId();
 		const outcomes = [];
 		for (const declaration of spec.devices) {
-			const outcome = await this.applyDeclaration(declaration, integrationId, index);
+			const outcome = await this.applyDeclaration(declaration, integrationId, index, live);
 			if (outcome !== null) outcomes.push(outcome);
 		}
 		return {
@@ -28410,6 +28681,26 @@ var DeclaredDevices = class {
 		return new Map(rows.map((row) => [row.stableId, row]));
 	}
 	/**
+	* Devices this kernel already has CONSTRUCTED, by stableId.
+	*
+	* Distinct from {@link readIndex}, and the distinction is the bug: the index
+	* is persisted rows, this is live objects. A row without an object must be
+	* adopted; an object must be left exactly as it is.
+	*
+	* Failure is non-fatal and deliberately so — an empty map degrades to the
+	* previous behaviour (attempt the adopt) rather than skipping a device that
+	* genuinely needs bringing up.
+	*/
+	async readLiveByStableId() {
+		try {
+			const devices = await this.ports.devices.getAll();
+			return new Map(devices.map((device) => [device.stableId, device]));
+		} catch (err) {
+			this.ports.logger.warn("could not read live devices — falling back to adopt-by-row", { meta: { error: err instanceof Error ? err.message : String(err) } });
+			return /* @__PURE__ */ new Map();
+		}
+	}
+	/**
 	* One declaration: adopt what exists, create what does not.
 	*
 	* The create branch is the destructive one — it seeds `initialMeta`, and
@@ -28418,8 +28709,15 @@ var DeclaredDevices = class {
 	* the declared name over the operator's rename. D49: that branch needs a
 	* second read to agree.
 	*/
-	async applyDeclaration(declaration, integrationId, index) {
+	async applyDeclaration(declaration, integrationId, index, live) {
 		try {
+			const alreadyLive = live.get(declaration.stableId);
+			if (alreadyLive !== void 0) return {
+				stableId: declaration.stableId,
+				deviceId: alreadyLive.id,
+				device: alreadyLive,
+				created: false
+			};
 			let existing = index.get(declaration.stableId);
 			if (existing === void 0) {
 				existing = (await this.readIndex()).get(declaration.stableId);
@@ -31524,7 +31822,7 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineAnalytics.cancelMediaRelocate": {
+	"pipelineAnalytics.cancelStorageMigrationMove": {
 		capName: "pipeline-analytics",
 		capScope: "device",
 		addonId: null,
@@ -31596,12 +31894,6 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"pipelineAnalytics.getMediaRelocateStatus": {
-		capName: "pipeline-analytics",
-		capScope: "device",
-		addonId: null,
-		access: "view"
-	},
 	"pipelineAnalytics.getMotionEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -31638,6 +31930,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getStorageMigrationMoveStatus": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getTrack": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -31716,6 +32014,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.pauseForStorageMigration": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.proposeRetrainAnnotations": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -31746,7 +32050,7 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineAnalytics.relocateMedia": {
+	"pipelineAnalytics.refreshStorageLocationsForMigration": {
 		capName: "pipeline-analytics",
 		capScope: "device",
 		addonId: null,
@@ -31758,6 +32062,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.resumeForStorageMigration": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.saveRetrainAnnotations": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -31782,6 +32092,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.startStorageMigrationMove": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.wipeAllAnalytics": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -32148,6 +32464,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.pauseForStorageMigration": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.rebalance": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -32172,6 +32494,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.resumeForStorageMigration": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.saveTemplate": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -32568,7 +32896,7 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"recording.cancelRelocate": {
+	"recording.cancelStorageMigrationMove": {
 		capName: "recording",
 		capScope: "system",
 		addonId: null,
@@ -32604,7 +32932,7 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"recording.getRelocateStatus": {
+	"recording.getStorageMigrationMoveStatus": {
 		capName: "recording",
 		capScope: "system",
 		addonId: null,
@@ -32628,6 +32956,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recording.pauseForStorageMigration": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"recording.pruneFootage": {
 		capName: "recording",
 		capScope: "system",
@@ -32646,7 +32980,7 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"recording.relocateFootage": {
+	"recording.refreshStorageLocationsForMigration": {
 		capName: "recording",
 		capScope: "system",
 		addonId: null,
@@ -32670,12 +33004,24 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"recording.resumeForStorageMigration": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"recording.setDeviceConfig": {
 		capName: "recording",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"recording.startStorageMigrationMove": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"recordingExport.cancelExport": {
 		capName: "recordingExport",
 		capScope: "system",
@@ -32712,6 +33058,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recordingExport.readExportBytes": {
+		capName: "recordingExport",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"sceneMonitor.captureReference": {
 		capName: "scene-monitor",
 		capScope: "device",
@@ -33066,6 +33418,30 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"storageMigration.cancel": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"storageMigration.plan": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"storageMigration.start": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"storageMigration.status": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"storageProvider.abortUpload": {
 		capName: "storage-provider",
 		capScope: "system",
@@ -33444,12 +33820,42 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"terminalSession.adoptLegacyMonitor": {
+		capName: "terminal-session",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"terminalSession.close": {
 		capName: "terminal-session",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"terminalSession.createInstance": {
+		capName: "terminal-session",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"terminalSession.deleteInstance": {
+		capName: "terminal-session",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"terminalSession.listInstances": {
+		capName: "terminal-session",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"terminalSession.listLegacyCameras": {
+		capName: "terminal-session",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"terminalSession.listProfiles": {
 		capName: "terminal-session",
 		capScope: "system",
@@ -33480,6 +33886,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"terminalSession.setInstanceEnabled": {
+		capName: "terminal-session",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"terminalSession.writeInput": {
 		capName: "terminal-session",
 		capScope: "system",
@@ -34109,7 +34521,23 @@ var TimelapseRuleInputSchema = object({
 	/** Canonical notification priority ordinal (1..5); per-target overridable. */
 	priority: PriorityField.default(3)
 });
-object({
+/**
+* Partial patch for an update — any subset of the INPUT fields, with NO
+* defaults (an absent key means "leave unchanged", never "reset to default").
+* Provenance and ownership are absent by construction: a patch can rename or
+* retune a rule, never re-own it or forge its generation state.
+*
+* CLEAR SIGNAL: `template` is the one OPTIONAL field an editor can REMOVE, so
+* it is `.nullable()` here and NOWHERE else. Wire representation:
+*  - key absent          → leave the template unchanged
+*  - `"template": null`  → CLEAR it (the persisted rule loses the key)
+*  - `"template": {...}` → replace it
+* `undefined` is deliberately NOT the clear signal: it does not survive
+* `JSON.stringify`, so a viewer editor could not express "remove". The
+* PERSISTED rule never carries `null` — the store drops the key (see
+* `TimelapseStore.update`).
+*/
+var TimelapseRulePatchSchema = object({
 	name: NameField.optional(),
 	enabled: boolean().optional(),
 	deviceIds: DeviceIdsField.optional(),
@@ -34130,15 +34558,50 @@ var TimelapseRuleSchema = TimelapseRuleInputSchema.extend({
 	*/
 	ownerUserId: string().optional(),
 	/**
-	* Epoch-ms of the last successful generation — the 1-hour re-generation
-	* guard's durable state (predecessor parity). Absent = never generated.
+	* Epoch-ms of the NEWEST successful generation across every camera of this
+	* rule. What a UI shows, and the compatibility floor for
+	* {@link readTimelapseGeneratedAt}. Absent = never generated.
 	*/
 	lastGeneratedAt: number().optional(),
+	/**
+	* PER-CAMERA generation state, keyed by `String(deviceId)` — the
+	* re-generation guard's real durable state.
+	*
+	* One rule covers several cameras and each renders its own video, so a rule
+	* -wide stamp is wrong in the direction that DESTROYS work: camera A
+	* succeeding at 06:05 tells camera B, whose render failed, that it is
+	* already done — and B's night is gone for good, because the window will not
+	* come back.
+	*
+	* ADDITIVE, so the migration is free: a row written before this field simply
+	* has no map, and {@link readTimelapseGeneratedAt} falls back to
+	* {@link TimelapseRuleSchema.shape.lastGeneratedAt}. Reading an old row as
+	* "never generated" would re-render and re-notify every camera of every rule
+	* once, on the deploy that shipped the map.
+	*/
+	generatedByDevice: record(string(), number()).optional(),
 	/** userId of the caller who created the rule (server-stamped). */
 	createdBy: string(),
 	createdAt: number(),
 	updatedAt: number()
 });
+/**
+* The last successful generation for ONE camera of a rule, epoch-ms.
+*
+* The per-device map wins; a rule with no map falls back to the rule-wide
+* `lastGeneratedAt` (the compatible-migration path — see
+* {@link TimelapseRuleSchema}); a rule with neither returns 0, which every
+* guard reads as "never generated".
+*
+* Read through this helper and never off the field directly: the fallback is
+* the whole migration, and a call site that forgot it would re-render an
+* entire rule set once.
+*/
+function readTimelapseGeneratedAt(rule, deviceId) {
+	const map = rule.generatedByDevice;
+	if (map !== void 0) return map[String(deviceId)] ?? 0;
+	return rule.lastGeneratedAt ?? 0;
+}
 object({
 	/**
 	* Fraction of the box's own size added on EACH side before cutting.
@@ -34417,6 +34880,12 @@ Object.defineProperty(exports, "OpsLogEntrySchema", {
 		return OpsLogEntrySchema;
 	}
 });
+Object.defineProperty(exports, "RECORDING_EXPORT_MAX_READ_BYTES", {
+	enumerable: true,
+	get: function() {
+		return RECORDING_EXPORT_MAX_READ_BYTES;
+	}
+});
 Object.defineProperty(exports, "RetrainStatusSchema", {
 	enumerable: true,
 	get: function() {
@@ -34429,6 +34898,12 @@ Object.defineProperty(exports, "TimelapseRuleInputSchema", {
 		return TimelapseRuleInputSchema;
 	}
 });
+Object.defineProperty(exports, "TimelapseRulePatchSchema", {
+	enumerable: true,
+	get: function() {
+		return TimelapseRulePatchSchema;
+	}
+});
 Object.defineProperty(exports, "TimelapseRuleSchema", {
 	enumerable: true,
 	get: function() {
@@ -34519,6 +34994,12 @@ Object.defineProperty(exports, "defineCustomActions", {
 		return defineCustomActions;
 	}
 });
+Object.defineProperty(exports, "deriveRecordingMode", {
+	enumerable: true,
+	get: function() {
+		return deriveRecordingMode;
+	}
+});
 Object.defineProperty(exports, "embeddingEncoderCapability", {
 	enumerable: true,
 	get: function() {
@@ -34621,6 +35102,12 @@ Object.defineProperty(exports, "readDeviceStateFrom", {
 		return readDeviceStateFrom;
 	}
 });
+Object.defineProperty(exports, "readTimelapseGeneratedAt", {
+	enumerable: true,
+	get: function() {
+		return readTimelapseGeneratedAt;
+	}
+});
 Object.defineProperty(exports, "record", {
 	enumerable: true,
 	get: function() {