@urun-sh/core 0.2.60 → 0.3.1

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { g as AppOptions, f as App$1, a2 as SessionPhase, a8 as SessionStatus, a4 as SessionPhaseName, A as AccessTokenOptions, Q as RuntimeArtifact, S as RuntimeArtifactDownload, R as Recording, Y as Session$1, C as ChannelEndpoint, af as TransportSession, h as AttachOptions, Z as SessionDiagnostic, b as ActivationEvent, a7 as SessionStatsSample, J as RecordingsAccessor, T as RuntimeArtifactsAccessor, a0 as SessionEndResult, a9 as SessionStream$1, ae as StreamDataTransport, $ as SessionDocumentImpl, ad as StreamChunkOptions, m as ChunkReadable, P as Presence, t as DocConnector, u as DocTokenSupplier, N as RequestOptions, O as RequestStreamOptions, ac as StoreOptions, ab as Store, k as ChannelMultiplexer, a1 as SessionFailureKind, ah as TransportState } from './stream-data-B5wxsIPL.mjs';
-export { c as ActivationState, i as AudioPlayoutOptions, D as DERIVED_LEG_SEP, q as DerivedLegRole, s as DocConnectionState, I as InboundStatsSample, M as MediaChunkBinding, v as MediaChunkSource, w as MediaChunkSourceFactory, x as MediaRecorderChunkSourceOptions, y as PresenceState, z as PrewakeOptions, B as PrewakeResult, E as PrewakeStatus, F as RecordingBucket, G as RecordingLifecycle, H as RecordingStatus, K as ReleaseSessionBeaconOptions, U as RuntimeAvailability, V as RuntimeWakeDetail, W as RuntimeWakeGolden, X as RuntimeWakeReasonCode, _ as SessionDocument, a3 as SessionPhaseError, a6 as SessionStatsOptions, aa as SessionText, ai as VideoPlayoutOptions, an as derivedLegName, ao as derivedLegRole, ap as isPendingRecording, aq as mediaRecorderChunkSource, ar as prewake, as as releaseSessionBeacon } from './stream-data-B5wxsIPL.mjs';
+import { g as AppOptions, f as App$1, ae as SessionPhase, ak as SessionStatus, ag as SessionPhaseName, A as AccessTokenOptions, $ as RuntimeArtifact, a0 as RuntimeArtifactDownload, T as Recording, aA as TransportState, a8 as Session$1, C as ChannelEndpoint, ax as TransportSession, h as AttachOptions, a9 as SessionDiagnostic, b as ActivationEvent, aj as SessionStatsSample, z as GenerationTick, X as RecordingsAccessor, a1 as RuntimeArtifactsAccessor, ac as SessionEndResult, al as SessionStream$1, as as StreamDataTransport, ab as SessionDocumentImpl, ar as StreamChunkOptions, m as ChunkReadable, P as Presence, v as DocConnector, x as DocTokenSupplier, w as DocServerUrlResolver, Z as RequestOptions, _ as RequestStreamOptions, aq as StoreOptions, ap as Store, k as ChannelMultiplexer, ad as SessionFailureKind, H as MediaSession, aw as TransportOfferResponse, aF as WtAudioLaneSeam, aG as WtAudioUplinkSeam, aN as WtVideoUplinkSeam, aM as WtDataUplinkSender, aK as WtDataLaneSink } from './stream-data-BJoG7tYI.mjs';
+export { c as ActivationState, i as AudioPlayoutOptions, D as DERIVED_LEG_SEP, n as DGRAM_HEADER_BYTES, r as DerivedLegRole, s as DgramHeader, u as DocConnectionState, G as GENERATION_TICK_EMIT_INTERVAL_MS, y as GENERATION_TICK_MAX_EXTRAPOLATION_MS, I as InboundStatsSample, M as MediaChunkBinding, B as MediaChunkSource, E as MediaChunkSourceFactory, F as MediaRecorderChunkSourceOptions, N as NegotiatorDataLaneSeam, J as NegotiatorOptions, K as PresenceState, O as PrewakeOptions, Q as PrewakeResult, R as PrewakeStatus, S as QuicStreamDataTransport, U as RecordingBucket, V as RecordingLifecycle, W as RecordingStatus, Y as ReleaseSessionBeaconOptions, a2 as RuntimeAvailability, a3 as RuntimeWakeDetail, a4 as RuntimeWakeGolden, a5 as RuntimeWakeReasonCode, a6 as SIGNALING_PROTOCOL_VERSION, a7 as STREAM_END, aa as SessionDocument, af as SessionPhaseError, ai as SessionStatsOptions, am as SessionText, an as SignalCarrier, ao as Signaling, at as TransportEstablishedNotify, au as TransportNegotiator, av as TransportOfferRequest, az as TransportSessionSignaling, aB as VideoPlayoutOptions, aC as WT_CONTROL_FRAME_MAX, aD as WT_DATA_STREAM_VERSION, aE as WatchGenerationTickOptions, aH as WtControlDecoder, aI as WtControlMessage, aJ as WtDataEnvelope, aL as WtDataStreamParser, aP as consumeWtDataStreams, aS as decodeStreamEnvelope, aU as derivedLegName, aV as derivedLegRole, aW as encodeStreamEnvelope, aX as encodeWtControlFrame, aY as isPendingRecording, aZ as mediaRecorderChunkSource, a_ as parseDgramHeader, a$ as prewake, b0 as releaseSessionBeacon, b3 as watchGenerationTick, b4 as writeDgramHeader } from './stream-data-BJoG7tYI.mjs';
 import 'yjs';
 import 'y-protocols/awareness';
 
