@urun-sh/core 0.2.14 → 0.2.16

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-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 } from './stream-data-GIyoXg7t.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, a0 as TransportState, a4 as isPendingRecording, a5 as mediaRecorderChunkSource } from './stream-data-GIyoXg7t.js';
+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 'yjs';
 import 'y-protocols/awareness';
 
@@ -375,6 +375,21 @@ declare class StreamDirectionConflict extends Error {
     constructor(stream: string, owner: 'runtime' | 'browser', attempted: 'runtime' | 'browser');
 }
 
+declare const DEFAULT_PRODUCE_ACK_TIMEOUT_MS = 15000;
+
+declare class ProduceAckTimeoutError extends Error {
+    
+    readonly kind: 'audio' | 'video';
+    
+    readonly stream: string;
+    
+    readonly timeoutMs: number;
+    constructor(kind: 'audio' | 'video', options?: {
+        stream?: string;
+        timeoutMs?: number;
+    });
+}
+
 declare class RequestAbortError extends RequestError {
     constructor(requestId?: string);
 }
@@ -533,4 +548,254 @@ interface InputPresencePublisher {
 
 declare function createInputPresencePublisher(options: InputPresencePublisherOptions): InputPresencePublisher;
 
-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, DEFAULT_DOC_SYNC_TIMEOUT_MS, DEFAULT_WHEN_LIVE_TIMEOUT_MS, FOREGROUND_COALESCE_MS, INPUT_PRESENCE_DEFAULT_HZ, INPUT_PRESENCE_FIELD, type InputPresenceAwareness, type InputPresencePublisher, type InputPresencePublisherOptions, type InputPresenceState, InvalidDurationError, PermanentLockedError, type PhaseObservable, PinRequiresActiveTempError, Presence, type PrewakeOptions, type PrewakeResult, type PrewakeStatus, 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, Store, StoreOptions, StreamChunkOptions, StreamDirectionConflict, type VideoStreamOptions, type WhenLiveOptions, createActivityTracker, createInputPresencePublisher, createRecordingsClient, createRuntimeArtifactsClient, createStore, describeSessionFailure, describeSessionPhase, isDurationString, isWakingPhase, normalizeRetention, observePageLifecycle, prewake, sessionFailureFromMediaError, sharedCaptureController, videoStream, whenLive };
+interface MediaSession {
+    readonly kind: 'webtransport' | 'webrtc';
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    
+    onDead(cb: (reason: string) => void): void;
+    
+    stats(): {
+        recvBps: number;
+        lossPct: number;
+        jitterMs: number;
+    };
+}
+
+interface Signaling {
+    request<T = unknown>(method: string, params?: unknown): Promise<T>;
+    notify(method: string, params?: unknown): void;
+    
+    on(method: string, handler: (params: Record<string, unknown>) => void): () => void;
+}
+
+interface SignalCarrier {
+    
+    sendSignal(msg: Record<string, unknown>): void;
+    
+    onSignal(handler: (msg: Record<string, unknown>) => void): () => void;
+}
+declare class TransportSessionSignaling implements Signaling {
+    private carrier;
+    private requestTimeoutMs;
+    constructor(carrier: SignalCarrier, requestTimeoutMs?: number);
+    request<T = unknown>(method: string, params?: unknown): Promise<T>;
+    notify(method: string, params?: unknown): void;
+    on(method: string, handler: (params: Record<string, unknown>) => void): () => void;
+}
+
+interface TransportOfferRequest {
+    sessionId: string;
+    capabilities: {
+        
+        webtransport: boolean;
+        
+        webcodecs: boolean;
+        
+        codecs: string[];
+    };
+}
+interface TransportOfferResponse {
+    
+    webrtc: {
+        routerRtpCapabilities: unknown;
+    };
+    
+    webtransport?: {
+        url: string;
+        
+        certHashes: string[];
+        
+        token: string;
+        codec: string;
+    };
+}
+interface TransportEstablishedNotify {
+    sessionId: string;
+    transport: 'webtransport' | 'webrtc';
+    
+    fallbackReason?: string;
+}
+type WtControlMessage = {
+    t: 'hello';
+    token: string;
+    sessionId: string;
+} | {
+    t: 'hello-ack';
+    codec: string;
+    width: number;
+    height: number;
+} | {
+    t: 'ping';
+    ts: number;
+} | {
+    t: 'pong';
+    ts: number;
+} | {
+    t: 'keyframe-request';
+} | {
+    t: 'feedback';
+    recvBps: number;
+    lossPct: number;
+    jitterMs: number;
+};
+
+declare const WT_CONTROL_FRAME_MAX: number;
+
+declare function encodeWtControlFrame(msg: WtControlMessage): Uint8Array;
+
+declare class WtControlDecoder {
+    private buf;
+    push(bytes: Uint8Array): WtControlMessage[];
+}
+declare const DGRAM_HEADER_BYTES = 12;
+interface DgramHeader {
+    groupId: number;
+    frameSeq: number;
+    keyframe: boolean;
+    fragIndex: number;
+    fragCount: number;
+}
+
+declare function parseDgramHeader(view: DataView): DgramHeader;
+
+declare function writeDgramHeader(h: DgramHeader): Uint8Array;
+
+interface NegotiatorOptions {
+    
+    quicDeadlineMs?: number;
+    
+    allowWebTransport?: boolean;
+    onTransportChange?: (kind: MediaSession['kind'], reason?: string) => void;
+    
+    canvas?: HTMLCanvasElement;
+    
+    createWebRtcSession: () => MediaSession;
+    createWebTransportSession?: (offer: NonNullable<TransportOfferResponse['webtransport']>) => MediaSession;
+}
+declare class TransportNegotiator {
+    private signaling;
+    private sessionId;
+    private opts;
+    private session;
+    private offer;
+    constructor(signaling: Signaling, sessionId: string, opts: NegotiatorOptions);
+    get activeTransport(): MediaSession['kind'] | null;
+    connect(): Promise<MediaSession>;
+    disconnect(): Promise<void>;
+    private createWebTransportSession;
+    private startWebRtc;
+    
+    private armFailover;
+    private notifyEstablished;
+}
+
+declare class WebTransportSession implements MediaSession {
+    private offer;
+    private sessionId;
+    private canvas;
+    readonly kind: "webtransport";
+    private wt;
+    private decoder;
+    private writer;
+    private deadCb;
+    private deadFired;
+    private stopped;
+    private feedbackTimer;
+    private reassembler;
+    private lastArrivalTs;
+    private jitterEwmaMs;
+    private lastStats;
+    private firstFrameResolve;
+    private firstFrameReject;
+    constructor(offer: NonNullable<TransportOfferResponse['webtransport']>, sessionId: string, canvas: HTMLCanvasElement);
+    
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    onDead(cb: (reason: string) => void): void;
+    stats(): {
+        recvBps: number;
+        lossPct: number;
+        jitterMs: number;
+    };
+    private initDecoder;
+    private datagramLoop;
+    private decodeFrame;
+    private sendControl;
+    private readControl;
+    private controlLoop;
+    
+    private feedbackLoop;
+    private die;
+}
+
+interface ConsumingTransport {
+    getTrackByName(name: string): MediaStreamTrack | undefined;
+    on(event: 'track', handler: (track: MediaStreamTrack) => void): () => void;
+    on(event: 'stateChange', handler: (state: TransportState) => void): () => void;
+}
+declare class WebRtcSession implements MediaSession {
+    private transport;
+    private streamName;
+    readonly kind: "webrtc";
+    private deadCb;
+    private deadFired;
+    private unsubscribers;
+    constructor(transport: ConsumingTransport, streamName?: string);
+    
+    start(): Promise<void>;
+    
+    stop(): Promise<void>;
+    onDead(cb: (reason: string) => void): void;
+    stats(): {
+        recvBps: number;
+        lossPct: number;
+        jitterMs: number;
+    };
+    private die;
+}
+
+interface ReassembledFrame {
+    seq: number;
+    groupId: number;
+    keyframe: boolean;
+    data: Uint8Array;
+}
+interface ReassemblerCallbacks {
+    
+    onFrame(frame: ReassembledFrame): void;
+    
+    onKeyframeNeeded(): void;
+}
+interface ReassemblerOptions {
+    
+    now?: () => number;
+    
+    keyframeRequestDebounceMs?: number;
+}
+declare class FrameReassembler {
+    private cb;
+    private pending;
+    private newestGroupSeen;
+    private newestFrameDelivered;
+    private needKeyframe;
+    private kfRequestedAt;
+    private now;
+    private debounceMs;
+    private bytesInWindow;
+    private framesDelivered;
+    private framesAbandoned;
+    constructor(cb: ReassemblerCallbacks, opts?: ReassemblerOptions);
+    
+    push(chunk: Uint8Array): void;
+    
+    drainWindow(): {
+        bytes: number;
+        delivered: number;
+        abandoned: number;
+    };
+    private deliver;
+    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 };