@lox-audio-server/sonos 0.1.0

package/dist/sonos/api/namespaces/groups.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupsNamespace = void 0;
+const namespace_1 = require("../namespace");
+class GroupsNamespace extends namespace_1.SonosNamespace {
+    constructor(api) {
+        super(api, 'groups', 'groups', 'householdId');
+    }
+    async modifyGroupMembers(groupId, playerIdsToAdd, playerIdsToRemove) {
+        return this.api.sendCommand(this.namespace, 'modifyGroupMembers', { playerIdsToAdd, playerIdsToRemove }, { groupId });
+    }
+    async setGroupMembers(groupId, playerIds, areaIds) {
+        const options = { playerIds };
+        if (areaIds)
+            options.areaIds = areaIds;
+        return this.api.sendCommand(this.namespace, 'setGroupMembers', options, { groupId });
+    }
+    async getGroups(householdId, includeDeviceInfo = false) {
+        return this.api.sendCommand(this.namespace, 'getGroups', { includeDeviceInfo }, { householdId });
+    }
+    async createGroup(householdId, playerIds, musicContextGroupId) {
+        const options = { playerIds };
+        if (musicContextGroupId)
+            options.musicContextGroupId = musicContextGroupId;
+        return this.api.sendCommand(this.namespace, 'createGroup', options, { householdId });
+    }
+    async subscribe(householdId, callback) {
+        return this.handleSubscribe(householdId, callback);
+    }
+}
+exports.GroupsNamespace = GroupsNamespace;

package/dist/sonos/api/namespaces/homeTheater.d.ts

@@ -0,0 +1,5 @@
+import { SonosNamespace } from '../namespace';
+export declare class HomeTheaterNamespace extends SonosNamespace<any> {
+    constructor(api: any);
+    loadHomeTheaterPlayback(playerId: string): Promise<void>;
+}

package/dist/sonos/api/namespaces/homeTheater.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HomeTheaterNamespace = void 0;
+const namespace_1 = require("../namespace");
+class HomeTheaterNamespace extends namespace_1.SonosNamespace {
+    constructor(api) {
+        super(api, 'homeTheater', 'homeTheaterStatus', 'playerId');
+    }
+    async loadHomeTheaterPlayback(playerId) {
+        await this.api.sendCommand(this.namespace, 'loadHomeTheaterPlayback', undefined, { playerId });
+    }
+}
+exports.HomeTheaterNamespace = HomeTheaterNamespace;

package/dist/sonos/api/namespaces/playback.d.ts

@@ -0,0 +1,17 @@
+import { LoadContentRequest, PlaybackStatus, PlayModes } from '../../types';
+import { SonosNamespace, SubscribeCallback, UnsubscribeCallback } from '../namespace';
+export declare class PlaybackNamespace extends SonosNamespace<PlaybackStatus> {
+    constructor(api: any);
+    getPlaybackStatus(groupId: string): Promise<PlaybackStatus>;
+    loadLineIn(groupId: string, deviceId?: string, playOnCompletion?: boolean): Promise<void>;
+    loadContent(groupId: string, content: LoadContentRequest): Promise<void>;
+    pause(groupId: string): Promise<void>;
+    play(groupId: string): Promise<void>;
+    togglePlayPause(groupId: string): Promise<void>;
+    setPlayModes(groupId: string, playModes: PlayModes): Promise<void>;
+    seek(groupId: string, positionMillis: number, itemId?: string): Promise<void>;
+    seekRelative(groupId: string, deltaMillis: number, itemId?: string): Promise<void>;
+    skipToNextTrack(groupId: string): Promise<void>;
+    skipToPreviousTrack(groupId: string): Promise<void>;
+    subscribe(groupId: string, callback: SubscribeCallback<PlaybackStatus>): Promise<UnsubscribeCallback>;
+}

