@blockcast/mmt-transport 0.2.2 → 0.3.0

package/src/multicast-subscription-pool.test.ts

@@ -1,115 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { MulticastSubscriptionPool } from "./multicast-subscription-pool.js";
-import type { TransportConfig, WindowMulticastSubscriptionEventMap } from "./types.js";
-
-const config: TransportConfig = {
-	group: "232.1.1.1",
-	source: "192.0.2.1",
-	port: 5000,
-	streamType: "video",
-};
-
-describe("MulticastSubscriptionPool", () => {
-	it("shares an endpoint and unsubscribes only after the last owner releases", async () => {
-		const listeners = new Map<keyof WindowMulticastSubscriptionEventMap, (event: CustomEvent<never>) => void>();
-		const unsubscribe = vi.fn();
-		const subscription = {
-			addEventListener: vi.fn((type, listener) => listeners.set(type, listener)),
-			removeEventListener: vi.fn(),
-			unsubscribe,
-		};
-		const subscribe = vi.fn().mockResolvedValue(subscription);
-		const gateway = { subscribe };
-		const pool = new MulticastSubscriptionPool();
-		const firstPacket = vi.fn();
-		const secondPacket = vi.fn();
-
-		const first = await pool.acquire(gateway, config, { onBytes: firstPacket });
-		const second = await pool.acquire(gateway, { ...config, group: " 232.1.1.1 " }, { onBytes: secondPacket });
-		expect(subscribe).toHaveBeenCalledOnce();
-
-		const payload = new Uint8Array([1, 2]).buffer;
-		listeners.get("bytes")?.({ detail: payload } as CustomEvent<never>);
-		expect(firstPacket).toHaveBeenCalledWith(payload);
-		expect(secondPacket).toHaveBeenCalledWith(payload);
-
-		await first.release();
-		expect(unsubscribe).not.toHaveBeenCalled();
-		await second.release();
-		expect(unsubscribe).toHaveBeenCalledOnce();
-		expect(pool.size).toBe(0);
-	});
-
-	it("counts an awaiting acquire before the previous owner releases", async () => {
-		const unsubscribe = vi.fn();
-		const subscription = {
-			addEventListener: vi.fn(), removeEventListener: vi.fn(), unsubscribe,
-		};
-		const subscribe = vi.fn().mockResolvedValue(subscription);
-		const gateway = { subscribe };
-		const pool = new MulticastSubscriptionPool();
-		const first = await pool.acquire(gateway, config, { onBytes: vi.fn() });
-		const secondPending = pool.acquire(gateway, config, { onBytes: vi.fn() });
-		await first.release();
-		const second = await secondPending;
-		expect(unsubscribe).not.toHaveBeenCalled();
-		expect(pool.size).toBe(1);
-		await second.release();
-		expect(unsubscribe).toHaveBeenCalledOnce();
-	});
-
-	it("does not conflate transport preferences or gateway instances", async () => {
-		const makeSubscription = () => ({
-			addEventListener: vi.fn(), removeEventListener: vi.fn(), unsubscribe: vi.fn(),
-		});
-		const firstGateway = { subscribe: vi.fn().mockResolvedValue(makeSubscription()) };
-		const secondGateway = { subscribe: vi.fn().mockResolvedValue(makeSubscription()) };
-		const pool = new MulticastSubscriptionPool();
-		const native = await pool.acquire(firstGateway, { ...config, mode: "native" }, { onBytes: vi.fn() });
-		const tunnel = await pool.acquire(firstGateway, { ...config, mode: "tunnel", amtRelay: "relay.example" }, { onBytes: vi.fn() });
-		const replacement = await pool.acquire(secondGateway, { ...config, mode: "native" }, { onBytes: vi.fn() });
-		expect(firstGateway.subscribe).toHaveBeenCalledTimes(2);
-		expect(secondGateway.subscribe).toHaveBeenCalledOnce();
-		await Promise.all([native.release(), tunnel.release(), replacement.release()]);
-	});
-
-	it("evicts a closed entry so the next owner reconnects", async () => {
-		const stateListeners: Array<(event: CustomEvent<"closed">) => void> = [];
-		const subscribe = vi.fn().mockImplementation(async () => ({
-			addEventListener: vi.fn((type, listener) => {
-				if (type === "state") stateListeners.push(listener);
-			}),
-			removeEventListener: vi.fn(),
-			unsubscribe: vi.fn(),
-		}));
-		const gateway = { subscribe };
-		const pool = new MulticastSubscriptionPool();
-		const first = await pool.acquire(gateway, config, { onBytes: vi.fn() });
-		stateListeners[0]({ detail: "closed" } as CustomEvent<"closed">);
-		expect(pool.size).toBe(0);
-		const second = await pool.acquire(gateway, config, { onBytes: vi.fn() });
-		expect(subscribe).toHaveBeenCalledTimes(2);
-		await first.release();
-		await second.release();
-	});
-
-	it("isolates consumer callback failures", async () => {
-		let bytesListener: ((event: CustomEvent<ArrayBuffer>) => void) | undefined;
-		const subscribe = vi.fn().mockResolvedValue({
-			addEventListener: vi.fn((type, listener) => {
-				if (type === "bytes") bytesListener = listener;
-			}),
-			removeEventListener: vi.fn(), unsubscribe: vi.fn(),
-		});
-		const gateway = { subscribe };
-		const pool = new MulticastSubscriptionPool();
-		const secondConsumer = vi.fn();
-		const first = await pool.acquire(gateway, config, { onBytes: () => { throw new Error("boom"); } });
-		const second = await pool.acquire(gateway, config, { onBytes: secondConsumer });
-		const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
-		bytesListener?.({ detail: new ArrayBuffer(1) } as CustomEvent<ArrayBuffer>);
-		expect(secondConsumer).toHaveBeenCalledOnce();
-		consoleError.mockRestore();
-		await Promise.all([first.release(), second.release()]);
-	});
-});

