swarmdo 1.45.0 → 1.54.1

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/entities/index.d.ts

@@ -0,0 +1,5 @@
+export { DeviceTrustLevel, getDeviceTrustLabel, } from './device-trust-level.js';
+export type { DeviceStatus, DeviceCapability, DeviceTrustScore, VectorStoreStats, DeviceAgent, } from './device-agent.js';
+export type { FleetTopology, DeploymentStrategy, FirmwarePolicy, TelemetryPolicy, HealthThresholds, DeviceFleet, } from './device-fleet.js';
+export type { AnomalyType, AnomalyAction, TelemetryReading, AnomalyDetection, } from './telemetry.js';
+//# sourceMappingURL=index.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/entities/index.js

@@ -0,0 +1,2 @@
+export { DeviceTrustLevel, getDeviceTrustLabel, } from './device-trust-level.js';
+//# sourceMappingURL=index.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/entities/telemetry.d.ts

@@ -0,0 +1,35 @@
+export type AnomalyType = 'drift' | 'spike' | 'flatline' | 'oscillation' | 'pattern-break' | 'cluster-outlier';
+export type AnomalyAction = 'log' | 'alert' | 'quarantine' | 'recalibrate' | 'rollback-firmware' | 'human-review';
+/**
+ * A single telemetry reading from a Cognitum Seed device.
+ */
+export interface TelemetryReading {
+    readingId: string;
+    deviceId: string;
+    fleetId: string;
+    timestamp: Date;
+    /** Embedding vector for similarity search. */
+    vector: number[];
+    /** Raw sensor metrics keyed by metric name. */
+    rawMetrics: Record<string, number>;
+    /** Anomaly score, 0.0 (normal) - 1.0 (anomalous). */
+    anomalyScore: number;
+    metadata: Record<string, unknown>;
+}
+/**
+ * Result of anomaly detection on a telemetry reading.
+ */
+export interface AnomalyDetection {
+    readingId: string;
+    deviceId: string;
+    /** Anomaly score, 0.0 - 1.0. */
+    score: number;
+    type: AnomalyType;
+    /** Detection confidence, 0.0 - 1.0. */
+    confidence: number;
+    /** Identifier of the baseline pattern this was compared against. */
+    baselinePattern?: string;
+    suggestedAction: AnomalyAction;
+    metadata: Record<string, unknown>;
+}
+//# sourceMappingURL=telemetry.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/entities/telemetry.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=telemetry.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/device-repository.d.ts

@@ -0,0 +1,11 @@
+import type { DeviceAgent } from '../entities/index.js';
+export interface DeviceRepository {
+    save(device: DeviceAgent): Promise<void>;
+    findById(deviceId: string): Promise<DeviceAgent | null>;
+    findByFleet(fleetId: string): Promise<DeviceAgent[]>;
+    findByZone(zoneId: string): Promise<DeviceAgent[]>;
+    findAll(): Promise<DeviceAgent[]>;
+    delete(deviceId: string): Promise<boolean>;
+    count(): Promise<number>;
+}
+//# sourceMappingURL=device-repository.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/device-repository.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=device-repository.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/fleet-repository.d.ts

@@ -0,0 +1,9 @@
+import type { DeviceFleet } from '../entities/index.js';
+export interface FleetRepository {
+    save(fleet: DeviceFleet): Promise<void>;
+    findById(fleetId: string): Promise<DeviceFleet | undefined>;
+    findAll(): Promise<DeviceFleet[]>;
+    delete(fleetId: string): Promise<boolean>;
+    count(): Promise<number>;
+}
+//# sourceMappingURL=fleet-repository.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/fleet-repository.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fleet-repository.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/index.d.ts

@@ -0,0 +1,5 @@
+export type { DeviceRepository } from './device-repository.js';
+export type { TrustHistoryEntry, TrustHistoryRepository, } from './trust-history-repository.js';
+export type { FleetRepository } from './fleet-repository.js';
+export type { TelemetryRepository } from './telemetry-repository.js';
+//# sourceMappingURL=index.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/telemetry-repository.d.ts

