swarmdo 1.4.8 → 1.6.0

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

@@ -1,139 +0,0 @@
-// ---------------------------------------------------------------------------
-// Service
-// ---------------------------------------------------------------------------
-/**
- * State-machine-based firmware rollout engine.
- *
- * Lifecycle: pending -> canary -> rolling -> complete
- *                         |                     |
- *                    rolled-back              failed
- */
-export class FirmwareOrchestrationService {
-    deps;
-    rollouts = new Map();
-    rolloutCounter = 0;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    /**
-     * Create a new rollout.  Canary devices are selected as the first N%
-     * of `targetDeviceIds` based on `policy.canaryPercentage`.
-     */
-    createRollout(fleetId, firmwareVersion, targetDeviceIds, policy) {
-        const rolloutId = `rollout-${fleetId}-${Date.now()}-${this.rolloutCounter++}`;
-        const canaryCount = Math.max(1, Math.ceil(targetDeviceIds.length * (policy.canaryPercentage / 100)));
-        const canaryDeviceIds = targetDeviceIds.slice(0, canaryCount);
-        const rollout = {
-            rolloutId,
-            fleetId,
-            firmwareVersion,
-            strategy: 'canary',
-            stage: 'pending',
-            targetDeviceIds,
-            canaryDeviceIds,
-            completedDeviceIds: [],
-            failedDeviceIds: [],
-            anomalyThreshold: policy.rollbackOnAnomalyThreshold,
-            startedAt: new Date(),
-            updatedAt: new Date(),
-        };
-        this.rollouts.set(rolloutId, rollout);
-        return rollout;
-    }
-    /**
-     * 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)
-     */
-    async advanceRollout(rolloutId) {
-        const rollout = this.getExistingRollout(rolloutId);
-        switch (rollout.stage) {
-            case 'pending':
-                return this.transitionPendingToCanary(rollout);
-            case 'canary':
-                return this.transitionCanaryToNextStage(rollout);
-            case 'rolling':
-                return this.transitionRollingToComplete(rollout);
-            default:
-                return rollout;
-        }
-    }
-    /**
-     * Force-rollback a rollout regardless of current stage.
-     */
-    rollbackRollout(rolloutId) {
-        const rollout = this.getExistingRollout(rolloutId);
-        rollout.stage = 'rolled-back';
-        rollout.updatedAt = new Date();
-        return rollout;
-    }
-    /**
-     * Retrieve a rollout by ID.  Throws if not found.
-     */
-    getRollout(rolloutId) {
-        return this.getExistingRollout(rolloutId);
-    }
-    /**
-     * List rollouts, optionally filtered by fleet ID.
-     */
-    listRollouts(fleetId) {
-        const all = Array.from(this.rollouts.values());
-        if (fleetId === undefined)
-            return all;
-        return all.filter((r) => r.fleetId === fleetId);
-    }
-    // ---------------------------------------------------------------------------
-    // State-machine transitions
-    // ---------------------------------------------------------------------------
-    async transitionPendingToCanary(rollout) {
-        await this.deployToDevices(rollout, rollout.canaryDeviceIds, rollout.firmwareVersion);
-        rollout.stage = 'canary';
-        rollout.updatedAt = new Date();
-        return rollout;
-    }
-    async transitionCanaryToNextStage(rollout) {
-        for (const deviceId of rollout.canaryDeviceIds) {
-            const score = await this.deps.getDeviceAnomalyScore(deviceId);
-            if (score > rollout.anomalyThreshold) {
-                rollout.stage = 'rolled-back';
-                rollout.updatedAt = new Date();
-                return rollout;
-            }
-        }
-        rollout.stage = 'rolling';
-        rollout.updatedAt = new Date();
-        return rollout;
-    }
-    async transitionRollingToComplete(rollout) {
-        const remainingDeviceIds = rollout.targetDeviceIds.filter((id) => !rollout.canaryDeviceIds.includes(id));
-        await this.deployToDevices(rollout, remainingDeviceIds, rollout.firmwareVersion);
-        rollout.stage = 'complete';
-        rollout.updatedAt = new Date();
-        rollout.completedAt = new Date();
-        return rollout;
-    }
-    // ---------------------------------------------------------------------------
-    // Helpers
-    // ---------------------------------------------------------------------------
-    async deployToDevices(rollout, deviceIds, version) {
-        for (const deviceId of deviceIds) {
-            const result = await this.deps.deployFirmware(deviceId, version);
-            if (result.success) {
-                rollout.completedDeviceIds.push(deviceId);
-            }
-            else {
-                rollout.failedDeviceIds.push(deviceId);
-            }
-        }
-    }
-    getExistingRollout(rolloutId) {
-        const rollout = this.rollouts.get(rolloutId);
-        if (!rollout) {
-            throw new Error(`Rollout ${rolloutId} not found`);
-        }
-        return rollout;
-    }
-}
-//# sourceMappingURL=firmware-orchestration-service.js.map

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

