@urun-sh/core 0.2.60 → 0.3.1

package/dist/{stream-data-B5wxsIPL.d.ts → stream-data-BJoG7tYI.d.ts}

@@ -33,6 +33,23 @@ interface MediaRecorderChunkSourceOptions {
 
 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 {
@@ -48,6 +65,8 @@ interface DocConnectionState {
 
 type DocTokenSupplier = () => string | undefined | Promise<string | undefined>;
 
+type DocServerUrlResolver = () => string | undefined | Promise<string | undefined>;
+
 interface DocConnection {
     
     readonly awareness: Awareness;
@@ -80,6 +99,8 @@ interface WebsocketDocConnectorOptions {
     maxBackoffTimeMs?: number;
     
     dialTimeoutMs?: number;
+    
+    resolveServerUrl?: DocServerUrlResolver;
 }
 
 declare function createWebsocketDocConnector(opts: WebsocketDocConnectorOptions): DocConnector;
@@ -117,7 +138,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';
@@ -156,7 +177,7 @@ type RuntimeWakeDetail = (RuntimeWakeDetailBase & {
     golden?: never;
 });
 
-type SessionFailureKind = 'create-failed' | 'never-live' | 'transport-failed' | 'media-permission' | 'ended' | 'runtime-failed' | 'expired' | 'produce-timeout';
+type SessionFailureKind = 'create-failed' | 'never-live' | 'transport-failed' | 'media-permission' | 'ended' | 'runtime-failed' | 'expired' | 'insufficient-credits' | 'produce-timeout';
 
 interface SessionPhaseError {
     
@@ -213,6 +234,8 @@ interface SessionPhase {
     endsAt?: Date;
     
     error?: SessionPhaseError;
+    
+    reason?: string;
 }
 
 interface SessionStatus {
@@ -481,6 +504,8 @@ interface Session {
     
     onStats?(handler: (sample: SessionStatsSample) => void): () => void;
     
+    on(event: 'generationTick', handler: (tick: GenerationTick) => void): () => void;
+    
     whenLive(options?: {
         timeout?: number;
         signal?: AbortSignal;
@@ -600,6 +625,8 @@ interface AppOptions {
     
     allowWebTransport?: boolean;
     
+    allowWebRtcFallback?: boolean;
+    
     releaseOnLeave?: boolean;
     
     sessionKey?: string;
@@ -638,9 +665,15 @@ interface App {
     [fnName: string]: (args?: Record<string, unknown>) => Session;
 }
 
-type SessionGatewayStatus = 'allocated' | 'pending' | 'queued' | 'rejected' | 'failed' | 'canceled';
+type SessionGatewayStatus = 'allocated' | 'pending' | 'queued' | 'rejected' | 'failed' | 'canceled'
+
+ | 'redirect';
 interface SessionGatewayResponse {
     status?: SessionGatewayStatus;
+    
+    location?: string;
+    
+    session_api_base?: string;
     request_id?: string;
     session_id?: string;
     ws_url?: string;
@@ -660,6 +693,11 @@ interface SessionGatewayResponse {
     ends_at?: string;
     error_code?: string;
     error_message?: string;
+    
+    message?: string;
+    error?: string;
+    
+    balance_credits?: number;
 }
 
 interface AdmissionUpdate {
@@ -779,6 +817,331 @@ 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>): 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;
+}
+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 +1180,8 @@ interface TransportEvents {
     
     signal: (msg: Record<string, unknown>) => void;
 }
+
+declare const SIGNALING_PROTOCOL_VERSION = "v1";
 interface SessionStartOptions {
     app?: string;
     functionName?: string;
@@ -853,6 +1218,9 @@ declare class TransportSession {
     private _videoProducer;
     private _publishedAudio;
     private _publishedVideo;
+    private _wtMicUplink;
+    private _wtCamUplink;
+    private _wtDataUpSender;
     private _pendingProduce;
     private _multiplexer;
     private _reconnectAttempts;
@@ -895,7 +1263,9 @@ declare class TransportSession {
     
     private _selectedCandidatePair;
     
-    private _candidatePairDiagnosticEmitted;
+    private _reportedCandidatePairKey;
+    
+    private _candidatePairRefreshSeq;
     
     private _diagnosticSinkFailed;
     
@@ -939,6 +1309,8 @@ declare class TransportSession {
     
     get connectedUrl(): string | null;
     
+    get intentionalDisconnect(): boolean;
+    
     getTrackByName(name: string): MediaStreamTrack | undefined;
     
     private _streamNameOf;
@@ -963,16 +1335,20 @@ declare class TransportSession {
     private _emitDiagnostic;
     sendInput(data: Record<string, unknown>, sequence?: number): void;
     
-    sendSignal(msg: Record<string, unknown>): 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;
@@ -1016,6 +1392,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 +1424,14 @@ declare class TransportSession {
     private _onConsumeData;
     private _onConsume;
     
+    
+    get audioPlayoutOptions(): {
+        jitterBufferTargetMs?: number;
+    } | undefined;
+    
+    get wtMicUplinkSeam(): WtAudioUplinkSeam;
+    
+    get wtCamUplinkSeam(): WtVideoUplinkSeam;
     private _jitterBufferTargetMs;
     
     private _capJitterBuffer;
@@ -1079,6 +1472,7 @@ declare class TransportSession {
     
     private _cleanupDataChannels;
     private _cleanupMedia;
+    
     private _send;
     private _setState;
     
@@ -1098,7 +1492,7 @@ declare class TransportSession {
     
     private _emitError;
     
-    reportAllocationFailure(error: Error, httpStatus?: number): void;
+    reportAllocationFailure(error: Error, httpStatus?: number, code?: string): void;
 }
 
 declare class SessionDocumentImpl implements SessionDocument {
@@ -1156,6 +1550,12 @@ declare class SessionTextImpl implements SessionText {
     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;
@@ -1187,4 +1587,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 RuntimeArtifact as $, type AccessTokenOptions$1 as A, type MediaChunkSource as B, type ChannelEndpoint as C, DERIVED_LEG_SEP as D, type MediaChunkSourceFactory as E, type MediaRecorderChunkSourceOptions as F, GENERATION_TICK_EMIT_INTERVAL_MS as G, type MediaSession as H, type InboundStatsSample as I, type NegotiatorOptions as J, type PresenceState as K, LoopbackStreamData as L, type MediaChunkBinding as M, type NegotiatorDataLaneSeam as N, type PrewakeOptions as O, type Presence as P, type PrewakeResult as Q, type PrewakeStatus as R, type QuicStreamDataTransport as S, type Recording as T, type RecordingBucket as U, type RecordingLifecycle as V, type RecordingStatus as W, type RecordingsAccessor as X, type ReleaseSessionBeaconOptions as Y, type RequestOptions as Z, type RequestStreamOptions as _, type AccessTokenOptions as a, prewake as a$, type RuntimeArtifactDownload as a0, type RuntimeArtifactsAccessor as a1, type RuntimeAvailability as a2, type RuntimeWakeDetail as a3, type RuntimeWakeGolden as a4, type RuntimeWakeReasonCode as a5, SIGNALING_PROTOCOL_VERSION as a6, STREAM_END as a7, type Session as a8, type SessionDiagnostic as a9, type TransportState as aA, type VideoPlayoutOptions as aB, WT_CONTROL_FRAME_MAX as aC, WT_DATA_STREAM_VERSION as aD, type WatchGenerationTickOptions as aE, type WtAudioLaneSeam as aF, type WtAudioUplinkSeam as aG, WtControlDecoder as aH, type WtControlMessage as aI, type WtDataEnvelope as aJ, type WtDataLaneSink as aK, WtDataStreamParser as aL, WtDataUplinkSender as aM, type WtVideoUplinkSeam as aN, allocateSession as aO, consumeWtDataStreams as aP, createPresence as aQ, createWebsocketDocConnector as aR, decodeStreamEnvelope as aS, deriveYjsServerUrl as aT, derivedLegName as aU, derivedLegRole as aV, encodeStreamEnvelope as aW, encodeWtControlFrame as aX, isPendingRecording as aY, mediaRecorderChunkSource as aZ, parseDgramHeader as a_, type SessionDocument as aa, SessionDocumentImpl as ab, type SessionEndResult as ac, type SessionFailureKind as ad, type SessionPhase as ae, type SessionPhaseError as af, type SessionPhaseName as ag, type SessionStartOptions as ah, type SessionStatsOptions as ai, type SessionStatsSample as aj, type SessionStatus as ak, type SessionStream as al, type SessionText as am, type SignalCarrier as an, type Signaling as ao, type Store as ap, type StoreOptions as aq, type StreamChunkOptions as ar, type StreamDataTransport as as, type TransportEstablishedNotify as at, TransportNegotiator as au, type TransportOfferRequest as av, type TransportOfferResponse as aw, TransportSession as ax, type TransportSessionOptions as ay, TransportSessionSignaling as az, type ActivationEvent as b, releaseSessionBeacon as b0, streamDataLabel as b1, transportStreamData as b2, watchGenerationTick as b3, writeDgramHeader as b4, 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 DocServerUrlResolver as w, type DocTokenSupplier as x, GENERATION_TICK_MAX_EXTRAPOLATION_MS as y, type GenerationTick as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@urun-sh/core",
-  "version": "0.2.60",
+  "version": "0.3.1",
   "description": "Core transport and channel primitives for the urun TypeScript SDK",
   "repository": {
     "type": "git",