@@ -0,0 +1,12 @@
+import type { TelemetryReading, AnomalyDetection } from '../entities/telemetry.js';
+export interface TelemetryRepository {
+    store(reading: TelemetryReading): Promise<void>;
+    storeBatch(readings: TelemetryReading[]): Promise<number>;
+    findByDevice(deviceId: string, limit?: number): Promise<TelemetryReading[]>;
+    searchSimilar(vector: number[], k: number, deviceId?: string): Promise<TelemetryReading[]>;
+    storeAnomaly(anomaly: AnomalyDetection): Promise<void>;
+    findAnomalies(deviceId: string, limit?: number): Promise<AnomalyDetection[]>;
+    count(deviceId?: string): Promise<number>;
+    deleteByDevice(deviceId: string): Promise<number>;
+}
+//# sourceMappingURL=telemetry-repository.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/telemetry-repository.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=telemetry-repository.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/trust-history-repository.d.ts

@@ -0,0 +1,19 @@
+import type { DeviceTrustLevel } from '../entities/index.js';
+import type { DeviceTrustScore } from '../entities/index.js';
+export interface TrustHistoryEntry {
+    deviceId: string;
+    timestamp: Date;
+    oldLevel: DeviceTrustLevel;
+    newLevel: DeviceTrustLevel;
+    score: DeviceTrustScore;
+    /** What caused the change: 'registration', 'pair', 'unpair', 'refresh', 'probe'. */
+    trigger: string;
+}
+export interface TrustHistoryRepository {
+    append(entry: TrustHistoryEntry): Promise<void>;
+    findByDevice(deviceId: string, limit?: number): Promise<TrustHistoryEntry[]>;
+    findByLevel(level: DeviceTrustLevel): Promise<TrustHistoryEntry[]>;
+    deleteByDevice(deviceId: string): Promise<number>;
+    count(): Promise<number>;
+}
+//# sourceMappingURL=trust-history-repository.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/trust-history-repository.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=trust-history-repository.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/services/anomaly-detection-service.d.ts

@@ -0,0 +1,44 @@
+import type { TelemetryReading, AnomalyDetection } from '../entities/index.js';
+export interface AnomalyDetectionConfig {
+    /** Score threshold above which a reading is anomalous. Default 0.7. */
+    anomalyThreshold: number;
+    /** Score threshold for quarantine action. Default 0.9. */
+    quarantineThreshold: number;
+    /** Window size for baseline computation. */
+    baselineWindowSize: number;
+}
+export interface TelemetryBaseline {
+    deviceId: string;
+    /** Mean vector across the baseline window. */
+    meanVector: number[];
+    /** Standard deviation per dimension. */
+    stdVector: number[];
+    /** Number of readings in the baseline. */
+    sampleCount: number;
+    /** When the baseline was last computed. */
+    computedAt: Date;
+}
+export declare class AnomalyDetectionService {
+    private readonly config;
+    private readonly baselines;
+    constructor(config?: Partial<AnomalyDetectionConfig>);
+    /**
+     * Compute a baseline from a window of readings for a device.
+     * Calculates mean and standard deviation per vector dimension.
+     */
+    computeBaseline(deviceId: string, readings: TelemetryReading[]): TelemetryBaseline;
+    /** Get the current baseline for a device, if one has been computed. */
+    getBaseline(deviceId: string): TelemetryBaseline | undefined;
+    /**
+     * Detect anomalies in a reading by comparing against the device's baseline.
+     * Uses z-score based detection: how many standard deviations each dimension
+     * deviates from the baseline mean.
+     */
+    detect(reading: TelemetryReading): AnomalyDetection;
+    /** Classify an anomaly type based on the z-score pattern. */
+    private classifyAnomaly;
+    private suggestAction;
+    /** Check whether a detection result exceeds the anomaly threshold. */
+    isAnomalous(detection: AnomalyDetection): boolean;
+}
+//# sourceMappingURL=anomaly-detection-service.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/services/anomaly-detection-service.js