@@ -1,34 +0,0 @@
-import type { DeviceFleet, FleetTopology, FirmwarePolicy, TelemetryPolicy, HealthThresholds } from '../entities/index.js';
-import type { FleetRepository } from '../repositories/index.js';
-export interface CreateFleetOptions {
-    fleetId: string;
-    name: string;
-    description?: string;
-    zoneId: string;
-    topology?: FleetTopology;
-    firmwarePolicy?: Partial<FirmwarePolicy>;
-    telemetryPolicy?: Partial<TelemetryPolicy>;
-    healthThresholds?: Partial<HealthThresholds>;
-}
-export interface FleetSummary {
-    fleetId: string;
-    name: string;
-    zoneId: string;
-    deviceCount: number;
-    topology: FleetTopology;
-    createdAt: Date;
-}
-export declare class FleetTopologyService {
-    private readonly repo;
-    constructor(repo: FleetRepository);
-    createFleet(options: CreateFleetOptions): Promise<DeviceFleet>;
-    getFleet(fleetId: string): Promise<DeviceFleet>;
-    listFleets(): Promise<FleetSummary[]>;
-    addDeviceToFleet(fleetId: string, deviceId: string): Promise<DeviceFleet>;
-    removeDeviceFromFleet(fleetId: string, deviceId: string): Promise<DeviceFleet>;
-    updateTopology(fleetId: string, topology: FleetTopology): Promise<DeviceFleet>;
-    updateFirmwarePolicy(fleetId: string, policy: Partial<FirmwarePolicy>): Promise<DeviceFleet>;
-    deleteFleet(fleetId: string): Promise<void>;
-    getFleetDeviceCount(fleetId: string): Promise<number>;
-}
-//# sourceMappingURL=fleet-topology-service.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/services/fleet-topology-service.js

