@ikonai/sdk 1.0.44 → 1.0.46

package/login/index.d.ts

@@ -0,0 +1,4 @@
+export { getLoginPromptState, setLoginPromptRequired, clearLoginPrompt, subscribe, setLoginPendingCall, consumeLoginPendingCall, PENDING_CALL_KEY } from './login-store';
+export type { LoginPromptState, LoginPendingCall } from './login-store';
+export { loginErrorInterceptor } from './login-error-interceptor';
+export { reprovisionAfterLogin, consumeLoginHandoff } from './reprovision';

package/login/login-error-interceptor.d.ts

@@ -0,0 +1,13 @@
+import { ErrorInterceptor } from '../functions/function-registry';
+/**
+ * Error interceptor for the deferred-login flow.
+ *
+ * When a function call fails with code "login_required":
+ * 1. Stashes the pending call in sessionStorage (for replay after page reload).
+ * 2. Sets the login prompt state to required (triggers the login dialog).
+ * 3. Returns null so the original promise rejects normally with the error.
+ *
+ * After the user logs in, the page reloads against the new endpoint.
+ * The app's mount logic reads the pending call from sessionStorage and auto-invokes it.
+ */
+export declare const loginErrorInterceptor: ErrorInterceptor;

package/login/login-store.d.ts

@@ -0,0 +1,17 @@
+export declare const PENDING_CALL_KEY = "ikon.login.pendingCall";
+export interface LoginPromptState {
+    required: boolean;
+    reason: string | null;
+}
+export interface LoginPendingCall {
+    functionName: string;
+    args: unknown[];
+}
+type Listener = () => void;
+export declare function getLoginPromptState(): LoginPromptState;
+export declare function setLoginPromptRequired(reason: string | null): void;
+export declare function clearLoginPrompt(): void;
+export declare function subscribe(listener: Listener): () => void;
+export declare function setLoginPendingCall(pending: LoginPendingCall): void;
+export declare function consumeLoginPendingCall(): LoginPendingCall | null;
+export {};

package/login/reprovision.d.ts

@@ -0,0 +1,22 @@
+import { consumeLoginPendingCall } from './login-store';
+/**
+ * Reprovision the client by reloading the page against a new server endpoint.
+ *
+ * The deferred-login handoff data (pending call, app route) lives in sessionStorage
+ * and survives the page reload. On reload, the app boots against the new endpoint
+ * (which now has a real user identity) and the app's mount logic can replay the
+ * pending call from sessionStorage via {@link consumeLoginHandoff}.
+ *
+ * This follows the same pattern as `ikon.client.logout` (clear + reload).
+ *
+ * @param connectUrl The full connect URL for the authenticated session.
+ */
+export declare function reprovisionAfterLogin(connectUrl: string): void;
+/**
+ * Check on app mount whether we just came back from a login reprovision.
+ * Returns the app route to restore and any pending call to replay.
+ */
+export declare function consumeLoginHandoff(): {
+    appRoute: string | null;
+    pendingCall: ReturnType<typeof consumeLoginPendingCall>;
+};

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

@@ -63,6 +63,12 @@ export interface IkonAudioCaptureRequest {
         bitrate?: number;
         targetIds?: number[];
     };
+    /**
+     * Optional correlation identifier embedded in the AudioStreamBegin payload. Used by the
+     * server-side CaptureButton to derive onCaptureStart/onCaptureStop from the audio path
+     * itself, eliminating any race between UI action dispatch and the audio stream.
+     */
+    correlationId?: string;
     onStopped?: () => void;
     /**
      * Called when capture encounters an error.
@@ -87,8 +93,15 @@ export interface IkonAudioCaptureHandle {
     readonly currentConstraints: MediaTrackConstraints;
     /** The current audio options (bitrate, etc.) applied to the capture. */
     readonly currentOptions: IkonAudioCaptureOptions;
-    startSegment(): void;
-    endSegment(): void;
+    /**
+     * Start a new logical recording segment. Optional correlationId identifies the originator
+     * (e.g., a CaptureButton instance) and is propagated to the server so the
+     * CaptureCorrelationBridge can fire onCaptureStart for the right registration. For the
+     * worker-encoded path the correlationId is fixed at startMic time and this argument is
+     * ignored; for the WebRTC path it is sent with each segment-start signal.
+     */
+    startSegment(correlationId?: string): void;
+    endSegment(correlationId?: string): void;
     stop(): Promise<void>;
     /** Update audio constraints on the active capture. Returns true if successful. */
     updateConstraints(constraints: MediaTrackConstraints): Promise<boolean>;

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