@@ -0,0 +1,117 @@
+export class AnomalyDetectionService {
+    config;
+    baselines = new Map();
+    constructor(config) {
+        this.config = {
+            anomalyThreshold: config?.anomalyThreshold ?? 0.7,
+            quarantineThreshold: config?.quarantineThreshold ?? 0.9,
+            baselineWindowSize: config?.baselineWindowSize ?? 100,
+        };
+    }
+    /**
+     * Compute a baseline from a window of readings for a device.
+     * Calculates mean and standard deviation per vector dimension.
+     */
+    computeBaseline(deviceId, readings) {
+        if (readings.length === 0)
+            throw new Error('Cannot compute baseline from empty readings');
+        const dim = readings[0].vector.length;
+        const n = readings.length;
+        // Compute mean
+        const mean = new Array(dim).fill(0);
+        for (const r of readings) {
+            for (let i = 0; i < dim; i++)
+                mean[i] += r.vector[i] / n;
+        }
+        // Compute standard deviation
+        const std = new Array(dim).fill(0);
+        for (const r of readings) {
+            for (let i = 0; i < dim; i++) {
+                const diff = r.vector[i] - mean[i];
+                std[i] += (diff * diff) / n;
+            }
+        }
+        for (let i = 0; i < dim; i++)
+            std[i] = Math.sqrt(std[i]);
+        const baseline = {
+            deviceId,
+            meanVector: mean,
+            stdVector: std,
+            sampleCount: n,
+            computedAt: new Date(),
+        };
+        this.baselines.set(deviceId, baseline);
+        return baseline;
+    }
+    /** Get the current baseline for a device, if one has been computed. */
+    getBaseline(deviceId) {
+        return this.baselines.get(deviceId);
+    }
+    /**
+     * Detect anomalies in a reading by comparing against the device's baseline.
+     * Uses z-score based detection: how many standard deviations each dimension
+     * deviates from the baseline mean.
+     */
+    detect(reading) {
+        const baseline = this.baselines.get(reading.deviceId);
+        if (!baseline) {
+            return {
+                readingId: reading.readingId,
+                deviceId: reading.deviceId,
+                score: 0,
+                type: 'drift',
+                confidence: 0,
+                suggestedAction: 'log',
+                metadata: { reason: 'no-baseline' },
+            };
+        }
+        // Z-score per dimension
+        const zScores = reading.vector.map((v, i) => {
+            const s = baseline.stdVector[i];
+            return s > 0 ? Math.abs(v - baseline.meanVector[i]) / s : 0;
+        });
+        const maxZ = Math.max(...zScores);
+        const meanZ = zScores.reduce((a, b) => a + b, 0) / zScores.length;
+        // Composite anomaly score (0-1): 3 std devs maps to score 1.0
+        const score = Math.min(1, meanZ / 3);
+        const type = this.classifyAnomaly(reading, zScores, maxZ);
+        const suggestedAction = this.suggestAction(score);
+        const confidence = Math.min(1, baseline.sampleCount / this.config.baselineWindowSize);
+        return {
+            readingId: reading.readingId,
+            deviceId: reading.deviceId,
+            score,
+            type,
+            confidence,
+            baselinePattern: `baseline-${reading.deviceId}`,
+            suggestedAction,
+            metadata: { maxZ, meanZ, baselineSamples: baseline.sampleCount },
+        };
+    }
+    /** Classify an anomaly type based on the z-score pattern. */
+    classifyAnomaly(reading, zScores, maxZ) {
+        const highZCount = zScores.filter((z) => z > 2).length;
+        const allLow = zScores.every((z) => z < 0.5);
+        if (maxZ > 5)
+            return 'spike';
+        if (allLow && reading.rawMetrics && Object.values(reading.rawMetrics).every((v) => v === 0))
+            return 'flatline';
+        if (highZCount > zScores.length * 0.5)
+            return 'cluster-outlier';
+        if (highZCount > 0 && highZCount <= 2)
+            return 'drift';
+        return 'pattern-break';
+    }
+    suggestAction(score) {
+        if (score >= this.config.quarantineThreshold)
+            return 'quarantine';
+        if (score >= this.config.anomalyThreshold)
+            return 'alert';
+        return 'log';
+    }
+    /** Check whether a detection result exceeds the anomaly threshold. */
+    isAnomalous(detection) {
+        return detection.score >= this.config.anomalyThreshold;
+    }
+}
+//# sourceMappingURL=anomaly-detection-service.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/services/device-lifecycle-service.d.ts