@@ -1,101 +0,0 @@
-const DEFAULT_FIRMWARE_POLICY = {
-    channel: 'stable',
-    autoUpdate: false,
-    approvalRequired: true,
-    canaryPercentage: 10,
-    canaryDurationMinutes: 30,
-    rollbackOnAnomalyThreshold: 0.8,
-};
-const DEFAULT_TELEMETRY_POLICY = {
-    ingestionIntervalSeconds: 60,
-    retentionDays: 30,
-    anomalyDetectionEnabled: true,
-    anomalyThreshold: 0.7,
-    vectorDimension: 128,
-};
-const DEFAULT_HEALTH_THRESHOLDS = {
-    maxOfflineMinutes: 10,
-    minUptimeRatio: 0.95,
-    maxConsecutiveAnomalies: 3,
-    minFirmwareCurrency: 0.8,
-};
-export class FleetTopologyService {
-    repo;
-    constructor(repo) {
-        this.repo = repo;
-    }
-    async createFleet(options) {
-        const existing = await this.repo.findById(options.fleetId);
-        if (existing)
-            throw new Error(`Fleet ${options.fleetId} already exists`);
-        const fleet = {
-            fleetId: options.fleetId,
-            name: options.name,
-            description: options.description ?? '',
-            zoneId: options.zoneId,
-            deviceIds: [],
-            topology: options.topology ?? 'star',
-            firmwarePolicy: { ...DEFAULT_FIRMWARE_POLICY, ...options.firmwarePolicy },
-            telemetryPolicy: { ...DEFAULT_TELEMETRY_POLICY, ...options.telemetryPolicy },
-            healthThresholds: { ...DEFAULT_HEALTH_THRESHOLDS, ...options.healthThresholds },
-            createdAt: new Date(),
-            updatedAt: new Date(),
-        };
-        await this.repo.save(fleet);
-        return fleet;
-    }
-    async getFleet(fleetId) {
-        const fleet = await this.repo.findById(fleetId);
-        if (!fleet)
-            throw new Error(`Fleet ${fleetId} not found`);
-        return fleet;
-    }
-    async listFleets() {
-        const fleets = await this.repo.findAll();
-        return fleets.map((f) => ({
-            fleetId: f.fleetId,
-            name: f.name,
-            zoneId: f.zoneId,
-            deviceCount: f.deviceIds.length,
-            topology: f.topology,
-            createdAt: f.createdAt,
-        }));
-    }
-    async addDeviceToFleet(fleetId, deviceId) {
-        const fleet = await this.getFleet(fleetId);
-        if (fleet.deviceIds.includes(deviceId)) {
-            return fleet;
-        }
-        fleet.deviceIds.push(deviceId);
-        await this.repo.save(fleet);
-        return fleet;
-    }
-    async removeDeviceFromFleet(fleetId, deviceId) {
-        const fleet = await this.getFleet(fleetId);
-        fleet.deviceIds = fleet.deviceIds.filter((id) => id !== deviceId);
-        await this.repo.save(fleet);
-        return fleet;
-    }
-    async updateTopology(fleetId, topology) {
-        const fleet = await this.getFleet(fleetId);
-        fleet.topology = topology;
-        await this.repo.save(fleet);
-        return fleet;
-    }
-    async updateFirmwarePolicy(fleetId, policy) {
-        const fleet = await this.getFleet(fleetId);
-        fleet.firmwarePolicy = { ...fleet.firmwarePolicy, ...policy };
-        await this.repo.save(fleet);
-        return fleet;
-    }
-    async deleteFleet(fleetId) {
-        const deleted = await this.repo.delete(fleetId);
-        if (!deleted)
-            throw new Error(`Fleet ${fleetId} not found`);
-    }
-    async getFleetDeviceCount(fleetId) {
-        const fleet = await this.getFleet(fleetId);
-        return fleet.deviceIds.length;
-    }
-}
-//# sourceMappingURL=fleet-topology-service.js.map

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

@@ -1,10 +0,0 @@
-export { DeviceLifecycleService, type DeviceLifecycleDeps, } from './device-lifecycle-service.js';
-export { TelemetryService, type TelemetryServiceDeps, type StoreQueryResult, type IngestResult, type StoreHealthStatus, } from './telemetry-service.js';
-export { MeshService, type MeshServiceDeps, type MeshPeer, type MeshTopology, } from './mesh-service.js';
-export { AnomalyDetectionService, type AnomalyDetectionConfig, type TelemetryBaseline, } from './anomaly-detection-service.js';
-export { TelemetryIngestionService, type TelemetryIngestionDeps, type IngestionResult, } from './telemetry-ingestion-service.js';
-export { FleetTopologyService, type CreateFleetOptions, type FleetSummary, } from './fleet-topology-service.js';
-export { FirmwareOrchestrationService, type FirmwareOrchestrationDeps, type FirmwareRollout, type RolloutStage, } from './firmware-orchestration-service.js';
-export { WitnessVerificationService, type WitnessVerificationDeps, type WitnessVerificationResult, type WitnessEntry, type WitnessGap, } from './witness-verification-service.js';
-export { SONAIntegrationService, type SONAClient, type SONAIntegrationConfig, } from './sona-integration-service.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,10 +0,0 @@
-export { DeviceLifecycleService, } from './device-lifecycle-service.js';
-export { TelemetryService, } from './telemetry-service.js';
-export { MeshService, } from './mesh-service.js';
-export { AnomalyDetectionService, } from './anomaly-detection-service.js';
-export { TelemetryIngestionService, } from './telemetry-ingestion-service.js';
-export { FleetTopologyService, } from './fleet-topology-service.js';
-export { FirmwareOrchestrationService, } from './firmware-orchestration-service.js';
-export { WitnessVerificationService, } from './witness-verification-service.js';
-export { SONAIntegrationService, } from './sona-integration-service.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,64 +0,0 @@
-export interface MeshServiceDeps {
-    getMeshStatus: (deviceId: string) => Promise<{
-        ap_active?: boolean;
-        auto_mesh?: boolean;
-        peer_count?: number;
-        peers?: Array<{
-            device_id?: string;
-            address?: string;
-        }>;
-    }>;
-    getPeers: (deviceId: string) => Promise<{
-        count?: number;
-        peers?: Array<{
-            device_id?: string;
-            address?: string;
-        }>;
-    }>;
-    getSwarmStatus: (deviceId: string) => Promise<{
-        device_id?: string;
-        epoch?: number;
-        peer_count?: number;
-        total_vectors?: number;
-        uptime_secs?: number;
-    }>;
-    getClusterHealth: (deviceId: string) => Promise<{
-        cluster_enabled?: boolean;
-        peer_count?: number;
-        auto_sync_interval_secs?: number;
-    }>;
-}
-export interface MeshPeer {
-    deviceId: string;
-    address?: string;
-}
-export interface MeshTopology {
-    deviceId: string;
-    apActive: boolean;
-    autoMesh: boolean;
-    clusterEnabled: boolean;
-    autoSyncIntervalSecs: number;
-    peerCount: number;
-    peers: MeshPeer[];
-    swarmEpoch?: number;
-    swarmTotalVectors?: number;
-    swarmUptimeSecs?: number;
-}
-export declare class MeshService {
-    private readonly deps;
-    constructor(deps: MeshServiceDeps);
-    /**
-     * Aggregate all mesh endpoints into a single topology snapshot.
-     */
-    getTopology(deviceId: string): Promise<MeshTopology>;
-    /**
-     * Discover and return the device IDs of all known mesh peers.
-     */
-    discoverPeers(deviceId: string): Promise<string[]>;
-    /**
-     * De-duplicate peers from multiple sources, preferring entries that carry
-     * both a device_id and an address.
-     */
-    private mergePeers;
-}
-//# sourceMappingURL=mesh-service.d.ts.map

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