@@ -47,6 +47,8 @@ declare function createClientToken(apiKey: string, options?: CreateClientTokenOp
 
 declare function isWakingPhase(phase: SessionPhase | SessionPhaseName | null | undefined): boolean;
 
+declare function isServerTerminalPhase(phase: SessionPhase | null | undefined): boolean;
+
 interface PhaseObservable {
     
     readonly phase: SessionPhase;
@@ -193,6 +195,100 @@ declare class RecordingsClient {
 
 declare function createRecordingsClient(options: RecordingsClientOptions): RecordingsClient;
 
+declare const USER_ACTIVITY_FIELD = "user_activity";
+
+declare const FOCUS_FIELD = "focus";
+
+declare const USER_ACTIVITY_MIN_INTERVAL_MS = 30000;
+
+type PresenceConnectivityState = 'idle' | 'connecting' | 'ready' | 'transient_failure';
+type PresenceVisibility = 'visible' | 'hidden';
+type PresenceFocus = 'focused' | 'unfocused';
+
+type PresenceInteractionKind = 'typing' | 'pointer' | 'tty';
+
+interface UserActivityPayload {
+    at: number;
+    counts: {
+        typing: number;
+        pointer: number;
+        tty: number;
+        consumer_reads: number;
+    };
+    inflight: number;
+    visibility?: PresenceVisibility;
+    focus?: PresenceFocus;
+}
+
+interface PresenceAwarenessSink {
+    setLocalStateField(field: string, value: unknown): void;
+}
+
+interface PresenceTransportLike {
+    on(event: 'stateChange', handler: (state: TransportState) => void): () => void;
+    readonly state: TransportState;
+}
+interface PresenceTrackerOptions {
+    
+    awareness?: PresenceAwarenessSink;
+    
+    now?: () => number;
+    
+    windowTarget?: Pick<Window, 'addEventListener' | 'removeEventListener'> | null;
+    documentTarget?: (Pick<Document, 'addEventListener' | 'removeEventListener'> & {
+        hasFocus?: () => boolean;
+    }) | null;
+}
+declare class PresenceTracker {
+    private readonly _awareness;
+    private readonly _now;
+    private readonly _win;
+    private _state;
+    private readonly _stateHandlers;
+    private readonly _transportUnsubs;
+    private _disposed;
+    private readonly _counts;
+    private _inflight;
+    private _visibility;
+    private _focus;
+    private _lastSignalAt;
+    private _lastPublishedAt;
+    private _trailing;
+    private _onWindowFocus;
+    private _onWindowBlur;
+    constructor(options?: PresenceTrackerOptions);
+    
+    get state(): PresenceConnectivityState;
+    
+    onState(handler: (state: PresenceConnectivityState) => void): () => void;
+    
+    transportConnecting(): void;
+    
+    transportReady(): void;
+    
+    transportClosed(): void;
+    
+    attachTransport(transport: PresenceTransportLike): () => void;
+    private _setState;
+    
+    interaction(kind: PresenceInteractionKind, count?: number): void;
+    
+    consumerRead(count?: number): void;
+    
+    get inflight(): number;
+    
+    workBegin(): () => void;
+    
+    setVisibility(visibility: PresenceVisibility): void;
+    
+    setFocus(focus: PresenceFocus): void;
+    
+    private _signal;
+    private _publishNow;
+    
+    dispose(): void;
+}
+
 declare const DEFAULT_DOC_SYNC_TIMEOUT_MS = 30000;
 declare class SessionStream implements SessionStream$1 {
     private _name;
@@ -276,6 +372,8 @@ declare class Session implements Session$1 {
     
     private _activity;
     
+    private _presenceTracker;
+    
     private _activation;
     
     private _activeRequests;
@@ -299,6 +397,9 @@ declare class Session implements Session$1 {
     private _dialNegotiation;
     
     private _dialNegotiationStarted;
+    
+    private _generationTickHandlers;
+    private _generationTickStop;
     constructor(sessionId: string, multiplexer: ChannelEndpoint, transport: TransportSession, recordingsAuth?: RecordingsClientOptions, artifactsAuth?: RuntimeArtifactsClientOptions);
     private _wireControlDocIncarnation;
     
@@ -321,6 +422,8 @@ declare class Session implements Session$1 {
     
     whenLive(options?: WhenLiveOptions): Promise<void>;
     
+    on(event: 'generationTick', handler: (tick: GenerationTick) => void): () => void;
+    
     get recordings(): RecordingsAccessor;
     get artifacts(): RuntimeArtifactsAccessor;
     setArtifactsAuth(auth: RuntimeArtifactsClientOptions): void;
@@ -336,12 +439,15 @@ declare class Session implements Session$1 {
     
     touch(): void;
     
+    get presenceTracker(): PresenceTracker | null;
+    
     connectDocs(connector: DocConnector): void;
     
     setDocTransport(opts: {
         wsUrl: string;
         token?: string | DocTokenSupplier;
         webSocket?: typeof WebSocket;
+        resolveServerUrl?: DocServerUrlResolver;
     }): void;
     
     useStreamDataTransport(transport: StreamDataTransport): void;
@@ -366,6 +472,7 @@ declare class Session implements Session$1 {
     
     negotiateMediaTransport(opts?: {
         allowWebTransport?: boolean;
+        allowWebRtcFallback?: boolean;
     }): void;
     
     get mediaTransport(): 'webtransport' | 'webrtc' | null;
@@ -569,12 +676,105 @@ declare class TransportSessionMismatchError extends Error {
 declare class SessionAllocationError extends Error {
     
     readonly httpStatus?: number;
+    
+    readonly code?: string;
+    
+    readonly balanceCredits?: number;
+    
+    readonly platformStatus?: string;
     constructor(message: string, options?: {
         httpStatus?: number;
+        code?: string;
+        balanceCredits?: number;
+        platformStatus?: string;
         cause?: unknown;
     });
 }
 
+interface CreditsClientOptions {
+    
+    functionsUrl: string;
+    
+    orgId: string;
+    
+    apiKey?: string;
+    
+    jwt?: string;
+    
+    getAccessToken?: (options?: AccessTokenOptions) => string | null | undefined | Promise<string | null | undefined>;
+    
+    authProvider?: string;
+}
+
+interface CreditBalance {
+    org_id: string;
+    
+    balance_credits: number;
+    
+    available_credits: number;
+    free_credits: number;
+    subscription_credits: number;
+    purchased_credits: number;
+    overage_credits: number;
+    
+    activated: boolean;
+    
+    exempt: boolean;
+    updated_at: string;
+}
+
+interface CreditLedgerEntry {
+    id: string;
+    
+    delta_credits: number;
+    
+    reason: string;
+    note?: string;
+    
+    session_id?: string;
+    created_at: string;
+}
+
+interface CreditsLedgerOptions {
+    
+    limit?: number;
+}
+
+declare class CreditsError extends Error {
+    
+    readonly status: number;
+    
+    readonly code: string;
+    constructor(message: string, options: {
+        status: number;
+        code: string;
+        cause?: unknown;
+    });
+}
+
+declare class CreditsUnauthorizedError extends CreditsError {
+    constructor(message?: string, code?: string);
+}
+
+declare class CreditsClient {
+    private readonly _options;
+    private readonly _base;
+    constructor(_options: CreditsClientOptions);
+    
+    getBalance(): Promise<CreditBalance>;
+    
+    getLedger(options?: CreditsLedgerOptions): Promise<CreditLedgerEntry[]>;
+    
+    private _request;
+    private _buildUrl;
+    private _fetch;
+    private _resolveToken;
+    private _readJson;
+    private _readError;
+}
+
+declare function createCreditsClient(options: CreditsClientOptions): CreditsClient;
+
 type CaptureKind = 'audio' | 'video';
 type GetUserMedia = (constraints: MediaStreamConstraints) => Promise<MediaStream>;
 
@@ -792,233 +992,18 @@ interface CameraWarp {
 }
 declare function createCameraWarp(options?: CameraWarpOptions): CameraWarp;
 
-declare const WT_DATA_STREAM_VERSION = 1;
-
-interface WtDataEnvelope {
-    name: string;
-    payload: unknown;
-}
-
-interface WtDataLaneSink {
-    onData(name: string, payload: unknown): void;
-    onLaneError(err: Error): void;
-}
-
-interface QuicStreamDataTransport {
-    
-    markStreamDataLaneQuic(): void;
-    
-    dispatchQuicStreamData(name: string, payload: unknown): void;
-    
-    quicStreamDataLaneLost(reason: string): void;
-    
-    raiseQuicStreamDataError(err: Error): void;
-}
-
-declare class WtDataStreamParser {
-    private buf;
-    private name;
-    private ended;
-    
-    get streamName(): string | null;
-    push(chunk: Uint8Array): WtDataEnvelope[];
-    
-    finish(): void;
-}
-
-interface WtByteReader {
-    read(): Promise<{
-        value?: Uint8Array;
-        done: boolean;
-    }>;
-    cancel?(reason?: unknown): Promise<void>;
-}
-interface WtIncomingUniStream {
-    getReader(): WtByteReader;
-}
-interface WtIncomingUniStreams {
-    getReader(): {
-        read(): Promise<{
-            value?: WtIncomingUniStream;
-            done: boolean;
-        }>;
-    };
-}
-
-declare function consumeWtDataStreams(incoming: WtIncomingUniStreams, sink: WtDataLaneSink): Promise<void>;
-
-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;
-    };
-    
-    readonly firstMedia: Promise<void>;
-    
-    consumeDataStreams?(sink: WtDataLaneSink): void;
-}
-
-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[];
-        
-        wtData?: boolean;
-    };
-}
-interface TransportOfferResponse {
-    
-    webrtc: {
-        routerRtpCapabilities: unknown;
-    };
-    
-    webtransport?: {
-        url: string;
-        
-        certHashes: string[];
-        
-        token: string;
-        codec: string;
-        
-        data?: boolean;
-    };
-}
-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 NegotiatorDataLaneSeam {
-    
-    onData(name: string, payload: unknown): void;
-    
-    onQuicLane(): void;
-    
-    onQuicLaneLost(reason: string): void;
-    
-    onLaneError(err: Error): void;
-}
-interface NegotiatorOptions {
-    
-    quicDeadlineMs?: number;
-    
-    allowWebTransport?: boolean;
-    onTransportChange?: (kind: MediaSession['kind'], reason?: string) => void;
-    
-    canvas?: HTMLCanvasElement;
-    
-    createWebRtcSession: () => MediaSession;
-    createWebTransportSession?: (offer: NonNullable<TransportOfferResponse['webtransport']>) => MediaSession;
-    
-    dataLane?: NegotiatorDataLaneSeam;
-}
-declare class TransportNegotiator {
-    private signaling;
-    private sessionId;
-    private opts;
-    private session;
+declare class WebTransportSession implements MediaSession {
     private offer;
+    private sessionId;
+    private canvas;
     
-    private quicDataLane;
-    constructor(signaling: Signaling, sessionId: string, opts: NegotiatorOptions);
-    get activeTransport(): MediaSession['kind'] | null;
-    connect(): Promise<MediaSession>;
-    disconnect(): Promise<void>;
+    private audioLane?;
     
-    retryWebTransport(): Promise<MediaSession | null>;
+    private audioUplink?;
     
-    private engageQuicDataLane;
-    private createWebTransportSession;
-    private startWebRtc;
+    private videoUplink?;
     
-    private armFailover;
-    private notifyEstablished;
-}
-
-declare class WebTransportSession implements MediaSession {
-    private offer;
-    private sessionId;
-    private canvas;
+    private dataUplink?;
     readonly kind: "webtransport";
     private wt;
     private decoder;
@@ -1037,17 +1022,40 @@ declare class WebTransportSession implements MediaSession {
     private lastStats;
     
     private dataLaneSink;
+    
+    private audioPlayout;
+    
+    private audioUplinkLane;
+    
+    private videoUplinkLane;
+    
+    private dataUplinkSender;
     private firstFrameResolve;
     private firstFrameReject;
     
     private firstFrameOutput;
+    
+    private hasVideoLane;
     private firstDecodeTimer;
     
     readonly firstMedia: Promise<void>;
-    constructor(offer: NonNullable<TransportOfferResponse['webtransport']>, sessionId: string, canvas: HTMLCanvasElement);
+    constructor(offer: NonNullable<TransportOfferResponse['webtransport']>, sessionId: string, canvas: HTMLCanvasElement, 
+    
+    audioLane?: WtAudioLaneSeam | undefined, 
+    
+    audioUplink?: WtAudioUplinkSeam | undefined, 
+    
+    videoUplink?: WtVideoUplinkSeam | undefined, 
+    
+    dataUplink?: {
+        onUplink(sender: WtDataUplinkSender): void;
+        onUplinkLost(reason: string): void;
+    } | undefined);
     
     start(): Promise<void>;
     stop(): Promise<void>;
+    
+    private dropUplinks;
     onDead(cb: (reason: string) => void): void;
     stats(): {
         recvBps: number;
@@ -1146,4 +1154,4 @@ declare class FrameReassembler {
     private requestKeyframe;
 }
 
-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 CameraWarp, type CameraWarpOptions, type CameraWarpTransform, type CaptureClaim, CaptureController, type CaptureControllerOptions, type CaptureKind, CaptureUnavailableError, ChunkReadable, type ClientToken, ClientTokenError, type ConsumingTransport, type CreateClientTokenOptions, DATA_CHANNEL_MESSAGE_CEILING, DEFAULT_DOC_SYNC_TIMEOUT_MS, DEFAULT_GATEWAY_URL, DEFAULT_PRODUCE_ACK_TIMEOUT_MS, DEFAULT_REFERENCE_JPEG_QUALITY, DEFAULT_REFERENCE_MAX_SIZE, DEFAULT_WHEN_LIVE_TIMEOUT_MS, DGRAM_HEADER_BYTES, type DgramHeader, DocTokenSupplier, FOREGROUND_COALESCE_MS, FrameReassembler, INPUT_PRESENCE_DEFAULT_HZ, INPUT_PRESENCE_FIELD, type InputPresenceAwareness, type InputPresencePublisher, type InputPresencePublisherOptions, type InputPresenceState, InvalidDurationError, LEGACY_ACTIVATION_HINT_PATH, type MediaSession, type NegotiatorDataLaneSeam, type NegotiatorOptions, type NormalizeReferenceImageOptions, PLATFORM_DOC_NAME, PermanentLockedError, type PhaseObservable, PinRequiresActiveTempError, Presence, ProduceAckTimeoutError, type QuicStreamDataTransport, type ReassembledFrame, type ReassemblerCallbacks, type ReassemblerOptions, Recording, RecordingNotFoundError, RecordingsAccessor, RecordingsClient, type RecordingsClientOptions, RecordingsError, RecordingsUnauthorizedError, type ReferenceImage, type ReferenceImageSource, type ReferenceImageType, RequestAbortError, RequestCancelledError, RequestDocSyncError, RequestError, RequestOptions, RequestStreamOptions, RequestTimeoutError, RetainNotTempError, type RetentionIntent, RuntimeArtifact, RuntimeArtifactDownload, RuntimeArtifactNotFoundError, RuntimeArtifactsAccessor, RuntimeArtifactsClient, type RuntimeArtifactsClientOptions, RuntimeArtifactsError, RuntimeArtifactsUnauthorizedError, Session, SessionAllocationError, SessionDiagnostic, SessionEndError, SessionEndResult, SessionEndUnavailableError, SessionFailedError, SessionFailureKind, Session$1 as SessionInterface, SessionPhase, SessionPhaseName, SessionStatsSample, SessionStatus, SessionStream$1 as SessionStream, type SignalCarrier, type Signaling, Store, StoreOptions, StreamChunkOptions, StreamDirectionConflict, type TransportEstablishedNotify, TransportNegotiator, type TransportOfferRequest, type TransportOfferResponse, TransportSessionMismatchError, TransportSessionSignaling, TransportState, URUN_DEV_ENV, VISIBILITY_FIELD, type VideoStreamOptions, WIRE_MESSAGE_BUDGET, WT_CONTROL_FRAME_MAX, WT_DATA_STREAM_VERSION, WebRtcSession, WebTransportSession, type WhenLiveOptions, WtControlDecoder, type WtControlMessage, type WtDataEnvelope, type WtDataLaneSink, WtDataStreamParser, activationHintFrom, cameraCaptureAvailable, captureStillFromVideo, computeBackoffDelay, consumeWtDataStreams, createActivityTracker, createCameraWarp, createClientToken, createInputPresencePublisher, createRecordingsClient, createRuntimeArtifactsClient, createStore, describeSessionFailure, describeSessionPhase, encodeWtControlFrame, fitWithin, isDurationString, isRetryableSessionError, isWakingPhase, normalizeReferenceImage, normalizeRetention, observeLeaveConfirm, observePageLifecycle, observePageTeardown, parseDgramHeader, referenceImageErrorMessage, 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 CameraWarp, type CameraWarpOptions, type CameraWarpTransform, type CaptureClaim, CaptureController, type CaptureControllerOptions, type CaptureKind, CaptureUnavailableError, ChunkReadable, type ClientToken, ClientTokenError, type ConsumingTransport, type CreateClientTokenOptions, type CreditBalance, type CreditLedgerEntry, CreditsClient, type CreditsClientOptions, CreditsError, type CreditsLedgerOptions, CreditsUnauthorizedError, DATA_CHANNEL_MESSAGE_CEILING, DEFAULT_DOC_SYNC_TIMEOUT_MS, DEFAULT_GATEWAY_URL, DEFAULT_PRODUCE_ACK_TIMEOUT_MS, DEFAULT_REFERENCE_JPEG_QUALITY, DEFAULT_REFERENCE_MAX_SIZE, DEFAULT_WHEN_LIVE_TIMEOUT_MS, DocTokenSupplier, FOCUS_FIELD, FOREGROUND_COALESCE_MS, FrameReassembler, GenerationTick, INPUT_PRESENCE_DEFAULT_HZ, INPUT_PRESENCE_FIELD, type InputPresenceAwareness, type InputPresencePublisher, type InputPresencePublisherOptions, type InputPresenceState, InvalidDurationError, LEGACY_ACTIVATION_HINT_PATH, MediaSession, type NormalizeReferenceImageOptions, PLATFORM_DOC_NAME, PermanentLockedError, type PhaseObservable, PinRequiresActiveTempError, Presence, type PresenceAwarenessSink, type PresenceConnectivityState, type PresenceFocus, type PresenceInteractionKind, PresenceTracker, type PresenceTrackerOptions, type PresenceTransportLike, type PresenceVisibility, ProduceAckTimeoutError, type ReassembledFrame, type ReassemblerCallbacks, type ReassemblerOptions, Recording, RecordingNotFoundError, RecordingsAccessor, RecordingsClient, type RecordingsClientOptions, RecordingsError, RecordingsUnauthorizedError, type ReferenceImage, type ReferenceImageSource, type ReferenceImageType, RequestAbortError, RequestCancelledError, RequestDocSyncError, RequestError, RequestOptions, RequestStreamOptions, RequestTimeoutError, RetainNotTempError, type RetentionIntent, RuntimeArtifact, RuntimeArtifactDownload, RuntimeArtifactNotFoundError, RuntimeArtifactsAccessor, RuntimeArtifactsClient, type RuntimeArtifactsClientOptions, RuntimeArtifactsError, RuntimeArtifactsUnauthorizedError, Session, SessionAllocationError, SessionDiagnostic, SessionEndError, SessionEndResult, SessionEndUnavailableError, SessionFailedError, SessionFailureKind, Session$1 as SessionInterface, SessionPhase, SessionPhaseName, SessionStatsSample, SessionStatus, SessionStream$1 as SessionStream, Store, StoreOptions, StreamChunkOptions, StreamDirectionConflict, TransportOfferResponse, TransportSessionMismatchError, TransportState, URUN_DEV_ENV, USER_ACTIVITY_FIELD, USER_ACTIVITY_MIN_INTERVAL_MS, type UserActivityPayload, VISIBILITY_FIELD, type VideoStreamOptions, WIRE_MESSAGE_BUDGET, WebRtcSession, WebTransportSession, type WhenLiveOptions, WtDataLaneSink, activationHintFrom, cameraCaptureAvailable, captureStillFromVideo, computeBackoffDelay, createActivityTracker, createCameraWarp, createClientToken, createCreditsClient, createInputPresencePublisher, createRecordingsClient, createRuntimeArtifactsClient, createStore, describeSessionFailure, describeSessionPhase, fitWithin, isDurationString, isRetryableSessionError, isServerTerminalPhase, isWakingPhase, normalizeReferenceImage, normalizeRetention, observeLeaveConfirm, observePageLifecycle, observePageTeardown, referenceImageErrorMessage, sessionFailureFromMediaError, sharedCaptureController, videoStream, whenLive };