@ikonai/sdk 1.0.79 → 1.1.0

package/media/ikon-audio-capture.d.ts

@@ -61,7 +61,6 @@ export interface IkonAudioCaptureRequest {
     constraints?: MediaTrackConstraints;
     options?: {
         bitrate?: number;
-        targetIds?: number[];
     };
     /**
      * Optional correlation identifier embedded in the AudioStreamBegin payload. Used by the
@@ -82,7 +81,6 @@ export interface IkonAudioCaptureRequest {
 }
 export interface IkonAudioCaptureOptions {
     bitrate?: number;
-    targetIds?: number[];
 }
 export interface IkonAudioCaptureHandle {
     captureId: string;
@@ -120,6 +118,7 @@ export interface IkonAudioCaptureHandle {
 }
 export declare class IkonAudioCapture {
     private readonly client;
+    private static readonly RESUME_TIMEOUT_MS;
     private worker;
     private sendPort;
     private workletModuleUrl;
@@ -129,9 +128,9 @@ export declare class IkonAudioCapture {
     private nextTrackId;
     private captures;
     private pendingCaptures;
+    private activeWebRtcCaptureInvalidate;
     private readonly config;
     private deviceChangeHandler;
-    private audioContextStateHandler;
     constructor(client: IkonClient, config?: IkonAudioCaptureConfig);
     /**
      * Emit a diagnostic event for telemetry/debugging.
@@ -200,6 +199,12 @@ export declare class IkonAudioCapture {
     private ensureWorker;
     private ensureSendPort;
     private ensureAudioContext;
+    /**
+     * Resume with a timeout: on iOS an interrupted context's resume() can return a promise
+     * that never settles, which would hang the whole mic start silently — the caller's error
+     * path never runs and nothing reaches the user or the logs.
+     */
+    private resumeWithTimeout;
     /**
      * Attempt getUserMedia with retry and constraint fallback.
      * Phase-based approach: try requested constraints first, then fallback if overconstrained.
@@ -219,6 +224,13 @@ export declare class IkonAudioCapture {
      * De-duplicates concurrent loading attempts for the same context.
      */
     private ensureWorklet;
+    /**
+     * Called by the client when the WebRTC transport is lost mid-session. The active WebRTC
+     * capture handle can no longer send or end segments (its signaling object is gone), so mark
+     * it stopped and fire its onStopped callback — owners (e.g. CaptureButton) then drop the
+     * handle, and the next startMic re-evaluates the transport and takes the protocol channel.
+     */
+    handleWebRtcTransportLost(): void;
     startMic(request?: IkonAudioCaptureRequest): Promise<IkonAudioCaptureHandle>;
     stop(captureId: string): Promise<boolean>;
     startSegment(captureId: string): boolean;

package/media/ikon-audio-playback.d.ts

@@ -1,3 +1,4 @@
+import { GlobalState } from '../../shared/protocol/src/index.ts';
 import { IkonClient } from '../client/ikon-client';
 export interface IkonAudioPlaybackConfig {
     /**
@@ -61,6 +62,8 @@ export declare class IkonAudioPlayback {
     private recoveryTask;
     /** Timeout for AudioContext.resume() - normally resolves instantly, but some browsers hang indefinitely */
     private static readonly RESUME_TIMEOUT_MS;
+    private static readonly MAX_WORKER_REBUILD_ATTEMPTS;
+    private workerRebuildAttempts;
     private audioContext;
     private outputSampleRateHz;
     private audioWorkletNode;
@@ -73,6 +76,9 @@ export declare class IkonAudioPlayback {
     private audioWorker;
     private protocolPort;
     private readonly mediaSessionHelper;
+    private hiddenMuted;
+    private lastReportedPlaybackState;
+    private readonly lastPlaybackByStream;
     private readonly fallbackQueues;
     private readonly activeStreams;
     private mediaSessionConfig;
@@ -127,6 +133,27 @@ export declare class IkonAudioPlayback {
      * Set up audio worklet after recreating AudioContext on iOS.
      */
     private setupAudioGraphAfterRecreate;
+    /**
+     * Replay active audio stream state from GlobalState into the decode worker.
+     * GlobalState is the server's authoritative stream registry, delivered to every
+     * joiner and reconnector — this is how a client that missed a stream's live
+     * AUDIO_STREAM_BEGIN (late join, soft reconnect, worker rebuilt mid-stream)
+     * recovers its decode state. Idempotent: live same-format streams are untouched.
+     */
+    syncStreamsFromGlobalState(globalState: GlobalState): void;
+    /**
+     * Tell the decode worker whether WebRTC currently carries the audio. While it does,
+     * the worker skips protocol audio frames (the RTP stack decodes them); once WebRTC
+     * falls back to the protocol channel the worker must decode them itself.
+     */
+    setWebRtcActive(active: boolean): void;
+    /**
+     * Called when the protocol transport that backs this pipeline's message port is torn
+     * down (e.g. the protocol worker is terminated during a reconnect). Drops the decode
+     * worker and its dead port; the enabled state and audio graph survive, so the next
+     * playback setup rebuilds the worker with a live port.
+     */
+    handleProtocolTransportLost(): void;
     /**
      * Dispose of resources. After calling this, the instance should not be reused.
      */
@@ -163,10 +190,20 @@ export declare class IkonAudioPlayback {
     private onAudioWorkerMessage;
     private postToWorklet;
     private notifyPlaybackActive;
+    private computePlaybackState;
+    private sendPlaybackReport;
+    /**
+     * Push an immediate report for every active stream when audibility flips
+     * (context suspended/resumed, tab hidden/visible, unlock succeeded) — the
+     * periodic worklet reports would otherwise lag the change by up to 500 ms,
+     * and while output is disconnected the worklet does not tick at all.
+     */
+    private reportPlaybackStateIfChanged;
     private enqueuePendingWorkletMessage;
     private stopAudioWorklet;
     private stopScriptProcessor;
     private stopAudioGraph;
+    private handleWorkerCrash;
     private stopWorkers;
     private ensureStateSubscription;
 }

package/media/ikon-video-playback.d.ts

@@ -1,3 +1,4 @@
+import { GlobalState } from '../../shared/protocol/src/index.ts';
 import { IkonClient } from '../client/ikon-client';
 export interface IkonVideoPlaybackConfig {
     /**
@@ -18,9 +19,11 @@ export interface IkonVideoPlaybackConfig {
  * decoding and presenting frames efficiently.
  */
 export declare class IkonVideoPlayback {
+    private static readonly MAX_WORKER_REBUILD_ATTEMPTS;
     private readonly client;
     private readonly config;
     private enabled;
+    private workerRebuildAttempts;
     private stateUnsubscribe;
     private worker;
     private protocolPort;
@@ -53,6 +56,27 @@ export declare class IkonVideoPlayback {
     private requestIdrForStream;
     private detachProtocolPort;
     private ensureProtocolPort;
+    /**
+     * Replay active video stream state from GlobalState into the decode worker.
+     * GlobalState is the server's authoritative stream registry, delivered to every
+     * joiner and reconnector — this is how a client that missed a stream's live
+     * VIDEO_STREAM_BEGIN (late join, soft reconnect, worker rebuilt mid-stream)
+     * recovers its decode state. Idempotent: known streams are untouched.
+     */
+    syncStreamsFromGlobalState(globalState: GlobalState): void;
+    /**
+     * Tell the decode worker whether WebRTC currently carries the video. While it does,
+     * the worker skips protocol video frames (the RTP stack decodes them); once WebRTC
+     * falls back to the protocol channel the worker must decode them itself.
+     */
+    setWebRtcActive(active: boolean): void;
+    /**
+     * Called when the protocol transport that backs this pipeline's message port is torn
+     * down (e.g. the protocol worker is terminated during a reconnect). Drops the decode
+     * worker and its dead port; the next playback setup rebuilds them with live ports.
+     */
+    handleProtocolTransportLost(): void;
+    private handleWorkerCrash;
     private stopWorker;
     private ensureStateSubscription;
 }

package/media/media-session-helper.d.ts

@@ -10,6 +10,14 @@ export interface MediaSessionCallbacks {
 export declare class MediaSessionHelper {
     private _silentAudioElement;
     get silentAudioElement(): HTMLAudioElement | null;
+    /**
+     * Create and start the silent audio element without Media Session metadata.
+     *
+     * On iOS this is load-bearing even in the foreground: pure Web Audio output is
+     * silenced by the hardware ringer switch, while a playing media element promotes
+     * the audio session to playback category so speech is audible on muted phones.
+     */
+    ensureSilentPlaybackElement(): void;
     setup(config: MediaSessionConfig | undefined, callbacks: MediaSessionCallbacks): void;
     cleanup(): void;
 }

package/media/video-constants.d.ts

@@ -13,7 +13,17 @@ export declare const VIDEO_DECODE_CODEC_H264 = "avc1.42E01E";
 export declare const VIDEO_DECODE_CODEC_VP8 = "vp8";
 export declare const VIDEO_DECODE_CODEC_VP9 = "vp09.00.10.08";
 export declare const VIDEO_DECODE_CODEC_AV1 = "av01.0.04M.08";
-export declare const VIDEO_CAPTURE_DEFAULT_CODEC_PREFERENCES: readonly ('h264' | 'vp8' | 'vp9' | 'av1')[];
+export type VideoCodecPreference = 'h264' | 'vp8' | 'vp9' | 'av1';
+export declare const VIDEO_CAPTURE_DEFAULT_CODEC_PREFERENCES: readonly VideoCodecPreference[];
+/**
+ * The order the capture encoder tries codecs in, given what the caller asked for.
+ *
+ * The caller's list orders the search; it does not bound it. A browser that cannot encode the
+ * app's first choice must still capture — Chromium builds without H.264 are ordinary, and an app
+ * naming h264 alone used to leave capture producing nothing at all on them, silently: the encoder
+ * resolved nothing, and the only sign was media that never arrived.
+ */
+export declare function resolveCodecPreferenceOrder(preferred: VideoCodecPreference[] | undefined): VideoCodecPreference[];
 export declare const VIDEO_RESOLUTION_FALLBACKS: readonly [{
     readonly width: 1920;
     readonly height: 1080;

package/media/viseme-tracker.d.ts

@@ -1,4 +1,4 @@
-import { AudioShapeSet } from '../../../../shared/protocol/src/index.ts';
+import { AudioShapeSet, GlobalState } from '../../shared/protocol/src/index.ts';
 import { IkonClient } from '../client/ikon-client';
 /**
  * Time-synchronized lip-sync / shape-set receiver.
@@ -13,9 +13,11 @@ import { IkonClient } from '../client/ikon-client';
  * over WebRTC RTP tracks or the SDK's own playback pipeline.
  */
 export declare class VisemeTracker {
+    private static readonly MAX_WORKER_REBUILD_ATTEMPTS;
     private readonly client;
     private worker;
     private protocolPort;
+    private workerRebuildAttempts;
     private readonly streamShapeSets;
     private readonly currentShapeSetValues;
     private readonly visemeBuffers;
@@ -27,6 +29,13 @@ export declare class VisemeTracker {
      * Idempotent; safe to call once audio is known to be in use.
      */
     enable(): void;
+    /**
+     * Replay active audio stream state from GlobalState into the viseme worker.
+     * GlobalState is the server's authoritative stream registry, delivered to every
+     * joiner and reconnector — this is how lip-sync recovers mid-utterance after a
+     * late join or reconnect. Idempotent: known streams are untouched.
+     */
+    syncStreamsFromGlobalState(globalState: GlobalState): void;
     dispose(): void;
     getShapeSets(streamId: string): AudioShapeSet[] | null;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikonai/sdk",
-  "version": "1.0.79",
+  "version": "1.1.0",
   "type": "module",
   "main": "./index.js",
   "types": "./index.d.ts",

package/storage.d.ts

@@ -18,3 +18,16 @@ export declare function clearDeviceId(): void;
  * Returns null if the token cannot be decoded or doesn't contain an id.
  */
 export declare function extractUserIdFromToken(token: string): string | null;
+/**
+ * Auth-relevant claims decoded from an Ikon backend JWT.
+ */
+export interface AuthTokenClaims {
+    userId: string | null;
+    authSession: string | null;
+    role: string | null;
+}
+/**
+ * Extract auth-relevant claims from an Ikon backend JWT (payload fields `id`, `authSession`,
+ * `role`). Returns null if the token cannot be decoded.
+ */
+export declare function extractAuthClaimsFromToken(token: string): AuthTokenClaims | null;

package/transport/transport.d.ts

@@ -1,4 +1,4 @@
-import { ProtocolMessage } from '../../../../shared/protocol/src/index.ts';
+import { ProtocolMessage } from '../../shared/protocol/src/index.ts';
 /**
  * Transport interface for Ikon server connections.
  * Designed to support both WebSocket and WebTransport implementations.

package/transport/web-socket-transport.d.ts

@@ -1,4 +1,4 @@
-import { ProtocolMessage } from '../../../../shared/protocol/src/index.ts';
+import { ProtocolMessage } from '../../shared/protocol/src/index.ts';
 import { Transport, TransportConfig } from './transport';
 /**
  * WebSocket transport implementation for Ikon server connections.

package/transport/web-transport-transport.d.ts

@@ -1,4 +1,4 @@
-import { ProtocolMessage } from '../../../../shared/protocol/src/index.ts';
+import { ProtocolMessage } from '../../shared/protocol/src/index.ts';
 import { Transport, TransportConfig } from './transport';
 /**
  * Check if WebTransport is supported in the current environment.

package/utils/inspect-mode.d.ts

@@ -1,3 +1,7 @@
+/** Window event dispatched whenever inspect mode flips on, so UI that mounted before the
+ * flip (e.g. a boot-snapshot-seeded surface rendering ahead of the client connect that
+ * initializes the URL param) can react instead of reading a stale one-shot value. */
+export declare const IKON_INSPECT_MODE_CHANGED_EVENT = "ikon-inspect-mode-changed";
 export declare function initializeInspectMode(): boolean;
 export declare function isInspectModeEnabled(): boolean;
 export declare function enableInspectMode(): void;

package/utils/log-sender.d.ts

@@ -1,3 +1,3 @@
-export declare function startLogSender(backendUrl: string, authToken: string, sessionId?: string, channelInstanceId?: string): void;
+export declare function startLogSender(backendUrl: string, authToken: string): void;
 export declare function sendAnalyticsEvent(eventName: string, parameters: Record<string, string>): void;
 export declare function stopLogSender(): void;

package/utils/platform.d.ts

@@ -3,3 +3,7 @@
  * Also detects iPadOS which reports as "Macintosh" but has touch support.
  */
 export declare const isIOS: () => boolean;
+/**
+ * Detect if running on a mobile or tablet device (Android, iOS, and other mobile UAs).
+ */
+export declare const isMobileDevice: () => boolean;

package/utils/query-params.d.ts

@@ -12,8 +12,6 @@
  * - ikon-debug        Enable SDK debug logging (true)
  * - ikon-lang         Override language detection (e.g., "en", "fi")
  * - ikon-server-url   External connect URL for shareable preview links
- * - ikon-git-source   Enable Git source deployment mode (true)
- * - ikon-git-branch   Git branch for Git source deployment (e.g., "main")
  * - ikon-audio        Force audio on (true) or off (false)
  * - ikon-video        Force video on (true) or off (false)
  * - ikon-webrtc       Force WebRTC on (true) or off (false)
@@ -22,6 +20,7 @@
  * - ikon-retry        Enable retry loops in auth/channel connect (default true; set false to fail fast)
  * - ikon-api          Route backend API calls through same-origin /ikon/api (default true on deployed apps; false to force direct calls to api.{env}.ikon.live; always off in local dev)
  * - ikon-snapshot     Connect as a build-time snapshot client (true). Sets Context.IsSnapshot so app/Parallax code can branch on snapshot-mode rendering. Dev affordance for tuning the boot-snapshot UI.
+ * - ikon-session      Join the live app session named by this sessionIdentityHash, bypassing identity resolution. The server publishes the shareable form as GlobalState.SessionUrl. No live session with that hash is an error, never a fresh instance.
  */
 export declare const IKON_PARAM_PROXY = "ikon-proxy";
 export declare const IKON_PARAM_WEBSOCKET = "ikon-websocket";
@@ -29,8 +28,6 @@ export declare const IKON_PARAM_WEBTRANSPORT = "ikon-webtransport";
 export declare const IKON_PARAM_DEBUG = "ikon-debug";
 export declare const IKON_PARAM_LANG = "ikon-lang";
 export declare const IKON_PARAM_SERVER_URL = "ikon-server-url";
-export declare const IKON_PARAM_GIT_SOURCE = "ikon-git-source";
-export declare const IKON_PARAM_GIT_BRANCH = "ikon-git-branch";
 export declare const IKON_PARAM_AUDIO = "ikon-audio";
 export declare const IKON_PARAM_VIDEO = "ikon-video";
 export declare const IKON_PARAM_WEBRTC = "ikon-webrtc";
@@ -41,6 +38,7 @@ export declare const IKON_PARAM_AUTH = "ikon-auth";
 export declare const IKON_PARAM_RETRY = "ikon-retry";
 export declare const IKON_PARAM_API = "ikon-api";
 export declare const IKON_PARAM_SNAPSHOT = "ikon-snapshot";
+export declare const IKON_PARAM_SESSION = "ikon-session";
 /**
  * Set an SDK query parameter in the URL via history.replaceState.
  */
@@ -83,3 +81,9 @@ export declare function getApiParam(): boolean | null;
  * the app / Parallax can render in snapshot mode. A dev affordance for tuning the boot-snapshot UI.
  */
 export declare function getSnapshotParam(): boolean;
+/**
+ * The sessionIdentityHash of a specific live app session to join (`?ikon-session=<hash>`).
+ * Bypasses identity resolution: the backend connects to the session that owns this hash, and
+ * fails the connect when none is live rather than quietly starting a fresh one.
+ */
+export declare function getSessionParam(): string | null;

package/vite.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vite').UserConfig;
+export default _default;

package/webrtc/webrtc-signaling.d.ts

@@ -1,4 +1,4 @@
-import { ProtocolMessage, Opcode, WebRTCTrackMap } from '../../../../shared/protocol/src/index.ts';
+import { ProtocolMessage, Opcode, WebRTCTrackMap } from '../../shared/protocol/src/index.ts';
 import { WebRTCConnectionState } from './webrtc-connection';
 export interface WebRTCSignalingConfig {
     sessionId: number;
@@ -40,6 +40,8 @@ export declare class WebRTCSignaling {
     disconnect(): void;
     sendDataChannelMessage(data: ArrayBuffer): void;
     private audioCaptureStream;
+    private audioCaptureConstraints;
+    private audioSegmentActive;
     private videoCaptureStreams;
     /**
      * Returns the first active video capture MediaStream, if any.
@@ -54,17 +56,24 @@ export declare class WebRTCSignaling {
     startAudioCapture(constraints?: MediaTrackConstraints): Promise<void>;
     startAudioSegment(correlationId?: string): void;
     endAudioSegment(correlationId?: string): void;
+    private acquireAudioTrack;
+    private releaseAudioTrack;
     /**
      * Communicate the originator's correlation id for a video capture sender to the server-side
      * WebRtcMediaBridge so the next VideoStreamBegin it emits for this sender carries it.
      * Called by the video capture path when starting a CaptureButton-initiated stream.
      */
     sendVideoCaptureCorrelation(senderIndex: number, correlationId?: string): void;
-    startVideoCapture(constraints?: MediaTrackConstraints, bitrate?: number, senderIndex?: number, correlationId?: string): Promise<void>;
+    startVideoCapture(constraints?: MediaTrackConstraints, bitrate?: number, senderIndex?: number, correlationId?: string): Promise<MediaStream>;
     startScreenCapture(constraints?: MediaTrackConstraints, bitrate?: number, senderIndex?: number, correlationId?: string): Promise<MediaStream>;
     stopVideoCapture(senderIndex: number): Promise<void>;
     private sendVideoStreamBegin;
     private sendVideoStreamEnd;
+    /**
+     * Stop only the audio capture side. Video capture (camera, screen share) is left running —
+     * ending a push-to-talk session must not tear down an ongoing screen share.
+     */
+    stopAudioCapture(): void;
     stopCapture(): Promise<void>;
     private applyEncodingParams;
     private sendOffer;

package/worker/audio-playback-worker.d.ts

@@ -1,3 +1,4 @@
+import { AudioStreamBegin } from '../../shared/protocol/src/index.ts';
 export type AudioPlaybackWorkerTransport = 'sab' | 'pcm';
 export type AudioPlaybackWorkerConfigureMessage = {
     type: 'configure';
@@ -20,7 +21,19 @@ export type AudioPlaybackWorkerRebindMessage = {
 export type AudioPlaybackWorkerDisposeMessage = {
     type: 'dispose';
 };
-export type AudioPlaybackWorkerIn = AudioPlaybackWorkerConfigureMessage | AudioPlaybackWorkerAttachProtocolPortMessage | AudioPlaybackWorkerRebindMessage | AudioPlaybackWorkerDisposeMessage;
+export type AudioPlaybackWorkerSetWebRtcEnabledMessage = {
+    type: 'setWebRtcEnabled';
+    enabled: boolean;
+};
+export type AudioPlaybackWorkerSyncStreamsMessage = {
+    type: 'syncStreams';
+    streams: Array<{
+        senderId: number;
+        trackId: number;
+        info: AudioStreamBegin;
+    }>;
+};
+export type AudioPlaybackWorkerIn = AudioPlaybackWorkerConfigureMessage | AudioPlaybackWorkerAttachProtocolPortMessage | AudioPlaybackWorkerRebindMessage | AudioPlaybackWorkerDisposeMessage | AudioPlaybackWorkerSetWebRtcEnabledMessage | AudioPlaybackWorkerSyncStreamsMessage;
 export type AudioPlaybackWorkerOut = {
     type: 'streamBegin';
     streamId: string;

package/worker/video-capture-worker.d.ts

@@ -1,4 +1,5 @@
-type CodecPreference = 'h264' | 'vp8' | 'vp9' | 'av1';
+import { VideoCodecPreference } from '../media/video-constants';
+type CodecPreference = VideoCodecPreference;
 type HardwareAcceleration = 'preferHardware' | 'preferSoftware';
 export type VideoCaptureWorkerOptions = {
     preferredCodecs?: CodecPreference[];
@@ -8,6 +9,5 @@ export type VideoCaptureWorkerOptions = {
     bitrate?: number;
     keyFrameIntervalFrames?: number;
     hardwareAcceleration?: HardwareAcceleration;
-    targetIds?: number[];
 };
 export {};

package/worker/video-playback-worker.d.ts

@@ -1,4 +1,4 @@
-import { VideoCodec } from '../../../../shared/protocol/src/index.ts';
+import { VideoCodec, VideoStreamBegin } from '../../shared/protocol/src/index.ts';
 export type VideoPlaybackWorkerConfigureMessage = {
     type: 'configure';
     webRtcEnabled?: boolean;
@@ -31,7 +31,19 @@ export type VideoPlaybackWorkerSetEnabledMessage = {
 export type VideoPlaybackWorkerDisposeMessage = {
     type: 'dispose';
 };
-export type VideoPlaybackWorkerIn = VideoPlaybackWorkerConfigureMessage | VideoPlaybackWorkerAttachProtocolPortMessage | VideoPlaybackWorkerAttachSurfaceMessage | VideoPlaybackWorkerDetachSurfaceMessage | VideoPlaybackWorkerWatchStreamMessage | VideoPlaybackWorkerUnwatchStreamMessage | VideoPlaybackWorkerSetEnabledMessage | VideoPlaybackWorkerDisposeMessage;
+export type VideoPlaybackWorkerSetWebRtcEnabledMessage = {
+    type: 'setWebRtcEnabled';
+    enabled: boolean;
+};
+export type VideoPlaybackWorkerSyncStreamsMessage = {
+    type: 'syncStreams';
+    streams: Array<{
+        senderId: number;
+        trackId: number;
+        info: VideoStreamBegin;
+    }>;
+};
+export type VideoPlaybackWorkerIn = VideoPlaybackWorkerConfigureMessage | VideoPlaybackWorkerAttachProtocolPortMessage | VideoPlaybackWorkerAttachSurfaceMessage | VideoPlaybackWorkerDetachSurfaceMessage | VideoPlaybackWorkerWatchStreamMessage | VideoPlaybackWorkerUnwatchStreamMessage | VideoPlaybackWorkerSetEnabledMessage | VideoPlaybackWorkerDisposeMessage | VideoPlaybackWorkerSetWebRtcEnabledMessage | VideoPlaybackWorkerSyncStreamsMessage;
 export type VideoPlaybackWorkerOut = {
     type: 'streamBegin';
     streamId: string;

package/worker/viseme-worker.d.ts

@@ -1,4 +1,4 @@
-import { AudioShapeSet, AudioShapeSetValues } from '../../../../shared/protocol/src/index.ts';
+import { AudioShapeSet, AudioShapeSetValues, AudioStreamBegin } from '../../shared/protocol/src/index.ts';
 export type VisemeWorkerAttachProtocolPortMessage = {
     type: 'attachProtocolPort';
     port: MessagePort;
@@ -6,7 +6,15 @@ export type VisemeWorkerAttachProtocolPortMessage = {
 export type VisemeWorkerDisposeMessage = {
     type: 'dispose';
 };
-export type VisemeWorkerIn = VisemeWorkerAttachProtocolPortMessage | VisemeWorkerDisposeMessage;
+export type VisemeWorkerSyncStreamsMessage = {
+    type: 'syncStreams';
+    streams: Array<{
+        senderId: number;
+        trackId: number;
+        info: AudioStreamBegin;
+    }>;
+};
+export type VisemeWorkerIn = VisemeWorkerAttachProtocolPortMessage | VisemeWorkerDisposeMessage | VisemeWorkerSyncStreamsMessage;
 export type VisemeWorkerOut = {
     type: 'streamBegin';
     streamId: string;