package/dist/sonos/api/namespaces/playback.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaybackNamespace = void 0;
+const namespace_1 = require("../namespace");
+class PlaybackNamespace extends namespace_1.SonosNamespace {
+    constructor(api) {
+        super(api, 'playback', 'playbackStatus', 'groupId');
+    }
+    async getPlaybackStatus(groupId) {
+        return this.api.sendCommand(this.namespace, 'getPlaybackStatus', undefined, { groupId });
+    }
+    async loadLineIn(groupId, deviceId, playOnCompletion = false) {
+        const options = {};
+        if (deviceId)
+            options.deviceId = deviceId;
+        options.playOnCompletion = playOnCompletion;
+        await this.api.sendCommand(this.namespace, 'loadLineIn', options, { groupId });
+    }
+    async loadContent(groupId, content) {
+        await this.api.sendCommand(this.namespace, 'loadContent', content, { groupId });
+    }
+    async pause(groupId) {
+        await this.api.sendCommand(this.namespace, 'pause', undefined, { groupId });
+    }
+    async play(groupId) {
+        await this.api.sendCommand(this.namespace, 'play', undefined, { groupId });
+    }
+    async togglePlayPause(groupId) {
+        await this.api.sendCommand(this.namespace, 'togglePlayPause', undefined, { groupId });
+    }
+    async setPlayModes(groupId, playModes) {
+        await this.api.sendCommand(this.namespace, 'setPlayModes', { playModes }, { groupId });
+    }
+    async seek(groupId, positionMillis, itemId) {
+        const options = { positionMillis };
+        if (itemId)
+            options.itemId = itemId;
+        await this.api.sendCommand(this.namespace, 'seek', options, { groupId });
+    }
+    async seekRelative(groupId, deltaMillis, itemId) {
+        const options = { deltaMillis };
+        if (itemId)
+            options.itemId = itemId;
+        await this.api.sendCommand(this.namespace, 'seekRelative', options, { groupId });
+    }
+    async skipToNextTrack(groupId) {
+        await this.api.sendCommand(this.namespace, 'skipToNextTrack', undefined, { groupId });
+    }
+    async skipToPreviousTrack(groupId) {
+        await this.api.sendCommand(this.namespace, 'skipToPreviousTrack', undefined, { groupId });
+    }
+    async subscribe(groupId, callback) {
+        return this.handleSubscribe(groupId, callback);
+    }
+}
+exports.PlaybackNamespace = PlaybackNamespace;

package/dist/sonos/api/namespaces/playbackMetadata.d.ts

@@ -0,0 +1,7 @@
+import { MetadataStatus } from '../../types';
+import { SonosNamespace, SubscribeCallback, UnsubscribeCallback } from '../namespace';
+export declare class PlaybackMetadataNamespace extends SonosNamespace<MetadataStatus> {
+    constructor(api: any);
+    getMetadataStatus(groupId: string): Promise<MetadataStatus>;
+    subscribe(groupId: string, callback: SubscribeCallback<MetadataStatus>): Promise<UnsubscribeCallback>;
+}

package/dist/sonos/api/namespaces/playbackMetadata.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaybackMetadataNamespace = void 0;
+const namespace_1 = require("../namespace");
+class PlaybackMetadataNamespace extends namespace_1.SonosNamespace {
+    constructor(api) {
+        super(api, 'playbackMetadata', 'metadataStatus', 'groupId');
+    }
+    async getMetadataStatus(groupId) {
+        return this.api.sendCommand(this.namespace, 'getMetadataStatus', undefined, { groupId });
+    }
+    async subscribe(groupId, callback) {
+        return this.handleSubscribe(groupId, callback);
+    }
+}
+exports.PlaybackMetadataNamespace = PlaybackMetadataNamespace;

package/dist/sonos/api/namespaces/playbackSession.d.ts

