@camstack/system 1.2.164 → 1.2.166

package/dist/builtins/storage-orchestrator/storage-orchestrator.service.d.ts

@@ -165,7 +165,7 @@ export declare class StorageOrchestratorService {
      * Reconciles both directions so operator edits survive a reboot:
      *   1. hydrate — DB rows win over any early in-memory seed (restores
      *      operator config like `minFreePercent` that the pre-store boot
-     *      can't see), with the same `isSystem` upgrade as {@link initialize};
+     *      can't see);
      *   2. backfill — in-memory locations the DB doesn't have yet (the
      *      pre-store seed defaults on a fresh install) are persisted, so the
      *      store becomes the durable source of truth from here on.
@@ -308,13 +308,12 @@ export declare class StorageOrchestratorService {
     private refuseIncompatibleProvider;
     upsertLocation(input: Omit<StorageLocation, 'createdAt' | 'updatedAt'>): StorageLocation;
     /**
-     * Remove a location. Refuses to remove the default of a type unless a
-     * sibling default exists (defensive — `upsertLocation` already ensures
-     * at most one default per type, but the logic guards against future
-     * bypass paths e.g. SQLite migration that imports two defaults).
-     *
-     * Persistence (Task 6) mirrors the delete asynchronously, with errors
-     * routed to the logger — see `upsertLocation` for the rationale.
+     * Remove a location. Refuses the last location of a type and the last
+     * enabled location of a type. `isSystem` is informational — a frozen
+     * recordings `:default` is deletable once a sibling is live. Deleting
+     * the flagged default promotes an enabled sibling. Occupancy still
+     * refuses unless `force` is set; force never overrides uniqueness /
+     * last-enabled.
      */
     deleteLocation(id: string, options?: DeleteLocationOptions): Promise<void>;
     /**
@@ -323,15 +322,14 @@ export declare class StorageOrchestratorService {
      */
     private probeOccupancy;
     /**
-     * Remove system-seeded locations whose type is no longer declared by any
-     * addon (stale defaults from a removed location type). Operator-added
-     * (non-system) locations of an undeclared type are KEPT but warned — the
-     * operator owns them. Requires the registry to be set first.
+     * Remove seed-shaped locations (`<type>:default`) whose type is no longer
+     * declared by any addon (stale defaults from a removed location type).
+     * Operator-added locations of an undeclared type are KEPT but warned.
      *
      * FAIL-SAFE: if the registry is EMPTY (no addon declared any location), we
      * refuse to prune anything. An empty registry almost always means
      * declarations failed to load (boot ordering, a stale install) — pruning
-     * "everything undeclared" in that state would wipe every system location
+     * "everything undeclared" in that state would wipe every seeded location
      * (data/logs/recordings/…). Better to keep stale rows than destroy live ones.
      */
     pruneUndeclaredSystemLocations(): void;

package/dist/builtins/system-config/system-config.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-BhE8zNfY.js");
+const require_dist = require("../../dist-CFTKQGym.js");
 //#region src/builtins/system-config/system-config.addon.ts
 /**
 * Built-in `system-config` addon — Phase 4 of the settings redesign.

package/dist/builtins/system-config/system-config.addon.mjs

@@ -1,4 +1,4 @@
-import { Mt as BaseAddon, Yt as hydrateSchema, jt as errMsg } from "../../dist-BpsHt11f.mjs";
+import { Mt as errMsg, Nt as BaseAddon, Xt as hydrateSchema } from "../../dist-Dw9cm1NS.mjs";
 //#region src/builtins/system-config/system-config.addon.ts
 /**
 * Built-in `system-config` addon — Phase 4 of the settings redesign.

package/dist/builtins/winston-logging/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-BhE8zNfY.js");
+const require_dist = require("../../dist-CFTKQGym.js");
 const require_formatter = require("../../formatter-DqAKDlvN.js");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);

package/dist/builtins/winston-logging/index.mjs

@@ -1,4 +1,4 @@
-import { Mt as BaseAddon, ot as logDestinationCapability } from "../../dist-BpsHt11f.mjs";
+import { Nt as BaseAddon, st as logDestinationCapability } from "../../dist-Dw9cm1NS.mjs";
 import { t as formatLogLine } from "../../formatter-B7qW8bPJ.mjs";
 import * as path$1 from "node:path";
 import path from "node:path";

package/dist/{dist-BhE8zNfY.js → dist-CFTKQGym.js}

@@ -4270,6 +4270,13 @@ var MediaRelocateModeSchema = zod.z.enum([
 ]);
 var RelocateMediaInputSchema = zod.z.object({
 	toLocationId: zod.z.string(),
+	/**
+	* Restrict the pass to rows currently on this location. Omitted / `'*'` =
+	* every row that is not already on `toLocationId` (the historical
+	* behaviour). A named source is what a from→to migration needs: without it
+	* "move events off disk 2" also emptied disk 1.
+	*/
+	fromLocationId: zod.z.string().optional(),
 	throttleMbps: zod.z.number().min(1).max(1e3).optional(),
 	/** Omitted = `move`, the pre-existing behaviour. */
 	mode: MediaRelocateModeSchema.optional()
@@ -4337,6 +4344,19 @@ var StorageMigrationDestinationsSchema = zod.z.object({
 	galleryMedia: zod.z.string().min(1).optional()
 }).refine((value) => Object.keys(value).length > 0, { message: "select at least one storage class" });
 /**
+* Optional named source per class. Omitted = the class's current default
+* (the historical behaviour). A named source that is NOT the default is a
+* drain of that disk: bytes move, the default stays, and the source is
+* disabled when the move finishes.
+*/
+var StorageMigrationSourcesSchema = zod.z.object({
+	recordings: zod.z.string().min(1).optional(),
+	recordingsLow: zod.z.string().min(1).optional(),
+	eventMedia: zod.z.string().min(1).optional(),
+	backups: zod.z.string().min(1).optional(),
+	galleryMedia: zod.z.string().min(1).optional()
+}).optional();
+/**
 * How a migration sequences the cutover against the byte move.
 *
 *  - `blocking`     — the historical order: pause, move every byte, repoint,
@@ -4358,6 +4378,8 @@ var StorageMigrationModeSchema = zod.z.enum(["blocking", "nonBlocking"]);
 /** Shared input for planning and starting an orchestrated storage migration. */
 var StorageMigrationInputSchema = zod.z.object({
 	destinations: StorageMigrationDestinationsSchema,
+	/** Omitted = each class's current default. */
+	sources: StorageMigrationSourcesSchema,
 	throttleMbps: zod.z.number().min(1).max(1e3).optional(),
 	/** Omitted = `blocking`, which stays the default. */
 	mode: StorageMigrationModeSchema.optional()
@@ -4437,6 +4459,13 @@ var StorageMigrationMoveSchema = zod.z.object({
 	storageClass: StorageMigrationClassSchema,
 	fromLocationId: zod.z.string(),
 	toLocationId: zod.z.string(),
+	/**
+	* True when `from` was NOT the class default at plan time. The move still
+	* copies bytes, but the default is left alone and the source is disabled
+	* once the copy verifies. Absent on jobs planned before this field existed
+	* — those jobs always repointed, which is `false`.
+	*/
+	freezeSource: zod.z.boolean().optional(),
 	moverJobId: zod.z.string().nullable(),
 	state: RelocateJobStateSchema.nullable(),
 	error: zod.z.string().nullable(),
@@ -4450,6 +4479,7 @@ var StorageMigrationJobSchema = zod.z.object({
 	*  can tell a seconds-long cutover from a thirty-hour one. */
 	mode: StorageMigrationModeSchema,
 	destinations: StorageMigrationDestinationsSchema,
+	sources: StorageMigrationSourcesSchema,
 	throttleMbps: zod.z.number(),
 	moves: zod.z.array(StorageMigrationMoveSchema),
 	pauseLeaseId: zod.z.string().nullable(),
@@ -4499,6 +4529,7 @@ var StorageMigrationFindingSchema = zod.z.object({
 });
 var StorageMigrationPlanSchema = zod.z.object({
 	destinations: StorageMigrationDestinationsSchema,
+	sources: StorageMigrationSourcesSchema,
 	/** The mode this plan was built for. A plan is only valid for its mode: the
 	*  `eventMedia` seal gate and the single-cardinality refusal both depend on
 	*  it. */
@@ -4506,7 +4537,8 @@ var StorageMigrationPlanSchema = zod.z.object({
 	moves: zod.z.array(zod.z.object({
 		storageClass: StorageMigrationClassSchema,
 		fromLocationId: zod.z.string(),
-		toLocationId: zod.z.string()
+		toLocationId: zod.z.string(),
+		freezeSource: zod.z.boolean().optional()
 	})),
 	findings: zod.z.array(StorageMigrationFindingSchema)
 });
@@ -4692,10 +4724,51 @@ var LedgerWalkReportSchema = zod.z.object({
 var RelocatableMediaCountSchema = zod.z.object({ rows: zod.z.number().int().nonnegative() }).nullable();
 var RelocatableMediaCountInputSchema = zod.z.object({
 	toLocationId: zod.z.string().min(1),
+	/** Restrict the count to one source; omitted / `'*'` = every non-target row. */
+	fromLocationId: zod.z.string().optional(),
 	/** Omitted = `move`. */
 	mode: MediaRelocateModeSchema.optional()
 });
 /**
+* Operator cleanup of leftover analytics rows, optional debug media, and
+* ghost ledger entries on frozen footage locations.
+*
+* A pass is tens of minutes on a standing backlog. The hub method RETURNS
+* `{ jobId }` immediately; progress is `cleanupStatus`. Awaiting the work
+* is how `addons.custom` hit the 60 s UDS deadline while reclaim continued
+* with no operator-visible status.
+*/
+var StorageCleanupPhaseSchema = zod.z.enum([
+	"orphans",
+	"debug-media",
+	"ghost-ledger",
+	"done",
+	"failed",
+	"cancelled"
+]);
+var StorageCleanupInputSchema = zod.z.object({ 
+/** Also walk motion stills / track filmstrips. Off by default. */
+includeDebugMedia: zod.z.boolean().optional() });
+var StorageCleanupJobSchema = zod.z.object({
+	jobId: zod.z.string(),
+	phase: StorageCleanupPhaseSchema,
+	includeDebugMedia: zod.z.boolean(),
+	orphansReclaimed: zod.z.number().int().nonnegative(),
+	orphanBytesReclaimed: zod.z.number().int().nonnegative(),
+	debugMediaReclaimed: zod.z.number().int().nonnegative(),
+	debugMediaBytesReclaimed: zod.z.number().int().nonnegative(),
+	ghostsForgotten: zod.z.number().int().nonnegative(),
+	ghostBytesForgotten: zod.z.number().int().nonnegative(),
+	/** Short operator-facing line: current collection, pass, or location. */
+	detail: zod.z.string().nullable(),
+	cancelRequested: zod.z.boolean(),
+	startedAt: zod.z.number(),
+	updatedAt: zod.z.number(),
+	finishedAt: zod.z.number().nullable(),
+	error: zod.z.string().nullable()
+});
+var StorageCleanupStatusInputSchema = zod.z.object({ jobId: zod.z.string().optional() });
+/**
 * `StorageLocationType` — an addon-declared id that identifies the *kind* of
 * storage a location serves. Defined here (not in `capabilities/storage.cap.ts`)
 * so the persisted record schema and the consumer-facing cap can both consume it
@@ -4723,11 +4796,10 @@ var StorageLocationTypeSchema = zod.z.string().regex(/^[a-z][a-zA-Z0-9-]*$/);
 * The default location for a type uses `id === <type>:default` by
 * convention (the bare type ref like `'backups'` resolves to it).
 *
-* `isSystem: true` marks a location as orchestrator-seeded and
-* undeletable. The bootstrap-installed defaults (one per type) carry
-* this flag; operator-added locations don't. Editing the config of
-* a system location is allowed (path migration, provider swap) but
-* deleting it is rejected at the cap level.
+* `isSystem` is a legacy persisted flag. Seed still creates the initial
+* `<type>:default` locations; the flag is no longer a lock, a badge, or a
+* prune selector. New writes leave it false. Deletion is gated on uniqueness
+* / last-enabled, not on this bit.
 */
 var StorageLocationSchema = zod.z.object({
 	id: zod.z.string().regex(/^[a-z][a-zA-Z0-9-]*:[a-zA-Z0-9-]+$/),
@@ -21633,7 +21705,23 @@ var storageMigrationCapability = {
 		drain: method(StorageMigrationDrainInputSchema, zod.z.object({ jobId: zod.z.string() }), {
 			kind: "mutation",
 			auth: "admin"
-		})
+		}),
+		/**
+		* One operator cleanup of leftover analytics (DB + blobs) and ghost
+		* ledger rows on frozen footage locations. Optional debug-media sweep.
+		* Returns immediately; poll {@link cleanupStatus}.
+		*/
+		cleanupStart: method(StorageCleanupInputSchema, zod.z.object({ jobId: zod.z.string() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		cleanupStatus: method(StorageCleanupStatusInputSchema, StorageCleanupJobSchema.nullable(), { auth: "admin" }),
+		cleanupCancel: method(zod.z.object({ jobId: zod.z.string() }), zod.z.object({ cancelled: zod.z.boolean() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Recent finished migration jobs, newest first. The live job is `status`. */
+		history: method(zod.z.object({}), zod.z.array(StorageMigrationJobSchema).readonly(), { auth: "admin" })
 	}
 };
 var ProviderInfoSchema = zod.z.discriminatedUnion("shouldSaveDiskSpace", [zod.z.object({
@@ -29899,6 +29987,33 @@ var RecordingRebalanceInputSchema = zod.z.object({
 	minMoveGb: zod.z.number().min(0).optional()
 });
 /**
+* Operator-facing placement of one camera onto a recordings location.
+*
+* `pinLocationId` is the operator instruction: a location id, or `null` for
+* Auto (the planner may move this camera). `locationId` is where high/mid
+* currently write — the plan, which may disagree with the pin when Auto.
+*/
+var RecordingDevicePlacementSchema = zod.z.object({
+	deviceId: zod.z.number().int(),
+	profile: zod.z.string(),
+	locationId: zod.z.string()
+});
+var RecordingDevicePinSchema = zod.z.object({
+	deviceId: zod.z.number().int(),
+	/** Recordings-class location this camera is pinned to. */
+	locationId: zod.z.string()
+});
+var RecordingPlacementViewSchema = zod.z.object({
+	assignments: zod.z.array(RecordingDevicePlacementSchema),
+	pins: zod.z.array(RecordingDevicePinSchema),
+	defaultLocations: zod.z.record(zod.z.string(), zod.z.string())
+});
+var RecordingSetDevicePlacementInputSchema = zod.z.object({
+	deviceId: zod.z.number().int(),
+	/** `null` = Auto. Otherwise a `recordings:*` location id. */
+	locationId: zod.z.string().nullable()
+});
+/**
 * Result of locating footage at a wall-clock instant for one device/profile.
 * `segment` carries the covering segment's window; `gap` reports the forward
 * nearest covered edge (`null` past the end of footage / when none exists)
@@ -30251,6 +30366,22 @@ var recordingCapability = {
 		startStorageRebalance: method(RecordingRebalanceInputSchema, RecordingRebalancePlanSchema, {
 			kind: "mutation",
 			auth: "admin"
+		}),
+		/**
+		* The placement plan in force plus operator pins. Drives the Locations
+		* admin page: Auto vs a named recordings location, per camera.
+		*/
+		getPlacement: method(zod.z.object({}), RecordingPlacementViewSchema, {
+			kind: "query",
+			auth: "admin"
+		}),
+		/**
+		* Pin a camera to a recordings location, or clear the pin (Auto). High and
+		* mid follow the pin; low stays with the recordingsLow planner.
+		*/
+		setDevicePlacement: method(RecordingSetDevicePlacementInputSchema, zod.z.object({ ok: zod.z.literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
 		})
 	}
 };
@@ -38325,6 +38456,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recording.getPlacement": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"recording.getPlaybackManifest": {
 		capName: "recording",
 		capScope: "system",
@@ -38451,6 +38588,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"recording.setDevicePlacement": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"recording.startStorageMigrationMove": {
 		capName: "recording",
 		capScope: "system",
@@ -38895,12 +39038,36 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"storageMigration.cleanupCancel": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"storageMigration.cleanupStart": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"storageMigration.cleanupStatus": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"storageMigration.drain": {
 		capName: "storage-migration",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"storageMigration.history": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"storageMigration.movers": {
 		capName: "storage-migration",
 		capScope: "system",
@@ -41387,6 +41554,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"recording.setDevicePlacement": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"recording.startStorageMigrationMove": [{
 		name: "deviceId",
 		form: "single",
@@ -42858,6 +43030,12 @@ Object.defineProperty(exports, "ScopedTokenSchema", {
 		return ScopedTokenSchema;
 	}
 });
+Object.defineProperty(exports, "StorageCleanupJobSchema", {
+	enumerable: true,
+	get: function() {
+		return StorageCleanupJobSchema;
+	}
+});
 Object.defineProperty(exports, "StorageLocationTypeSchema", {
 	enumerable: true,
 	get: function() {