@urun-sh/core 0.2.60 → 0.3.0

package/dist/internal.mjs

@@ -1,2 +1,2 @@
 import { createRequire as __urunCreateRequire } from 'node:module'; const require = globalThis.require ?? __urunCreateRequire(import.meta.url);
-import{E as r,H as t,I as n,J as a,K as s,O as p,P as m,Q as c,U as i,V as l,W as S,X as f,Y as x,Z as C,_ as D,a as e,b as o}from"./chunk-MVSPHHJP.mjs";export{e as ChannelMultiplexer,l as DOC_SYNC_WIRE_CONTRACT_VERSION,o as DeferredChannelMultiplexer,x as DeferredDocConnector,p as LoopbackStreamData,C as SessionDocumentImpl,i as TransportSession,r as allocateSession,D as createPresence,f as createWebsocketDocConnector,S as deriveYjsServerUrl,s as ensureNodeWebRTC,t as isNodeRuntime,n as nodeMediasoupHandlerName,a as nodeWebRTCUnavailableReason,c as streamDataLabel,m as transportStreamData};
+import{$ as C,F as r,I as t,J as n,K as a,L as s,P as p,Q as m,R as c,W as i,X as l,Y as S,Z as f,_ as x,a as e,aa as D,b as o}from"./chunk-WRCXYQH2.mjs";export{e as ChannelMultiplexer,l as DOC_SYNC_WIRE_CONTRACT_VERSION,o as DeferredChannelMultiplexer,x as DeferredDocConnector,p as LoopbackStreamData,C as SessionDocumentImpl,i as TransportSession,r as allocateSession,D as createPresence,f as createWebsocketDocConnector,S as deriveYjsServerUrl,s as ensureNodeWebRTC,t as isNodeRuntime,n as nodeMediasoupHandlerName,a as nodeWebRTCUnavailableReason,c as streamDataLabel,m as transportStreamData};

package/dist/{stream-data-B5wxsIPL.d.mts → stream-data-ChGPDdoN.d.mts}

@@ -117,7 +117,7 @@ declare function createPresence(awareness: Awareness): Presence;
 
 type TransportState = 'connecting' | 'connected' | 'reconnecting' | 'renegotiating' | 'disconnected' | 'failed';
 
