@urun-sh/core 0.2.16 → 0.2.18

package/dist/index.d.ts

@@ -1,10 +1,46 @@
-import { b as AppOptions, a as App$1, K as SessionPhase, T as SessionStatus, O as SessionPhaseName, A as AccessTokenOptions$1, y as RuntimeArtifact, z as RuntimeArtifactDownload, R as Recording, G as Session$1, C as ChannelEndpoint, _ as TransportSession, c as AttachOptions, v as RecordingsAccessor, B as RuntimeArtifactsAccessor, U as SessionStream$1, Z as StreamDataTransport, I as SessionDocumentImpl, Y as StreamChunkOptions, g as ChunkReadable, P as Presence, k as DocConnector, w as RequestOptions, x as RequestStreamOptions, X as StoreOptions, W as Store, e as ChannelMultiplexer, J as SessionFailureKind, a0 as TransportState } from './stream-data-D8AOc7CR.js';
-export { L as Layer, l as LayoutConfig, m as LayoutContext, M as MediaChunkBinding, o as MediaChunkSource, p as MediaChunkSourceFactory, q as MediaRecorderChunkSourceOptions, r as PresenceState, s as RecordingBucket, t as RecordingLifecycle, u as RecordingStatus, E as RuntimeAvailability, S as SceneContext, F as SceneGraph, H as SessionDocument, N as SessionPhaseError, V as SessionText, a4 as isPendingRecording, a5 as mediaRecorderChunkSource } from './stream-data-D8AOc7CR.js';
+import { d as AppOptions, c as App$1, Q as SessionPhase, W as SessionStatus, U as SessionPhaseName, A as AccessTokenOptions$1, B as RuntimeArtifact, E as RuntimeArtifactDownload, R as Recording, I as Session$1, C as ChannelEndpoint, a1 as TransportSession, e as AttachOptions, a as ActivationEvent, x as RecordingsAccessor, F as RuntimeArtifactsAccessor, N as SessionEndResult, X as SessionStream$1, a0 as StreamDataTransport, K as SessionDocumentImpl, $ as StreamChunkOptions, i as ChunkReadable, P as Presence, m as DocConnector, y as RequestOptions, z as RequestStreamOptions, _ as StoreOptions, Z as Store, g as ChannelMultiplexer, O as SessionFailureKind, a3 as TransportState } from './stream-data-ChMs2mq2.js';
+export { b as ActivationState, L as Layer, n as LayoutConfig, o as LayoutContext, M as MediaChunkBinding, q as MediaChunkSource, r as MediaChunkSourceFactory, s as MediaRecorderChunkSourceOptions, t as PresenceState, u as RecordingBucket, v as RecordingLifecycle, w as RecordingStatus, G as RuntimeAvailability, S as SceneContext, H as SceneGraph, J as SessionDocument, T as SessionPhaseError, Y as SessionText, a7 as isPendingRecording, a8 as mediaRecorderChunkSource } from './stream-data-ChMs2mq2.js';
 import 'yjs';
 import 'y-protocols/awareness';
 
 declare function App(appId: string, options: AppOptions): App$1;
 