@@ -0,0 +1,30 @@
+import { SessionStatus, Track } from '../../types';
+import { SonosNamespace, SubscribeCallback, UnsubscribeCallback } from '../namespace';
+export declare class PlaybackSessionNamespace extends SonosNamespace<SessionStatus> {
+    constructor(api: any);
+    createSession(groupId: string, appId: string, appContext: string, accountId?: string, customData?: Record<string, unknown>): Promise<SessionStatus>;
+    loadCloudQueue(sessionId: string, queueBaseUrl: string, options: {
+        httpAuthorization?: string;
+        useHttpAuthorizationForMedia?: boolean;
+        itemId?: string;
+        queueVersion?: string;
+        positionMillis?: number;
+        playOnCompletion?: boolean;
+        trackMetadata?: Track;
+    }): Promise<void>;
+    loadStreamUrl(sessionId: string, streamUrl: string, options?: {
+        playOnCompletion?: boolean;
+        stationMetadata?: Record<string, unknown>;
+        itemId?: string;
+    }): Promise<void>;
+    refreshCloudQueue(sessionId: string): Promise<void>;
+    seek(sessionId: string, positionMillis: number, itemId?: string): Promise<void>;
+    seekRelative(sessionId: string, deltaMillis: number, itemId?: string): Promise<void>;
+    skipToItem(sessionId: string, itemId: string, options?: {
+        queueVersion?: string;
+        positionMillis?: number;
+        playOnCompletion?: boolean;
+    }): Promise<void>;
+    suspend(sessionId: string, queueVersion?: string): Promise<void>;
+    subscribe(sessionId: string, callback: SubscribeCallback<SessionStatus>): Promise<UnsubscribeCallback>;
+}

package/dist/sonos/api/namespaces/playbackSession.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaybackSessionNamespace = void 0;
+const namespace_1 = require("../namespace");
+class PlaybackSessionNamespace extends namespace_1.SonosNamespace {
+    constructor(api) {
+        super(api, 'playbackSession', 'playbackSession', 'sessionId');
+    }
+    async createSession(groupId, appId, appContext, accountId, customData) {
+        const options = { appId, appContext };
+        if (accountId)
+            options.accountId = accountId;
+        if (customData)
+            options.customData = customData;
+        return this.api.sendCommand(this.namespace, 'createSession', options, { groupId });
+    }
+    async loadCloudQueue(sessionId, queueBaseUrl, options) {
+        await this.api.sendCommand(this.namespace, 'loadCloudQueue', {
+            queueBaseUrl,
+            httpAuthorization: options.httpAuthorization,
+            useHttpAuthorizationForMedia: options.useHttpAuthorizationForMedia,
+            itemId: options.itemId,
+            queueVersion: options.queueVersion,
+            positionMillis: options.positionMillis,
+            playOnCompletion: options.playOnCompletion,
+            trackMetadata: options.trackMetadata,
+        }, { sessionId });
+    }
+    async loadStreamUrl(sessionId, streamUrl, options = {}) {
+        await this.api.sendCommand(this.namespace, 'loadStreamUrl', {
+            streamUrl,
+            playOnCompletion: options.playOnCompletion,
+            stationMetadata: options.stationMetadata,
+            itemId: options.itemId,
+        }, { sessionId });
+    }
+    async refreshCloudQueue(sessionId) {
+        await this.api.sendCommand(this.namespace, 'refreshCloudQueue', undefined, { sessionId });
+    }
+    async seek(sessionId, positionMillis, itemId) {
+        const options = { positionMillis };
+        if (itemId)
+            options.itemId = itemId;
+        await this.api.sendCommand(this.namespace, 'seek', options, { sessionId });
+    }
+    async seekRelative(sessionId, deltaMillis, itemId) {
+        const options = { deltaMillis };
+        if (itemId)
+            options.itemId = itemId;
+        await this.api.sendCommand(this.namespace, 'seekRelative', options, { sessionId });
+    }
+    async skipToItem(sessionId, itemId, options = {}) {
+        await this.api.sendCommand(this.namespace, 'skipToItem', {
+            itemId,
+            queueVersion: options.queueVersion,
+            positionMillis: options.positionMillis,
+            playOnCompletion: options.playOnCompletion,
+        }, { sessionId });
+    }
+    async suspend(sessionId, queueVersion) {
+        await this.api.sendCommand(this.namespace, 'suspend', queueVersion ? { queueVersion } : undefined, { sessionId });
+    }
+    async subscribe(sessionId, callback) {
+        return this.handleSubscribe(sessionId, callback);
+    }
+}
+exports.PlaybackSessionNamespace = PlaybackSessionNamespace;