package/src/multicast-tier.test.ts

@@ -1,80 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { MulticastOrchestrator } from "./multicast-orchestrator.js";
-import { endpointKey, selectMulticastTier, type MulticastTierEndpoint } from "./multicast-tier.js";
-
-const low: MulticastTierEndpoint = {
-	groupAddress: "232.1.1.1", port: 5000, tracks: [{ name: "video/720p" }], bandwidth: 2_000_000,
-};
-const high: MulticastTierEndpoint = {
-	groupAddress: "232.1.1.2", port: 5000, tracks: [{ name: "video/4k" }], bandwidth: 15_000_000,
-};
-
-describe("multicast tier selection", () => {
-	it("starts conservatively and applies headroom", () => {
-		expect(selectMulticastTier([high, low], undefined)).toBe(low);
-		expect(selectMulticastTier([low, high], 16_000_000)).toBe(low);
-		expect(selectMulticastTier([low, high], 20_000_000)).toBe(high);
-	});
-
-	it("switches make-before-break only on a valid target RAP", () => {
-		let now = 0;
-		const orchestrator = new MulticastOrchestrator({
-			endpoints: [low, high], now: () => now, dwellMs: 1000, joinDeadlineMs: 5000,
-		});
-		expect(orchestrator.start()).toBe(low);
-		expect(orchestrator.onGoodput({ bitrate: 20_000_000 })).toBeUndefined();
-		now = 1000;
-		expect(orchestrator.onGoodput({ bitrate: 20_000_000 })?.kind).toBe("join-target");
-		expect(orchestrator.onTierPacket({
-			endpointKey: endpointKey(high), keyframe: false, timestamp: 10, hasValidCodecConfig: true,
-		})).toBeUndefined();
-		expect(orchestrator.onTierPacket({
-			endpointKey: endpointKey(high), keyframe: true, timestamp: 11, hasValidCodecConfig: true,
-		})?.kind).toBe("commit-swap");
-	});
-
-	it("preserves a pinned initial tier", () => {
-		let now = 0;
-		const orchestrator = new MulticastOrchestrator({
-			endpoints: [low, high], initialEndpoint: high, adaptive: false,
-			now: () => now, dwellMs: 1000, joinDeadlineMs: 5000,
-		});
-		expect(orchestrator.start()).toBe(high);
-		expect(orchestrator.onGoodput({ bitrate: 1_000_000 })).toBeUndefined();
-		now = 10_000;
-		expect(orchestrator.onGoodput({ bitrate: 1_000_000 })).toBeUndefined();
-		expect(orchestrator.current).toBe(high);
-	});
-
-	it("abandons a silent target when polled after the join deadline", () => {
-		let now = 0;
-		const orchestrator = new MulticastOrchestrator({
-			endpoints: [low, high], now: () => now, dwellMs: 1000, joinDeadlineMs: 5000,
-		});
-		orchestrator.start();
-		orchestrator.onGoodput({ bitrate: 20_000_000 });
-		now = 1000;
-		orchestrator.onGoodput({ bitrate: 20_000_000 });
-		now = 6000;
-		expect(orchestrator.poll()?.kind).toBe("abandon-join");
-		expect(orchestrator.state).toBe("stable");
-	});
-
-	it("rejects a target RAP older than the active tier high-water mark", () => {
-		let now = 0;
-		const orchestrator = new MulticastOrchestrator({
-			endpoints: [low, high], now: () => now, dwellMs: 1000, joinDeadlineMs: 5000,
-		});
-		orchestrator.start();
-		orchestrator.onTierPacket({
-			endpointKey: endpointKey(low), keyframe: false, timestamp: 10_000, hasValidCodecConfig: true,
-		});
-		orchestrator.onGoodput({ bitrate: 20_000_000 });
-		now = 1000;
-		orchestrator.onGoodput({ bitrate: 20_000_000 });
-		expect(orchestrator.onTierPacket({
-			endpointKey: endpointKey(high), keyframe: true, timestamp: 9_000, hasValidCodecConfig: true,
-		})).toBeUndefined();
-		expect(orchestrator.state).toBe("joining");
-	});
-});