@@ -1,70 +0,0 @@
-// ---------------------------------------------------------------------------
-// Dependency contract
-// ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
-// Service
-// ---------------------------------------------------------------------------
-export class MeshService {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    /**
-     * Aggregate all mesh endpoints into a single topology snapshot.
-     */
-    async getTopology(deviceId) {
-        const [mesh, peers, swarm, cluster] = await Promise.all([
-            this.deps.getMeshStatus(deviceId),
-            this.deps.getPeers(deviceId),
-            this.deps.getSwarmStatus(deviceId),
-            this.deps.getClusterHealth(deviceId),
-        ]);
-        const mergedPeers = this.mergePeers(mesh.peers ?? [], peers.peers ?? []);
-        return {
-            deviceId,
-            apActive: mesh.ap_active ?? false,
-            autoMesh: mesh.auto_mesh ?? false,
-            clusterEnabled: cluster.cluster_enabled ?? false,
-            autoSyncIntervalSecs: cluster.auto_sync_interval_secs ?? 0,
-            peerCount: mergedPeers.length,
-            peers: mergedPeers,
-            swarmEpoch: swarm.epoch,
-            swarmTotalVectors: swarm.total_vectors,
-            swarmUptimeSecs: swarm.uptime_secs,
-        };
-    }
-    /**
-     * Discover and return the device IDs of all known mesh peers.
-     */
-    async discoverPeers(deviceId) {
-        const [mesh, peers] = await Promise.all([
-            this.deps.getMeshStatus(deviceId),
-            this.deps.getPeers(deviceId),
-        ]);
-        const merged = this.mergePeers(mesh.peers ?? [], peers.peers ?? []);
-        return merged.map((p) => p.deviceId);
-    }
-    // ---------------------------------------------------------------------------
-    // Helpers
-    // ---------------------------------------------------------------------------
-    /**
-     * De-duplicate peers from multiple sources, preferring entries that carry
-     * both a device_id and an address.
-     */
-    mergePeers(...sources) {
-        const seen = new Map();
-        for (const list of sources) {
-            for (const raw of list) {
-                const id = raw.device_id;
-                if (!id)
-                    continue;
-                const existing = seen.get(id);
-                if (!existing || (!existing.address && raw.address)) {
-                    seen.set(id, { deviceId: id, address: raw.address });
-                }
-            }
-        }
-        return [...seen.values()];
-    }
-}
-//# sourceMappingURL=mesh-service.js.map

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