package/dist/sonos/api/namespaces/playerVolume.d.ts

@@ -0,0 +1,12 @@
+import { PlayerVolume } from '../../types';
+import { SonosNamespace, SubscribeCallback, UnsubscribeCallback } from '../namespace';
+export declare class PlayerVolumeNamespace extends SonosNamespace<PlayerVolume> {
+    constructor(api: any);
+    setVolume(playerId: string, volume?: number, muted?: boolean): Promise<void>;
+    getVolume(playerId: string): Promise<PlayerVolume>;
+    duck(playerId: string, durationMillis?: number): Promise<void>;
+    unduck(playerId: string): Promise<void>;
+    setMute(playerId: string, muted: boolean): Promise<void>;
+    setRelativeVolume(playerId: string, volumeDelta?: number, muted?: boolean): Promise<void>;
+    subscribe(playerId: string, callback: SubscribeCallback<PlayerVolume>): Promise<UnsubscribeCallback>;
+}

package/dist/sonos/api/namespaces/playerVolume.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayerVolumeNamespace = void 0;
+const namespace_1 = require("../namespace");
+class PlayerVolumeNamespace extends namespace_1.SonosNamespace {
+    constructor(api) {
+        super(api, 'playerVolume', 'playerVolume', 'playerId');
+    }
+    async setVolume(playerId, volume, muted) {
+        const options = {};
+        if (typeof volume === 'number')
+            options.volume = volume;
+        if (typeof muted === 'boolean')
+            options.muted = muted;
+        await this.api.sendCommand(this.namespace, 'setVolume', options, { playerId });
+    }
+    async getVolume(playerId) {
+        return this.api.sendCommand(this.namespace, 'getVolume', undefined, { playerId });
+    }
+    async duck(playerId, durationMillis) {
+        await this.api.sendCommand(this.namespace, 'duck', durationMillis ? { durationMillis } : undefined, { playerId });
+    }
+    async unduck(playerId) {
+        await this.api.sendCommand(this.namespace, 'unduck', undefined, { playerId });
+    }
+    async setMute(playerId, muted) {
+        await this.api.sendCommand(this.namespace, 'setMute', { muted }, { playerId });
+    }
+    async setRelativeVolume(playerId, volumeDelta, muted) {
+        const options = {};
+        if (typeof volumeDelta === 'number')
+            options.volumeDelta = volumeDelta;
+        if (typeof muted === 'boolean')
+            options.muted = muted;
+        await this.api.sendCommand(this.namespace, 'setRelativeVolume', options, { playerId });
+    }
+    async subscribe(playerId, callback) {
+        return this.handleSubscribe(playerId, callback);
+    }
+}
+exports.PlayerVolumeNamespace = PlayerVolumeNamespace;

package/dist/sonos/api/websocket.d.ts

@@ -0,0 +1,51 @@
+import { AudioClipNamespace } from './namespaces/audioClip';
+import { GroupsNamespace } from './namespaces/groups';
+import { GroupVolumeNamespace } from './namespaces/groupVolume';
+import { PlaybackNamespace } from './namespaces/playback';
+import { PlaybackMetadataNamespace } from './namespaces/playbackMetadata';
+import { PlaybackSessionNamespace } from './namespaces/playbackSession';
+import { PlayerVolumeNamespace } from './namespaces/playerVolume';
+import { HomeTheaterNamespace } from './namespaces/homeTheater';
+export interface WebSocketReliabilityOptions {
+    heartbeatIntervalMs?: number;
+    retryDelayMs?: number;
+    retryJitterMs?: number;
+    maxReconnects?: number;
+}
+export declare class SonosWebSocketApi {
+    private websocketUrl;
+    private ws?;
+    private resultFutures;
+    private stopCalled;
+    private heartbeatTimer?;
+    private heartbeatIntervalMs;
+    private retryDelayMs;
+    private retryJitterMs;
+    private maxReconnects?;
+    readonly audioClip: AudioClipNamespace;
+    readonly groups: GroupsNamespace;
+    readonly groupVolume: GroupVolumeNamespace;
+    readonly playback: PlaybackNamespace;
+    readonly playbackMetadata: PlaybackMetadataNamespace;
+    readonly playbackSession: PlaybackSessionNamespace;
+    readonly playerVolume: PlayerVolumeNamespace;
+    readonly homeTheater: HomeTheaterNamespace;
+    logger: Console;
+    onConnect?: () => void | Promise<void>;
+    onDisconnect?: (reason?: string) => void | Promise<void>;
+    constructor(websocketUrl: string, opts?: WebSocketReliabilityOptions);
+    get connected(): boolean;
+    connect(): Promise<void>;
+    startListening(): Promise<void>;
+    disconnect(): Promise<void>;
+    sendCommand(namespace: string, command: string, options?: Record<string, unknown>, pathParams?: Record<string, unknown>): Promise<any>;
+    sendCommandNoWait(namespace: string, command: string, options?: Record<string, unknown>, pathParams?: Record<string, unknown>): void;
+    private send;
+    private handleRawMessage;
+    private handleIncoming;
+    private waitForClose;
+    private startHeartbeat;
+    private clearHeartbeat;
+    private delay;
+    private computeRetryDelay;
+}

