@fastybird/smart-panel-backend 0.1.0-alpha.5

package/dist/modules/spaces/services/space-media-activity.service.js

@@ -0,0 +1,739 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpaceMediaActivityService = void 0;
+const typeorm_1 = require("typeorm");
+const common_1 = require("@nestjs/common");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const typeorm_2 = require("@nestjs/typeorm");
+const logger_1 = require("../../../common/logger");
+const transform_utils_1 = require("../../../common/utils/transform.utils");
+const platform_registry_service_1 = require("../../devices/services/platform.registry.service");
+const space_active_media_activity_entity_1 = require("../entities/space-active-media-activity.entity");
+const spaces_constants_1 = require("../spaces.constants");
+const spaces_exceptions_1 = require("../spaces.exceptions");
+const derived_media_endpoint_service_1 = require("./derived-media-endpoint.service");
+const space_media_activity_binding_service_1 = require("./space-media-activity-binding.service");
+const spaces_service_1 = require("./spaces.service");
+const STEP_TIMEOUT_MS = 5000;
+const STEP_DELAY_MS = 600;
+function diagnoseBinding(binding, endpointMap) {
+    const diagnostics = [];
+    const slots = [
+        { id: binding.displayEndpointId, name: 'Display' },
+        { id: binding.audioEndpointId, name: 'Audio' },
+        { id: binding.sourceEndpointId, name: 'Source' },
+        { id: binding.remoteEndpointId, name: 'Remote' },
+    ];
+    for (const { id, name } of slots) {
+        if (id && !endpointMap.has(id)) {
+            diagnostics.push(`${name} endpoint not found (${id})`);
+        }
+    }
+    const audioEndpoint = binding.audioEndpointId ? endpointMap.get(binding.audioEndpointId) : undefined;
+    const displayEndpoint = binding.displayEndpointId ? endpointMap.get(binding.displayEndpointId) : undefined;
+    const sourceEndpoint = binding.sourceEndpointId ? endpointMap.get(binding.sourceEndpointId) : undefined;
+    if (audioEndpoint && binding.audioVolumePreset !== null && !audioEndpoint.capabilities.volume) {
+        diagnostics.push(`Volume preset skipped (${audioEndpoint.name} has no volume capability)`);
+    }
+    if (displayEndpoint && binding.displayInputId && !displayEndpoint.capabilities.inputSelect) {
+        diagnostics.push(`Display input preset skipped (${displayEndpoint.name} has no input select capability)`);
+    }
+    if (audioEndpoint && binding.audioInputId && !audioEndpoint.capabilities.inputSelect) {
+        diagnostics.push(`Audio input preset skipped (${audioEndpoint.name} has no input select capability)`);
+    }
+    if (sourceEndpoint && binding.sourceInputId && !sourceEndpoint.capabilities.inputSelect) {
+        diagnostics.push(`Source input preset skipped (${sourceEndpoint.name} has no input select capability)`);
+    }
+    if (displayEndpoint && !displayEndpoint.capabilities.power) {
+        diagnostics.push(`Display power-on skipped (${displayEndpoint.name} has no power capability)`);
+    }
+    if (audioEndpoint && !audioEndpoint.capabilities.power) {
+        diagnostics.push(`Audio power-on skipped (${audioEndpoint.name} has no power capability)`);
+    }
+    if (sourceEndpoint && !sourceEndpoint.capabilities.power) {
+        diagnostics.push(`Source power-on skipped (${sourceEndpoint.name} has no power capability)`);
+    }
+    return diagnostics;
+}
+let SpaceMediaActivityService = class SpaceMediaActivityService {
+    constructor(activeRepository, spacesService, bindingService, derivedEndpointService, platformRegistryService, eventEmitter) {
+        this.activeRepository = activeRepository;
+        this.spacesService = spacesService;
+        this.bindingService = bindingService;
+        this.derivedEndpointService = derivedEndpointService;
+        this.platformRegistryService = platformRegistryService;
+        this.eventEmitter = eventEmitter;
+        this.logger = (0, logger_1.createExtensionLogger)(spaces_constants_1.SPACES_MODULE_NAME, 'SpaceMediaActivityService');
+    }
+    async getActiveRecord(spaceId) {
+        return this.activeRepository.findOne({ where: { spaceId } });
+    }
+    async getActive(spaceId) {
+        await this.spacesService.getOneOrThrow(spaceId);
+        return this.getActiveRecord(spaceId);
+    }
+    async activate(spaceId, activityKey) {
+        await this.spacesService.getOneOrThrow(spaceId);
+        if (!Object.values(spaces_constants_1.MediaActivityKey).includes(activityKey)) {
+            throw new spaces_exceptions_1.SpacesValidationException(`Invalid activity key: ${activityKey}`);
+        }
+        if (activityKey === spaces_constants_1.MediaActivityKey.OFF) {
+            return this.deactivate(spaceId);
+        }
+        const existingRecord = await this.getActiveRecord(spaceId);
+        if (existingRecord &&
+            existingRecord.activityKey === activityKey &&
+            (existingRecord.state === spaces_constants_1.MediaActivationState.ACTIVE || existingRecord.state === spaces_constants_1.MediaActivationState.ACTIVATING)) {
+            this.logger.debug(`Activity ${activityKey} already active for space=${spaceId}, returning current state`);
+            return this.buildResultFromRecord(existingRecord);
+        }
+        const bindings = await this.bindingService.findBySpace(spaceId);
+        const binding = bindings.find((b) => b.activityKey === activityKey);
+        if (!binding) {
+            throw new spaces_exceptions_1.SpacesValidationException(`No binding found for activity "${activityKey}" in space ${spaceId}. ` +
+                `Please call POST /spaces/${spaceId}/media/bindings/apply-defaults first.`);
+        }
+        const endpointsResult = await this.derivedEndpointService.buildEndpointsForSpace(spaceId);
+        const endpointMap = new Map();
+        for (const ep of endpointsResult.endpoints) {
+            endpointMap.set(ep.endpointId, ep);
+        }
+        this.logBindingGuardrails(spaceId, activityKey, binding, endpointMap);
+        const plan = this.buildExecutionPlan(spaceId, activityKey, binding, endpointMap);
+        let record = existingRecord;
+        if (!record) {
+            record = this.activeRepository.create({
+                spaceId,
+                activityKey,
+                state: spaces_constants_1.MediaActivationState.ACTIVATING,
+                activatedAt: new Date(),
+                resolved: JSON.stringify((0, transform_utils_1.toSnakeCaseKeys)(plan.resolved)),
+                lastResult: null,
+            });
+        }
+        else {
+            if (record.activityKey && record.activityKey !== activityKey) {
+                this.logger.debug(`Switching activity: ${record.activityKey} → ${activityKey} for space=${spaceId} (previous state=${record.state})`);
+            }
+            record.activityKey = activityKey;
+            record.state = spaces_constants_1.MediaActivationState.ACTIVATING;
+            record.activatedAt = new Date();
+            record.resolved = JSON.stringify((0, transform_utils_1.toSnakeCaseKeys)(plan.resolved));
+            record.lastResult = null;
+        }
+        await this.activeRepository.save(record);
+        const planSteps = plan.steps.map((step, index) => ({
+            index,
+            label: step.label ?? `Step ${index + 1}`,
+            critical: step.critical,
+        }));
+        this.emitEvent(spaces_constants_1.EventType.MEDIA_ACTIVITY_ACTIVATING, spaceId, activityKey, plan.resolved, undefined, undefined, planSteps);
+        try {
+            const conflictWarnings = await this.handleConflicts(spaceId, activityKey, endpointMap);
+            const executionResult = await this.executePlan(plan);
+            const hasCriticalFailure = executionResult.failures.some((f) => f.critical);
+            const finalState = hasCriticalFailure ? spaces_constants_1.MediaActivationState.FAILED : spaces_constants_1.MediaActivationState.ACTIVE;
+            const allFailures = executionResult.failures;
+            const warningItems = allFailures.filter((f) => !f.critical);
+            const errorItems = allFailures.filter((f) => f.critical);
+            const lastResult = {
+                stepsTotal: plan.steps.length,
+                stepsSucceeded: executionResult.succeeded,
+                stepsFailed: executionResult.failures.length,
+                failures: allFailures.length > 0 ? allFailures : undefined,
+                warnings: warningItems.length > 0 ? warningItems : undefined,
+                errors: errorItems.length > 0 ? errorItems : undefined,
+                warningCount: warningItems.length,
+                errorCount: errorItems.length,
+            };
+            record.state = finalState;
+            record.lastResult = JSON.stringify((0, transform_utils_1.toSnakeCaseKeys)(lastResult));
+            await this.activeRepository.save(record);
+            const warnings = [
+                ...conflictWarnings,
+                ...executionResult.failures.filter((f) => !f.critical).map((f) => `Step ${f.stepIndex}: ${f.reason}`),
+            ];
+            if (finalState === spaces_constants_1.MediaActivationState.ACTIVE) {
+                this.emitEvent(spaces_constants_1.EventType.MEDIA_ACTIVITY_ACTIVATED, spaceId, activityKey, plan.resolved, lastResult, warnings);
+            }
+            else {
+                this.emitEvent(spaces_constants_1.EventType.MEDIA_ACTIVITY_FAILED, spaceId, activityKey, plan.resolved, lastResult);
+            }
+            this.logger.debug(`Activity activation complete: space=${spaceId} activity=${activityKey} state=${finalState} ` +
+                `succeeded=${executionResult.succeeded} failed=${executionResult.failures.length}`);
+            return {
+                activityKey,
+                state: finalState,
+                resolved: plan.resolved,
+                summary: lastResult,
+                warnings: warnings.length > 0 ? warnings : undefined,
+                requiresRealtime: true,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Unexpected error during activity activation: space=${spaceId} activity=${activityKey}`, error instanceof Error ? error.stack : String(error));
+            const unexpectedFailure = {
+                stepIndex: 0,
+                critical: true,
+                reason: `Unexpected error: ${error instanceof Error ? error.message : String(error)}`,
+                timestamp: new Date().toISOString(),
+            };
+            const lastResult = {
+                stepsTotal: plan.steps.length,
+                stepsSucceeded: 0,
+                stepsFailed: plan.steps.length,
+                failures: [unexpectedFailure],
+                errors: [unexpectedFailure],
+                warningCount: 0,
+                errorCount: 1,
+            };
+            record.state = spaces_constants_1.MediaActivationState.FAILED;
+            record.lastResult = JSON.stringify((0, transform_utils_1.toSnakeCaseKeys)(lastResult));
+            await this.activeRepository.save(record);
+            this.emitEvent(spaces_constants_1.EventType.MEDIA_ACTIVITY_FAILED, spaceId, activityKey, plan.resolved, lastResult);
+            return {
+                activityKey,
+                state: spaces_constants_1.MediaActivationState.FAILED,
+                resolved: plan.resolved,
+                summary: lastResult,
+                requiresRealtime: true,
+            };
+        }
+    }
+    async preview(spaceId, activityKey) {
+        await this.spacesService.getOneOrThrow(spaceId);
+        if (!Object.values(spaces_constants_1.MediaActivityKey).includes(activityKey)) {
+            throw new spaces_exceptions_1.SpacesValidationException(`Invalid activity key: ${activityKey}`);
+        }
+        if (activityKey === spaces_constants_1.MediaActivityKey.OFF) {
+            throw new spaces_exceptions_1.SpacesValidationException('Cannot preview the "off" activity');
+        }
+        const bindings = await this.bindingService.findBySpace(spaceId);
+        const binding = bindings.find((b) => b.activityKey === activityKey);
+        if (!binding) {
+            throw new spaces_exceptions_1.SpacesValidationException(`No binding found for activity "${activityKey}" in space ${spaceId}. ` +
+                `Please call POST /spaces/${spaceId}/media/bindings/apply-defaults first.`);
+        }
+        const endpointsResult = await this.derivedEndpointService.buildEndpointsForSpace(spaceId);
+        const endpointMap = new Map();
+        for (const ep of endpointsResult.endpoints) {
+            endpointMap.set(ep.endpointId, ep);
+        }
+        const plan = this.buildExecutionPlan(spaceId, activityKey, binding, endpointMap);
+        const diagnostics = diagnoseBinding(binding, endpointMap);
+        const warnings = diagnostics.map((label) => ({ label }));
+        const indexedPlan = plan.steps.map((step, index) => ({
+            ...step,
+            label: step.label ?? `Step ${index + 1}: ${step.action.kind} on ${step.targetDeviceId}`,
+        }));
+        this.logger.debug(`Dry-run preview: space=${spaceId} activity=${activityKey} steps=${indexedPlan.length} warnings=${warnings.length}`);
+        return {
+            spaceId,
+            activityKey,
+            resolved: plan.resolved,
+            plan: indexedPlan,
+            warnings,
+        };
+    }
+    async deactivate(spaceId) {
+        await this.spacesService.getOneOrThrow(spaceId);
+        const record = await this.getActiveRecord(spaceId);
+        const deactivationWarnings = [];
+        if (record) {
+            if (record.resolved && record.state !== spaces_constants_1.MediaActivationState.DEACTIVATED) {
+                try {
+                    const resolved = JSON.parse(record.resolved);
+                    const stopWarnings = await this.bestEffortStopPlayback(spaceId, resolved);
+                    deactivationWarnings.push(...stopWarnings);
+                }
+                catch (error) {
+                    const err = error;
+                    deactivationWarnings.push(`Best-effort stop failed: ${err.message}`);
+                    this.logger.warn(`Best-effort stop playback failed during deactivation: ${err.message}`);
+                }
+            }
+            record.activityKey = null;
+            record.state = spaces_constants_1.MediaActivationState.DEACTIVATED;
+            record.lastResult = null;
+            await this.activeRepository.save(record);
+        }
+        this.emitEvent(spaces_constants_1.EventType.MEDIA_ACTIVITY_DEACTIVATED, spaceId, null);
+        return {
+            activityKey: null,
+            state: spaces_constants_1.MediaActivationState.DEACTIVATED,
+            warnings: deactivationWarnings.length > 0 ? deactivationWarnings : undefined,
+            requiresRealtime: true,
+        };
+    }
+    async bestEffortStopPlayback(spaceId, resolved) {
+        const endpointsResult = await this.derivedEndpointService.buildEndpointsForSpace(spaceId);
+        const playbackEndpoints = endpointsResult.endpoints.filter((e) => e.capabilities.playback && e.links.playback);
+        const resolvedDeviceIds = new Set([resolved.displayDeviceId, resolved.audioDeviceId, resolved.sourceDeviceId, resolved.remoteDeviceId].filter(Boolean));
+        const targetEndpoints = playbackEndpoints.filter((ep) => resolvedDeviceIds.has(ep.deviceId));
+        return this.pausePlaybackOnEndpoints(targetEndpoints, (ep) => `Failed to stop playback on ${ep.name}`);
+    }
+    buildExecutionPlan(spaceId, activityKey, binding, endpointMap) {
+        const steps = [];
+        const resolved = {};
+        const displayEndpoint = binding.displayEndpointId ? endpointMap.get(binding.displayEndpointId) : undefined;
+        const audioEndpoint = binding.audioEndpointId ? endpointMap.get(binding.audioEndpointId) : undefined;
+        const sourceEndpoint = binding.sourceEndpointId ? endpointMap.get(binding.sourceEndpointId) : undefined;
+        const remoteEndpoint = binding.remoteEndpointId ? endpointMap.get(binding.remoteEndpointId) : undefined;
+        if (displayEndpoint) {
+            resolved.displayDeviceId = displayEndpoint.deviceId;
+        }
+        if (audioEndpoint) {
+            resolved.audioDeviceId = audioEndpoint.deviceId;
+        }
+        if (sourceEndpoint) {
+            resolved.sourceDeviceId = sourceEndpoint.deviceId;
+        }
+        if (remoteEndpoint) {
+            resolved.remoteDeviceId = remoteEndpoint.deviceId;
+        }
+        resolved.controlTargets = this.computeControlTargets(displayEndpoint, audioEndpoint, sourceEndpoint, remoteEndpoint, endpointMap);
+        const poweredDeviceIds = new Set();
+        const powerEndpoints = [displayEndpoint, audioEndpoint, sourceEndpoint].filter((ep) => !!ep && ep.capabilities.power && !!ep.links.power);
+        for (const ep of powerEndpoints) {
+            if (poweredDeviceIds.has(ep.deviceId)) {
+                continue;
+            }
+            poweredDeviceIds.add(ep.deviceId);
+            steps.push({
+                targetDeviceId: ep.deviceId,
+                action: {
+                    kind: 'setProperty',
+                    propertyId: ep.links.power.propertyId,
+                    value: true,
+                },
+                critical: activityKey === spaces_constants_1.MediaActivityKey.WATCH || activityKey === spaces_constants_1.MediaActivityKey.GAMING,
+                label: `Power on ${ep.name}`,
+            });
+        }
+        if (displayEndpoint &&
+            binding.displayInputId &&
+            displayEndpoint.capabilities.inputSelect &&
+            displayEndpoint.links.inputSelect) {
+            steps.push({
+                targetDeviceId: displayEndpoint.deviceId,
+                action: {
+                    kind: 'setProperty',
+                    propertyId: displayEndpoint.links.inputSelect.propertyId,
+                    value: binding.displayInputId,
+                },
+                critical: true,
+                label: `Set display input to ${binding.displayInputId}`,
+            });
+        }
+        if (audioEndpoint &&
+            binding.audioInputId &&
+            audioEndpoint.capabilities.inputSelect &&
+            audioEndpoint.links.inputSelect) {
+            steps.push({
+                targetDeviceId: audioEndpoint.deviceId,
+                action: {
+                    kind: 'setProperty',
+                    propertyId: audioEndpoint.links.inputSelect.propertyId,
+                    value: binding.audioInputId,
+                },
+                critical: true,
+                label: `Set audio input to ${binding.audioInputId}`,
+            });
+        }
+        if (sourceEndpoint &&
+            binding.sourceInputId &&
+            sourceEndpoint.capabilities.inputSelect &&
+            sourceEndpoint.links.inputSelect) {
+            steps.push({
+                targetDeviceId: sourceEndpoint.deviceId,
+                action: {
+                    kind: 'setProperty',
+                    propertyId: sourceEndpoint.links.inputSelect.propertyId,
+                    value: binding.sourceInputId,
+                },
+                critical: true,
+                label: `Set source input to ${binding.sourceInputId}`,
+            });
+        }
+        if (audioEndpoint &&
+            binding.audioVolumePreset !== null &&
+            audioEndpoint.capabilities.volume &&
+            audioEndpoint.links.volume) {
+            steps.push({
+                targetDeviceId: audioEndpoint.deviceId,
+                action: {
+                    kind: 'setProperty',
+                    propertyId: audioEndpoint.links.volume.propertyId,
+                    value: binding.audioVolumePreset,
+                },
+                critical: false,
+                label: `Set volume to ${binding.audioVolumePreset}%`,
+            });
+        }
+        return {
+            spaceId,
+            activityKey,
+            resolved,
+            steps,
+        };
+    }
+    logBindingGuardrails(spaceId, activityKey, binding, endpointMap) {
+        const diagnostics = diagnoseBinding(binding, endpointMap);
+        const ctx = `space=${spaceId} activity=${activityKey}`;
+        for (const label of diagnostics) {
+            this.logger.warn(`${label} (${ctx})`);
+        }
+    }
+    async executePlan(plan) {
+        let succeeded = 0;
+        const failures = [];
+        const deviceIds = [...new Set(plan.steps.map((s) => s.targetDeviceId))];
+        const devices = await this.spacesService.findDevicesByIds(deviceIds);
+        const deviceMap = new Map(devices.map((d) => [d.id, d]));
+        for (let i = 0; i < plan.steps.length; i++) {
+            const step = plan.steps[i];
+            const stepLabel = step.label ?? `Step ${i + 1}`;
+            const device = deviceMap.get(step.targetDeviceId);
+            this.emitStepProgress(plan.spaceId, plan.activityKey, i, plan.steps.length, 'executing', stepLabel);
+            await new Promise((resolve) => setTimeout(resolve, STEP_DELAY_MS));
+            if (!device) {
+                this.emitStepProgress(plan.spaceId, plan.activityKey, i, plan.steps.length, 'failed', stepLabel);
+                failures.push({
+                    stepIndex: i,
+                    reason: `Device ${step.targetDeviceId} not found`,
+                    critical: step.critical,
+                    targetDeviceId: step.targetDeviceId,
+                    kind: step.action.kind,
+                    propertyId: step.action.propertyId,
+                    label: step.label,
+                    timestamp: new Date().toISOString(),
+                });
+                if (step.critical) {
+                    this.logger.warn(`Critical step ${i} failed: device not found, aborting`);
+                    break;
+                }
+                continue;
+            }
+            const platform = this.platformRegistryService.get(device);
+            if (!platform) {
+                this.emitStepProgress(plan.spaceId, plan.activityKey, i, plan.steps.length, 'failed', stepLabel);
+                failures.push({
+                    stepIndex: i,
+                    reason: `No platform for device ${step.targetDeviceId}`,
+                    critical: step.critical,
+                    targetDeviceId: step.targetDeviceId,
+                    kind: step.action.kind,
+                    propertyId: step.action.propertyId,
+                    label: step.label,
+                    timestamp: new Date().toISOString(),
+                });
+                if (step.critical) {
+                    this.logger.warn(`Critical step ${i} failed: no platform, aborting`);
+                    break;
+                }
+                continue;
+            }
+            if (step.action.kind !== 'setProperty' || !step.action.propertyId) {
+                this.emitStepProgress(plan.spaceId, plan.activityKey, i, plan.steps.length, 'failed', stepLabel);
+                failures.push({
+                    stepIndex: i,
+                    reason: `Unsupported action kind: ${step.action.kind}`,
+                    critical: step.critical,
+                    targetDeviceId: step.targetDeviceId,
+                    kind: step.action.kind,
+                    label: step.label,
+                    timestamp: new Date().toISOString(),
+                });
+                if (step.critical) {
+                    break;
+                }
+                continue;
+            }
+            let foundChannel = null;
+            let foundProperty = null;
+            for (const channel of device.channels ?? []) {
+                for (const property of channel.properties ?? []) {
+                    if (property.id === step.action.propertyId) {
+                        foundChannel = channel;
+                        foundProperty = property;
+                        break;
+                    }
+                }
+                if (foundProperty) {
+                    break;
+                }
+            }
+            if (!foundChannel || !foundProperty) {
+                this.emitStepProgress(plan.spaceId, plan.activityKey, i, plan.steps.length, 'failed', stepLabel);
+                failures.push({
+                    stepIndex: i,
+                    reason: `Property ${step.action.propertyId} not found on device`,
+                    critical: step.critical,
+                    targetDeviceId: step.targetDeviceId,
+                    kind: step.action.kind,
+                    propertyId: step.action.propertyId,
+                    label: step.label,
+                    timestamp: new Date().toISOString(),
+                });
+                if (step.critical) {
+                    this.logger.warn(`Critical step ${i} failed: property not found, aborting`);
+                    break;
+                }
+                continue;
+            }
+            try {
+                const command = {
+                    device,
+                    channel: foundChannel,
+                    property: foundProperty,
+                    value: step.action.value,
+                };
+                const result = await Promise.race([
+                    platform.processBatch([command]),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('Step timeout')), STEP_TIMEOUT_MS)),
+                ]);
+                if (result) {
+                    succeeded++;
+                    this.emitStepProgress(plan.spaceId, plan.activityKey, i, plan.steps.length, 'succeeded', stepLabel);
+                }
+                else {
+                    this.emitStepProgress(plan.spaceId, plan.activityKey, i, plan.steps.length, 'failed', stepLabel);
+                    failures.push({
+                        stepIndex: i,
+                        reason: 'Command execution returned false',
+                        critical: step.critical,
+                        targetDeviceId: step.targetDeviceId,
+                        kind: step.action.kind,
+                        propertyId: step.action.propertyId,
+                        label: step.label,
+                        timestamp: new Date().toISOString(),
+                    });
+                    if (step.critical) {
+                        this.logger.warn(`Critical step ${i} failed: command returned false, aborting`);
+                        break;
+                    }
+                }
+            }
+            catch (error) {
+                const err = error;
+                this.emitStepProgress(plan.spaceId, plan.activityKey, i, plan.steps.length, 'failed', stepLabel);
+                failures.push({
+                    stepIndex: i,
+                    reason: err.message,
+                    critical: step.critical,
+                    targetDeviceId: step.targetDeviceId,
+                    kind: step.action.kind,
+                    propertyId: step.action.propertyId,
+                    label: step.label,
+                    timestamp: new Date().toISOString(),
+                });
+                if (step.critical) {
+                    this.logger.warn(`Critical step ${i} threw error: ${err.message}, aborting`);
+                    break;
+                }
+            }
+        }
+        return { succeeded, failures };
+    }
+    computeControlTargets(displayEndpoint, audioEndpoint, sourceEndpoint, remoteEndpoint, endpointMap) {
+        const allEndpoints = Array.from(endpointMap.values());
+        const targets = {};
+        if (audioEndpoint?.capabilities.volume) {
+            targets.volumeTargetDeviceId = audioEndpoint.deviceId;
+        }
+        else if (displayEndpoint?.capabilities.volume) {
+            targets.volumeTargetDeviceId = displayEndpoint.deviceId;
+        }
+        else {
+            const fallback = allEndpoints.find((e) => e.type === spaces_constants_1.MediaEndpointType.AUDIO_OUTPUT && e.capabilities.volume);
+            if (fallback) {
+                targets.volumeTargetDeviceId = fallback.deviceId;
+            }
+        }
+        if (displayEndpoint?.capabilities.inputSelect) {
+            targets.inputTargetDeviceId = displayEndpoint.deviceId;
+        }
+        else {
+            const fallback = allEndpoints.find((e) => e.type === spaces_constants_1.MediaEndpointType.DISPLAY && e.capabilities.inputSelect);
+            if (fallback) {
+                targets.inputTargetDeviceId = fallback.deviceId;
+            }
+        }
+        if (sourceEndpoint?.capabilities.playback) {
+            targets.playbackTargetDeviceId = sourceEndpoint.deviceId;
+        }
+        else if (audioEndpoint?.capabilities.playback) {
+            targets.playbackTargetDeviceId = audioEndpoint.deviceId;
+        }
+        else {
+            const fallback = allEndpoints.find((e) => e.capabilities.playback);
+            if (fallback) {
+                targets.playbackTargetDeviceId = fallback.deviceId;
+            }
+        }
+        if (remoteEndpoint?.capabilities.remoteCommands) {
+            targets.remoteTargetDeviceId = remoteEndpoint.deviceId;
+        }
+        else if (displayEndpoint?.capabilities.remoteCommands) {
+            targets.remoteTargetDeviceId = displayEndpoint.deviceId;
+        }
+        else {
+            const fallback = allEndpoints.find((e) => e.type === spaces_constants_1.MediaEndpointType.REMOTE_TARGET && e.capabilities.remoteCommands);
+            if (fallback) {
+                targets.remoteTargetDeviceId = fallback.deviceId;
+            }
+        }
+        return targets;
+    }
+    async handleConflicts(spaceId, activityKey, endpointMap) {
+        const warnings = [];
+        if (activityKey !== spaces_constants_1.MediaActivityKey.WATCH && activityKey !== spaces_constants_1.MediaActivityKey.GAMING) {
+            return warnings;
+        }
+        const existingRecord = await this.getActiveRecord(spaceId);
+        if (!existingRecord || !existingRecord.activityKey) {
+            return warnings;
+        }
+        if (existingRecord.state !== spaces_constants_1.MediaActivationState.ACTIVE &&
+            existingRecord.state !== spaces_constants_1.MediaActivationState.ACTIVATING) {
+            return warnings;
+        }
+        const currentKey = existingRecord.activityKey;
+        if (currentKey !== spaces_constants_1.MediaActivityKey.BACKGROUND && currentKey !== spaces_constants_1.MediaActivityKey.LISTEN) {
+            return warnings;
+        }
+        this.logger.debug(`Conflict detected: activating ${activityKey} while ${currentKey} is active in space=${spaceId}`);
+        const allEndpoints = Array.from(endpointMap.values());
+        const playbackEndpoints = allEndpoints.filter((e) => e.capabilities.playback && e.links.playback);
+        const pauseWarnings = await this.pausePlaybackOnEndpoints(playbackEndpoints, (ep) => `Failed to pause ${ep.name} (non-critical)`, (ep) => `Paused playback on ${ep.name} (conflict with ${currentKey})`);
+        warnings.push(...pauseWarnings);
+        return warnings;
+    }
+    async pausePlaybackOnEndpoints(endpoints, failureMessage, successMessage) {
+        const messages = [];
+        for (const ep of endpoints) {
+            try {
+                const devices = await this.spacesService.findDevicesByIds([ep.deviceId]);
+                const device = devices[0];
+                if (!device) {
+                    continue;
+                }
+                const platform = this.platformRegistryService.get(device);
+                if (!platform) {
+                    continue;
+                }
+                let foundChannel = null;
+                let foundProperty = null;
+                for (const channel of device.channels ?? []) {
+                    for (const property of channel.properties ?? []) {
+                        if (property.id === ep.links.playback.propertyId) {
+                            foundChannel = channel;
+                            foundProperty = property;
+                            break;
+                        }
+                    }
+                    if (foundProperty) {
+                        break;
+                    }
+                }
+                if (foundChannel && foundProperty) {
+                    const command = {
+                        device,
+                        channel: foundChannel,
+                        property: foundProperty,
+                        value: 'pause',
+                    };
+                    await Promise.race([
+                        platform.processBatch([command]),
+                        new Promise((_, reject) => setTimeout(() => reject(new Error('Pause playback timeout')), STEP_TIMEOUT_MS)),
+                    ]);
+                    if (successMessage) {
+                        messages.push(successMessage(ep));
+                    }
+                }
+            }
+            catch (error) {
+                const err = error;
+                messages.push(`${failureMessage(ep)}: ${err.message}`);
+                this.logger.warn(`Pause playback failed for endpoint ${ep.endpointId}: ${err.message}`);
+            }
+        }
+        return messages;
+    }
+    buildResultFromRecord(record) {
+        const resolved = record.resolved ? JSON.parse(record.resolved) : undefined;
+        const summary = record.lastResult ? JSON.parse(record.lastResult) : undefined;
+        return {
+            activityKey: record.activityKey,
+            state: record.state,
+            resolved,
+            summary,
+            requiresRealtime: true,
+        };
+    }
+    emitEvent(eventType, spaceId, activityKey, resolved, summary, warnings, steps) {
+        const stateMap = {
+            [spaces_constants_1.EventType.MEDIA_ACTIVITY_ACTIVATING]: spaces_constants_1.MediaActivationState.ACTIVATING,
+            [spaces_constants_1.EventType.MEDIA_ACTIVITY_ACTIVATED]: spaces_constants_1.MediaActivationState.ACTIVE,
+            [spaces_constants_1.EventType.MEDIA_ACTIVITY_FAILED]: spaces_constants_1.MediaActivationState.FAILED,
+            [spaces_constants_1.EventType.MEDIA_ACTIVITY_DEACTIVATED]: spaces_constants_1.MediaActivationState.DEACTIVATED,
+        };
+        const payload = {
+            space_id: spaceId,
+            activity_key: activityKey,
+            state: stateMap[eventType] ?? spaces_constants_1.MediaActivationState.DEACTIVATED,
+            timestamp: new Date().toISOString(),
+        };
+        if (resolved) {
+            payload.resolved = (0, transform_utils_1.toSnakeCaseKeys)(resolved);
+        }
+        if (summary) {
+            payload.summary = (0, transform_utils_1.toSnakeCaseKeys)(summary);
+        }
+        if (warnings && warnings.length > 0) {
+            payload.warnings = warnings;
+        }
+        if (steps && steps.length > 0) {
+            payload.steps = steps;
+        }
+        this.eventEmitter.emit(eventType, payload);
+        this.logger.debug(`Emitted ${eventType} for space=${spaceId} activity=${activityKey}`);
+    }
+    emitStepProgress(spaceId, activityKey, stepIndex, stepsTotal, status, label) {
+        const payload = {
+            space_id: spaceId,
+            activity_key: activityKey,
+            step_index: stepIndex,
+            steps_total: stepsTotal,
+            status,
+            label,
+            timestamp: new Date().toISOString(),
+        };
+        this.eventEmitter.emit(spaces_constants_1.EventType.MEDIA_ACTIVITY_STEP_PROGRESS, payload);
+        this.logger.debug(`Step progress: space=${spaceId} activity=${activityKey} step=${stepIndex}/${stepsTotal} status=${status}`);
+    }
+};
+exports.SpaceMediaActivityService = SpaceMediaActivityService;
+exports.SpaceMediaActivityService = SpaceMediaActivityService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_2.InjectRepository)(space_active_media_activity_entity_1.SpaceActiveMediaActivityEntity)),
+    __metadata("design:paramtypes", [typeorm_1.Repository,
+        spaces_service_1.SpacesService,
+        space_media_activity_binding_service_1.SpaceMediaActivityBindingService,
+        derived_media_endpoint_service_1.DerivedMediaEndpointService,
+        platform_registry_service_1.PlatformRegistryService,
+        event_emitter_1.EventEmitter2])
+], SpaceMediaActivityService);
+//# sourceMappingURL=space-media-activity.service.js.map