@meshstream/p2p-web 0.0.0-stage → 0.2.0

package/dist/hls.d.ts

@@ -0,0 +1,157 @@
+import type Hls from "hls.js";
+import { HlsJsP2PEngine } from "p2p-media-loader-hlsjs";
+import type { WebP2pCapabilityResult } from "./capabilities.js";
+import type { SdkConfigResponse } from "./config.js";
+import { type P2pDiagnostics, type P2pStats } from "./report.js";
+import type { MeshStreamPlaybackState } from "./qoe.js";
+import { type OriginHeaders, type OriginHeadersProvider } from "./origin-headers.js";
+export declare const DEFAULT_P2P_STRATEGY: Readonly<{
+    uploadSlots: 4;
+    downloadSlots: 5;
+    simultaneousP2PDownloads: 3;
+    httpDownloadInitialTimeoutMs: 0;
+    highDemandTimeWindow: 15;
+    httpDownloadTimeWindow: 3000;
+    p2pDownloadTimeWindow: 6000;
+    peerHighDemandTimeWindow: 6;
+    peerHttpDownloadTimeWindow: 3000;
+    peerP2pDownloadTimeWindow: 12000;
+    livePeerHighDemandTimeWindow: 2;
+    livePeerHttpDownloadTimeWindow: 4;
+    liveSeedCohortCount: 4;
+    liveSeedHttpDownloadTimeWindow: 6;
+    maxMessageSizeBytes: number;
+    p2pNotReceivingBytesTimeoutMs: 2000;
+    webRtcConnectionTimeoutMs: 15000;
+}>;
+export interface HlsP2pConfig {
+    hlsjsInstance: Hls;
+    streamUrl: string;
+    contentId?: string;
+    originHeaders?: OriginHeaders;
+    originHeadersProvider?: OriginHeadersProvider;
+    sdkConfig?: Pick<SdkConfigResponse, "applicationId" | "keyId" | "reportUrl" | "trackerUrls" | "primaryTrackerUrl" | "iceServers" | "playbackAuth" | "defaults">;
+    trackerUrl?: string;
+    trackerUrls?: string[];
+    appId?: string;
+    sessionId?: string;
+    iceServers?: RTCIceServer[];
+    p2pEnabled?: boolean;
+    httpDownloadInitialTimeoutMs?: number;
+    uploadSlots?: number;
+    downloadSlots?: number;
+    networkType?: string;
+    liveWindowBucket?: string;
+    capability?: WebP2pCapabilityResult;
+    logLevel?: "none" | "error" | "warn" | "info" | "debug";
+    sessionTokenManager?: {
+        getAuthorizationHeader(): Promise<string | undefined>;
+        diagnostics?(): {
+            attempts: number;
+            successes: number;
+            failures: number;
+            durationMs: number;
+        };
+    };
+}
+export type P2pUnavailableReason = "NO_PEERS" | "TRACKER_ERROR" | "DISABLED" | "UNSUPPORTED" | "CONFIG_UNAVAILABLE" | "INITIALIZATION_FAILED" | "KEY_P2P_DISABLED" | "QUOTA_EXHAUSTED" | "QUOTA_DISABLED";
+export interface P2pEventListener {
+    onStatistics?(stats: P2pStats): void;
+    onPlaybackStateChanged?(state: MeshStreamPlaybackState): void;
+    onPeerCountChanged?(peerCount: number): void;
+    onP2pReady?(): void;
+    onP2pUnavailable?(reason: P2pUnavailableReason): void;
+    onTrackerError?(totalErrors: number): void;
+    onPeerConnectError?(totalErrors: number): void;
+    onCdnFallback?(bytes: number): void;
+}
+type PublicEvent = "peer-connect" | "peer-close" | "p2p-download" | "p2p-upload" | "http-download" | "tracker-error" | "segment-error";
+type Listener = (payload: unknown) => void;
+export interface LivePeerHttpSchedulingInput {
+    livePeerSchedulingActive: boolean;
+    peerHasSegment: boolean;
+    p2pSlotsAvailable: boolean;
+    previousP2pFailures: number;
+}
+export declare class HlsP2pClient {
+    private engine;
+    private readonly hlsjsInstance;
+    private readonly engineConfig;
+    private readonly trackerCandidates;
+    private activeTrackerIndex;
+    private failoverInFlight;
+    private disposed;
+    private engineGeneration;
+    readonly swarmId: string;
+    private readonly streamUrl;
+    private readonly contentId?;
+    private readonly appId?;
+    private readonly keyId?;
+    private readonly uploadSlots;
+    private readonly downloadSlots;
+    private readonly reportIntervalMs;
+    private readonly capability?;
+    private readonly reportUrl?;
+    private readonly sessionId;
+    private readonly sessionTokenManager?;
+    private readonly startedAtMs;
+    private readonly listeners;
+    private readonly eventListeners;
+    private readonly activePeers;
+    private readonly pagehideHandler;
+    private reportTimer;
+    private reportInFlight;
+    private pendingFinalReport;
+    private hasReportedContext;
+    private eventTimer;
+    private p2pEnabled;
+    private p2pReady;
+    private peerWindowProfile;
+    /** Remains unknown until hls.js parses the first media playlist. */
+    private playbackIsLive;
+    private readonly liveSeedCohort;
+    private readonly hlsLivePlaylistHandler;
+    private readonly stats;
+    private readonly diagnosticState;
+    static isSupported(): boolean;
+    constructor(config: HlsP2pConfig);
+    on(event: PublicEvent, listener: Listener): void;
+    off(event: PublicEvent, listener: Listener): void;
+    addEventListener(listener: P2pEventListener): void;
+    removeEventListener(listener: P2pEventListener): void;
+    setP2pEnabled(enabled: boolean): void;
+    statistics(): P2pStats;
+    diagnostics(): P2pDiagnostics;
+    dispose(): void;
+    getHlsConfig(): ReturnType<HlsJsP2PEngine["getConfigForHlsJs"]>;
+    private emit;
+    private bindEvents;
+    private createEngine;
+    private failoverTracker;
+    private notify;
+    private notifyPlaybackState;
+    private startStatsReporting;
+    private applyPeerOptimizedWindows;
+    private reportStats;
+    private currentLiveLatency;
+    private recordLiveLatency;
+}
+/**
+ * Restores hls.js's low-latency-safe defaults after the upstream P2P engine
+ * expands live sync to the full playlist. Explicit customer hls.js settings
+ * remain authoritative, as do server-provided HLS hold-back values.
+ */
+export declare function applyDefaultHlsLiveLatencyPolicy(hls: Pick<Hls, "config" | "userConfig">, isLive: boolean): void;
+/**
+ * Elects a stable subset of viewers to retain one additional live fragment.
+ * Session-local election avoids a coordination request and never affects VOD.
+ */
+export declare function isLiveSeedCohort(sessionId: string, swarmId: string, cohortCount?: 4): boolean;
+/**
+ * Keep the CDN as the fallback for an urgent live fragment, but do not race it
+ * against a peer that has already announced the fragment. A prior P2P failure
+ * is deliberately terminal for this decision so the retry immediately uses
+ * HTTP rather than extending a playback stall.
+ */
+export declare function shouldUsePeerForLiveHttpRequest({ livePeerSchedulingActive, peerHasSegment, p2pSlotsAvailable, previousP2pFailures, }: LivePeerHttpSchedulingInput): boolean;
+export {};

package/dist/ice.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_STUN_URLS: readonly string[];
+export declare function defaultIceServers(): RTCIceServer[];

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { attach, attachToHls, attachToRxPlayer, attachToVhs, type MeshStreamAttachOptions, type MeshStreamAttachToHlsOptions, type MeshStreamAttachToRxPlayerOptions, type MeshStreamAttachToVhsOptions, type MeshStreamMediaPlayer, type MeshStreamP2pEventListener, type MeshStreamP2pFallbackReason, type MeshStreamPlaybackStartResult, } from "./adapters.js";
+export { type P2pStats } from "./report.js";
+export { type OriginHeaders, type OriginHeadersProvider, type OriginRequestKind, } from "./origin-headers.js";
+export { MeshStreamDirectFilePlayer } from "./direct-file.js";
+export { getCapability, type MeshStreamCapability } from "./public-capabilities.js";
+export { type MeshStreamPlaybackState, type MeshStreamQoeSnapshot } from "./qoe.js";