package/src/stall-detector.test.ts

@@ -1,34 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { TransportStallDetector } from "./stall-detector.js";
-
-describe("TransportStallDetector", () => {
-	it("detects repair-only starvation and recovery", () => {
-		let now = 0;
-		const onStarvation = vi.fn();
-		const onRecovery = vi.fn();
-		const detector = new TransportStallDetector({ windowMs: 1000, now: () => now, onStarvation, onRecovery });
-		detector.update({ sourceSymbols: 0, repairSymbols: 0, blocksComplete: 0, blocksRecovered: 0 });
-		now = 1000;
-		detector.update({ sourceSymbols: 0, repairSymbols: 10, blocksComplete: 0, blocksRecovered: 0 });
-		expect(onStarvation).toHaveBeenCalledOnce();
-		now = 1100;
-		detector.update({ sourceSymbols: 1, repairSymbols: 10, blocksComplete: 1, blocksRecovered: 0 });
-		expect(onRecovery).toHaveBeenCalledOnce();
-	});
-
-	it("detects starvation when all packet counters stop", () => {
-		let now = 0;
-		const onStarvation = vi.fn();
-		const detector = new TransportStallDetector({
-			windowMs: 1000,
-			now: () => now,
-			onStarvation,
-			onRecovery: vi.fn(),
-		});
-		const snapshot = { sourceSymbols: 10, repairSymbols: 2, blocksComplete: 1, blocksRecovered: 0 };
-		detector.update(snapshot);
-		now = 1000;
-		detector.update(snapshot);
-		expect(onStarvation).toHaveBeenCalledOnce();
-	});
-});

package/src/transport-manager.test.ts