@@ -0,0 +1,70 @@
+import type { DeviceAgent, DeviceTrustScore } from '../entities/index.js';
+import { DeviceTrustLevel } from '../entities/index.js';
+export interface DeviceLifecycleDeps {
+    getStatus: (deviceId: string) => Promise<{
+        device_id: string;
+        uptime_secs: number;
+        epoch: number;
+        total_vectors: number;
+        dimension: number;
+        paired: boolean;
+        roles: string[];
+        witness_chain_length?: number;
+    }>;
+    getIdentity: (deviceId: string) => Promise<{
+        device_id: string;
+        public_key?: string;
+        firmware_version?: string;
+        epoch?: number;
+    }>;
+    getPairStatus: (deviceId: string) => Promise<{
+        paired: boolean;
+        client_count?: number;
+    }>;
+    getWitnessChain: (deviceId: string) => Promise<{
+        depth: number;
+        epoch: number;
+        head_hash: string;
+    }>;
+    getCustodyEpoch: (deviceId: string) => Promise<{
+        epoch: number;
+    }>;
+    pairDevice: (deviceId: string, clientName: string) => Promise<{
+        paired: boolean;
+        token?: string;
+    }>;
+    unpairDevice: (deviceId: string, clientName?: string) => Promise<void>;
+    onDeviceRegistered?: (device: DeviceAgent) => void;
+    onTrustChange?: (deviceId: string, oldLevel: DeviceTrustLevel, newLevel: DeviceTrustLevel) => void;
+}
+export declare class DeviceLifecycleService {
+    private readonly deps;
+    constructor(deps: DeviceLifecycleDeps);
+    /**
+     * Register a new device by fetching its status and identity, then
+     * constructing a DeviceAgent entity with initial trust REGISTERED.
+     */
+    registerDevice(endpoint: string, fleetId: string, zoneId: string): Promise<DeviceAgent>;
+    /**
+     * Pair a device using the SDK's pair.create() and promote its trust level.
+     */
+    pairDevice(device: DeviceAgent, clientName: string): Promise<DeviceAgent>;
+    /**
+     * Unpair a device and demote its trust level.
+     */
+    unpairDevice(device: DeviceAgent): Promise<DeviceAgent>;
+    /**
+     * Re-fetch all device state and recalculate trust.
+     */
+    refreshDeviceState(device: DeviceAgent): Promise<DeviceAgent>;
+    /**
+     * Compute a composite trust score from device telemetry signals.
+     */
+    computeTrustScore(device: DeviceAgent, witnessDepth: number, uptimeSecs: number, paired?: boolean): DeviceTrustScore;
+    /**
+     * Map a composite trust score to a discrete DeviceTrustLevel.
+     */
+    evaluateTrustLevel(score: DeviceTrustScore): DeviceTrustLevel;
+    private deriveCapabilities;
+}
+//# sourceMappingURL=device-lifecycle-service.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/services/device-lifecycle-service.js

