@urun-sh/core 0.5.6 → 0.6.1

package/dist/stream-data-DWvEgRbF.d.ts

@@ -0,0 +1,1746 @@
+import * as Y from 'yjs';
+import { Awareness } from 'y-protocols/awareness';
+
+interface MediaChunkSource {
+    
+    start(onChunk: (chunk: Uint8Array) => void, onEnd: () => void): void;
+    
+    stop(): void;
+}
+
+interface MediaChunkBinding {
+    
+    track(): MediaStreamTrack | null;
+    
+    onTrack(cb: (track: MediaStreamTrack | null) => void): () => void;
+}
+
+type MediaChunkSourceFactory = (binding: MediaChunkBinding) => MediaChunkSource;
+
+type ChunkReadable = ReadableStream<Uint8Array> & AsyncIterable<Uint8Array>;
+
+interface StreamChunkOptions {
+    
+    source?: MediaChunkSourceFactory;
+}
+
+interface MediaRecorderChunkSourceOptions {
+    
+    mimeType?: string;
+    
+    timesliceMs?: number;
+}
+
+declare function mediaRecorderChunkSource(binding: MediaChunkBinding, options?: MediaRecorderChunkSourceOptions): MediaChunkSource;
+
+interface GenerationTick {
+    
+    seconds: number;
+    
+    estimatedCredits?: number;
+}
+
+declare const GENERATION_TICK_EMIT_INTERVAL_MS = 1000;
+
+declare const GENERATION_TICK_MAX_EXTRAPOLATION_MS = 12000;
+interface WatchGenerationTickOptions {
+    
+    creditsPerSecond?: number;
+}
+
+declare function watchGenerationTick(control: Pick<SessionDocument, 'get' | 'on'>, handler: (tick: GenerationTick) => void, options?: WatchGenerationTickOptions): () => void;
+
+declare const DOC_SYNC_WIRE_CONTRACT_VERSION = 1;
+
+interface DocConnectionState {
+    
+    connected: boolean;
+    
+    consecutiveFailures: number;
+    
+    lastCloseCode: number | null;
+    
+    lastCloseReason: string | null;
+}
+
+type DocTokenSupplier = () => string | undefined | Promise<string | undefined>;
+
+type DocServerUrlResolver = () => string | undefined | Promise<string | undefined>;
+
+interface DocConnection {
+    
+    readonly awareness: Awareness;
+    
+    readonly synced: boolean;
+    
+    onSync(handler: (synced: boolean) => void): () => void;
+    
+    ensureConnected?(): void;
+    
+    onConnectionState?(handler: (state: DocConnectionState) => void): () => void;
+    
+    disconnect?(): void;
+    
+    destroy(): void;
+}
+
+type DocConnector = (docName: string, doc: Y.Doc, awareness: Awareness) => DocConnection;
+
+declare function deriveYjsServerUrl(signalingWsUrl: string): string;
+
+interface WebsocketDocConnectorOptions {
+    
+    serverUrl: string;
+    
+    sessionId: string;
+    
+    token?: string | DocTokenSupplier;
+    
+    WebSocketPolyfill?: typeof WebSocket;
+    
+    maxBackoffTimeMs?: number;
+    
+    dialTimeoutMs?: number;
+    
+    resolveServerUrl?: DocServerUrlResolver;
+}
+
+declare function createWebsocketDocConnector(opts: WebsocketDocConnectorOptions): DocConnector;
+
+declare class DeferredDocConnector {
+    private _target;
+    
+    private _bridges;
+    
+    readonly connect: DocConnector;
+    
+    get connected(): boolean;
+    
+    setTarget(target: DocConnector): void;
+}
+
+type PresenceState = Record<string, unknown>;
+
+interface Presence {
+    
+    readonly clientId: number;
+    
+    set(state: PresenceState | null): void;
+    
+    setField(field: string, value: unknown): void;
+    
+    getLocal(): PresenceState | null;
+    
+    getStates(): Map<number, PresenceState>;
+    
+    on(event: 'change', handler: (states: Map<number, PresenceState>) => void): () => void;
+}
+
+declare function createPresence(awareness: Awareness): Presence;
+
+type TransportState = 'connecting' | 'connected' | 'reconnecting' | 'renegotiating' | 'disconnected' | 'failed';
+
+type SessionPhaseName = 'idle' | 'queued' | 'unavailable' | 'provisioning' | 'waiting_for_capacity' | 'connecting' | 'live' | 'paused' | 'error' | 'unknown';
+
+interface RuntimeAvailability {
+    state: 'unavailable' | 'starting' | 'busy';
+    
+    reason?: string;
+    
+    wake?: RuntimeWakeDetail;
+}
+
+type RuntimeWakeReasonCode = 'capture-attested' | 'no-portable-golden' | 'portable-golden-release-mismatch' | 'portable-golden-attestation-invalid';
+
+interface RuntimeWakeGolden {
+    snapshotId: string;
+    snapshotCompatKey: string;
+    artifactSizeBytes: number;
+    durableArenaBytes: number;
+    volatileArenaBytes: 0;
+    uncoveredWeightBytes: number;
+}
+interface RuntimeWakeDetailBase {
+    schema: 'urun.runtime.wake.v1';
+    expectationBasis: 'snapshot-registry';
+    restoreObservation: 'not-observed';
+}
+
+type RuntimeWakeDetail = (RuntimeWakeDetailBase & {
+    portability: 'portable';
+    expectedWakePath: 'portable-golden-restore';
+    reasonCode: 'capture-attested';
+    golden: RuntimeWakeGolden;
+}) | (RuntimeWakeDetailBase & {
+    portability: 'none';
+    expectedWakePath: 'cold-boot';
+    reasonCode: Exclude<RuntimeWakeReasonCode, 'capture-attested'>;
+    
+    golden?: never;
+});
+
+type SessionFailureKind = 'create-failed' | 'never-live' | 'transport-failed' | 'media-permission' | 'runtime-failed' | 'insufficient-credits' | 'produce-timeout';
+
+interface SessionPhaseError {
+    
+    reason: string;
+    
+    code?: string;
+    
+    kind?: SessionFailureKind;
+    
+    httpStatus?: number;
+    
+    retryAfterSeconds?: number;
+}
+
+interface SessionDiagnostic {
+    
+    level: 'debug' | 'info' | 'warning' | 'error';
+    
+    kind: string;
+    
+    message: string;
+    
+    detail?: Record<string, unknown>;
+}
+
+type ActivationState = 'activating' | 'still-activating' | 'cold-boot' | 'degraded' | 'first-media';
+
+interface ActivationEvent {
+    
+    state: ActivationState;
+    
+    elapsedMs: number;
+    
+    hint?: string;
+    
+    stream?: string;
+}
+
+interface SessionPhase {
+    
+    name: SessionPhaseName;
+    
+    queue?: {
+        position: number;
+        depth: number;
+    };
+    
+    runtime?: RuntimeAvailability;
+    
+    wakingSince?: number;
+    
+    requestId?: string;
+    
+    sessionId?: string;
+    
+    endsAt?: Date;
+    
+    error?: SessionPhaseError;
+    
+    reason?: string;
+    
+    region?: string | null;
+}
+
+interface SessionStatus {
+    
+    phase: SessionPhaseName;
+    
+    transportState: TransportState;
+    
+    sessionId?: string;
+    
+    requestId?: string;
+    
+    lastServerStatus?: string;
+    
+    elapsedMs?: number;
+    
+    queue?: {
+        position: number;
+        depth: number;
+    };
+    
+    runtime?: RuntimeAvailability;
+    
+    endsAt?: Date;
+    
+    wakingSince?: number;
+    
+    error?: SessionPhaseError;
+    
+    region?: string | null;
+}
+
+interface TransportSessionOptions {
+    
+    url: string;
+    
+    fallbackUrls?: readonly string[];
+    
+    orgId?: string;
+    
+    jwt?: string;
+    
+    authProvider?: string;
+    
+    sessionId?: string;
+    
+    iceServers?: RTCIceServer[];
+    
+    mediaLiveness?: MediaLivenessOptions;
+    
+    audioPlayout?: AudioPlayoutOptions;
+    
+    videoPlayout?: VideoPlayoutOptions;
+    
+    sessionStats?: SessionStatsOptions;
+    
+    diagnosticSink?: (diagnostic: SessionDiagnostic) => void;
+}
+
+interface AudioPlayoutOptions {
+    
+    jitterBufferTargetMs?: number;
+}
+
+interface VideoPlayoutOptions {
+    
+    jitterBufferTargetMs?: number;
+}
+
+interface SessionStatsOptions {
+    
+    pollMs?: number;
+}
+
+interface InboundStatsSample {
+    
+    consumerId: string;
+    
+    total: number;
+    framesDecoded: number | null;
+    
+    jitter: number | null;
+    packetsReceived: number | null;
+    packetsLost: number | null;
+    nackCount: number | null;
+    pliCount: number | null;
+    firCount: number | null;
+    keyFramesDecoded: number | null;
+    framesReceived: number | null;
+    framesDropped: number | null;
+    retransmittedPacketsReceived: number | null;
+    retransmittedBytesReceived: number | null;
+    jitterBufferDelay: number | null;
+    jitterBufferEmittedCount: number | null;
+    
+    estimatedPlayoutTimestamp: number | null;
+    jitterBufferTargetDelay: number | null;
+    jitterBufferMinimumDelay: number | null;
+    concealedSamples: number | null;
+    insertedSamplesForDeceleration: number | null;
+}
+
+interface SessionStatsSample {
+    
+    timestamp: number;
+    
+    stream: string | null;
+    
+    avSyncMs: number | null;
+    
+    audio: InboundStatsSample | null;
+    
+    video: InboundStatsSample | null;
+}
+
+interface MediaLivenessOptions {
+    
+    pollMs?: number;
+    
+    stallTimeoutMs?: number;
+}
+
+type ChannelName = 'scene_graph' | 'ui_components' | 'events' | 'agent_status' | 'control';
+
+interface ChannelMessage {
+    
+    channel: string;
+    
+    type: string;
+    
+    [key: string]: unknown;
+}
+
+interface StoreOptions {
+    
+    baseUrl: string;
+    
+    orgId: string;
+    
+    jwt?: string;
+    
+    authProvider?: string;
+    
+    apiKey?: string;
+}
+
+interface Store {
+    
+    get(key: string): Promise<unknown>;
+    
+    has(key: string): Promise<boolean>;
+    
+    on(name: string, handler: (data: unknown) => void): () => void;
+    
+    emit(name: string, data: unknown): void;
+}
+
+interface SessionText {
+    
+    append(text: string): void;
+    
+    toString(): string;
+    
+    readonly length: number;
+    
+    on(event: 'delta', handler: (inserted: string) => void): () => void;
+}
+
+interface SessionDocument {
+    
+    set(patch: Record<string, unknown>): void;
+    
+    get(path?: string, defaultValue?: unknown): unknown;
+    
+    on(event: 'change', handler: (snapshot: Record<string, unknown>) => void): () => void;
+    
+    text(field: string): SessionText;
+    
+    readonly synced: boolean;
+    
+    onSynced(handler: () => void): () => void;
+    
+    onConnectionState?(handler: (state: DocConnectionState) => void): () => void;
+    
+    disconnect?(): void;
+    
+    reconnect?(): void;
+}
+
+interface SessionStream {
+    
+    readonly track: MediaStreamTrack | null;
+    
+    attach(track: MediaStreamTrack): Promise<void>;
+    
+    attachVideo(track: MediaStreamTrack): Promise<void>;
+    
+    detach(): Promise<void>;
+    
+    detachVideo(): Promise<void>;
+    
+    seek(target: number | 'live'): Promise<void>;
+    
+    chunks(options?: StreamChunkOptions): ChunkReadable;
+    
+    onSeeked(handler: (target: number | 'live') => void): () => void;
+    
+    on(event: 'track', handler: (track: MediaStreamTrack | null) => void): () => void;
+    
+    messages(): AsyncIterable<unknown>;
+    
+    emit(payload: unknown, options?: {
+        to?: string;
+    }): Promise<void>;
+}
+
+interface RequestOptions {
+    
+    timeout?: number;
+    
+    signal?: AbortSignal;
+}
+
+interface RequestStreamOptions {
+    
+    signal?: AbortSignal;
+    
+    docSyncTimeout?: number;
+}
+
+type SessionEndResult = {
+    status: 'paused';
+    
+    sessionId: string;
+    
+    reason: string;
+} | {
+    status: 'canceled';
+    requestId: string;
+    platformStatus?: string;
+};
+
+interface Session {
+    
+    readonly id: string;
+    
+    readonly phase: SessionPhase;
+    
+    readonly endsAt: Date | null;
+    
+    readonly status: SessionStatus;
+    
+    readonly region?: string | null;
+    
+    stream(name: string): SessionStream;
+    
+    doc(key: string): SessionDocument;
+    
+    readonly mediaTransport: 'webtransport' | 'webrtc' | null;
+    
+    watchDownlinkStall(opts?: {
+        stallMs?: number;
+    }): () => void;
+    
+    readonly presence: Presence;
+    
+    touch(): void;
+    
+    activity?(): void;
+    
+    request(payload: unknown, options?: RequestOptions): Promise<unknown>;
+    
+    requestStream(payload: unknown, options?: RequestStreamOptions): AsyncIterable<string>;
+    
+    complete(payload: unknown, options?: RequestStreamOptions): Promise<unknown>;
+    
+    onPhase(handler: (phase: SessionPhase) => void): () => void;
+    
+    onDiagnostic(handler: (diagnostic: SessionDiagnostic) => void): () => void;
+    
+    onActivation?(handler: (event: ActivationEvent) => void): () => void;
+    
+    onStats?(handler: (sample: SessionStatsSample) => void): () => void;
+    
+    on(event: 'generationTick', handler: (tick: GenerationTick) => void): () => void;
+    
+    whenLive(options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    
+    readonly recordings: RecordingsAccessor;
+    
+    readonly artifacts: RuntimeArtifactsAccessor;
+    
+    recover(): void;
+    
+    onRecovery(hook: () => void): () => void;
+    
+    end(): Promise<SessionEndResult>;
+    
+    cancel(): Promise<SessionEndResult>;
+    
+    detach(): void;
+    
+    disconnect(): void;
+}
+
+type RecordingBucket = 'temp' | 'pinned';
+
+type RecordingLifecycle = 'temp' | 'pinned' | 'permanent';
+
+type RecordingStatus = 'active' | 'deleting' | 'deleted' | 'pending_pin' | 'pending_unpin' | 'pending_permanent' | 'pending_delete';
+
+interface Recording {
+    
+    id: string;
+    
+    org_id: string;
+    
+    session_id: string;
+    
+    stream_name: string;
+    
+    bucket: RecordingBucket;
+    
+    s3_key: string;
+    
+    init_key: string;
+    
+    manifest_key: string;
+    
+    expires_at: string | null;
+    
+    lifecycle: RecordingLifecycle;
+    
+    retention: string | null;
+    
+    size_bytes: number | null;
+    
+    duration_s: number | null;
+    
+    status: RecordingStatus;
+    
+    created_at: string;
+    
+    updated_at: string;
+}
+
+declare function isPendingRecording(recording: Pick<Recording, 'status'>): boolean;
+
+interface RecordingsAccessor {
+    
+    list(sessionId?: string): Promise<Recording[]>;
+    
+    get(id: string): Promise<Recording>;
+    
+    retain(id: string, duration: string): Promise<Recording>;
+    
+    pin(id: string): Promise<Recording>;
+    
+    unpin(id: string): Promise<Recording>;
+    
+    permanent(id: string): Promise<Recording>;
+    
+    delete(id: string): Promise<Recording>;
+}
+interface RuntimeArtifact {
+    artifactId: string;
+    kind: string;
+    filename: string;
+    contentType: string;
+    sizeBytes: number;
+    sha256: string;
+    status: string;
+    createdAt?: string;
+    expiresAt?: string;
+}
+interface RuntimeArtifactDownload {
+    artifact: RuntimeArtifact;
+    downloadUrl: string;
+}
+interface RuntimeArtifactsAccessor {
+    
+    list(sessionId?: string): Promise<RuntimeArtifact[]>;
+    
+    getDownloadUrl(artifactId: string, sessionId?: string): Promise<RuntimeArtifactDownload>;
+}
+
+interface AppOptions {
+    
+    baseUrl: string;
+    
+    fallbackUrls?: readonly string[];
+    
+    orgId: string;
+    
+    jwt?: string;
+    
+    getAccessToken?: (options?: AccessTokenOptions$1) => string | null | undefined | Promise<string | null | undefined>;
+    
+    authProvider?: string;
+    
+    diagnosticSink?: (diagnostic: SessionDiagnostic) => void;
+    
+    functionsUrl?: string;
+    
+    allowWebTransport?: boolean;
+    
+    allowWebRtcFallback?: boolean;
+    
+    releaseOnLeave?: boolean;
+    
+    sessionKey?: string;
+    
+    priority?: 'preempt';
+    
+    audioPlayout?: AudioPlayoutOptions;
+    
+    videoPlayout?: VideoPlayoutOptions;
+    
+    sessionStats?: SessionStatsOptions;
+}
+interface AccessTokenOptions$1 {
+    forceRefresh?: boolean;
+    reason?: 'initial' | 'unauthorized' | 'background';
+}
+
+interface AttachOptions {
+    
+    baseUrl: string;
+    
+    fallbackUrls?: readonly string[];
+    
+    orgId: string;
+    
+    jwt?: string;
+    
+    getAccessToken?: (options?: AccessTokenOptions$1) => string | null | undefined | Promise<string | null | undefined>;
+    
+    authProvider?: string;
+    
+    functionsUrl?: string;
+    
+    activity?: ActivitySignalMode;
+}
+
+type ActivitySignalMode = 'auto' | 'explicit';
+
+interface StartSessionOptions {
+    
+    sessionId?: string;
+    
+    label?: string;
+    
+    sharedApp?: boolean;
+    
+    activity?: ActivitySignalMode;
+}
+
+interface App {
+    [fnName: string]: (args?: Record<string, unknown>, options?: StartSessionOptions) => Session;
+}
+
+type SessionGatewayStatus = 'allocated' | 'pending' | 'queued' | 'rejected' | 'failed' | 'canceled'
+
+ | 'paused'
+
+ | 'redirect'
+
+ | 'waiting_for_capacity'
+
+ | (string & {});
+interface SessionGatewayResponse {
+    status?: SessionGatewayStatus;
+    
+    location?: string;
+    
+    session_api_base?: string;
+    
+    serving_region?: string | null;
+    request_id?: string;
+    session_id?: string;
+    ws_url?: string;
+    
+    ice_servers?: RTCIceServer[];
+    queued?: boolean;
+    retry_after_seconds?: number;
+    queue_position?: number;
+    queue_depth?: number;
+    
+    runtime_state?: string;
+    
+    runtime_reason?: string;
+    
+    reason?: string;
+    
+    decision_reason?: string;
+    
+    provisioning_refusal_source?: string;
+    
+    provisioning_refusal_message?: string;
+    
+    runtime_wake?: unknown;
+    
+    ends_at?: string;
+    error_code?: string;
+    error_message?: string;
+    
+    message?: string;
+    error?: string;
+    
+    balance_credits?: number;
+}
+
+interface AdmissionUpdate {
+    
+    status: string;
+    
+    requestId?: string;
+    
+    sessionId?: string;
+    
+    queue?: {
+        position: number;
+        depth: number;
+    };
+    
+    runtime?: RuntimeAvailability;
+    
+    reason?: string;
+    
+    decisionReason?: string;
+    
+    refusalSource?: string;
+    
+    refusalMessage?: string;
+    
+    region?: string | null;
+}
+interface AllocateSessionOptions {
+    baseUrl: string;
+    fallbackUrls?: readonly string[];
+    app: string;
+    functionName: string;
+    orgId: string;
+    jwt?: string;
+    getAccessToken?: (options?: AccessTokenOptions) => string | null | undefined | Promise<string | null | undefined>;
+    authProvider?: string;
+    idempotencyKey: string;
+    
+    onAdmission?: (update: AdmissionUpdate) => void;
+    
+    
+    onRequest?: (handle: {
+        requestId: string;
+        baseUrl: string;
+        sessionId?: string;
+    }) => void;
+    
+    sessionKey?: string;
+    
+    label?: string;
+    
+    priority?: 'preempt';
+    
+    sharedApp?: boolean;
+}
+interface AccessTokenOptions {
+    forceRefresh?: boolean;
+    reason?: 'initial' | 'unauthorized' | 'background';
+}
+interface AllocatedSession {
+    baseUrl: string;
+    sessionId: string;
+    wsUrl: string;
+    
+    endsAt: Date | null;
+    response: SessionGatewayResponse;
+}
+interface ReleaseSessionBeaconOptions {
+    baseUrl: string;
+    requestId: string;
+    
+    sessionId?: string;
+    orgId: string;
+    
+    jwt?: string;
+    authProvider?: string;
+    
+    reason?: string;
+}
+
+declare function releaseSessionBeacon(options: ReleaseSessionBeaconOptions): void;
+declare function allocateSession(options: AllocateSessionOptions): Promise<AllocatedSession>;
+
+interface SessionDirectoryRequestOptions {
+    baseUrl: string;
+    fallbackUrls?: readonly string[];
+    orgId: string;
+    jwt?: string;
+    getAccessToken?: AllocateSessionOptions['getAccessToken'];
+    authProvider?: string;
+}
+interface PrewakeOptions {
+    baseUrl: string;
+    
+    app: string;
+    
+    functionName: string;
+    orgId: string;
+    jwt?: string;
+    getAccessToken?: (options?: AccessTokenOptions) => string | null | undefined | Promise<string | null | undefined>;
+    authProvider?: string;
+}
+type PrewakeStatus = 'warming' | 'prebound' | 'unknown-app' | 'unavailable';
+interface PrewakeResult {
+    
+    status: PrewakeStatus;
+    
+    expiresAt?: string;
+    
+    warmCapable?: boolean;
+}
+
+declare function prewake(options: PrewakeOptions): Promise<PrewakeResult>;
+
+interface ChannelEndpoint {
+    on(channel: string, handler: (data: ChannelMessage) => void): () => void;
+    emit(channel: string, data: Record<string, unknown>): void;
+}
+declare class ChannelMultiplexer implements ChannelEndpoint {
+    private _handlers;
+    private _ws;
+    private _onMessage;
+    private _onOpen;
+    private _listeningForOpen;
+    private _pendingSends;
+    private _disposed;
+    constructor(ws: WebSocket);
+    
+    on(channel: string, handler: (data: ChannelMessage) => void): () => void;
+    
+    emit(channel: string, data: Record<string, unknown>): void;
+    
+    dispose(): void;
+    private flushPendingSends;
+    private listenForOpen;
+}
+declare class DeferredChannelMultiplexer implements ChannelEndpoint {
+    private _handlers;
+    private _pendingSends;
+    private _target;
+    private _targetUnsubscribes;
+    private _disposed;
+    setTarget(target: ChannelEndpoint): void;
+    rewriteSessionChannels(oldSessionId: string, newSessionId: string): void;
+    on(channel: string, handler: (data: ChannelMessage) => void): () => void;
+    emit(channel: string, data: Record<string, unknown>): void;
+    dispose(): void;
+    private detachTarget;
+}
+
+type WtMicSource = MediaStreamTrack | AudioNode;
+
+interface WtMicUplinkHandle {
+    setSource(source: WtMicSource | null): void;
+    
+    deliveredDatagrams(): number;
+}
+
+interface WtAudioUplinkSeam {
+    onUplink(handle: WtMicUplinkHandle): void;
+    onUplinkLost(reason: string): void;
+}
+
+interface WtCamUplinkHandle {
+    setSource(track: MediaStreamTrack | null): void;
+    
+    requestKeyframe(): void;
+    
+    deliveredDatagrams(): number;
+}
+
+interface WtVideoUplinkSeam {
+    onUplink(handle: WtCamUplinkHandle): void;
+    onUplinkLost(reason: string): void;
+}
+
+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 PathLiveness {
+    
+    alive: boolean;
+    
+    evidence: string;
+}
+
+interface PathHealthReporting {
+    
+    pathLiveness(): PathLiveness;
+    
+    fail(reason: string): 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;
+    
+    watchDownlinkStall?(opts: {
+        stallMs?: number;
+    }): 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>): boolean;
+    
+    onSignal(handler: (msg: Record<string, unknown>) => void): () => void;
+    
+    emitDiagnostic(diagnostic: SessionDiagnostic): 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;
+        
+        wtAudio?: boolean;
+        
+        wtAudioUp?: boolean;
+        
+        wtVideoUp?: boolean;
+        
+        wtDataUp?: boolean;
+    };
+}
+interface TransportOfferResponse {
+    
+    webrtc: {
+        routerRtpCapabilities: unknown;
+    };
+    
+    webtransport?: {
+        url: string;
+        
+        certHashes: string[];
+        
+        token: string;
+        
+        codec?: string;
+        
+        data?: boolean;
+        
+        audio?: {
+            codec: string;
+            sampleRate: number;
+            channels: number;
+        };
+        
+        audioUp?: boolean;
+        
+        videoUp?: boolean;
+        
+        dataUp?: 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;
+    
+    lane: number;
+}
+
+declare function parseDgramHeader(view: DataView): DgramHeader;
+
+declare function writeDgramHeader(h: Omit<DgramHeader, 'lane'> & {
+    lane?: number;
+}): Uint8Array;
+
+interface WtAudioLaneSeam {
+    
+    jitterBufferTargetMs?: number;
+    
+    onTrack: (track: MediaStreamTrack | null) => void;
+}
+
+interface WtDataUplinkTransport {
+    openUniStream(): Promise<{
+        write(chunk: Uint8Array): Promise<void>;
+        close(): Promise<void>;
+    }>;
+}
+
+declare class WtDataUplinkSender {
+    private transport;
+    private streams;
+    private dead;
+    private deadCb;
+    
+    private chain;
+    constructor(transport: WtDataUplinkTransport);
+    onDead(cb: (reason: string) => void): void;
+    
+    send(name: string, envelope: Uint8Array): Promise<void>;
+    stop(reason?: string): void;
+    private die;
+}
+
+interface WtDataUplinkSeam {
+    onUplink(sender: WtDataUplinkSender): void;
+    onUplinkLost(reason: string): void;
+}
+
+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;
+    
+    audioLane?: WtAudioLaneSeam;
+    
+    audioUplink?: WtAudioUplinkSeam;
+    
+    videoUplink?: WtVideoUplinkSeam;
+    
+    dataUplink?: WtDataUplinkSeam;
+    
+    webRtcDial?: {
+        proceed(reason: string): void;
+        skip(reason: string): void;
+    };
+    
+    allowWebRtcFallback?: boolean;
+    
+    onWtRequiredOutage?: (reason: string) => void;
+    
+    webRtcFailoverDeadlineMs?: number;
+    
+    onMediaTransportLost?: (reason: string) => void;
+}
+declare class TransportNegotiator {
+    private signaling;
+    private sessionId;
+    private opts;
+    private session;
+    private offer;
+    
+    private quicDataLane;
+    
+    private wtOnlyLeg;
+    
+    private webRtcDialProceeded;
+    static readonly WT_REDIAL_BASE_MS = 2000;
+    static readonly WT_REDIAL_MAX = 3;
+    static readonly WT_REDIAL_CAP_MS = 30000;
+    
+    private wtRedialFailures;
+    private wtRedialTimer;
+    
+    private disconnected;
+    
+    private downlinkStallWatch;
+    
+    watchDownlinkStall(opts?: {
+        stallMs?: number;
+    }): void;
+    private applyStallWatch;
+    constructor(signaling: Signaling, sessionId: string, opts: NegotiatorOptions);
+    get activeTransport(): MediaSession['kind'] | null;
+    
+    get isWtOnlyLeg(): boolean;
+    connect(): Promise<MediaSession>;
+    disconnect(): Promise<void>;
+    
+    retryWebTransport(): Promise<MediaSession | null>;
+    
+    private engageQuicDataLane;
+    private createWebTransportSession;
+    
+    private createWebRtc;
+    
+    private startWebRtcOn;
+    private startWebRtc;
+    
+    private skipWebRtcDial;
+    
+    private proceedWebRtcDial;
+    
+    private armFailover;
+    
+    private redialWtAfterDeath;
+    
+    private attemptWtRedial;
+    
+    private lateWebRtcFailover;
+    private notifyEstablished;
+}
+
+interface TransportConnection {
+    url: string;
+    sessionId: string;
+    jwt?: string;
+    
+    iceServers?: RTCIceServer[];
+    
+    endsAt?: Date | null;
+}
+declare function streamDataLabel(name: string): string;
+
+declare const DERIVED_LEG_SEP = "--";
+declare const DERIVED_LEG_ROLES: readonly ["video", "audio"];
+type DerivedLegRole = (typeof DERIVED_LEG_ROLES)[number];
+
+declare function derivedLegRole(name: string): DerivedLegRole | undefined;
+
+declare function derivedLegName(parent: string, role: DerivedLegRole): string;
+interface TransportEvents {
+    connected: () => void;
+    disconnected: () => void;
+    track: (track: MediaStreamTrack) => void;
+    error: (error: Error) => void;
+    started: () => void;
+    audioTransportReady: () => void;
+    
+    stateChange: (state: TransportState) => void;
+    
+    phase: (phase: SessionPhase) => void;
+    
+    diagnostic: (diagnostic: SessionDiagnostic) => void;
+    
+    stats: (sample: SessionStatsSample) => void;
+    
+    seeked: (stream: string, target: number | 'live') => void;
+    
+    signal: (msg: Record<string, unknown>) => void;
+}
+
+declare const SIGNALING_PROTOCOL_VERSION = "v1";
+interface SessionStartOptions {
+    app?: string;
+    functionName?: string;
+    prompt?: string;
+    cameraControl?: Record<string, unknown>;
+    args?: Record<string, unknown>;
+    video?: {
+        width?: number;
+        height?: number;
+        frameRate?: number;
+    };
+    
+    role?: 'viewer';
+}
+declare class TransportSession {
+    private _state;
+    private _sessionId;
+    private _tracks;
+    
+    private _tracksByName;
+    private _options;
+    private _emitter;
+    private _ws;
+    
+    private _connectedUrl;
+    private _device;
+    private _mediaUnavailableReason;
+    private _mediaVerdictResolve;
+    private _mediaVerdict;
+    private _recvTransport;
+    private _pendingConsumeData;
+    private _sendTransport;
+    private _consumers;
+    private _audioProducer;
+    private _videoProducer;
+    private _publishedAudio;
+    private _publishedVideo;
+    private _wtMicUplink;
+    private _wtCamUplink;
+    private _wtDataUpSender;
+    private _pendingProduce;
+    private _multiplexer;
+    private _reconnectAttempts;
+    private _intentionalDisconnect;
+    private _reconnectTimer;
+    
+    private _cancelPendingDial;
+    
+    private _stableResetTimer;
+    private _generation;
+    private _lastStartOptions;
+    private _resolveConnection;
+    private _recvIceRestartAttempts;
+    private _recvIceRestartTimer;
+    private _sendIceRestartAttempts;
+    private _sendIceRestartTimer;
+    private _phase;
+    private _requestId;
+    private _liveReached;
+    
+    private _lastServerStatus;
+    
+    private _endsAt;
+    
+    private _forceResolveOnNextConnect;
+    
+    private _connectStartedAt;
+    
+    private _wakingSince;
+    
+    private _mediaProbeTimer;
+    
+    private _statsTimer;
+    
+    private _statsSampleInFlight;
+    
+    private _joinProbes;
+    
+    private _decodeDeathHandled;
+    
+    private _selectedCandidatePair;
+    
+    private _reportedCandidatePairKey;
+    
+    private _candidatePairRefreshSeq;
+    
+    private _diagnosticSinkFailed;
+    
+    private _currentEpoch;
+    
+    private _selfEpochAdoptUntil;
+    
+    private _pausedIncarnation;
+    
+    private _consumerId;
+    
+    private _streamDataHandlers;
+    
+    private _streamDataLane;
+    
+    private _dataProducers;
+    
+    private _dataProducerPromises;
+    
+    private _dataConsumers;
+    
+    private _pendingDataProduce;
+    
+    private _sendTransportWaiters;
+    
+    get consumerId(): string;
+    get state(): TransportState;
+    
+    get currentIncarnation(): number;
+    get phase(): SessionPhase;
+    
+    get isProducingMedia(): boolean;
+    
+    get endsAt(): Date | null;
+    
+    setEndsAt(endsAt: Date | null): void;
+    
+    seedRegion(region: string | null | undefined): void;
+    
+    private _pastDeadline;
+    
+    get status(): SessionStatus;
+    
+    get region(): string | null | undefined;
+    get sessionId(): string | null;
+    get tracks(): Map<string, MediaStreamTrack>;
+    get multiplexer(): ChannelMultiplexer | null;
+    get isOpen(): boolean;
+    
+    get connectedUrl(): string | null;
+    
+    get intentionalDisconnect(): boolean;
+    
+    getTrackByName(name: string): MediaStreamTrack | undefined;
+    
+    private _streamNameOf;
+    setAuth(options: Pick<TransportSessionOptions, 'orgId' | 'jwt' | 'authProvider'>): void;
+    constructor(options?: TransportSessionOptions);
+    setConnection(options: Pick<TransportSessionOptions, 'url' | 'fallbackUrls' | 'sessionId' | 'iceServers'>): void;
+    setConnectionResolver(resolveConnection: (() => Promise<TransportConnection>) | null): void;
+    
+    applyControlDocState(state: Record<string, unknown> | null | undefined): void;
+    
+    setIncarnation(epoch: number): void;
+    
+    isStaleIncarnation(epoch: number): boolean;
+    
+    isStaleClosedMarker(marker: Record<string, unknown> | null | undefined): boolean;
+    
+    private _isStaleLivenessEvidence;
+    connect(startOptions?: SessionStartOptions): Promise<void>;
+    
+    leaveLeg(): boolean;
+    
+    disconnect(reason?: string): void;
+    on<E extends keyof TransportEvents>(event: E, handler: TransportEvents[E]): () => void;
+    
+    private _emitDiagnostic;
+    sendInput(data: Record<string, unknown>, sequence?: number): void;
+    
+    sendSignal(msg: Record<string, unknown>): boolean;
+    
+    onSignal(handler: (msg: Record<string, unknown>) => void): () => void;
+    
+    emitDiagnostic(diagnostic: SessionDiagnostic): void;
+    
+    onStreamData(name: string, handler: (payload: unknown) => void): () => void;
+    
+    sendStreamData(name: string, payload: unknown, _options?: {
+        to?: string;
+    }): Promise<void>;
+    
+    get wtDataUplinkSeam(): WtDataUplinkSeam;
+    
+    private _awaitSendTransport;
+    
+    private _settleSendTransportWaiters;
+    
+    private _ensureDataProducer;
+    
+    private _awaitDataChannelOpen;
+    
+    private _dispatchStreamData;
+    
+    markStreamDataLaneQuic(): void;
+    
+    dispatchQuicStreamData(name: string, payload: unknown): void;
+    
+    raiseQuicStreamDataError(err: Error): void;
+    
+    quicStreamDataLaneLost(reason: string): void;
+    
+    private _streamNameFromLabel;
+    
+    mediaUnavailableReason(): string | null;
+    
+    mediaAvailability(): Promise<string | null>;
+    
+    private _requireMediaSupport;
+    addTrack(track: MediaStreamTrack, name?: string): Promise<void>;
+    
+    private _publishTrack;
+    private _rememberPublishIntent;
+    removeTrack(): void;
+    
+    addVideoTrack(track: MediaStreamTrack, name?: string): Promise<void>;
+    
+    stopVideo(): void;
+    requestDiagnostics(): void;
+    seekStream(name: string, target: number | 'live'): void;
+    private _handleMessage;
+    
+    private _onServerError;
+    
+    private _onStreamSeeked;
+    
+    private _reportUnknownServerStatus;
+    
+    private _onStatus;
+    
+    private _webRtcDialHeld;
+    
+    private _heldRouterCaps;
+    
+    holdWebRtcDial(): {
+        proceed: (reason: string) => void;
+        skip: (reason: string) => void;
+    };
+    private _onRouterCapabilities;
+    private _onCreateRecvTransport;
+    
+    private _buildRecvTransport;
+    private _reportSelectedCandidatePair;
+    
+    private _tryRestartRecvIce;
+    private _trySendIceRestart;
+    
+    private _requestIceRestart;
+    
+    private _onIceRestarted;
+    private _armRecvIceRestartWatchdog;
+    private _armSendIceRestartWatchdog;
+    private _clearRecvIceRestart;
+    private _clearSendIceRestart;
+    private _onCreateSendTransport;
+    
+    private _republishPublishedTracks;
+    
+    private _onConsumeData;
+    private _onConsume;
+    
+    
+    get audioPlayoutOptions(): {
+        jitterBufferTargetMs?: number;
+    } | undefined;
+    
+    get wtMicUplinkSeam(): WtAudioUplinkSeam;
+    
+    get wtCamUplinkSeam(): WtVideoUplinkSeam;
+    private _jitterBufferTargetMs;
+    
+    private _capJitterBuffer;
+    
+    private _closeConsumer;
+    
+    private _closeConsumersByProducer;
+    private _mediaPollMs;
+    
+    private _firstFrameWindowMs;
+    
+    private _startMediaProbe;
+    private _stopMediaProbe;
+    
+    private _statsPollMs;
+    private _startStatsSampler;
+    private _stopStatsSampler;
+    
+    private _lanePairKey;
+    private _sampleSessionStats;
+    
+    private _resetJoinProbes;
+    private _sampleMediaArrival;
+    
+    private _renegotiate;
+    
+    recover(): void;
+    private _attemptReconnect;
+    private _connectUrls;
+    private _connectOnce;
+    private _startMessage;
+    private _cleanupSocket;
+    
+    private _replaceCurrentLegForReconnect;
+    
+    private _scheduleReconnectBudgetReset;
+    private _clearReconnectBudgetReset;
+    
+    private _cleanupDataChannels;
+    private _cleanupMedia;
+    
+    private _send;
+    private _setState;
+    
+    
+    private _isParkedPhase;
+    private _setPhase;
+    
+    reportAdmission(update: AdmissionUpdate): void;
+    
+    private _emitError;
+    
+    reportAllocationFailure(error: Error, httpStatus?: number, code?: string, retryAfterSeconds?: number): void;
+}
+
+declare class SessionDocumentImpl implements SessionDocument {
+    private _doc;
+    private _root;
+    private _awareness;
+    private _listeners;
+    private _key;
+    private _sessionId;
+    private _connection;
+    private _connUnsub;
+    
+    private _synced;
+    
+    private _syncWaiters;
+    
+    private _texts;
+    private _observer;
+    constructor(key: string, sessionId: string, connector?: DocConnector | null);
+    
+    get awareness(): Awareness;
+    
+    setSessionId(sessionId: string): void;
+    
+    get synced(): boolean;
+    
+    ensureConnected(): void;
+    
+    reconnect(): void;
+    
+    disconnect(): void;
+    
+    onConnectionState(handler: (state: DocConnectionState) => void): () => void;
+    
+    onSynced(handler: () => void): () => void;
+    
+    set(patch: Record<string, unknown>): void;
+    get(path?: string, defaultValue?: unknown): unknown;
+    on(event: 'change', handler: (snap: Record<string, unknown>) => void): () => void;
+    
+    text(field: string): SessionTextImpl;
+    dispose(): void;
+    private _markSynced;
+    
+    private applyPatch;
+    private snapshot;
+    private notify;
+}
+
+declare class SessionTextImpl implements SessionText {
+    private _ytext;
+    private _delta;
+    private _observer;
+    constructor(_ytext: Y.Text);
+    append(text: string): void;
+    toString(): string;
+    get length(): number;
+    on(event: 'delta', handler: (inserted: string) => void): () => void;
+    dispose(): void;
+}
+
+declare const STREAM_END: unique symbol;
+
+declare function encodeStreamEnvelope(payload: unknown): Uint8Array;
+
+declare function decodeStreamEnvelope(frame: Uint8Array | ArrayBuffer): unknown;
+
+interface StreamDataTransport {
+    
+    readonly consumerId: string;
+    
+    onData(name: string, handler: (payload: unknown) => void): () => void;
+    
+    sendData(name: string, payload: unknown, options?: {
+        to?: string;
+    }): Promise<void>;
+}
+
+declare class LoopbackStreamData implements StreamDataTransport {
+    readonly consumerId: string;
+    private _handlers;
+    constructor(consumerId?: string);
+    onData(name: string, handler: (payload: unknown) => void): () => void;
+    sendData(name: string, payload: unknown, options?: {
+        to?: string;
+    }): Promise<void>;
+}
+
+interface DataChannelTransport {
+    readonly consumerId: string;
+    onStreamData(name: string, handler: (payload: unknown) => void): () => void;
+    sendStreamData(name: string, payload: unknown, options?: {
+        to?: string;
+    }): Promise<void>;
+}
+
+declare function transportStreamData(transport: DataChannelTransport): StreamDataTransport;
+
+export { type ReleaseSessionBeaconOptions as $, type AccessTokenOptions as A, type GenerationTick as B, type ChannelEndpoint as C, DERIVED_LEG_SEP as D, type MediaChunkSource as E, type MediaChunkSourceFactory as F, GENERATION_TICK_EMIT_INTERVAL_MS as G, type MediaRecorderChunkSourceOptions as H, type InboundStatsSample as I, type MediaSession as J, type NegotiatorOptions as K, LoopbackStreamData as L, type MediaChunkBinding as M, type NegotiatorDataLaneSeam as N, type PathLiveness as O, type PathHealthReporting as P, type Presence as Q, type PresenceState as R, type PrewakeOptions as S, type PrewakeResult as T, type PrewakeStatus as U, type QuicStreamDataTransport as V, type Recording as W, type RecordingBucket as X, type RecordingLifecycle as Y, type RecordingStatus as Z, type RecordingsAccessor as _, type AccessTokenOptions$1 as a, encodeStreamEnvelope as a$, type RequestOptions as a0, type RequestStreamOptions as a1, type RuntimeArtifact as a2, type RuntimeArtifactDownload as a3, type RuntimeArtifactsAccessor as a4, type RuntimeAvailability as a5, type RuntimeWakeDetail as a6, type RuntimeWakeGolden as a7, type RuntimeWakeReasonCode as a8, SIGNALING_PROTOCOL_VERSION as a9, type TransportOfferRequest as aA, type TransportOfferResponse as aB, TransportSession as aC, type TransportSessionOptions as aD, TransportSessionSignaling as aE, type TransportState as aF, type VideoPlayoutOptions as aG, WT_CONTROL_FRAME_MAX as aH, WT_DATA_STREAM_VERSION as aI, type WatchGenerationTickOptions as aJ, type WtAudioLaneSeam as aK, type WtAudioUplinkSeam as aL, WtControlDecoder as aM, type WtControlMessage as aN, type WtDataEnvelope as aO, type WtDataLaneSink as aP, WtDataStreamParser as aQ, WtDataUplinkSender as aR, type WtVideoUplinkSeam as aS, allocateSession as aT, consumeWtDataStreams as aU, createPresence as aV, createWebsocketDocConnector as aW, decodeStreamEnvelope as aX, deriveYjsServerUrl as aY, derivedLegName as aZ, derivedLegRole as a_, STREAM_END as aa, type Session as ab, type SessionDiagnostic as ac, type SessionDirectoryRequestOptions as ad, type SessionDocument as ae, SessionDocumentImpl as af, type SessionEndResult as ag, type SessionFailureKind as ah, type SessionPhase as ai, type SessionPhaseError as aj, type SessionPhaseName as ak, type SessionStartOptions as al, type SessionStatsOptions as am, type SessionStatsSample as an, type SessionStatus as ao, type SessionStream as ap, type SessionText as aq, type SignalCarrier as ar, type Signaling as as, type StartSessionOptions as at, type Store as au, type StoreOptions as av, type StreamChunkOptions as aw, type StreamDataTransport as ax, type TransportEstablishedNotify as ay, TransportNegotiator as az, type ActivationEvent as b, encodeWtControlFrame as b0, isPendingRecording as b1, mediaRecorderChunkSource as b2, parseDgramHeader as b3, prewake as b4, releaseSessionBeacon as b5, streamDataLabel as b6, transportStreamData as b7, watchGenerationTick as b8, writeDgramHeader as b9, type ActivationState as c, type ActivitySignalMode as d, type AllocateSessionOptions as e, type AllocatedSession as f, type App as g, type AppOptions as h, type AttachOptions as i, type AudioPlayoutOptions as j, type ChannelMessage as k, ChannelMultiplexer as l, type ChannelName as m, type ChunkReadable as n, DGRAM_HEADER_BYTES as o, DOC_SYNC_WIRE_CONTRACT_VERSION as p, DeferredChannelMultiplexer as q, DeferredDocConnector as r, type DerivedLegRole as s, type DgramHeader as t, type DocConnection as u, type DocConnectionState as v, type DocConnector as w, type DocServerUrlResolver as x, type DocTokenSupplier as y, GENERATION_TICK_MAX_EXTRAPOLATION_MS as z };