@@ -1,192 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import { TransportManager } from "./transport-manager.js";
-import type {
-	TransportConfig,
-	WindowMulticastSubscriptionEventMap,
-} from "./types.js";
-
-const CONFIG: TransportConfig = {
-	group: "232.1.1.50",
-	source: "192.168.1.181",
-	port: 8000,
-	streamType: "video",
-	driadEnabled: false,
-};
-
-describe("TransportManager window.multicast integration", () => {
-	let hadWindow = false;
-	let previousWindow: unknown;
-
-	beforeEach(() => {
-		hadWindow = Object.hasOwn(globalThis, "window");
-		previousWindow = (globalThis as unknown as { window?: unknown })
-			.window;
-		vi.spyOn(console, "log").mockImplementation(() => {});
-		vi.spyOn(console, "warn").mockImplementation(() => {});
-		vi.spyOn(console, "error").mockImplementation(() => {});
-	});
-
-	afterEach(() => {
-		if (hadWindow) {
-			(globalThis as unknown as { window?: unknown }).window =
-				previousWindow;
-		} else {
-			delete (globalThis as unknown as { window?: unknown }).window;
-		}
-		vi.restoreAllMocks();
-	});
-
-	it("does not treat legacy window.Multicast as a usable transport", async () => {
-		const subscribeSSM = vi.fn();
-		(globalThis as unknown as { window?: unknown }).window = {
-			Multicast: { subscribeSSM },
-		};
-
-		const manager = new TransportManager();
-		const connected = await manager.connect(CONFIG);
-
-		expect(connected).toBe(false);
-		expect(subscribeSSM).not.toHaveBeenCalled();
-	});
-
-	it("subscribes through lowercase window.multicast and forwards bytes", async () => {
-		const listeners = new Map<
-			keyof WindowMulticastSubscriptionEventMap,
-			(event: CustomEvent<unknown>) => void
-		>();
-		const subscription = {
-			id: "sub-1",
-			addEventListener: vi.fn((type, listener) => {
-				listeners.set(
-					type as keyof WindowMulticastSubscriptionEventMap,
-					listener as (event: CustomEvent<unknown>) => void,
-				);
-			}),
-			removeEventListener: vi.fn(),
-			unsubscribe: vi.fn().mockResolvedValue(undefined),
-		};
-		const subscribe = vi.fn().mockResolvedValue(subscription);
-		(globalThis as unknown as { window?: unknown }).window = {
-			multicast: {
-				capabilities: { consumeModes: ["bytes"] },
-				subscribe,
-			},
-		};
-
-		const manager = new TransportManager();
-		const onPacket = vi.fn();
-		manager.setPacketCallback(onPacket);
-
-		const connected = await manager.connect(CONFIG);
-		expect(connected).toBe(true);
-		expect(subscribe).toHaveBeenCalledWith({
-			group: CONFIG.group,
-			source: CONFIG.source,
-			port: CONFIG.port,
-			consume: "bytes",
-		});
-
-		const payload = new Uint8Array([1, 2, 3]).buffer;
-		listeners.get("bytes")?.({ detail: payload } as CustomEvent<unknown>);
-
-		expect(onPacket).toHaveBeenCalledWith(payload);
-		expect(manager.getState().packetsReceived).toBe(1);
-		expect(manager.getState().bytesReceived).toBe(3);
-		manager.disconnect();
-	});
-
-	it("releases the previous lease before reconnecting", async () => {
-		const unsubscribe = vi.fn();
-		const subscription = {
-			addEventListener: vi.fn(), removeEventListener: vi.fn(), unsubscribe,
-		};
-		const subscribe = vi.fn().mockResolvedValue(subscription);
-		(globalThis as unknown as { window?: unknown }).window = {
-			multicast: { capabilities: { consumeModes: ["bytes"] }, subscribe },
-		};
-		const manager = new TransportManager();
-		expect(await manager.connect(CONFIG)).toBe(true);
-		expect(await manager.connect(CONFIG)).toBe(true);
-		expect(unsubscribe).toHaveBeenCalledOnce();
-		manager.disconnect();
-		expect(unsubscribe).toHaveBeenCalledTimes(2);
-	});
-
-	it("releases a stale lease when connect calls overlap", async () => {
-		let resolveSubscription!: (subscription: {
-			addEventListener: ReturnType<typeof vi.fn>;
-			removeEventListener: ReturnType<typeof vi.fn>;
-			unsubscribe: ReturnType<typeof vi.fn>;
-		}) => void;
-		const unsubscribe = vi.fn();
-		const subscribe = vi.fn().mockReturnValue(new Promise((resolve) => {
-			resolveSubscription = resolve;
-		}));
-		(globalThis as unknown as { window?: unknown }).window = {
-			multicast: { capabilities: { consumeModes: ["bytes"] }, subscribe },
-		};
-		const manager = new TransportManager();
-		const first = manager.connect(CONFIG);
-		await vi.waitFor(() => expect(subscribe).toHaveBeenCalledOnce());
-		const second = manager.connect(CONFIG);
-		resolveSubscription({ addEventListener: vi.fn(), removeEventListener: vi.fn(), unsubscribe });
-
-		expect(await Promise.all([first, second])).toEqual([false, true]);
-		expect(subscribe).toHaveBeenCalledOnce();
-		manager.disconnect();
-		expect(unsubscribe).toHaveBeenCalledOnce();
-	});
-
-	it("does not publish a connection completed after disconnect", async () => {
-		let resolveSubscription!: (subscription: {
-			addEventListener: ReturnType<typeof vi.fn>;
-			removeEventListener: ReturnType<typeof vi.fn>;
-			unsubscribe: ReturnType<typeof vi.fn>;
-		}) => void;
-		const unsubscribe = vi.fn();
-		const subscribe = vi.fn().mockReturnValue(new Promise((resolve) => {
-			resolveSubscription = resolve;
-		}));
-		(globalThis as unknown as { window?: unknown }).window = {
-			multicast: { capabilities: { consumeModes: ["bytes"] }, subscribe },
-		};
-		const manager = new TransportManager();
-		const connecting = manager.connect(CONFIG);
-		await vi.waitFor(() => expect(subscribe).toHaveBeenCalledOnce());
-		manager.disconnect();
-		resolveSubscription({ addEventListener: vi.fn(), removeEventListener: vi.fn(), unsubscribe });
-
-		expect(await connecting).toBe(false);
-		expect(manager.getState().connected).toBe(false);
-		expect(unsubscribe).toHaveBeenCalledOnce();
-	});
-
-	it("rejects invalid endpoints before AMT fallback", async () => {
-		(globalThis as unknown as { window?: unknown }).window = {};
-		const manager = new TransportManager();
-		const onError = vi.fn();
-		manager.setErrorCallback(onError);
-		expect(await manager.connect({ ...CONFIG, group: "127.0.0.1", amtRelay: "relay.example" })).toBe(false);
-		expect(onError).toHaveBeenCalledOnce();
-	});
-
-	it("reports disconnected after an invalid reconnect", async () => {
-		const unsubscribe = vi.fn();
-		const subscribe = vi.fn().mockResolvedValue({
-			addEventListener: vi.fn(), removeEventListener: vi.fn(), unsubscribe,
-		});
-		(globalThis as unknown as { window?: unknown }).window = {
-			multicast: { capabilities: { consumeModes: ["bytes"] }, subscribe },
-		};
-		const manager = new TransportManager();
-		expect(await manager.connect(CONFIG)).toBe(true);
-
-		expect(await manager.connect({ ...CONFIG, group: "127.0.0.1" })).toBe(false);
-		expect(unsubscribe).toHaveBeenCalledOnce();
-		expect(manager.getState()).toMatchObject({
-			mode: "disconnected",
-			connected: false,
-		});
-	});
-});