+declare const DEFAULT_GATEWAY_URL = "https://api.urun.sh";
+interface CreateClientTokenOptions {
+    
+    baseUrl?: string;
+    
+    expiresIn?: number;
+    
+    allowedFunctions?: string[];
+    
+    allowedOrigins?: string[];
+    
+    maxSessionS?: number;
+    
+    subject?: string;
+    
+    metadata?: Record<string, unknown>;
+    
+    fetch?: typeof fetch;
+}
+
+interface ClientToken {
+    
+    token: string;
+    
+    expiresAt: Date;
+    
+    orgId: string;
+}
+
+declare class ClientTokenError extends Error {
+    readonly status?: number;
+    constructor(message: string, status?: number);
+}
+
+declare function createClientToken(apiKey: string, options?: CreateClientTokenOptions): Promise<ClientToken>;
+
 interface AccessTokenOptions {
     forceRefresh?: boolean;
     reason?: 'initial' | 'unauthorized' | 'background';
@@ -191,6 +227,8 @@ declare class SessionStream implements SessionStream$1 {
     
     private _onActivity?;
     private _track;
+    
+    private _overrideTrack;
     private _handlers;
     private _unsubscribeTransport;
     
@@ -217,6 +255,8 @@ declare class SessionStream implements SessionStream$1 {
     private _deliver;
     get track(): MediaStreamTrack | null;
     
+    _setOverrideTrack(track: MediaStreamTrack | null): void;
+    
     private _claimBrowserProducer;
     attach(track: MediaStreamTrack): Promise<void>;
     
@@ -247,13 +287,19 @@ declare class Session implements Session$1 {
     
     private _docConnector;
     
+    private _docEndpointKey;
+    
     private _streamData;
     
     private _presence;
     
     private _activity;
     
+    private _activation;
+    
     private _activeRequests;
+    private _endHandler?;
+    private _endPromise?;
     
     private _recordingsAuth?;
     
@@ -266,6 +312,10 @@ declare class Session implements Session$1 {
     private _recoveryHooks;
     
     private _lifecycleUnsub;
+    
+    private _dialNegotiation;
+    
+    private _dialNegotiationStarted;
     constructor(sessionId: string, multiplexer: ChannelEndpoint, transport: TransportSession, recordingsAuth?: RecordingsClientOptions, artifactsAuth?: RuntimeArtifactsClientOptions);
     private _wireControlDocIncarnation;
     
@@ -280,6 +330,8 @@ declare class Session implements Session$1 {
     
     onPhase(handler: (phase: SessionPhase) => void): () => void;
     
+    onActivation(handler: (event: ActivationEvent) => void): () => void;
+    
     whenLive(options?: WhenLiveOptions): Promise<void>;
     
     get recordings(): RecordingsAccessor;
@@ -287,6 +339,8 @@ declare class Session implements Session$1 {
     setArtifactsAuth(auth: RuntimeArtifactsClientOptions): void;
     private _requireArtifactsAuth;
     setSessionId(sessionId: string): void;
+    
+    setEndHandler(handler: () => Promise<SessionEndResult>): void;
     stream(name: string): SessionStream;
     
     doc(key: string): SessionDocumentImpl;
@@ -320,6 +374,13 @@ declare class Session implements Session$1 {
     recover(): void;
     
     onRecovery(hook: () => void): () => void;
+    
+    negotiateMediaTransport(opts?: {
+        allowWebTransport?: boolean;
+    }): void;
+    
+    get mediaTransport(): 'webtransport' | 'webrtc' | null;
+    end(): Promise<SessionEndResult>;
     disconnect(): void;
 }
 
@@ -327,6 +388,70 @@ declare const FOREGROUND_COALESCE_MS = 250;
 
 declare function observePageLifecycle(onForeground: () => void): () => void;
 
+declare const ACTIVATION_STILL_AFTER_MS = 15000;
+
+declare const ACTIVATION_COLD_BOOT_AFTER_MS = 45000;
+
+declare const ACTIVATION_DEGRADED_AFTER_MS = 120000;
+
+declare const ACTIVATION_HINT_PATH = "desired.activation";
+
+declare function activationHintFrom(value: unknown): string | undefined;
+
+interface ActivationStreamLike {
+    
+    readonly track: MediaStreamTrack | null;
+    
+    on(event: 'track', handler: (track: MediaStreamTrack | null) => void): () => void;
+}
+
+interface ActivationMonitorOptions {
+    
+    onPhase(handler: (phase: SessionPhase) => void): () => void;
+    
+    hint(): unknown;
+    
+    onData?(name: string, handler: (payload: unknown) => void): () => void;
+}
+
+declare class ActivationMonitor {
+    private _options;
+    private _watches;
+    private _handlers;
+    
+    private _liveAt;
+    private _stopped;
+    private _offPhase;
+    constructor(_options: ActivationMonitorOptions);
+    
+    watch(name: string, stream: ActivationStreamLike): void;
+    
+    unwatch(name: string): void;
+    
+    onActivation(handler: (event: ActivationEvent) => void): () => void;
+    
+    dispose(): void;
+    
+    private _hookFirstMediaSignals;
+    
+    private _arm;
+    
+    private _firstMedia;
+    
+    private _settle;
+    private _emit;
+}
+
+declare const BACKOFF_BASE_MS = 500;
+
+declare const BACKOFF_MAX_MS = 15000;
+
+declare const BACKOFF_MAX_ATTEMPTS = 6;
+
+declare function computeBackoffDelay(attempt: number, random?: () => number): number;
+
+declare function isRetryableSessionError(error: unknown): boolean;
+
 declare function createStore(options: StoreOptions): Store & {
     _getInternals(): {
         multiplexer: ChannelMultiplexer;
@@ -341,6 +466,25 @@ interface VideoStreamOptions {
 
 declare function videoStream(source: ReadableStream<Uint8Array>, options?: VideoStreamOptions): MediaStream;
 
+declare class SessionEndUnavailableError extends Error {
+    readonly code = "session_end_unavailable";
+    constructor(message?: string, options?: {
+        cause?: unknown;
+    });
+}
+
+declare class SessionEndError extends Error {
+    readonly code: string;
+    readonly httpStatus?: number;
+    readonly requestId: string;
+    constructor(message: string, options: {
+        requestId: string;
+        code?: string;
+        httpStatus?: number;
+        cause?: unknown;
+    });
+}
+
 declare class RequestError extends Error {
     
     readonly requestId?: string;
@@ -560,6 +704,8 @@ interface MediaSession {
         lossPct: number;
         jitterMs: number;
     };
+    
+    readonly firstMedia: Promise<void>;
 }
 
 interface Signaling {
@@ -708,6 +854,8 @@ declare class WebTransportSession implements MediaSession {
     private lastStats;
     private firstFrameResolve;
     private firstFrameReject;
+    
+    readonly firstMedia: Promise<void>;
     constructor(offer: NonNullable<TransportOfferResponse['webtransport']>, sessionId: string, canvas: HTMLCanvasElement);
     
     start(): Promise<void>;
@@ -741,6 +889,10 @@ declare class WebRtcSession implements MediaSession {
     private deadCb;
     private deadFired;
     private unsubscribers;
+    private firstMediaResolve;
+    private firstMediaReject;
+    
+    readonly firstMedia: Promise<void>;
     constructor(transport: ConsumingTransport, streamName?: string);
     
     start(): Promise<void>;
@@ -798,4 +950,4 @@ declare class FrameReassembler {
     private requestKeyframe;
 }
 
-export { ACTIVITY_DOM_EVENTS, ACTIVITY_FIELD, ACTIVITY_STAMP_MIN_INTERVAL_MS, type ActivityAwareness, type ActivityTracker, type ActivityTrackerOptions, App, App$1 as AppInterface, AppOptions, AttachOptions, type CaptureClaim, CaptureController, type CaptureControllerOptions, type CaptureKind, CaptureUnavailableError, ChunkReadable, type ConsumingTransport, DEFAULT_DOC_SYNC_TIMEOUT_MS, DEFAULT_PRODUCE_ACK_TIMEOUT_MS, DEFAULT_WHEN_LIVE_TIMEOUT_MS, DGRAM_HEADER_BYTES, type DgramHeader, FOREGROUND_COALESCE_MS, FrameReassembler, INPUT_PRESENCE_DEFAULT_HZ, INPUT_PRESENCE_FIELD, type InputPresenceAwareness, type InputPresencePublisher, type InputPresencePublisherOptions, type InputPresenceState, InvalidDurationError, type MediaSession, type NegotiatorOptions, PermanentLockedError, type PhaseObservable, PinRequiresActiveTempError, Presence, type PrewakeOptions, type PrewakeResult, type PrewakeStatus, ProduceAckTimeoutError, type ReassembledFrame, type ReassemblerCallbacks, type ReassemblerOptions, Recording, RecordingNotFoundError, RecordingsAccessor, RecordingsClient, type RecordingsClientOptions, RecordingsError, RecordingsUnauthorizedError, RequestAbortError, RequestCancelledError, RequestDocSyncError, RequestError, RequestOptions, RequestStreamOptions, RequestTimeoutError, RetainNotTempError, type RetentionIntent, RuntimeArtifact, RuntimeArtifactDownload, RuntimeArtifactNotFoundError, RuntimeArtifactsAccessor, RuntimeArtifactsClient, type RuntimeArtifactsClientOptions, RuntimeArtifactsError, RuntimeArtifactsUnauthorizedError, Session, SessionAllocationError, SessionFailedError, SessionFailureKind, Session$1 as SessionInterface, SessionPhase, SessionPhaseName, SessionStatus, SessionStream$1 as SessionStream, type SignalCarrier, type Signaling, Store, StoreOptions, StreamChunkOptions, StreamDirectionConflict, type TransportEstablishedNotify, TransportNegotiator, type TransportOfferRequest, type TransportOfferResponse, TransportSessionSignaling, TransportState, type VideoStreamOptions, WT_CONTROL_FRAME_MAX, WebRtcSession, WebTransportSession, type WhenLiveOptions, WtControlDecoder, type WtControlMessage, createActivityTracker, createInputPresencePublisher, createRecordingsClient, createRuntimeArtifactsClient, createStore, describeSessionFailure, describeSessionPhase, encodeWtControlFrame, isDurationString, isWakingPhase, normalizeRetention, observePageLifecycle, parseDgramHeader, prewake, sessionFailureFromMediaError, sharedCaptureController, videoStream, whenLive, writeDgramHeader };
+export { ACTIVATION_COLD_BOOT_AFTER_MS, ACTIVATION_DEGRADED_AFTER_MS, ACTIVATION_HINT_PATH, ACTIVATION_STILL_AFTER_MS, ACTIVITY_DOM_EVENTS, ACTIVITY_FIELD, ACTIVITY_STAMP_MIN_INTERVAL_MS, ActivationEvent, ActivationMonitor, type ActivationMonitorOptions, type ActivationStreamLike, type ActivityAwareness, type ActivityTracker, type ActivityTrackerOptions, App, App$1 as AppInterface, AppOptions, AttachOptions, BACKOFF_BASE_MS, BACKOFF_MAX_ATTEMPTS, BACKOFF_MAX_MS, type CaptureClaim, CaptureController, type CaptureControllerOptions, type CaptureKind, CaptureUnavailableError, ChunkReadable, type ClientToken, ClientTokenError, type ConsumingTransport, type CreateClientTokenOptions, DEFAULT_DOC_SYNC_TIMEOUT_MS, DEFAULT_GATEWAY_URL, DEFAULT_PRODUCE_ACK_TIMEOUT_MS, DEFAULT_WHEN_LIVE_TIMEOUT_MS, DGRAM_HEADER_BYTES, type DgramHeader, FOREGROUND_COALESCE_MS, FrameReassembler, INPUT_PRESENCE_DEFAULT_HZ, INPUT_PRESENCE_FIELD, type InputPresenceAwareness, type InputPresencePublisher, type InputPresencePublisherOptions, type InputPresenceState, InvalidDurationError, type MediaSession, type NegotiatorOptions, PermanentLockedError, type PhaseObservable, PinRequiresActiveTempError, Presence, type PrewakeOptions, type PrewakeResult, type PrewakeStatus, ProduceAckTimeoutError, type ReassembledFrame, type ReassemblerCallbacks, type ReassemblerOptions, Recording, RecordingNotFoundError, RecordingsAccessor, RecordingsClient, type RecordingsClientOptions, RecordingsError, RecordingsUnauthorizedError, RequestAbortError, RequestCancelledError, RequestDocSyncError, RequestError, RequestOptions, RequestStreamOptions, RequestTimeoutError, RetainNotTempError, type RetentionIntent, RuntimeArtifact, RuntimeArtifactDownload, RuntimeArtifactNotFoundError, RuntimeArtifactsAccessor, RuntimeArtifactsClient, type RuntimeArtifactsClientOptions, RuntimeArtifactsError, RuntimeArtifactsUnauthorizedError, Session, SessionAllocationError, SessionEndError, SessionEndResult, SessionEndUnavailableError, SessionFailedError, SessionFailureKind, Session$1 as SessionInterface, SessionPhase, SessionPhaseName, SessionStatus, SessionStream$1 as SessionStream, type SignalCarrier, type Signaling, Store, StoreOptions, StreamChunkOptions, StreamDirectionConflict, type TransportEstablishedNotify, TransportNegotiator, type TransportOfferRequest, type TransportOfferResponse, TransportSessionSignaling, TransportState, type VideoStreamOptions, WT_CONTROL_FRAME_MAX, WebRtcSession, WebTransportSession, type WhenLiveOptions, WtControlDecoder, type WtControlMessage, activationHintFrom, computeBackoffDelay, createActivityTracker, createClientToken, createInputPresencePublisher, createRecordingsClient, createRuntimeArtifactsClient, createStore, describeSessionFailure, describeSessionPhase, encodeWtControlFrame, isDurationString, isRetryableSessionError, isWakingPhase, normalizeRetention, observePageLifecycle, parseDgramHeader, prewake, sessionFailureFromMediaError, sharedCaptureController, videoStream, whenLive, writeDgramHeader };