@@ -7,6 +7,13 @@ export interface IkonVideoCaptureRequest {
     options?: IkonVideoCaptureOptions;
     userGesture?: boolean;
     constraints?: MediaTrackConstraints;
+    /**
+     * Optional correlation identifier sent to the server-side WebRtcMediaBridge so the next
+     * VideoStreamBegin it emits for this sender carries it. Used by the CaptureCorrelationBridge
+     * to route onCaptureStart/onCaptureStop dispatches to the originating CaptureButton without
+     * racing with the UI action channel.
+     */
+    correlationId?: string;
     onStopped?: () => void;
 }
 export interface IkonVideoCaptureHandle {

package/package.json

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

package/transport/transport.d.ts

@@ -36,9 +36,8 @@ export interface TransportCallbacks {
      * Called when the connection is closed.
      * @param reason - Optional reason for the close
      * @param wasClean - Whether the close was clean (normal)
-     * @param isServerClose - Whether the close code was 1000 or 1001, indicating server-initiated close
      */
-    onClose: (reason?: string, wasClean?: boolean, isServerClose?: boolean) => void;
+    onClose: (reason?: string, wasClean?: boolean) => void;
     /**
      * Called when an error occurs.
      */

package/utils/query-params.d.ts

@@ -8,7 +8,7 @@
  * Supported parameters:
  * - ikon-proxy        Force proxy mode on (true) or off (false)
  * - ikon-websocket    Force WebSocket transport on (true) or off (false)
- * - ikon-webtransport Force WebTransport on (true) or off (false)
+ * - ikon-webtransport Force WebTransport on (true); default is off. `false` is accepted for parity.
  * - 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
@@ -18,6 +18,8 @@
  * - ikon-video        Force video on (true) or off (false)
  * - ikon-webrtc       Force WebRTC on (true) or off (false)
  * - ikon-inspect      Enable element inspection overlay (true)
+ * - 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)
  */
 export declare const IKON_PARAM_PROXY = "ikon-proxy";
 export declare const IKON_PARAM_WEBSOCKET = "ikon-websocket";
@@ -31,6 +33,8 @@ export declare const IKON_PARAM_AUDIO = "ikon-audio";
 export declare const IKON_PARAM_VIDEO = "ikon-video";
 export declare const IKON_PARAM_WEBRTC = "ikon-webrtc";
 export declare const IKON_PARAM_INSPECT = "ikon-inspect";
+export declare const IKON_PARAM_RETRY = "ikon-retry";
+export declare const IKON_PARAM_API = "ikon-api";
 /**
  * Set an SDK query parameter in the URL via history.replaceState.
  */
@@ -45,3 +49,5 @@ export declare function getAudioParam(): boolean | null;
 export declare function getVideoParam(): boolean | null;
 export declare function getWebRtcParam(): boolean | null;
 export declare function getInspectParam(): boolean;
+export declare function getRetryParam(): boolean;
+export declare function getApiParam(): boolean | null;

package/webrtc/webrtc-signaling.d.ts

@@ -37,11 +37,23 @@ export declare class WebRTCSignaling {
      * Returns the first active video capture MediaStream, if any.
      */
     getActiveVideoCaptureStream(): MediaStream | null;
+    /**
+     * Look up a local video capture MediaStream by its app-level streamId.
+     * Capture streamId format: `webrtc_video_${sessionId}_${trackIndex}` (see sendVideoStreamBegin).
+     * Returns null if no local capture matches.
+     */
+    getLocalVideoCaptureStreamByStreamId(streamId: string): MediaStream | null;
     startAudioCapture(constraints?: MediaTrackConstraints): Promise<void>;
-    startAudioSegment(): void;
-    endAudioSegment(): void;
-    startVideoCapture(constraints?: MediaTrackConstraints, bitrate?: number, senderIndex?: number): Promise<void>;
-    startScreenCapture(constraints?: MediaTrackConstraints, bitrate?: number, senderIndex?: number): Promise<MediaStream>;
+    startAudioSegment(correlationId?: string): void;
+    endAudioSegment(correlationId?: string): void;
+    /**
+     * 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>;
+    startScreenCapture(constraints?: MediaTrackConstraints, bitrate?: number, senderIndex?: number, correlationId?: string): Promise<MediaStream>;
     stopVideoCapture(senderIndex: number): Promise<void>;
     private sendVideoStreamBegin;
     private sendVideoStreamEnd;