@@ -0,0 +1,194 @@
+import { DeviceTrustLevel } from '../entities/index.js';
+// ---------------------------------------------------------------------------
+// Service
+// ---------------------------------------------------------------------------
+export class DeviceLifecycleService {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * Register a new device by fetching its status and identity, then
+     * constructing a DeviceAgent entity with initial trust REGISTERED.
+     */
+    async registerDevice(endpoint, fleetId, zoneId) {
+        const status = await this.deps.getStatus(endpoint);
+        const identity = await this.deps.getIdentity(status.device_id);
+        const initialScore = this.computeTrustScore({}, status.witness_chain_length ?? 0, status.uptime_secs, status.paired);
+        const device = {
+            deviceId: status.device_id,
+            publicKey: identity.public_key ?? '',
+            firmwareVersion: identity.firmware_version ?? 'unknown',
+            trustLevel: DeviceTrustLevel.REGISTERED,
+            trustScore: initialScore,
+            fleetId,
+            zoneId,
+            status: 'online',
+            lastSeen: new Date(),
+            epoch: identity.epoch ?? status.epoch,
+            capabilities: this.deriveCapabilities(status.roles),
+            meshPeers: [],
+            vectorStoreStats: {
+                totalVectors: status.total_vectors,
+                deletedVectors: 0,
+                dimension: status.dimension,
+                fileSizeBytes: 0,
+            },
+            endpoint,
+            metadata: {},
+        };
+        this.deps.onDeviceRegistered?.(device);
+        return device;
+    }
+    /**
+     * Pair a device using the SDK's pair.create() and promote its trust level.
+     */
+    async pairDevice(device, clientName) {
+        const result = await this.deps.pairDevice(device.deviceId, clientName);
+        if (!result.paired) {
+            throw new Error(`Pairing failed for device ${device.deviceId}`);
+        }
+        const oldLevel = device.trustLevel;
+        const newLevel = device.trustLevel < DeviceTrustLevel.PROVISIONED
+            ? DeviceTrustLevel.PROVISIONED
+            : device.trustLevel;
+        const updated = {
+            ...device,
+            trustLevel: newLevel,
+            trustScore: {
+                ...device.trustScore,
+                overall: this.computeTrustScore(device, 0, 0, true).overall,
+                components: {
+                    ...device.trustScore.components,
+                    pairingIntegrity: 1.0,
+                },
+            },
+        };
+        if (oldLevel !== newLevel) {
+            this.deps.onTrustChange?.(device.deviceId, oldLevel, newLevel);
+        }
+        return updated;
+    }
+    /**
+     * Unpair a device and demote its trust level.
+     */
+    async unpairDevice(device) {
+        await this.deps.unpairDevice(device.deviceId);
+        const oldLevel = device.trustLevel;
+        const newLevel = DeviceTrustLevel.REGISTERED;
+        const updated = {
+            ...device,
+            trustLevel: newLevel,
+            trustScore: {
+                ...device.trustScore,
+                overall: this.computeTrustScore(device, 0, 0, false).overall,
+                components: {
+                    ...device.trustScore.components,
+                    pairingIntegrity: 0.0,
+                },
+            },
+        };
+        if (oldLevel !== newLevel) {
+            this.deps.onTrustChange?.(device.deviceId, oldLevel, newLevel);
+        }
+        return updated;
+    }
+    /**
+     * Re-fetch all device state and recalculate trust.
+     */
+    async refreshDeviceState(device) {
+        const [status, identity, pair, witness] = await Promise.all([
+            this.deps.getStatus(device.deviceId),
+            this.deps.getIdentity(device.deviceId),
+            this.deps.getPairStatus(device.deviceId),
+            this.deps.getWitnessChain(device.deviceId),
+        ]);
+        const updated = {
+            ...device,
+            publicKey: identity.public_key ?? device.publicKey,
+            firmwareVersion: identity.firmware_version ?? device.firmwareVersion,
+            epoch: identity.epoch ?? status.epoch,
+            lastSeen: new Date(),
+            status: 'online',
+            vectorStoreStats: {
+                ...device.vectorStoreStats,
+                totalVectors: status.total_vectors,
+                dimension: status.dimension,
+            },
+            capabilities: this.deriveCapabilities(status.roles),
+        };
+        const score = this.computeTrustScore({ ...updated, trustScore: device.trustScore }, witness.depth, status.uptime_secs, pair.paired);
+        const newLevel = this.evaluateTrustLevel(score);
+        const oldLevel = device.trustLevel;
+        updated.trustScore = score;
+        updated.trustLevel = newLevel;
+        if (oldLevel !== newLevel) {
+            this.deps.onTrustChange?.(device.deviceId, oldLevel, newLevel);
+        }
+        return updated;
+    }
+    /**
+     * Compute a composite trust score from device telemetry signals.
+     */
+    computeTrustScore(device, witnessDepth, uptimeSecs, paired) {
+        const SEVEN_DAYS_SECS = 604_800;
+        const EXPECTED_WITNESS_DEPTH = 10_000;
+        const pairingIntegrity = paired !== undefined
+            ? (paired ? 1.0 : 0.0)
+            : (device.trustScore?.components?.pairingIntegrity ?? 0.0);
+        const firmwareCurrency = 1.0; // Hardcoded — version comparison TBD
+        const uptimeStability = Math.min(1.0, uptimeSecs / SEVEN_DAYS_SECS);
+        const witnessIntegrity = Math.min(1.0, witnessDepth / EXPECTED_WITNESS_DEPTH);
+        const anomalyHistory = 1.0; // No anomaly detection yet
+        const meshParticipation = 0.5; // Single device, no mesh peers
+        const overall = 0.3 * pairingIntegrity +
+            0.15 * firmwareCurrency +
+            0.2 * uptimeStability +
+            0.15 * witnessIntegrity +
+            0.1 * anomalyHistory +
+            0.1 * meshParticipation;
+        return {
+            overall,
+            components: {
+                pairingIntegrity,
+                firmwareCurrency,
+                uptimeStability,
+                witnessIntegrity,
+                anomalyHistory,
+                meshParticipation,
+            },
+        };
+    }
+    /**
+     * Map a composite trust score to a discrete DeviceTrustLevel.
+     */
+    evaluateTrustLevel(score) {
+        if (score.overall < 0.3)
+            return DeviceTrustLevel.UNKNOWN;
+        if (score.overall < 0.5)
+            return DeviceTrustLevel.REGISTERED;
+        if (score.overall < 0.7)
+            return DeviceTrustLevel.PROVISIONED;
+        if (score.overall < 0.85)
+            return DeviceTrustLevel.CERTIFIED;
+        return DeviceTrustLevel.FLEET_TRUSTED;
+    }
+    // ---------------------------------------------------------------------------
+    // Helpers
+    // ---------------------------------------------------------------------------
+    deriveCapabilities(roles) {
+        const CAP_MAP = {
+            'vector-store': 'vector-store',
+            ota: 'ota-update',
+            mesh: 'mesh-routing',
+            witness: 'witness-chain',
+            sensor: 'sensor-telemetry',
+            compute: 'edge-compute',
+            mcp: 'mcp-server',
+        };
+        return roles
+            .map((r) => CAP_MAP[r])
+            .filter((c) => c != null);
+    }
+}
+//# sourceMappingURL=device-lifecycle-service.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/services/firmware-orchestration-service.d.ts

