@camstack/system 1.2.76 → 1.2.78

package/dist/builtins/storage-orchestrator/storage-orchestrator.addon.mjs

@@ -1,4 +1,5 @@
-import { Pt as parseJsonObject, at as settingsStoreCapability, h as StorageLocationTypeSchema, mt as BaseAddon, st as storageCapability } from "../../dist-CX8Z8M6S.mjs";
+import { It as parseJsonObject, ct as storageCapability, g as StorageMigrationJobSchema, gt as BaseAddon, h as StorageLocationTypeSchema, lt as storageMigrationCapability, ot as settingsStoreCapability } from "../../dist-CIIFhXqm.mjs";
+import { randomUUID } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path$1 from "node:path";
 import { buildStorageLocationRegistry } from "@camstack/system";
@@ -234,6 +235,52 @@ var StorageOrchestratorService = class {
 		return null;
 	}
 	/**
+	* Repoint several logical defaults as one in-memory commit. The migration
+	* coordinator persists its `repointing` phase before calling this method, so
+	* a process crash during the backing-store writes is recovered by replaying
+	* the same idempotent target set before anyone resumes writers.
+	*/
+	async setDefaultLocations(targetByType) {
+		if (targetByType.size === 0) return;
+		const now = Date.now();
+		const nextById = new Map(this.locations);
+		const touched = /* @__PURE__ */ new Map();
+		for (const [type, targetId] of targetByType) {
+			const target = nextById.get(targetId);
+			if (!target) throw new Error(`Storage location "${targetId}" not found`);
+			if (target.type !== type) throw new Error(`Storage location "${targetId}" is type "${target.type}", expected "${type}"`);
+			for (const [id, location] of nextById) {
+				if (location.type !== type) continue;
+				const isDefault = id === targetId;
+				if (location.isDefault === isDefault) continue;
+				const updated = {
+					...location,
+					isDefault,
+					updatedAt: now
+				};
+				nextById.set(id, updated);
+				touched.set(id, updated);
+			}
+		}
+		if (this.locationStore) {
+			const previous = /* @__PURE__ */ new Map();
+			for (const id of touched.keys()) {
+				const location = this.locations.get(id);
+				if (location) previous.set(id, location);
+			}
+			try {
+				for (const location of touched.values()) await this.locationStore.upsert(location);
+			} catch (err) {
+				for (const location of previous.values()) try {
+					await this.locationStore.upsert(location);
+				} catch {}
+				throw err;
+			}
+		}
+		this.locations.clear();
+		for (const [id, location] of nextById) this.locations.set(id, location);
+	}
+	/**
 	* Insert or update a location. If `isDefault: true`, atomically
 	* demotes any other default for the same type — operators always see
 	* exactly one default per type.
@@ -928,6 +975,355 @@ var StoragePressureManager = class {
 	}
 };
 //#endregion
+//#region src/builtins/storage-orchestrator/storage-migration-coordinator.ts
+var STORAGE_CLASSES = [
+	"recordings",
+	"recordingsLow",
+	"eventMedia"
+];
+var PARTICIPANTS = [
+	"pipeline",
+	"recorder",
+	"analytics"
+];
+var REVERSE_PARTICIPANTS = [
+	"analytics",
+	"recorder",
+	"pipeline"
+];
+/**
+* Durable orchestration layer over the independent recorder and event-media
+* movers. It owns the only public migration state machine; participants expose
+* intentionally narrow lease/move primitives and never alter camera settings.
+*/
+var StorageMigrationCoordinator = class {
+	deps;
+	active = null;
+	runPromise = null;
+	startReserved = false;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async plan(input) {
+		const moves = [];
+		for (const storageClass of STORAGE_CLASSES) {
+			const targetId = input.destinations[storageClass];
+			if (targetId === void 0) continue;
+			const source = this.deps.locations.getDefaultLocation(storageClass);
+			if (!source) throw new Error(`No default storage location for "${storageClass}"`);
+			const target = this.deps.locations.getLocationById(targetId);
+			if (!target) throw new Error(`Storage location "${targetId}" not found`);
+			if (target.type !== storageClass) throw new Error(`Storage location "${targetId}" is type "${target.type}", expected "${storageClass}"`);
+			if (source.id === target.id) throw new Error(`Storage location "${targetId}" is already the "${storageClass}" default`);
+			moves.push({
+				storageClass,
+				fromLocationId: source.id,
+				toLocationId: target.id,
+				moverJobId: null,
+				state: null,
+				error: null
+			});
+		}
+		if (moves.length === 0) throw new Error("select at least one storage class");
+		return {
+			destinations: input.destinations,
+			moves: moves.map(({ storageClass, fromLocationId, toLocationId }) => ({
+				storageClass,
+				fromLocationId,
+				toLocationId
+			}))
+		};
+	}
+	async start(input) {
+		if (this.startReserved) throw new Error("storage migration is already active");
+		this.startReserved = true;
+		try {
+			const existing = await this.status();
+			if (existing && isTerminal(existing) && existing.pausedParticipants.length > 0) {
+				await this.releaseAfterTerminal(existing);
+				await this.persist(existing);
+				if (existing.pausedParticipants.length > 0) throw new Error(`storage migration ${existing.jobId} still holds maintenance leases`);
+			}
+			if (existing && !isTerminal(existing)) throw new Error(`storage migration is already active (${existing.jobId})`);
+			const plan = await this.plan(input);
+			const now = this.deps.now();
+			const job = {
+				jobId: this.deps.newId(),
+				phase: "planning",
+				destinations: input.destinations,
+				throttleMbps: input.throttleMbps ?? 40,
+				moves: plan.moves.map((move) => ({
+					...move,
+					moverJobId: null,
+					state: null,
+					error: null
+				})),
+				pauseLeaseId: null,
+				pausedParticipants: [],
+				repointed: false,
+				cancelRequested: false,
+				startedAt: now,
+				updatedAt: now,
+				finishedAt: null,
+				error: null
+			};
+			this.active = job;
+			await this.persist(job);
+			this.runPromise = this.run(job);
+			this.runPromise;
+			return job.jobId;
+		} finally {
+			this.startReserved = false;
+		}
+	}
+	async status(jobId) {
+		const job = this.active ?? await this.deps.state.get();
+		if (jobId !== void 0 && job?.jobId !== jobId) return null;
+		return job;
+	}
+	async cancel(jobId) {
+		const job = await this.status(jobId);
+		if (!job || isTerminal(job) || job.repointed) return false;
+		job.cancelRequested = true;
+		await this.persist(job);
+		await Promise.all(job.moves.filter((move) => move.moverJobId !== null).map((move) => this.cancelMove(move)));
+		return true;
+	}
+	/** Boot recovery resumes a durable unfinished state. A missing in-memory
+	* child mover is recreated from the same copy-if-absent input. */
+	async recover() {
+		const job = await this.deps.state.get();
+		if (!job) return;
+		if (job.cancelRequested) {
+			await Promise.all(job.moves.filter((move) => move.moverJobId !== null).map((move) => this.cancelMove(move)));
+			await this.waitForMoves(job);
+			await this.releaseAfterTerminal(job);
+			job.phase = "cancelled";
+			job.finishedAt ??= this.deps.now();
+			await this.persist(job);
+			return;
+		}
+		if (isTerminal(job)) {
+			if (job.pausedParticipants.length > 0) {
+				await this.releaseAfterTerminal(job);
+				await this.persist(job);
+			}
+			return;
+		}
+		this.active = job;
+		job.pauseLeaseId ??= this.deps.newId();
+		if (job.repointed && job.phase === "resuming") job.phase = "refreshing";
+		await this.persist(job);
+		try {
+			await this.pauseParticipants(job, true);
+		} catch (err) {
+			job.error = err instanceof Error ? err.message : String(err);
+			await this.persist(job);
+			return;
+		}
+		if (this.runPromise === null) {
+			this.runPromise = this.run(job);
+			this.runPromise;
+		}
+	}
+	async run(job) {
+		try {
+			if (job.phase === "planning") await this.setPhase(job, "pausing");
+			if (job.phase === "pausing") {
+				job.pauseLeaseId ??= job.jobId;
+				await this.pauseParticipants(job);
+				if (job.cancelRequested) return this.finishCancelled(job);
+				await this.setPhase(job, "moving");
+			}
+			if (job.phase === "moving") {
+				await this.startOrResumeMoves(job);
+				await this.waitForMoves(job);
+				if (job.cancelRequested) return this.finishCancelled(job);
+				await this.setPhase(job, "verifying");
+			}
+			if (job.phase === "verifying") {
+				await this.verifyMoves(job);
+				if (job.cancelRequested) return this.finishCancelled(job);
+				await this.setPhase(job, "repointing");
+			}
+			if (job.phase === "repointing") {
+				const targets = new Map(job.moves.map((move) => [move.storageClass, move.toLocationId]));
+				await this.deps.locations.setDefaultLocations(targets);
+				job.repointed = true;
+				await this.setPhase(job, "refreshing");
+			}
+			if (job.phase === "refreshing") {
+				const leaseId = requireLease(job);
+				if (job.moves.some((move) => move.storageClass !== "eventMedia")) await this.deps.participants.recorder.refresh(leaseId);
+				if (job.moves.some((move) => move.storageClass === "eventMedia")) await this.deps.participants.analytics.refresh(leaseId);
+				await this.setPhase(job, "resuming");
+			}
+			if (job.phase === "resuming") {
+				await this.resumeParticipants(job);
+				await this.setPhase(job, "done");
+			}
+		} catch (err) {
+			job.error = err instanceof Error ? err.message : String(err);
+			if (job.repointed) {
+				job.phase = "refreshing";
+				job.finishedAt = null;
+				await this.persist(job);
+				return;
+			}
+			job.phase = "failed";
+			job.finishedAt = this.deps.now();
+			await this.releaseAfterTerminal(job);
+			await this.persist(job);
+		} finally {
+			if (isTerminal(job)) {
+				await this.releaseAfterTerminal(job);
+				this.active = job;
+			}
+			this.runPromise = null;
+		}
+	}
+	async pauseParticipants(job, reacquire = false) {
+		const leaseId = requireLease(job);
+		for (const name of PARTICIPANTS) {
+			if (job.cancelRequested) return;
+			if (!reacquire && job.pausedParticipants.includes(name)) continue;
+			await this.participant(name).pause(leaseId);
+			if (!job.pausedParticipants.includes(name)) job.pausedParticipants.push(name);
+			await this.persist(job);
+		}
+	}
+	async resumeParticipants(job) {
+		const leaseId = requireLease(job);
+		for (const name of REVERSE_PARTICIPANTS) {
+			if (!job.pausedParticipants.includes(name)) continue;
+			await this.participant(name).resume(leaseId);
+			job.pausedParticipants = job.pausedParticipants.filter((participant) => participant !== name);
+			await this.persist(job);
+		}
+	}
+	async releaseAfterTerminal(job) {
+		if (job.pauseLeaseId === null) return;
+		for (const name of REVERSE_PARTICIPANTS) {
+			if (!job.pausedParticipants.includes(name)) continue;
+			try {
+				await this.participant(name).resume(job.pauseLeaseId);
+				job.pausedParticipants = job.pausedParticipants.filter((participant) => participant !== name);
+				await this.persist(job);
+			} catch {}
+		}
+	}
+	async startOrResumeMoves(job) {
+		if (job.cancelRequested) return;
+		const mediaMove = job.moves.find((move) => move.storageClass === "eventMedia");
+		if (mediaMove?.moverJobId === null) {
+			mediaMove.moverJobId = await this.startMove(job, mediaMove);
+			await this.persist(job);
+		}
+		const footageMoves = job.moves.filter((move) => move.storageClass !== "eventMedia");
+		for (let index = 0; index < footageMoves.length; index++) {
+			const move = footageMoves[index];
+			if (move.moverJobId !== null) continue;
+			if (!footageMoves.slice(0, index).every((predecessor) => predecessor.state === "done")) return;
+			move.moverJobId = await this.startMove(job, move);
+			await this.persist(job);
+			return;
+		}
+	}
+	async waitForMoves(job) {
+		const sleep = this.deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+		const pollMs = this.deps.pollMs ?? 250;
+		for (;;) {
+			if (!job.cancelRequested) await this.startOrResumeMoves(job);
+			let complete = true;
+			for (const [index, move] of job.moves.entries()) {
+				if (job.cancelRequested && move.moverJobId === null) continue;
+				if (move.storageClass !== "eventMedia" && job.moves.slice(0, index).filter((predecessor) => predecessor.storageClass !== "eventMedia").some((predecessor) => predecessor.state !== "done")) {
+					complete = false;
+					continue;
+				}
+				if (move.moverJobId === null) {
+					if (!job.cancelRequested) complete = false;
+					continue;
+				}
+				const status = await this.moveStatus(move);
+				if (status === null) {
+					if (job.cancelRequested) {
+						move.state = "cancelled";
+						continue;
+					}
+					move.moverJobId = await this.startMove(job, move);
+					move.state = "running";
+					await this.persist(job);
+					complete = false;
+					continue;
+				}
+				move.state = status.state;
+				move.error = status.error;
+				if (status.state === "failed") throw new Error(move.error ?? `${move.storageClass} move failed`);
+				if (status.state === "cancelled") {
+					job.cancelRequested = true;
+					continue;
+				}
+				if (status.state !== "done") complete = false;
+			}
+			await this.persist(job);
+			if (complete) return;
+			await sleep(pollMs);
+		}
+	}
+	async verifyMoves(job) {
+		for (const move of job.moves) if (move.state !== "done") throw new Error(`${move.storageClass} move did not complete verification`);
+	}
+	async startMove(job, move) {
+		if (move.storageClass === "eventMedia") return (await this.deps.participants.analytics.startMove({
+			toLocationId: move.toLocationId,
+			throttleMbps: job.throttleMbps,
+			leaseId: requireLease(job)
+		})).jobId;
+		return (await this.deps.participants.recorder.startMove({
+			fromLocationId: move.fromLocationId,
+			toLocationId: move.toLocationId,
+			footageClass: move.storageClass,
+			throttleMbps: job.throttleMbps,
+			leaseId: requireLease(job)
+		})).jobId;
+	}
+	async moveStatus(move) {
+		if (move.moverJobId === null) return null;
+		return move.storageClass === "eventMedia" ? this.deps.participants.analytics.getMove(move.moverJobId) : this.deps.participants.recorder.getMove(move.moverJobId);
+	}
+	async cancelMove(move) {
+		if (move.moverJobId === null) return;
+		if (move.storageClass === "eventMedia") await this.deps.participants.analytics.cancelMove(move.moverJobId);
+		else await this.deps.participants.recorder.cancelMove(move.moverJobId);
+	}
+	participant(name) {
+		return this.deps.participants[name];
+	}
+	async setPhase(job, phase) {
+		job.phase = phase;
+		if (isTerminal(job)) job.finishedAt = this.deps.now();
+		await this.persist(job);
+	}
+	async finishCancelled(job) {
+		job.phase = "cancelled";
+		job.finishedAt = this.deps.now();
+		await this.releaseAfterTerminal(job);
+		await this.persist(job);
+	}
+	async persist(job) {
+		job.updatedAt = this.deps.now();
+		await this.deps.state.set(job);
+	}
+};
+function requireLease(job) {
+	if (job.pauseLeaseId === null) throw new Error("storage migration has no maintenance lease");
+	return job.pauseLeaseId;
+}
+function isTerminal(job) {
+	return job.phase === "done" || job.phase === "failed" || job.phase === "cancelled";
+}
+//#endregion
 //#region src/builtins/storage-orchestrator/storage-orchestrator.addon.ts
 /**
 * `storage-orchestrator` builtin — singleton owner of the consumer-
@@ -973,6 +1369,7 @@ var StorageOrchestratorAddon = class extends BaseAddon {
 	pressureManager = null;
 	pressureTimer = null;
 	pressureSweepInFlight = false;
+	migration = null;
 	/**
 	* Cached `providerId → nodeLocal` snapshot (SP1). Backs the orchestrator's
 	* synchronous `NodeLocalResolver` — `getProviderInfo()` is async, so we
@@ -1166,6 +1563,57 @@ var StorageOrchestratorAddon = class extends BaseAddon {
 				}
 			}
 		};
+		const migration = new StorageMigrationCoordinator({
+			locations: service,
+			state: this.state("storage-migration", StorageMigrationJobSchema.nullable(), null),
+			participants: {
+				pipeline: {
+					pause: async (leaseId) => {
+						await this.ctx.api.pipelineOrchestrator.pauseForStorageMigration.mutate({ leaseId });
+					},
+					resume: async (leaseId) => {
+						await this.ctx.api.pipelineOrchestrator.resumeForStorageMigration.mutate({ leaseId });
+					}
+				},
+				recorder: {
+					pause: async (leaseId) => {
+						await this.ctx.api.recording.pauseForStorageMigration.mutate({ leaseId });
+					},
+					resume: async (leaseId) => {
+						await this.ctx.api.recording.resumeForStorageMigration.mutate({ leaseId });
+					},
+					startMove: (input) => this.ctx.api.recording.startStorageMigrationMove.mutate(input),
+					getMove: (jobId) => this.ctx.api.recording.getStorageMigrationMoveStatus.query({ jobId }),
+					cancelMove: async (jobId) => (await this.ctx.api.recording.cancelStorageMigrationMove.mutate({ jobId })).cancelled,
+					refresh: async (leaseId) => {
+						await this.ctx.api.recording.refreshStorageLocationsForMigration.mutate({ leaseId });
+					}
+				},
+				analytics: {
+					pause: async (leaseId) => {
+						await this.ctx.api.pipelineAnalytics.pauseForStorageMigration.mutate({ leaseId });
+					},
+					resume: async (leaseId) => {
+						await this.ctx.api.pipelineAnalytics.resumeForStorageMigration.mutate({ leaseId });
+					},
+					startMove: (input) => this.ctx.api.pipelineAnalytics.startStorageMigrationMove.mutate(input),
+					getMove: (jobId) => this.ctx.api.pipelineAnalytics.getStorageMigrationMoveStatus.query({ jobId }),
+					cancelMove: async (jobId) => (await this.ctx.api.pipelineAnalytics.cancelStorageMigrationMove.mutate({ jobId })).cancelled,
+					refresh: async (leaseId) => {
+						await this.ctx.api.pipelineAnalytics.refreshStorageLocationsForMigration.mutate({ leaseId });
+					}
+				}
+			},
+			now: () => Date.now(),
+			newId: () => randomUUID()
+		});
+		this.migration = migration;
+		const migrationProvider = {
+			plan: (input) => migration.plan(input),
+			start: async (input) => ({ jobId: await migration.start(input) }),
+			status: ({ jobId }) => migration.status(jobId),
+			cancel: async ({ jobId }) => ({ cancelled: await migration.cancel(jobId) })
+		};
 		await this.seedFromDeclarations();
 		const eventBus = this.ctx.eventBus;
 		if (eventBus) {
@@ -1190,13 +1638,20 @@ var StorageOrchestratorAddon = class extends BaseAddon {
 			this.runPressureSweep();
 		}, PRESSURE_SWEEP_INTERVAL_MS);
 		this.ctx.logger.info("Storage orchestrator initialized");
-		return [{
-			capability: storageCapability,
-			provider
-		}, {
-			capability: settingsStoreCapability,
-			provider: createDataStoreDispatch(getEngines)
-		}];
+		return [
+			{
+				capability: storageCapability,
+				provider
+			},
+			{
+				capability: storageMigrationCapability,
+				provider: migrationProvider
+			},
+			{
+				capability: settingsStoreCapability,
+				provider: createDataStoreDispatch(getEngines)
+			}
+		];
 	}
 	async onShutdown() {
 		for (const dispose of this.seedSubscriptionDisposers) try {
@@ -1210,6 +1665,10 @@ var StorageOrchestratorAddon = class extends BaseAddon {
 		this.pressureManager = null;
 		this.service?.clearSessions();
 		this.service = null;
+		this.migration = null;
+	}
+	async onHubReachable() {
+		await this.migration?.recover();
 	}
 	/**
 	* Resolve the live engine from the capability registry and wrap it in a
@@ -1431,4 +1890,4 @@ var StorageOrchestratorAddon = class extends BaseAddon {
 	}
 };
 //#endregion
-export { StorageOrchestratorAddon, StorageOrchestratorAddon as default, StorageOrchestratorService as n, SqliteLocationStore as t };
+export { StorageOrchestratorAddon, StorageOrchestratorAddon as default, SqliteLocationStore as n, StorageOrchestratorService as r, StorageMigrationCoordinator as t };

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

@@ -193,6 +193,13 @@ export declare class StorageOrchestratorService {
     backfillNodeIds(hubNodeId: string): Promise<void>;
     listLocations(filter?: ListLocationsFilter): readonly StorageLocation[];
     getDefaultLocation(type: string): StorageLocation | null;
+    /**
+     * Repoint several logical defaults as one in-memory commit. The migration
+     * coordinator persists its `repointing` phase before calling this method, so
+     * a process crash during the backing-store writes is recovered by replaying
+     * the same idempotent target set before anyone resumes writers.
+     */
+    setDefaultLocations(targetByType: ReadonlyMap<string, string>): Promise<void>;
     /**
      * Insert or update a location. If `isDefault: true`, atomically
      * demotes any other default for the same type — operators always see

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-B1W4mT4z.js");
+const require_dist = require("../../dist-cINpngi1.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 { jt as hydrateSchema, mt as BaseAddon, pt as errMsg } from "../../dist-CX8Z8M6S.mjs";
+import { Nt as hydrateSchema, gt as BaseAddon, ht as errMsg } from "../../dist-CIIFhXqm.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-B1W4mT4z.js");
+const require_dist = require("../../dist-cINpngi1.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, q as logDestinationCapability } from "../../dist-CX8Z8M6S.mjs";
+import { J as logDestinationCapability, gt as BaseAddon } from "../../dist-CIIFhXqm.mjs";
 import { t as formatLogLine } from "../../formatter-B7qW8bPJ.mjs";
 import * as path$1 from "node:path";
 import path from "node:path";