-type SessionPhaseName = 'idle' | 'queued' | 'unavailable' | 'provisioning' | 'connecting' | 'live' | 'error' | 'ended' | 'expired';
+type SessionPhaseName = 'idle' | 'queued' | 'unavailable' | 'provisioning' | 'waiting_for_capacity' | 'connecting' | 'live' | 'error' | 'ended' | 'expired' | 'unknown';
 
 interface RuntimeAvailability {
     state: 'unavailable' | 'starting' | 'busy';
@@ -213,6 +213,8 @@ interface SessionPhase {
     endsAt?: Date;
     
     error?: SessionPhaseError;
+    
+    reason?: string;
 }
 
 interface SessionStatus {
@@ -600,6 +602,8 @@ interface AppOptions {
     
     allowWebTransport?: boolean;
     
+    allowWebRtcFallback?: boolean;
+    
     releaseOnLeave?: boolean;
     
     sessionKey?: string;
@@ -660,6 +664,9 @@ interface SessionGatewayResponse {
     ends_at?: string;
     error_code?: string;
     error_message?: string;
+    
+    message?: string;
+    error?: string;
 }
 
 interface AdmissionUpdate {
@@ -779,6 +786,329 @@ declare class DeferredChannelMultiplexer implements ChannelEndpoint {
     private detachTarget;
 }
 
+type WtMicSource = MediaStreamTrack | AudioNode;
+
+interface WtMicUplinkHandle {
+    setSource(source: WtMicSource | null): void;
+}
+
+interface WtAudioUplinkSeam {
+    onUplink(handle: WtMicUplinkHandle): void;
+    onUplinkLost(reason: string): void;
+}
+
+interface WtCamUplinkHandle {
+    setSource(track: MediaStreamTrack | null): void;
+    
+    requestKeyframe(): void;
+}
+
+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 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;
+        
+        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;
+}
+declare class TransportNegotiator {
+    private signaling;
+    private sessionId;
+    private opts;
+    private session;
+    private offer;
+    
+    private quicDataLane;
+    
+    private wtOnlyLeg;
+    constructor(signaling: Signaling, sessionId: string, opts: NegotiatorOptions);
+    get activeTransport(): MediaSession['kind'] | null;
+    connect(): Promise<MediaSession>;
+    disconnect(): Promise<void>;
+    
+    retryWebTransport(): Promise<MediaSession | null>;
+    
+    private engageQuicDataLane;
+    private createWebTransportSession;
+    private startWebRtc;
+    
+    private armFailover;
+    private notifyEstablished;
+}
+
 interface TransportConnection {
     url: string;
     sessionId: string;
@@ -817,6 +1147,8 @@ interface TransportEvents {
     
     signal: (msg: Record<string, unknown>) => void;
 }
+
+declare const SIGNALING_PROTOCOL_VERSION = "v1";
 interface SessionStartOptions {
     app?: string;
     functionName?: string;
@@ -853,6 +1185,9 @@ declare class TransportSession {
     private _videoProducer;
     private _publishedAudio;
     private _publishedVideo;
+    private _wtMicUplink;
+    private _wtCamUplink;
+    private _wtDataUpSender;
     private _pendingProduce;
     private _multiplexer;
     private _reconnectAttempts;
@@ -973,6 +1308,8 @@ declare class TransportSession {
         to?: string;
     }): Promise<void>;
     
+    get wtDataUplinkSeam(): WtDataUplinkSeam;
+    
     private _awaitSendTransport;
     
     private _settleSendTransportWaiters;
@@ -1016,6 +1353,15 @@ declare class TransportSession {
     private _onStreamSeeked;
     
     private _onStatus;
+    
+    private _webRtcDialHeld;
+    
+    private _heldRouterCaps;
+    
+    holdWebRtcDial(): {
+        proceed: (reason: string) => void;
+        skip: (reason: string) => void;
+    };
     private _onRouterCapabilities;
     private _onCreateRecvTransport;
     
@@ -1039,6 +1385,14 @@ declare class TransportSession {
     private _onConsumeData;
     private _onConsume;
     
+    
+    get audioPlayoutOptions(): {
+        jitterBufferTargetMs?: number;
+    } | undefined;
+    
+    get wtMicUplinkSeam(): WtAudioUplinkSeam;
+    
+    get wtCamUplinkSeam(): WtVideoUplinkSeam;
     private _jitterBufferTargetMs;
     
     private _capJitterBuffer;
@@ -1187,4 +1541,4 @@ interface DataChannelTransport {
 
 declare function transportStreamData(transport: DataChannelTransport): StreamDataTransport;
 
-export { SessionDocumentImpl as $, type AccessTokenOptions$1 as A, type PrewakeResult as B, type ChannelEndpoint as C, DERIVED_LEG_SEP as D, type PrewakeStatus as E, type RecordingBucket as F, type RecordingLifecycle as G, type RecordingStatus as H, type InboundStatsSample as I, type RecordingsAccessor as J, type ReleaseSessionBeaconOptions as K, LoopbackStreamData as L, type MediaChunkBinding as M, type RequestOptions as N, type RequestStreamOptions as O, type Presence as P, type RuntimeArtifact as Q, type Recording as R, type RuntimeArtifactDownload as S, type RuntimeArtifactsAccessor as T, type RuntimeAvailability as U, type RuntimeWakeDetail as V, type RuntimeWakeGolden as W, type RuntimeWakeReasonCode as X, type Session as Y, type SessionDiagnostic as Z, type SessionDocument as _, type AccessTokenOptions as a, type SessionEndResult as a0, type SessionFailureKind as a1, type SessionPhase as a2, type SessionPhaseError as a3, type SessionPhaseName as a4, type SessionStartOptions as a5, type SessionStatsOptions as a6, type SessionStatsSample as a7, type SessionStatus as a8, type SessionStream as a9, type SessionText as aa, type Store as ab, type StoreOptions as ac, type StreamChunkOptions as ad, type StreamDataTransport as ae, TransportSession as af, type TransportSessionOptions as ag, type TransportState as ah, type VideoPlayoutOptions as ai, allocateSession as aj, createPresence as ak, createWebsocketDocConnector as al, deriveYjsServerUrl as am, derivedLegName as an, derivedLegRole as ao, isPendingRecording as ap, mediaRecorderChunkSource as aq, prewake as ar, releaseSessionBeacon as as, streamDataLabel as at, transportStreamData as au, type ActivationEvent as b, type ActivationState as c, type AllocateSessionOptions as d, type AllocatedSession as e, type App as f, type AppOptions as g, type AttachOptions as h, type AudioPlayoutOptions as i, type ChannelMessage as j, ChannelMultiplexer as k, type ChannelName as l, type ChunkReadable as m, DOC_SYNC_WIRE_CONTRACT_VERSION as n, DeferredChannelMultiplexer as o, DeferredDocConnector as p, type DerivedLegRole as q, type DocConnection as r, type DocConnectionState as s, type DocConnector as t, type DocTokenSupplier as u, type MediaChunkSource as v, type MediaChunkSourceFactory as w, type MediaRecorderChunkSourceOptions as x, type PresenceState as y, type PrewakeOptions as z };
+export { type RuntimeWakeDetail as $, type AccessTokenOptions$1 as A, type MediaSession as B, type ChannelEndpoint as C, DERIVED_LEG_SEP as D, type NegotiatorOptions as E, type PresenceState as F, type PrewakeOptions as G, type PrewakeResult as H, type InboundStatsSample as I, type PrewakeStatus as J, type RecordingBucket as K, LoopbackStreamData as L, type MediaChunkBinding as M, type NegotiatorDataLaneSeam as N, type RecordingLifecycle as O, type Presence as P, type QuicStreamDataTransport as Q, type Recording as R, type RecordingStatus as S, type RecordingsAccessor as T, type ReleaseSessionBeaconOptions as U, type RequestOptions as V, type RequestStreamOptions as W, type RuntimeArtifact as X, type RuntimeArtifactDownload as Y, type RuntimeArtifactsAccessor as Z, type RuntimeAvailability as _, type AccessTokenOptions as a, type RuntimeWakeGolden as a0, type RuntimeWakeReasonCode as a1, SIGNALING_PROTOCOL_VERSION as a2, type Session as a3, type SessionDiagnostic as a4, type SessionDocument as a5, SessionDocumentImpl as a6, type SessionEndResult as a7, type SessionFailureKind as a8, type SessionPhase as a9, type WtAudioUplinkSeam as aA, WtControlDecoder as aB, type WtControlMessage as aC, type WtDataEnvelope as aD, type WtDataLaneSink as aE, WtDataStreamParser as aF, WtDataUplinkSender as aG, type WtVideoUplinkSeam as aH, allocateSession as aI, consumeWtDataStreams as aJ, createPresence as aK, createWebsocketDocConnector as aL, deriveYjsServerUrl as aM, derivedLegName as aN, derivedLegRole as aO, encodeWtControlFrame as aP, isPendingRecording as aQ, mediaRecorderChunkSource as aR, parseDgramHeader as aS, prewake as aT, releaseSessionBeacon as aU, streamDataLabel as aV, transportStreamData as aW, writeDgramHeader as aX, type SessionPhaseError as aa, type SessionPhaseName as ab, type SessionStartOptions as ac, type SessionStatsOptions as ad, type SessionStatsSample as ae, type SessionStatus as af, type SessionStream as ag, type SessionText as ah, type SignalCarrier as ai, type Signaling as aj, type Store as ak, type StoreOptions as al, type StreamChunkOptions as am, type StreamDataTransport as an, type TransportEstablishedNotify as ao, TransportNegotiator as ap, type TransportOfferRequest as aq, type TransportOfferResponse as ar, TransportSession as as, type TransportSessionOptions as at, TransportSessionSignaling as au, type TransportState as av, type VideoPlayoutOptions as aw, WT_CONTROL_FRAME_MAX as ax, WT_DATA_STREAM_VERSION as ay, type WtAudioLaneSeam as az, type ActivationEvent as b, type ActivationState as c, type AllocateSessionOptions as d, type AllocatedSession as e, type App as f, type AppOptions as g, type AttachOptions as h, type AudioPlayoutOptions as i, type ChannelMessage as j, ChannelMultiplexer as k, type ChannelName as l, type ChunkReadable as m, DGRAM_HEADER_BYTES as n, DOC_SYNC_WIRE_CONTRACT_VERSION as o, DeferredChannelMultiplexer as p, DeferredDocConnector as q, type DerivedLegRole as r, type DgramHeader as s, type DocConnection as t, type DocConnectionState as u, type DocConnector as v, type DocTokenSupplier as w, type MediaChunkSource as x, type MediaChunkSourceFactory as y, type MediaRecorderChunkSourceOptions as z };