@@ -1,44 +0,0 @@
-import type { AnomalyDetection, TelemetryReading } from '../entities/telemetry.js';
-import type { TelemetryBaseline } from './anomaly-detection-service.js';
-export interface SONAClient {
-    storePattern(key: string, pattern: Record<string, unknown>): Promise<void>;
-    searchPatterns(query: string, limit?: number): Promise<Array<{
-        key: string;
-        pattern: Record<string, unknown>;
-        score: number;
-    }>>;
-    trainTrajectory(trajectoryId: string, steps: Array<{
-        action: string;
-        reward: number;
-        state: Record<string, unknown>;
-    }>): Promise<void>;
-    predict(input: Record<string, unknown>): Promise<{
-        prediction: string;
-        confidence: number;
-    }>;
-}
-export interface SONAIntegrationConfig {
-    enabled: boolean;
-    trajectoryNamespace: string;
-    patternNamespace: string;
-    minConfidence: number;
-}
-export declare class SONAIntegrationService {
-    private readonly config;
-    private readonly client;
-    constructor(client: SONAClient | null, config?: Partial<SONAIntegrationConfig>);
-    get isEnabled(): boolean;
-    learnAnomalyPattern(anomaly: AnomalyDetection, baseline: TelemetryBaseline | undefined): Promise<void>;
-    learnBaselineShift(deviceId: string, oldBaseline: TelemetryBaseline | undefined, newBaseline: TelemetryBaseline): Promise<void>;
-    recordTelemetryTrajectory(deviceId: string, readings: TelemetryReading[], anomalies: AnomalyDetection[]): Promise<void>;
-    predictAnomalyRisk(reading: TelemetryReading): Promise<{
-        risk: string;
-        confidence: number;
-    } | null>;
-    findSimilarAnomalyPatterns(anomaly: AnomalyDetection, limit?: number): Promise<Array<{
-        key: string;
-        pattern: Record<string, unknown>;
-        score: number;
-    }>>;
-}
-//# sourceMappingURL=sona-integration-service.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/services/sona-integration-service.js

@@ -1,79 +0,0 @@
-export class SONAIntegrationService {
-    config;
-    client;
-    constructor(client, config) {
-        this.client = client;
-        this.config = {
-            enabled: config?.enabled ?? (client !== null),
-            trajectoryNamespace: config?.trajectoryNamespace ?? 'iot-trajectories',
-            patternNamespace: config?.patternNamespace ?? 'iot-patterns',
-            minConfidence: config?.minConfidence ?? 0.6,
-        };
-    }
-    get isEnabled() {
-        return this.config.enabled && this.client !== null;
-    }
-    async learnAnomalyPattern(anomaly, baseline) {
-        if (!this.isEnabled || !this.client)
-            return;
-        await this.client.storePattern(`anomaly:${anomaly.type}:${anomaly.deviceId}`, {
-            type: anomaly.type,
-            score: anomaly.score,
-            action: anomaly.suggestedAction,
-            deviceId: anomaly.deviceId,
-            baselineSamples: baseline?.sampleCount ?? 0,
-            timestamp: new Date().toISOString(),
-        });
-    }
-    async learnBaselineShift(deviceId, oldBaseline, newBaseline) {
-        if (!this.isEnabled || !this.client)
-            return;
-        const drift = oldBaseline
-            ? newBaseline.meanVector.map((v, i) => Math.abs(v - oldBaseline.meanVector[i]))
-            : newBaseline.meanVector.map(() => 0);
-        await this.client.storePattern(`baseline-shift:${deviceId}`, {
-            deviceId,
-            driftVector: drift,
-            maxDrift: Math.max(...drift),
-            oldSamples: oldBaseline?.sampleCount ?? 0,
-            newSamples: newBaseline.sampleCount,
-            timestamp: new Date().toISOString(),
-        });
-    }
-    async recordTelemetryTrajectory(deviceId, readings, anomalies) {
-        if (!this.isEnabled || !this.client)
-            return;
-        const steps = readings.map((r) => {
-            const anomaly = anomalies.find((a) => a.readingId === r.readingId);
-            return {
-                action: anomaly ? `anomaly:${anomaly.type}` : 'normal',
-                reward: anomaly ? -anomaly.score : 1.0,
-                state: {
-                    vector: r.vector,
-                    anomalyScore: r.anomalyScore,
-                    deviceId: r.deviceId,
-                },
-            };
-        });
-        const trajectoryId = `${this.config.trajectoryNamespace}:${deviceId}:${Date.now()}`;
-        await this.client.trainTrajectory(trajectoryId, steps);
-    }
-    async predictAnomalyRisk(reading) {
-        if (!this.isEnabled || !this.client)
-            return null;
-        const result = await this.client.predict({
-            vector: reading.vector,
-            deviceId: reading.deviceId,
-            anomalyScore: reading.anomalyScore,
-        });
-        if (result.confidence < this.config.minConfidence)
-            return null;
-        return { risk: result.prediction, confidence: result.confidence };
-    }
-    async findSimilarAnomalyPatterns(anomaly, limit = 5) {
-        if (!this.isEnabled || !this.client)
-            return [];
-        return this.client.searchPatterns(`anomaly:${anomaly.type} score:${anomaly.score.toFixed(2)}`, limit);
-    }
-}
-//# sourceMappingURL=sona-integration-service.js.map

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

