@camstack/system 1.2.179 → 1.2.180

package/dist/{dist-C7qWwrK1.js → dist-TEwQZL3g.js}

@@ -7164,6 +7164,89 @@ var LocationStatSchema = zod.z.object({
 	fileCount: zod.z.number(),
 	present: zod.z.boolean()
 });
+/** Lifecycle of a backup run. Terminal states: succeeded / failed / cancelled. */
+var BackupRunStateSchema = zod.z.enum([
+	"queued",
+	"running",
+	"succeeded",
+	"failed",
+	"cancelled"
+]);
+/**
+* Where a running backup currently is. `queued` before it starts,
+* `building` while the tar.gz is being staged, `uploading` during the
+* per-destination fan-out, `done` once terminal.
+*/
+var BackupRunPhaseSchema = zod.z.enum([
+	"queued",
+	"building",
+	"uploading",
+	"done"
+]);
+/**
+* Observable state of one backup run — readable WHILE it runs via
+* `backup.listRuns`. This is what makes the execution queue and
+* `backup.cancel` usable: the 2026-09-04 incident (two concurrent
+* multi-GB builds, staging 5.1 GB → 18 GB, load 62) was only
+* diagnosable with `du` because nothing reported that runs existed or
+* how large the staged archive had grown.
+*/
+var BackupRunSchema = zod.z.object({
+	/** Stable run id — the handle `backup.cancel` takes. */
+	id: zod.z.string(),
+	state: BackupRunStateSchema,
+	phase: BackupRunPhaseSchema,
+	/**
+	* Resolved destination location ids. Empty while queued (targets are
+	* resolved when the run starts, against the then-current policies).
+	*/
+	destinationIds: zod.z.array(zod.z.string()).readonly(),
+	label: zod.z.string().optional(),
+	/** ms-epoch when the run was submitted (trigger call / schedule fire). */
+	requestedAt: zod.z.number(),
+	/** ms-epoch when the run left the queue and started building. */
+	startedAt: zod.z.number().optional(),
+	/** ms-epoch when the run reached a terminal state. */
+	finishedAt: zod.z.number().optional(),
+	/** Compressed bytes of the staging archive written so far. */
+	stagedBytes: zod.z.number(),
+	/** Final staged archive size, once the build phase completes. */
+	archiveSizeBytes: zod.z.number().optional(),
+	/** Bytes pushed to the destination currently uploading. */
+	uploadedBytes: zod.z.number(),
+	/** Destinations where the archive fully landed (uploaded + indexed). */
+	completedDestinationIds: zod.z.array(zod.z.string()).readonly(),
+	/** Destinations that failed during the fan-out. */
+	failedDestinationIds: zod.z.array(zod.z.string()).readonly(),
+	/** Failure message when `state === 'failed'`. */
+	error: zod.z.string().optional(),
+	/**
+	* 1-based place in the execution queue — 1 = runs next. Present only
+	* while `state === 'queued'`. Stamped by the orchestrator from the
+	* queue's OWN pending order, never derived from timestamps, so the
+	* UI cannot show an order the executor will not honour.
+	*/
+	queuePosition: zod.z.number().int().min(1).optional()
+});
+/**
+* Result of `backup.trigger`. The call still resolves when the run
+* terminates (compat with schedule-driven runs and the admin UI), but
+* it now names the run and says whether it had to WAIT: a trigger that
+* arrives while another run is in flight is enqueued (or joined onto
+* an identical already-queued run), never started concurrently.
+*/
+var BackupTriggerResultSchema = zod.z.object({
+	/** The run this trigger mapped to — poll it via `listRuns`, stop it via `cancel`. */
+	runId: zod.z.string(),
+	/** True when the run waited behind an in-flight run instead of starting immediately. */
+	queued: zod.z.boolean(),
+	/** True when this trigger was coalesced onto an identical already-queued run. */
+	joined: zod.z.boolean(),
+	/** True when the run was cancelled before completing every destination. */
+	cancelled: zod.z.boolean(),
+	/** One entry per destination the archive landed at (partial on cancel). */
+	entries: zod.z.array(BackupEntrySchema).readonly()
+});
 /**
 * A backup schedule — the N:M "entry" that binds one cron cadence to a
 * SET of destination locations. Supersedes the per-location cron on
@@ -7221,6 +7304,11 @@ var backupCapability = {
 		* Trigger a backup. Without `destinations` the orchestrator fans
 		* out to every destination flagged as enabled in the routing
 		* config; with it, only the listed addons receive the archive.
+		*
+		* At most ONE backup run executes at a time — the source tree and
+		* the staging disk are shared by every run, so a second trigger
+		* while one is in flight is enqueued (or joined onto an identical
+		* queued run) and the result says so. See D342.
 		*/
 		trigger: method(zod.z.object({
 			/** Subset of registered `backup-destination` addon ids to write to. */
@@ -7234,7 +7322,30 @@ var backupCapability = {
 			* retention (manual runs).
 			*/
 			retentionCount: zod.z.number().int().min(1).max(1e3).optional()
-		}).optional(), zod.z.array(BackupEntrySchema).readonly(), {
+		}).optional(), BackupTriggerResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Every run the orchestrator knows about, in EXECUTION order: the
+		* running run first, then queued runs in the exact order they will
+		* execute (each with `queuePosition`, 1 = next), then the bounded
+		* finished history newest-first. Only one run executes at a time
+		* (D342) — the queued section IS the line. Each run carries live
+		* phase + byte counters so a runaway build is visible in seconds,
+		* not via `du`.
+		*/
+		listRuns: method(zod.z.void(), zod.z.array(BackupRunSchema).readonly(), { auth: "admin" }),
+		/**
+		* Stop a backup run. Mirrors `storage-migration.cancel` semantics:
+		* id in, `{ cancelled }` out — `false` when the run is unknown or
+		* already terminal. A QUEUED run is removed before it ever starts;
+		* the RUNNING run has its tar/upload stream actually aborted, the
+		* half-written staging archive is deleted, and the in-flight
+		* destination upload is aborted server-side (partial discarded).
+		* Destinations that already completed keep their archive.
+		*/
+		cancel: method(zod.z.object({ runId: zod.z.string() }), zod.z.object({ cancelled: zod.z.boolean() }), {
 			kind: "mutation",
 			auth: "admin"
 		}),
@@ -8112,6 +8223,38 @@ var streamBrokerCapability = {
 			auth: "admin"
 		}),
 		/**
+		* The HARDWARE behind a device number was replaced
+		* (`deviceManager.migrateDevice`). Forget every piece of broker state that
+		* described the old box, so the next catalog pull derives everything from
+		* the camera that is actually there:
+		*
+		*  - every `derived:*` stream definition — a derived is authored against a
+		*    specific profile layout, and against the wrong hardware its feeder
+		*    respawns forever (observed at attempt 2732 on the live hub,
+		*    2026-09-01);
+		*  - the profile-slot assignment entry, PURGED (not unassigned — unassign
+		*    marks the slot manual, which would pin the stale choice instead of
+		*    letting `computeInitialAssignment` re-derive it);
+		*  - the probe snapshots (`<deviceId>/…` — probed codec/resolution of the
+		*    old hardware);
+		*  - the persisted RTSP token rows for the device's brokers (keyed
+		*    `<deviceId>/<camStreamId>`; the stream ids change with the hardware,
+		*    so the rows are dead URLs).
+		*
+		* An RPC, deliberately — an event is telemetry and may be dropped (D8),
+		* and a dropped forget leaves a feeder respawning against a stream that
+		* does not exist.
+		*/
+		forgetDeviceHardware: method(zod.z.object({ deviceId: zod.z.number().int().nonnegative() }), zod.z.object({
+			derivedStreamsDeleted: zod.z.array(zod.z.string()).readonly(),
+			assignmentsPurged: zod.z.boolean(),
+			probeSnapshotsDropped: zod.z.number().int().nonnegative(),
+			rtspTokenRowsDeleted: zod.z.number().int().nonnegative()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
 		* Render a short GIF or MP4 from the broker's PRE-BUFFER around an instant.
 		*
 		* The pre-buffer is the only source that already holds the seconds BEFORE
@@ -34933,6 +35076,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"backup.cancel": {
+		capName: "backup",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"backup.delete": {
 		capName: "backup",
 		capScope: "system",
@@ -34975,6 +35124,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"backup.listRuns": {
+		capName: "backup",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"backup.listSchedules": {
 		capName: "backup",
 		capScope: "system",
@@ -39541,6 +39696,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"streamBroker.forgetDeviceHardware": {
+		capName: "stream-broker",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"streamBroker.getAllRtspEntries": {
 		capName: "stream-broker",
 		capScope: "system",
@@ -41999,6 +42160,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"streamBroker.forgetDeviceHardware": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"streamBroker.getDeviceAudioMute": [{
 		name: "deviceId",
 		form: "single",