diff --git a/examples/demo/demo.ts b/examples/demo/demo.ts
index 3659f65e3d..944dba7d64 100644
--- a/examples/demo/demo.ts
+++ b/examples/demo/demo.ts
@@ -46,7 +46,12 @@ import {
 import PTWorker from '../../src/packetTrailer/worker/packetTrailer.worker?worker';
 import type { DataTrackFrame } from '../../src/room/data-track/frame';
 import { TrackEvent } from '../../src/room/events';
-import { isSVCCodec, sleep, supportsH265 } from '../../src/room/utils';
+import {
+  isSVCCodec,
+  isSafariSpeakerSelectionSupported,
+  sleep,
+  supportsH265,
+} from '../../src/room/utils';
 
 setLogLevel(LogLevel.debug);
 
@@ -182,6 +187,9 @@ const appActions = {
       audioOutput: {
         deviceId: audioOutputId,
       },
+      // Route remote audio through AudioContext on iOS 26 so the shared relay element
+      // handles setSinkId — without this, iOS silently ignores setSinkId on WebRTC tracks.
+      webAudioMix: isSafariSpeakerSelectionSupported(),
       publishDefaults: {
         simulcast,
         videoSimulcastLayers: [VideoPresets.h180, VideoPresets.h360],
diff --git a/src/index.ts b/src/index.ts
index d54746e7f1..5974ba5d88 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -53,12 +53,14 @@ import {
   isLocalTrack,
   isRemoteParticipant,
   isRemoteTrack,
+  isSafariSpeakerSelectionSupported,
   isVideoCodec,
   isVideoTrack,
   supportsAV1,
   supportsAdaptiveStream,
   supportsAudioOutputSelection,
   supportsDynacast,
+  supportsSetSinkId,
   supportsVP9,
 } from './room/utils';
 import { getBrowser } from './utils/browserParser';
@@ -130,12 +132,14 @@ export {
   getEmptyVideoStreamTrack,
   getLogger,
   isBrowserSupported,
+  isSafariSpeakerSelectionSupported,
   setLogExtension,
   setLogLevel,
   supportsAV1,
   supportsAdaptiveStream,
   supportsAudioOutputSelection,
   supportsDynacast,
+  supportsSetSinkId,
   supportsVP9,
   Mutex,
   isAudioCodec,
diff --git a/src/room/Room.ts b/src/room/Room.ts
index 4c1b47f713..c241776286 100644
--- a/src/room/Room.ts
+++ b/src/room/Room.ts
@@ -103,10 +103,12 @@ import {
 import {
   Future,
   createDummyVideoStreamTrack,
+  disposeSharedRelay,
   extractChatMessage,
   extractTranscriptionSegments,
   getDisconnectReasonFromConnectionError,
   getEmptyAudioStreamTrack,
+  getOrCreateSharedRelay,
   isBrowserSupported,
   isCloud,
   isLocalAudioTrack,
@@ -114,6 +116,7 @@ import {
   isReactNative,
   isRemotePub,
   isSafariBased,
+  isSafariSpeakerSelectionSupported,
   isWeb,
   numberToBigInt,
   sleep,
@@ -1446,14 +1449,28 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       if (success && isMuted) shouldTriggerImmediateDeviceChange = true;
     } else if (kind === 'audiooutput') {
       shouldTriggerImmediateDeviceChange = true;
-      if (
-        (!supportsSetSinkId() && !this.options.webAudioMix) ||
-        (this.options.webAudioMix && this.audioContext && !('setSinkId' in this.audioContext))
-      ) {
+      // True when we can route output via AudioContext.setSinkId directly, e.g.,
+      //   Chrome / Edge / Firefox + webAudioMix : true  (use AudioContext.setSinkId)
+      //   Safari macOS (any version)            : false (AudioContext.setSinkId not implemented)
+      //   Safari iOS  (any version)             : false (AudioContext.setSinkId not implemented)
+      //   any browser without webAudioMix       : false
+      const audioContextHasSinkId =
+        this.options.webAudioMix && !!this.audioContext && 'setSinkId' in this.audioContext;
+      // True when we route output via the shared relay <audio> element (iOS 26 path).
+      //   iOS 26+ Safari + webAudioMix          : true
+      //   macOS Safari 26+ + webAudioMix        : true (also benefits from the relay approach)
+      //   anything else                         : false
+      const useSharedRelay = isSafariSpeakerSelectionSupported() && !!this.audioContext;
+      // Throw only when neither HTMLMediaElement.setSinkId nor AudioContext.setSinkId is usable.
+      // When webAudioMix=true but AudioContext.setSinkId is unavailable (e.g. iOS 26 Safari),
+      // we fall through and rely on the shared relay-element setSinkId path.
+      if (!supportsSetSinkId() && !audioContextHasSinkId) {
         throw new Error('cannot switch audio output, the current browser does not support it');
       }
-      if (this.options.webAudioMix) {
-        // setting `default` for web audio output doesn't work, so we need to normalize the id before
+      if (audioContextHasSinkId) {
+        // AudioContext.setSinkId (Chrome) doesn't accept 'default', so resolve to a real device id.
+        // On iOS 26 we use HTMLMediaElement.setSinkId on a relay element instead, which does
+        // accept 'default', so skip normalization there.
         deviceId =
           (await DeviceManager.getInstance().normalizeDeviceId('audiooutput', deviceId)) ?? '';
       }
@@ -1462,16 +1479,28 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.options.audioOutput.deviceId = deviceId;
 
       try {
-        if (this.options.webAudioMix) {
+        if (audioContextHasSinkId) {
           // @ts-expect-error setSinkId is not yet in the typescript type of AudioContext
           this.audioContext?.setSinkId(deviceId);
         }
 
-        // also set audio output on all audio elements, even if webAudioMix is enabled in order to workaround echo cancellation not working on chrome with non-default output devices
-        // see https://issues.chromium.org/issues/40252911#comment7
-        await Promise.all(
-          Array.from(this.remoteParticipants.values()).map((p) => p.setAudioOutput({ deviceId })),
-        );
+        if (useSharedRelay) {
+          // iOS 26 path: route via a single shared relay <audio> element on the AudioContext.
+          // Calling setSinkId here (within the user gesture) grants iOS permission for this
+          // element, which persists for the call — so new remote tracks joining later route
+          // through the already-permitted element without needing their own user gesture.
+          await (getOrCreateSharedRelay(this.audioContext!).relayElement.setSinkId(
+            deviceId,
+          ) as Promise<void>);
+        } else {
+          // Standard path for browsers with HTMLMediaElement.setSinkId (Chrome, Firefox, etc.):
+          // apply setSinkId on each participant's attached <audio> element directly.
+          // Note: Chrome with webAudioMix=true also needs this for echo cancellation with
+          // non-default output devices — see https://issues.chromium.org/issues/40252911#comment7
+          await Promise.all(
+            Array.from(this.remoteParticipants.values()).map((p) => p.setAudioOutput({ deviceId })),
+          );
+        }
       } catch (e) {
         this.options.audioOutput.deviceId = prevDeviceId;
         throw e;
@@ -1806,9 +1835,12 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.remoteParticipants.clear();
       this.sidToIdentity.clear();
       this.activeSpeakers = [];
-      if (this.audioContext && typeof this.options.webAudioMix === 'boolean') {
-        this.audioContext.close();
-        this.audioContext = undefined;
+      if (this.audioContext) {
+        disposeSharedRelay(this.audioContext);
+        if (typeof this.options.webAudioMix === 'boolean') {
+          this.audioContext.close();
+          this.audioContext = undefined;
+        }
       }
       if (isWeb()) {
         window.removeEventListener('beforeunload', this.onPageLeave);
@@ -2229,7 +2261,15 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         continue;
       }
       const devicesOfKind = availableDevices.filter((d) => d.kind === kind);
-      const activeDevice = this.getActiveDevice(kind);
+      // For audiooutput, also check options.audioOutput.deviceId as a fallback: switchActiveDevice
+      // sets that field before awaiting setSinkId, but only updates activeDeviceMap after the
+      // await resolves. If a devicechange handler fires inside that window before any audiooutput
+      // switch has been recorded, activeDeviceMap is empty and the fallback yields the in-flight
+      // selection rather than nothing.
+      const activeDevice =
+        kind === 'audiooutput'
+          ? (this.getActiveDevice(kind) ?? this.options.audioOutput?.deviceId)
+          : this.getActiveDevice(kind);
 
       if (activeDevice === previousDevices.filter((info) => info.kind === kind)[0]?.deviceId) {
         // in  Safari the first device is always the default, so we assume a user on the default device would like to switch to the default once it changes
@@ -2247,9 +2287,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       // switch to first available device if previously active device is not available any more
       if (
         devicesOfKind.length > 0 &&
-        !devicesOfKind.find((deviceInfo) => deviceInfo.deviceId === this.getActiveDevice(kind)) &&
+        !devicesOfKind.find((deviceInfo) => deviceInfo.deviceId === activeDevice) &&
         // avoid switching audio output on safari without explicit user action as it leads to slowed down audio playback
-        (kind !== 'audiooutput' || !isSafariBased())
+        // exception: iOS/Safari 26+ supports the Speaker Selection API
+        (kind !== 'audiooutput' || !isSafariBased() || isSafariSpeakerSelectionSupported())
       ) {
         await this.switchActiveDevice(kind, devicesOfKind[0].deviceId);
       }
@@ -2257,8 +2298,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   }
 
   private handleDeviceChange = async () => {
-    if (getBrowser()?.os !== 'iOS') {
-      // default devices are non deterministic on iOS, so we don't attempt to select them here
+    if (getBrowser()?.os !== 'iOS' || isSafariSpeakerSelectionSupported()) {
+      // default devices are non deterministic on iOS (pre-26), so we don't attempt to select them here
       await this.selectDefaultDevices();
     }
     this.emit(RoomEvent.MediaDevicesChanged);
diff --git a/src/room/track/RemoteAudioTrack.ts b/src/room/track/RemoteAudioTrack.ts
index 7d48caa7a2..17c074fc10 100644
--- a/src/room/track/RemoteAudioTrack.ts
+++ b/src/room/track/RemoteAudioTrack.ts
@@ -2,7 +2,12 @@ import { TrackEvent } from '../events';
 import type { AudioReceiverStats } from '../stats';
 import { computeBitrate } from '../stats';
 import type { LoggerOptions } from '../types';
-import { isReactNative, supportsSetSinkId } from '../utils';
+import {
+  getOrCreateSharedRelay,
+  isReactNative,
+  isSafariSpeakerSelectionSupported,
+  supportsSetSinkId,
+} from '../utils';
 import RemoteTrack from './RemoteTrack';
 import { Track } from './Track';
 import type { AudioOutputOptions } from './options';
@@ -82,6 +87,13 @@ export default class RemoteAudioTrack extends RemoteTrack<Track.Kind.Audio> {
    */
   async setSinkId(deviceId: string) {
     this.sinkId = deviceId;
+    // On iOS 26, audio routing is handled by the shared relay element at the AudioContext
+    // level — see Room.switchActiveDevice. The attached elements here are muted/vol=0, and
+    // calling setSinkId on them would throw NotAllowedError without a concurrent user gesture
+    // (e.g. when a participant joins after a device switch).
+    if (isSafariSpeakerSelectionSupported()) {
+      return;
+    }
     await Promise.all(
       this.attachedElements.map((elm) => {
         if (!supportsSetSinkId(elm)) {
@@ -103,8 +115,11 @@ export default class RemoteAudioTrack extends RemoteTrack<Track.Kind.Audio> {
       super.attach(element);
     }
 
-    if (this.sinkId && supportsSetSinkId(element)) {
-      element.setSinkId(this.sinkId).catch((e) => {
+    // Skip setSinkId on the primary element on iOS 26: the element is muted/vol=0 below and
+    // audio routing happens via the shared relay, so calling setSinkId here would only throw
+    // NotAllowedError when no user gesture is active.
+    if (this.sinkId && supportsSetSinkId(element) && !isSafariSpeakerSelectionSupported()) {
+      (element.setSinkId(this.sinkId) as Promise<void>).catch((e) => {
         this.log.error('Failed to set sink id on remote audio track', e, this.logContext);
       });
     }
@@ -189,7 +204,20 @@ export default class RemoteAudioTrack extends RemoteTrack<Track.Kind.Audio> {
     });
     this.gainNode = context.createGain();
     lastNode.connect(this.gainNode);
-    this.gainNode.connect(context.destination);
+
+    // When AudioContext.setSinkId is unavailable (notably iOS 26 Safari), audio is routed via
+    // a shared MediaStreamDestinationNode + relay <audio> element. setSinkId() is called once
+    // on that relay element during the user gesture in Room.switchActiveDevice and applies to
+    // all remote audio. This sidesteps the iOS quirk where HTMLMediaElement.setSinkId() has no
+    // effect on elements backed by WebRTC remote tracks (those go through the WebRTC engine's
+    // internal pipeline → AVAudioSession, bypassing AVPlayer).
+    const useSharedRelay = !('setSinkId' in context);
+    if (useSharedRelay) {
+      this.gainNode.connect(getOrCreateSharedRelay(context).destinationNode);
+    } else {
+      // AudioContext.setSinkId() is available (Chrome, Firefox etc.) — use it directly.
+      this.gainNode.connect(context.destination);
+    }
 
     if (this.elementVolume) {
       this.gainNode.gain.setTargetAtTime(this.elementVolume, 0, 0.1);
diff --git a/src/room/utils.test.ts b/src/room/utils.test.ts
index c7d099b3b3..44ca153cdf 100644
--- a/src/room/utils.test.ts
+++ b/src/room/utils.test.ts
@@ -1,6 +1,15 @@
 import { ClientInfo_Capability } from '@livekit/protocol';
-import { describe, expect, it } from 'vitest';
-import { extractMaxAgeFromRequestHeaders, getClientInfo, splitUtf8, toWebsocketUrl } from './utils';
+import { describe, expect, it, vi } from 'vitest';
+import {
+  disposeSharedRelay,
+  extractMaxAgeFromRequestHeaders,
+  getClientInfo,
+  getOrCreateSharedRelay,
+  isSafariSpeakerSelectionSupported,
+  splitUtf8,
+  supportsSetSinkId,
+  toWebsocketUrl,
+} from './utils';
 
 describe('toWebsocketUrl', () => {
   it('leaves wss urls alone', () => {
@@ -188,3 +197,214 @@ describe('extractMaxAgeFromRequestHeaders', () => {
     expect(extractMaxAgeFromRequestHeaders(headers)).toBe(3600);
   });
 });
+
+describe('isSafariSpeakerSelectionSupported', () => {
+  it('returns true for Safari >= 26', () => {
+    expect(
+      isSafariSpeakerSelectionSupported({
+        name: 'Safari',
+        version: '26.0',
+        os: 'macOS',
+        osVersion: '26.0',
+      }),
+    ).toBe(true);
+    expect(
+      isSafariSpeakerSelectionSupported({
+        name: 'Safari',
+        version: '27.1',
+        os: 'macOS',
+        osVersion: '27.1',
+      }),
+    ).toBe(true);
+  });
+
+  it('returns true for iOS Safari >= 26', () => {
+    expect(
+      isSafariSpeakerSelectionSupported({
+        name: 'Safari',
+        version: '26.0',
+        os: 'iOS',
+        osVersion: '26.0',
+      }),
+    ).toBe(true);
+  });
+
+  it('returns false for Safari < 26', () => {
+    expect(
+      isSafariSpeakerSelectionSupported({
+        name: 'Safari',
+        version: '25.9',
+        os: 'macOS',
+        osVersion: '25.9',
+      }),
+    ).toBe(false);
+  });
+
+  it('returns false for non-Safari browsers', () => {
+    expect(
+      isSafariSpeakerSelectionSupported({
+        name: 'Chrome',
+        version: '120.0',
+        os: 'macOS',
+        osVersion: '14.0',
+      }),
+    ).toBe(false);
+  });
+
+  it('returns false for non-Safari browsers on macOS 26', () => {
+    expect(
+      isSafariSpeakerSelectionSupported({
+        name: 'Chrome',
+        version: '140.0',
+        os: 'macOS',
+        osVersion: '26.0',
+      }),
+    ).toBe(false);
+    expect(
+      isSafariSpeakerSelectionSupported({
+        name: 'Firefox',
+        version: '140.0',
+        os: 'macOS',
+        osVersion: '26.0',
+      }),
+    ).toBe(false);
+  });
+
+  it('returns false for iOS Safari < 26', () => {
+    expect(
+      isSafariSpeakerSelectionSupported({
+        name: 'Safari',
+        version: '18.0',
+        os: 'iOS',
+        osVersion: '18.0',
+      }),
+    ).toBe(false);
+  });
+
+  it('returns true for non-Safari WebKit browsers on iOS 26+ (Chrome iOS, etc.)', () => {
+    // On iOS, third-party browsers are required to use WebKit and inherit Safari behaviour.
+    expect(
+      isSafariSpeakerSelectionSupported({
+        name: 'Chrome',
+        version: '140.0',
+        os: 'iOS',
+        osVersion: '26.0',
+      }),
+    ).toBe(true);
+  });
+});
+
+describe('supportsSetSinkId', () => {
+  it('returns true on Firefox when setSinkId is present', () => {
+    Object.defineProperty(navigator, 'userAgent', {
+      value: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:142.0) Gecko/20100101 Firefox/142.0',
+      configurable: true,
+    });
+    const fakeAudio = { setSinkId: () => {} } as any as HTMLMediaElement;
+    expect(supportsSetSinkId(fakeAudio)).toBe(true);
+  });
+
+  it('returns true on Chrome (any macOS version) when setSinkId is present', () => {
+    Object.defineProperty(navigator, 'userAgent', {
+      value:
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36',
+      configurable: true,
+    });
+    const fakeAudio = { setSinkId: () => {} } as any as HTMLMediaElement;
+    expect(supportsSetSinkId(fakeAudio)).toBe(true);
+  });
+
+  it('returns true on Safari 26 (short-circuits the feature check)', () => {
+    Object.defineProperty(navigator, 'userAgent', {
+      value:
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15',
+      configurable: true,
+    });
+    // No setSinkId on the element — the iOS/Safari 26 path should still return true.
+    const fakeAudio = {} as any as HTMLMediaElement;
+    expect(supportsSetSinkId(fakeAudio)).toBe(true);
+  });
+
+  it('returns false on Safari < 26 even when the element has setSinkId', () => {
+    Object.defineProperty(navigator, 'userAgent', {
+      value:
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15',
+      configurable: true,
+    });
+    const fakeAudio = { setSinkId: () => {} } as any as HTMLMediaElement;
+    expect(supportsSetSinkId(fakeAudio)).toBe(false);
+  });
+});
+
+describe('getOrCreateSharedRelay / disposeSharedRelay', () => {
+  function createMockContext() {
+    const stream = new MediaStream();
+    const destNode = {
+      stream,
+      disconnect: vi.fn(),
+    } as unknown as MediaStreamAudioDestinationNode;
+    const ctx = {
+      createMediaStreamDestination: vi.fn(() => destNode),
+    } as unknown as AudioContext;
+    return { ctx, destNode, stream };
+  }
+
+  it('creates a hidden DOM-attached <audio> element on first call', () => {
+    const { ctx, destNode, stream } = createMockContext();
+    const relay = getOrCreateSharedRelay(ctx);
+    expect(relay.destinationNode).toBe(destNode);
+    expect(relay.relayElement.srcObject).toBe(stream);
+    expect(relay.relayElement.parentElement).toBe(document.body);
+    expect(relay.relayElement.hidden).toBe(true);
+    expect(relay.relayElement.autoplay).toBe(true);
+    disposeSharedRelay(ctx);
+  });
+
+  it('returns the same relay on subsequent calls for the same context (singleton)', () => {
+    const { ctx } = createMockContext();
+    const a = getOrCreateSharedRelay(ctx);
+    const b = getOrCreateSharedRelay(ctx);
+    expect(a).toBe(b);
+    expect(ctx.createMediaStreamDestination).toHaveBeenCalledTimes(1);
+    disposeSharedRelay(ctx);
+  });
+
+  it('creates independent relays for different contexts', () => {
+    const a = createMockContext();
+    const b = createMockContext();
+    const relayA = getOrCreateSharedRelay(a.ctx);
+    const relayB = getOrCreateSharedRelay(b.ctx);
+    expect(relayA).not.toBe(relayB);
+    expect(relayA.destinationNode).toBe(a.destNode);
+    expect(relayB.destinationNode).toBe(b.destNode);
+    disposeSharedRelay(a.ctx);
+    disposeSharedRelay(b.ctx);
+  });
+
+  it('removes the element from the DOM and disconnects the destination on dispose', () => {
+    const { ctx, destNode } = createMockContext();
+    const relay = getOrCreateSharedRelay(ctx);
+    expect(relay.relayElement.parentElement).toBe(document.body);
+
+    disposeSharedRelay(ctx);
+
+    expect(relay.relayElement.parentElement).toBeNull();
+    expect(destNode.disconnect).toHaveBeenCalled();
+  });
+
+  it('creates a fresh relay after dispose', () => {
+    const { ctx } = createMockContext();
+    const first = getOrCreateSharedRelay(ctx);
+    disposeSharedRelay(ctx);
+    const second = getOrCreateSharedRelay(ctx);
+    expect(second).not.toBe(first);
+    expect(ctx.createMediaStreamDestination).toHaveBeenCalledTimes(2);
+    disposeSharedRelay(ctx);
+  });
+
+  it('is a no-op when no relay exists for the context', () => {
+    const { ctx, destNode } = createMockContext();
+    expect(() => disposeSharedRelay(ctx)).not.toThrow();
+    expect(destNode.disconnect).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/room/utils.ts b/src/room/utils.ts
index 64f3be1fda..c70397eaf8 100644
--- a/src/room/utils.ts
+++ b/src/room/utils.ts
@@ -145,13 +145,59 @@ export function isSVCCodec(codec?: string): boolean {
   return codec === 'av1' || codec === 'vp9';
 }
 
-export function supportsSetSinkId(elm?: HTMLMediaElement): boolean {
-  if (!document || isSafariBased()) {
-    return false;
+/** A shared relay element + destination node attached to an AudioContext on iOS 26.
+ *  iOS 26 grants setSinkId permission per-element (not per-origin), so a new <audio> element
+ *  created when a remote participant joins would fail setSinkId without a user gesture.
+ *  Routing all remote tracks through a single shared relay element (created once, setSinkId'd
+ *  once during the user gesture in Room.switchActiveDevice) sidesteps this. */
+const SHARED_RELAY_KEY = '_livekitSharedRelay';
+
+type AudioContextWithSharedRelay = AudioContext & {
+  [SHARED_RELAY_KEY]?: {
+    destinationNode: MediaStreamAudioDestinationNode;
+    relayElement: HTMLAudioElement;
+  };
+};
+
+export function getOrCreateSharedRelay(context: AudioContext): {
+  destinationNode: MediaStreamAudioDestinationNode;
+  relayElement: HTMLAudioElement;
+} {
+  const ctx = context as AudioContextWithSharedRelay;
+  if (!ctx[SHARED_RELAY_KEY]) {
+    const destinationNode = context.createMediaStreamDestination();
+    const relayElement = document.createElement('audio');
+    relayElement.hidden = true;
+    relayElement.autoplay = true;
+    relayElement.srcObject = destinationNode.stream;
+    document.body?.appendChild(relayElement);
+    relayElement.play().catch(() => {});
+    ctx[SHARED_RELAY_KEY] = { destinationNode, relayElement };
   }
-  if (!elm) {
-    elm = document.createElement('audio');
+  return ctx[SHARED_RELAY_KEY]!;
+}
+
+export function disposeSharedRelay(context: AudioContext) {
+  const ctx = context as AudioContextWithSharedRelay;
+  const relay = ctx[SHARED_RELAY_KEY];
+  if (relay) {
+    relay.relayElement.pause();
+    relay.relayElement.srcObject = null;
+    relay.relayElement.parentElement?.removeChild(relay.relayElement);
+    relay.destinationNode.disconnect();
+    delete ctx[SHARED_RELAY_KEY];
   }
+}
+
+export function supportsSetSinkId(elm?: HTMLMediaElement): boolean {
+  if (!document) return false;
+  // iOS/Safari 26+ has Speaker Selection API — trust the version check rather than
+  // feature-detecting via 'in', because Apple may not expose setSinkId on the prototype
+  // until the element is actually in a document context.
+  if (isSafariSpeakerSelectionSupported()) return true;
+  // Older Safari has no setSinkId at all.
+  if (isSafariBased()) return false;
+  if (!elm) elm = document.createElement('audio');
   return 'setSinkId' in elm;
 }
 
@@ -222,6 +268,20 @@ export function isSafariSvcApi(browser?: BrowserDetails): boolean {
   );
 }
 
+export function isSafariSpeakerSelectionSupported(browser?: BrowserDetails): boolean {
+  if (!browser) {
+    browser = getBrowser();
+  }
+  // Safari (macOS or iOS) since version 26.
+  // https://developer.apple.com/documentation/safari-release-notes/safari-26-release-notes#WebRTC
+  // The iOS clause also catches WebKit-based browsers other than Safari on iOS 26+ (e.g. Chrome iOS),
+  // which inherit Safari's setSinkId behaviour because Apple requires them to use WebKit.
+  return (
+    (browser?.name === 'Safari' && compareVersions(browser.version, '26') >= 0) ||
+    (browser?.os === 'iOS' && !!browser?.osVersion && compareVersions(browser.osVersion, '26') >= 0)
+  );
+}
+
 export function isMobile(): boolean {
   if (!isWeb()) return false;