@@ -1,37 +0,0 @@
-import type { TelemetryReading, AnomalyDetection } from '../entities/index.js';
-import type { AnomalyDetectionService, TelemetryBaseline } from './anomaly-detection-service.js';
-export interface TelemetryIngestionDeps {
-    queryDeviceStore: (deviceId: string, vector: number[], k: number) => Promise<Array<{
-        id: number | string;
-        distance: number;
-        metadata?: Record<string, unknown>;
-    }>>;
-    getStoreStatus: (deviceId: string) => Promise<{
-        total_vectors: number;
-        dimension: number;
-    }>;
-}
-export interface IngestionResult {
-    deviceId: string;
-    readingsProcessed: number;
-    anomaliesDetected: number;
-    anomalies: AnomalyDetection[];
-    baseline?: TelemetryBaseline;
-}
-export declare class TelemetryIngestionService {
-    private readonly deps;
-    private readonly anomalyDetector;
-    constructor(deps: TelemetryIngestionDeps, anomalyDetector: AnomalyDetectionService);
-    /**
-     * Process a batch of telemetry readings: run anomaly detection on each,
-     * and return the results.
-     */
-    processBatch(deviceId: string, readings: TelemetryReading[]): IngestionResult;
-    /**
-     * Compute or refresh the baseline for a device from its recent readings.
-     */
-    refreshBaseline(deviceId: string, readings: TelemetryReading[]): TelemetryBaseline;
-    /** Get the current baseline for a device. */
-    getBaseline(deviceId: string): TelemetryBaseline | undefined;
-}
-//# sourceMappingURL=telemetry-ingestion-service.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/services/telemetry-ingestion-service.js

@@ -1,39 +0,0 @@
-export class TelemetryIngestionService {
-    deps;
-    anomalyDetector;
-    constructor(deps, anomalyDetector) {
-        this.deps = deps;
-        this.anomalyDetector = anomalyDetector;
-    }
-    /**
-     * Process a batch of telemetry readings: run anomaly detection on each,
-     * and return the results.
-     */
-    processBatch(deviceId, readings) {
-        const anomalies = [];
-        for (const reading of readings) {
-            const detection = this.anomalyDetector.detect(reading);
-            if (this.anomalyDetector.isAnomalous(detection)) {
-                anomalies.push(detection);
-            }
-        }
-        return {
-            deviceId,
-            readingsProcessed: readings.length,
-            anomaliesDetected: anomalies.length,
-            anomalies,
-            baseline: this.anomalyDetector.getBaseline(deviceId),
-        };
-    }
-    /**
-     * Compute or refresh the baseline for a device from its recent readings.
-     */
-    refreshBaseline(deviceId, readings) {
-        return this.anomalyDetector.computeBaseline(deviceId, readings);
-    }
-    /** Get the current baseline for a device. */
-    getBaseline(deviceId) {
-        return this.anomalyDetector.getBaseline(deviceId);
-    }
-}
-//# sourceMappingURL=telemetry-ingestion-service.js.map