package/dist/sonos/api/websocket.js

@@ -0,0 +1,310 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonosWebSocketApi = void 0;
+const ws_1 = __importDefault(require("ws"));
+const node_crypto_1 = require("node:crypto");
+const constants_1 = require("../constants");
+const errors_1 = require("../errors");
+const audioClip_1 = require("./namespaces/audioClip");
+const groups_1 = require("./namespaces/groups");
+const groupVolume_1 = require("./namespaces/groupVolume");
+const playback_1 = require("./namespaces/playback");
+const playbackMetadata_1 = require("./namespaces/playbackMetadata");
+const playbackSession_1 = require("./namespaces/playbackSession");
+const playerVolume_1 = require("./namespaces/playerVolume");
+const homeTheater_1 = require("./namespaces/homeTheater");
+class SonosWebSocketApi {
+    websocketUrl;
+    ws;
+    resultFutures = new Map();
+    stopCalled = false;
+    heartbeatTimer;
+    heartbeatIntervalMs;
+    retryDelayMs;
+    retryJitterMs;
+    maxReconnects;
+    audioClip;
+    groups;
+    groupVolume;
+    playback;
+    playbackMetadata;
+    playbackSession;
+    playerVolume;
+    homeTheater;
+    logger = console;
+    onConnect;
+    onDisconnect;
+    constructor(websocketUrl, opts = {}) {
+        this.websocketUrl = websocketUrl;
+        this.audioClip = new audioClip_1.AudioClipNamespace(this);
+        this.groups = new groups_1.GroupsNamespace(this);
+        this.groupVolume = new groupVolume_1.GroupVolumeNamespace(this);
+        this.playback = new playback_1.PlaybackNamespace(this);
+        this.playbackMetadata = new playbackMetadata_1.PlaybackMetadataNamespace(this);
+        this.playbackSession = new playbackSession_1.PlaybackSessionNamespace(this);
+        this.playerVolume = new playerVolume_1.PlayerVolumeNamespace(this);
+        this.homeTheater = new homeTheater_1.HomeTheaterNamespace(this);
+        this.heartbeatIntervalMs = opts.heartbeatIntervalMs ?? 30000;
+        this.retryDelayMs = opts.retryDelayMs ?? 2000;
+        this.retryJitterMs = opts.retryJitterMs ?? 500;
+        this.maxReconnects = opts.maxReconnects;
+    }
+    get connected() {
+        return Boolean(this.ws && this.ws.readyState === ws_1.default.OPEN);
+    }
+    async connect() {
+        if (this.ws) {
+            throw new errors_1.InvalidState('Already connected');
+        }
+        this.logger.debug?.(`Connecting to Sonos WebSocket ${this.websocketUrl}`);
+        this.stopCalled = false;
+        try {
+            this.ws = new ws_1.default(this.websocketUrl, {
+                headers: {
+                    'X-Sonos-Api-Key': constants_1.LOCAL_API_TOKEN,
+                    'Sec-WebSocket-Protocol': 'v1.api.smartspeaker.audio',
+                },
+                rejectUnauthorized: false,
+                perMessageDeflate: true,
+                maxPayload: 0,
+            });
+        }
+        catch (err) {
+            throw new errors_1.CannotConnect('Failed to create websocket', err);
+        }
+        await new Promise((resolve, reject) => {
+            if (!this.ws)
+                return reject(new errors_1.CannotConnect('No websocket'));
+            this.ws.once('open', () => resolve());
+            this.ws.once('error', (err) => reject(new errors_1.CannotConnect('Failed to connect', err)));
+        });
+        this.ws.on('message', (data) => this.handleRawMessage(data));
+        this.ws.on('close', () => {
+            this.clearHeartbeat();
+        });
+        this.ws.on('error', (err) => {
+            this.logger.warn?.('WebSocket error', err);
+        });
+        this.ws.on('pong', () => {
+            // noop; pong receipt confirms liveness
+        });
+        this.startHeartbeat();
+        await this.onConnect?.();
+    }
+    async startListening() {
+        this.stopCalled = false;
+        while (!this.stopCalled) {
+            let attempts = 0;
+            try {
+                if (!this.connected) {
+                    await this.connect();
+                }
+                const reason = await this.waitForClose();
+                if (this.stopCalled)
+                    break;
+                await this.onDisconnect?.(reason);
+                this.logger.warn?.('WebSocket closed, reconnecting...', reason);
+                attempts += 1;
+                if (this.maxReconnects && attempts > this.maxReconnects) {
+                    this.logger.error?.('Max reconnect attempts reached');
+                    break;
+                }
+                await this.delay(this.computeRetryDelay(attempts));
+            }
+            catch (err) {
+                if (this.stopCalled)
+                    break;
+                this.logger.warn?.('WebSocket listen error, reconnecting...', err);
+                await this.onDisconnect?.(err instanceof Error ? err.message : undefined);
+                attempts += 1;
+                if (this.maxReconnects && attempts > this.maxReconnects) {
+                    this.logger.error?.('Max reconnect attempts reached after error');
+                    break;
+                }
+                await this.delay(this.computeRetryDelay(attempts));
+            }
+        }
+    }
+    async disconnect() {
+        this.stopCalled = true;
+        this.clearHeartbeat();
+        for (const pending of this.resultFutures.values()) {
+            pending.reject(new errors_1.ConnectionClosed('Connection closed'));
+        }
+        this.resultFutures.clear();
+        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+            await new Promise((resolve) => {
+                this.ws?.once('close', () => resolve());
+                this.ws?.close();
+            });
+        }
+        this.ws = undefined;
+    }
+    async sendCommand(namespace, command, options, pathParams) {
+        if (!this.connected || !this.ws)
+            throw new errors_1.InvalidState('Not connected');
+        const cmdId = (0, node_crypto_1.randomUUID)();
+        const cmdMessage = {
+            namespace: `${namespace}:${constants_1.API_VERSION}`,
+            command,
+            cmdId,
+            ...(pathParams ?? {}),
+        };
+        const payload = [cmdMessage, options ?? {}];
+        const resultPromise = new Promise((resolve, reject) => {
+            this.resultFutures.set(cmdId, { resolve, reject });
+        });
+        await this.send(payload);
+        return resultPromise.finally(() => this.resultFutures.delete(cmdId));
+    }
+    sendCommandNoWait(namespace, command, options, pathParams) {
+        if (!this.connected || !this.ws)
+            throw new errors_1.NotConnected('Not connected');
+        const cmdMessage = {
+            namespace: `${namespace}:${constants_1.API_VERSION}`,
+            command,
+            cmdId: (0, node_crypto_1.randomUUID)(),
+            ...(pathParams ?? {}),
+        };
+        const payload = [cmdMessage, options ?? {}];
+        void this.send(payload);
+    }
+    async send(payload) {
+        if (!this.ws || this.ws.readyState !== ws_1.default.OPEN) {
+            throw new errors_1.NotConnected('Not connected');
+        }
+        if (this.logger && this.logger.log && constants_1.LOG_LEVEL_VERBOSE) {
+            this.logger.log?.(constants_1.LOG_LEVEL_VERBOSE, 'Publishing message', payload);
+        }
+        const data = JSON.stringify(payload);
+        await new Promise((resolve, reject) => {
+            this.ws?.send(data, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    handleRawMessage(raw) {
+        try {
+            const parsed = JSON.parse(raw.toString());
+            try {
+                this.handleIncoming(parsed);
+            }
+            catch (err) {
+                this.logger.error?.('Failed to handle Sonos message', err);
+            }
+        }
+        catch (err) {
+            this.logger.error?.('Invalid JSON from Sonos', err);
+        }
+    }
+    handleIncoming(raw) {
+        if (!Array.isArray(raw) || raw.length !== 2) {
+            this.logger.error?.('Invalid Sonos message shape', raw);
+            return;
+        }
+        const [msg, msgData] = raw;
+        if (!msg || typeof msg !== 'object') {
+            throw new errors_1.InvalidMessage('Received malformed message');
+        }
+        // error response
+        if ('errorCode' in msgData) {
+            const errData = msgData;
+            if ('cmdId' in msg && msg.cmdId) {
+                const future = this.resultFutures.get(msg.cmdId);
+                future?.reject(new errors_1.FailedCommand(errData.errorCode, errData.reason));
+            }
+            else {
+                this.logger.error?.('Unhandled error', msgData);
+            }
+            return;
+        }
+        // command result
+        if ('success' in msg) {
+            if (msg.cmdId && this.resultFutures.has(msg.cmdId)) {
+                const pending = this.resultFutures.get(msg.cmdId);
+                if (msg.success) {
+                    pending?.resolve(msgData);
+                }
+                else {
+                    pending?.reject(new errors_1.FailedCommand(String(msgData['_objectType'] ?? 'unknown')));
+                }
+            }
+            return;
+        }
+        // event
+        if (msg.type) {
+            const namespaces = [
+                this.audioClip,
+                this.groups,
+                this.groupVolume,
+                this.playbackMetadata,
+                this.playbackSession,
+                this.playback,
+                this.playerVolume,
+                this.homeTheater,
+            ];
+            const target = namespaces.find((ns) => ns.eventType === msg.type);
+            if (target) {
+                target.handleEvent(msg, msgData);
+            }
+            else {
+                this.logger.debug?.(`Unhandled event type ${msg.type}`);
+            }
+            return;
+        }
+        this.logger.debug?.('Unhandled message', raw);
+    }
+    async waitForClose() {
+        return new Promise((resolve, reject) => {
+            const ws = this.ws;
+            if (!ws)
+                return reject(new errors_1.NotConnected('No websocket'));
+            const onClose = (code, reason) => {
+                ws.removeListener('error', onError);
+                resolve(`${code}:${reason.toString()}`);
+            };
+            const onError = (err) => {
+                ws.removeListener('close', onClose);
+                reject(new errors_1.ConnectionFailed(err));
+            };
+            ws.once('close', onClose);
+            ws.once('error', onError);
+        });
+    }
+    startHeartbeat() {
+        this.clearHeartbeat();
+        if (!this.heartbeatIntervalMs)
+            return;
+        this.heartbeatTimer = setInterval(() => {
+            if (!this.ws || this.ws.readyState !== ws_1.default.OPEN)
+                return;
+            try {
+                this.ws.ping();
+            }
+            catch (err) {
+                this.logger.warn?.('Heartbeat ping failed', err);
+                this.ws.terminate();
+            }
+        }, this.heartbeatIntervalMs);
+    }
+    clearHeartbeat() {
+        if (this.heartbeatTimer)
+            clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = undefined;
+    }
+    async delay(ms) {
+        await new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    computeRetryDelay(attempt) {
+        const base = this.retryDelayMs * Math.min(2 ** (attempt - 1), 8);
+        const jitter = Math.random() * this.retryJitterMs;
+        return base + jitter;
+    }
+}
+exports.SonosWebSocketApi = SonosWebSocketApi;