@@ -0,0 +1,69 @@
+import type { DeploymentStrategy, FirmwarePolicy } from '../entities/index.js';
+export type RolloutStage = 'pending' | 'canary' | 'rolling' | 'complete' | 'rolled-back' | 'failed';
+export interface FirmwareRollout {
+    rolloutId: string;
+    fleetId: string;
+    firmwareVersion: string;
+    strategy: DeploymentStrategy;
+    stage: RolloutStage;
+    targetDeviceIds: string[];
+    canaryDeviceIds: string[];
+    completedDeviceIds: string[];
+    failedDeviceIds: string[];
+    anomalyThreshold: number;
+    startedAt: Date;
+    updatedAt: Date;
+    completedAt?: Date;
+}
+export interface FirmwareOrchestrationDeps {
+    getDeviceFirmwareVersion: (deviceId: string) => Promise<string>;
+    deployFirmware: (deviceId: string, version: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    getDeviceAnomalyScore: (deviceId: string) => Promise<number>;
+}
+/**
+ * State-machine-based firmware rollout engine.
+ *
+ * Lifecycle: pending -> canary -> rolling -> complete
+ *                         |                     |
+ *                    rolled-back              failed
+ */
+export declare class FirmwareOrchestrationService {
+    private readonly deps;
+    private readonly rollouts;
+    private rolloutCounter;
+    constructor(deps: FirmwareOrchestrationDeps);
+    /**
+     * Create a new rollout.  Canary devices are selected as the first N%
+     * of `targetDeviceIds` based on `policy.canaryPercentage`.
+     */
+    createRollout(fleetId: string, firmwareVersion: string, targetDeviceIds: string[], policy: FirmwarePolicy): FirmwareRollout;
+    /**
+     * Advance the rollout through its state machine:
+     *   pending   -> canary   (deploy to canary devices)
+     *   canary    -> rolling  (anomaly check passes)
+     *   canary    -> rolled-back (anomaly check fails)
+     *   rolling   -> complete (deploy to remaining devices)
+     */
+    advanceRollout(rolloutId: string): Promise<FirmwareRollout>;
+    /**
+     * Force-rollback a rollout regardless of current stage.
+     */
+    rollbackRollout(rolloutId: string): FirmwareRollout;
+    /**
+     * Retrieve a rollout by ID.  Throws if not found.
+     */
+    getRollout(rolloutId: string): FirmwareRollout;
+    /**
+     * List rollouts, optionally filtered by fleet ID.
+     */
+    listRollouts(fleetId?: string): FirmwareRollout[];
+    private transitionPendingToCanary;
+    private transitionCanaryToNextStage;
+    private transitionRollingToComplete;
+    private deployToDevices;
+    private getExistingRollout;
+}
+//# sourceMappingURL=firmware-orchestration-service.d.ts.map