@aperture-browser/live-session 0.0.0-init.0

package/dist/index.js

@@ -0,0 +1,1150 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { Recording, resolveTenantHeader } from "@aperture-browser/api-client";
+import * as Data from "effect/Data";
+import * as Deferred from "effect/Deferred";
+import "effect/Fiber";
+import * as FiberSet from "effect/FiberSet";
+import * as Option from "effect/Option";
+//#region src/input-keycodes.ts
+const evdevKeycodeByCode = {
+	Escape: 1,
+	Digit1: 2,
+	Digit2: 3,
+	Digit3: 4,
+	Digit4: 5,
+	Digit5: 6,
+	Digit6: 7,
+	Digit7: 8,
+	Digit8: 9,
+	Digit9: 10,
+	Digit0: 11,
+	Minus: 12,
+	Equal: 13,
+	Backspace: 14,
+	Tab: 15,
+	KeyQ: 16,
+	KeyW: 17,
+	KeyE: 18,
+	KeyR: 19,
+	KeyT: 20,
+	KeyY: 21,
+	KeyU: 22,
+	KeyI: 23,
+	KeyO: 24,
+	KeyP: 25,
+	BracketLeft: 26,
+	BracketRight: 27,
+	Enter: 28,
+	ControlLeft: 29,
+	KeyA: 30,
+	KeyS: 31,
+	KeyD: 32,
+	KeyF: 33,
+	KeyG: 34,
+	KeyH: 35,
+	KeyJ: 36,
+	KeyK: 37,
+	KeyL: 38,
+	Semicolon: 39,
+	Quote: 40,
+	Backquote: 41,
+	ShiftLeft: 42,
+	Backslash: 43,
+	KeyZ: 44,
+	KeyX: 45,
+	KeyC: 46,
+	KeyV: 47,
+	KeyB: 48,
+	KeyN: 49,
+	KeyM: 50,
+	Comma: 51,
+	Period: 52,
+	Slash: 53,
+	ShiftRight: 54,
+	NumpadMultiply: 55,
+	AltLeft: 56,
+	Space: 57,
+	CapsLock: 58,
+	F1: 59,
+	F2: 60,
+	F3: 61,
+	F4: 62,
+	F5: 63,
+	F6: 64,
+	F7: 65,
+	F8: 66,
+	F9: 67,
+	F10: 68,
+	NumLock: 69,
+	ScrollLock: 70,
+	Numpad7: 71,
+	Numpad8: 72,
+	Numpad9: 73,
+	NumpadSubtract: 74,
+	Numpad4: 75,
+	Numpad5: 76,
+	Numpad6: 77,
+	NumpadAdd: 78,
+	Numpad1: 79,
+	Numpad2: 80,
+	Numpad3: 81,
+	Numpad0: 82,
+	NumpadDecimal: 83,
+	IntlBackslash: 86,
+	F11: 87,
+	F12: 88,
+	NumpadEnter: 96,
+	ControlRight: 97,
+	NumpadDivide: 98,
+	PrintScreen: 99,
+	AltRight: 100,
+	Home: 102,
+	ArrowUp: 103,
+	PageUp: 104,
+	ArrowLeft: 105,
+	ArrowRight: 106,
+	End: 107,
+	ArrowDown: 108,
+	PageDown: 109,
+	Insert: 110,
+	Delete: 111,
+	Pause: 119,
+	MetaLeft: 125,
+	MetaRight: 126,
+	ContextMenu: 127
+};
+//#endregion
+//#region src/keyboard.ts
+const CODE_TO_WINDOWS_VIRTUAL_KEY = {
+	Backspace: 8,
+	Tab: 9,
+	Enter: 13,
+	NumpadEnter: 13,
+	ShiftLeft: 16,
+	ShiftRight: 16,
+	ControlLeft: 17,
+	ControlRight: 17,
+	AltLeft: 18,
+	AltRight: 18,
+	Pause: 19,
+	CapsLock: 20,
+	Escape: 27,
+	Space: 32,
+	PageUp: 33,
+	PageDown: 34,
+	End: 35,
+	Home: 36,
+	ArrowLeft: 37,
+	ArrowUp: 38,
+	ArrowRight: 39,
+	ArrowDown: 40,
+	Insert: 45,
+	Delete: 46,
+	MetaLeft: 91,
+	MetaRight: 92,
+	ContextMenu: 93,
+	Semicolon: 186,
+	Equal: 187,
+	Comma: 188,
+	Minus: 189,
+	Period: 190,
+	Slash: 191,
+	Backquote: 192,
+	BracketLeft: 219,
+	Backslash: 220,
+	BracketRight: 221,
+	Quote: 222
+};
+const KEY_TO_WINDOWS_VIRTUAL_KEY = {
+	Backspace: 8,
+	Tab: 9,
+	Enter: 13,
+	Shift: 16,
+	Control: 17,
+	Alt: 18,
+	Pause: 19,
+	CapsLock: 20,
+	Escape: 27,
+	" ": 32,
+	PageUp: 33,
+	PageDown: 34,
+	End: 35,
+	Home: 36,
+	ArrowLeft: 37,
+	ArrowUp: 38,
+	ArrowRight: 39,
+	ArrowDown: 40,
+	Insert: 45,
+	Delete: 46,
+	Meta: 91,
+	ContextMenu: 93
+};
+const FORWARDED_BROWSER_SHORTCUT_CODES = /* @__PURE__ */ new Set([
+	"KeyA",
+	"KeyC",
+	"KeyF",
+	"KeyG",
+	"KeyH",
+	"KeyJ",
+	"KeyK",
+	"KeyL",
+	"KeyN",
+	"KeyO",
+	"KeyP",
+	"KeyR",
+	"KeyS",
+	"KeyT",
+	"KeyW",
+	"KeyX",
+	"KeyV",
+	"KeyZ",
+	"KeyY",
+	"BracketLeft",
+	"BracketRight",
+	"ArrowLeft",
+	"ArrowRight",
+	"ArrowUp",
+	"ArrowDown",
+	"Backspace",
+	"Delete",
+	"Enter",
+	"Tab"
+]);
+function keyboardModifiers(event) {
+	let modifiers = 0;
+	if (event.altKey) modifiers |= 1;
+	if (event.ctrlKey) modifiers |= 2;
+	if (event.metaKey) modifiers |= 4;
+	if (event.shiftKey) modifiers |= 8;
+	return modifiers;
+}
+function isPrintableKey(event) {
+	return event.key.length === 1 && !event.ctrlKey && !event.metaKey && !event.altKey;
+}
+function keyboardInputMessage(event, action) {
+	const virtualKeyCode = windowsVirtualKeyCodeForCodeOrKey(event.code, event.key);
+	const modifiers = keyboardModifiers(event);
+	const text = action === "down" && isPrintableKey(event) ? event.key : void 0;
+	const unmodifiedText = event.key.length === 1 ? event.key : void 0;
+	return {
+		key: event.key,
+		code: event.code,
+		text,
+		unmodifiedText,
+		modifiers,
+		windowsVirtualKeyCode: virtualKeyCode,
+		nativeVirtualKeyCode: virtualKeyCode,
+		location: event.location,
+		autoRepeat: event.repeat,
+		isKeypad: event.location === KeyboardEvent.DOM_KEY_LOCATION_NUMPAD
+	};
+}
+function shouldForwardBrowserShortcut(event) {
+	if (event.key === "Escape") return false;
+	if (isModifierCode(event.code)) return true;
+	if (!(event.metaKey || event.ctrlKey)) return true;
+	return FORWARDED_BROWSER_SHORTCUT_CODES.has(event.code);
+}
+function windowsVirtualKeyCodeForCodeOrKey(code, key) {
+	const byCode = code ? CODE_TO_WINDOWS_VIRTUAL_KEY[code] : void 0;
+	if (byCode !== void 0) return byCode;
+	if (code?.startsWith("Key") && code.length === 4) return code.charCodeAt(3);
+	if (code?.startsWith("Digit") && code.length === 6) return code.charCodeAt(5);
+	if (code?.startsWith("Numpad") && code.length === 7) {
+		const digit = Number(code.slice(6));
+		if (Number.isInteger(digit) && digit >= 0 && digit <= 9) return 96 + digit;
+	}
+	if (code?.startsWith("F")) {
+		const functionKey = Number(code.slice(1));
+		if (Number.isInteger(functionKey) && functionKey >= 1 && functionKey <= 24) return 111 + functionKey;
+	}
+	const byKey = key ? KEY_TO_WINDOWS_VIRTUAL_KEY[key] : void 0;
+	if (byKey !== void 0) return byKey;
+	if (key?.length === 1) return key.toUpperCase().charCodeAt(0);
+	return 0;
+}
+function isModifierCode(code) {
+	return code === "AltLeft" || code === "AltRight" || code === "ControlLeft" || code === "ControlRight" || code === "MetaLeft" || code === "MetaRight" || code === "ShiftLeft" || code === "ShiftRight";
+}
+//#endregion
+//#region src/protocol.ts
+const LIVE_SESSION_PROTOCOL = "aperture-session.v1";
+/**
+* Server messages are decoded strictly: an unknown property means the server speaks a
+* protocol revision this client does not understand.
+*/
+const strictParseOptions = { onExcessProperty: "error" };
+const int = Schema.Number.check(Schema.isInt());
+const positive = Schema.Number.check(Schema.isGreaterThan(0));
+const positiveInt = int.check(Schema.isGreaterThan(0));
+const unitInterval = Schema.Number.check(Schema.isBetween({
+	minimum: 0,
+	maximum: 1
+}));
+const emptyArray = Effect.succeed([]);
+function arrayOrEmpty(item) {
+	return Schema.Array(item).pipe(Schema.withDecodingDefaultKey(emptyArray));
+}
+const LeaseMode = Schema.Literals(["implicit", "explicit"]);
+const PresentationQuality = Schema.Struct({
+	profile: Schema.String,
+	fps: int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 120
+	})),
+	bitrateKbps: int.check(Schema.isGreaterThanOrEqualTo(100)),
+	keyframeInterval: positiveInt
+});
+const PresentationProfile = Schema.Struct({
+	id: Schema.String,
+	label: Schema.String,
+	codec: Schema.String,
+	mimeType: Schema.String,
+	sdpFmtpLine: Schema.String
+});
+const Presentation = Schema.Struct({
+	quality: Schema.optionalKey(PresentationQuality),
+	profiles: Schema.Array(PresentationProfile),
+	cursorVisible: Schema.Boolean
+});
+const Target = Schema.Struct({
+	id: Schema.String,
+	type: Schema.String,
+	title: Schema.String,
+	url: Schema.String,
+	loading: Schema.Boolean,
+	viewport: Schema.optionalKey(Schema.Struct({
+		width: positive,
+		height: positive,
+		contentWidth: positive,
+		contentHeight: positive,
+		canvasWidth: positive,
+		canvasHeight: positive,
+		deviceScaleFactor: positive
+	}))
+});
+const Participant = Schema.Struct({
+	clientId: Schema.String,
+	name: Schema.String,
+	avatarHash: Schema.String,
+	role: Schema.Literals([
+		"owner",
+		"editor",
+		"viewer",
+		"automation"
+	]),
+	activeTargetId: Schema.optionalKey(Schema.String),
+	followingClientId: Schema.optionalKey(Schema.String),
+	holdingInput: Schema.Boolean,
+	leaseMode: Schema.optionalKey(LeaseMode),
+	recovering: Schema.optionalKey(Schema.Boolean)
+});
+const Snapshot = Schema.Struct({
+	type: Schema.Literal("session.snapshot"),
+	clientId: Schema.String,
+	resumeSecret: Schema.String,
+	role: Schema.Literals([
+		"owner",
+		"editor",
+		"viewer"
+	]),
+	transport: Schema.Literals(["webrtc", "websocket"]),
+	holderClientId: Schema.optionalKey(Schema.String),
+	mode: Schema.optionalKey(LeaseMode),
+	activeTargetId: Schema.optionalKey(Schema.String),
+	targets: arrayOrEmpty(Target),
+	participants: arrayOrEmpty(Participant),
+	recordings: arrayOrEmpty(Recording),
+	presentation: Presentation
+});
+const PresenceState = Schema.Struct({
+	type: Schema.Literal("presence.state"),
+	participants: arrayOrEmpty(Participant)
+});
+const InputState = Schema.Struct({
+	type: Schema.Literal("input.state"),
+	holderClientId: Schema.optionalKey(Schema.String),
+	mode: Schema.optionalKey(LeaseMode)
+});
+const Cursor = Schema.Struct({
+	type: Schema.Literal("presence.cursor"),
+	clientId: Schema.String,
+	targetId: Schema.String,
+	x: unitInterval,
+	y: unitInterval,
+	realtimeCounter: positiveInt
+});
+const CursorClear = Schema.Struct({
+	type: Schema.Literal("presence.cursor.clear"),
+	clientId: Schema.String,
+	realtimeCounter: positiveInt
+});
+const Paint = Schema.Struct({
+	type: Schema.Literal("paint.point"),
+	clientId: Schema.String,
+	targetId: Schema.String,
+	strokeId: Schema.String,
+	color: Schema.String.check(Schema.isPattern(/^#[0-9a-fA-F]{6}$/)),
+	width: Schema.Number.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 16
+	})),
+	phase: Schema.Literals([
+		"start",
+		"move",
+		"end"
+	]),
+	x: unitInterval,
+	y: unitInterval,
+	realtimeCounter: Schema.optionalKey(positiveInt)
+});
+const TargetsState = Schema.Struct({
+	type: Schema.Literal("targets.state"),
+	activeTargetId: Schema.optionalKey(Schema.String),
+	targets: arrayOrEmpty(Target)
+});
+const RecordingsState = Schema.Struct({
+	type: Schema.Literal("recordings.state"),
+	recordings: arrayOrEmpty(Recording)
+});
+const PresentationState = Schema.Struct({
+	type: Schema.Literal("presentation.state"),
+	presentation: Presentation
+});
+const ErrorMessage = Schema.Struct({
+	type: Schema.Literal("error"),
+	code: Schema.String,
+	message: Schema.String
+});
+const CommandResult = Schema.Struct({
+	type: Schema.Literals([
+		"target.select.result",
+		"target.create.result",
+		"target.close.result",
+		"page.navigate.result",
+		"page.history-back.result",
+		"page.history-forward.result",
+		"page.reload.result",
+		"page.stop-loading.result",
+		"viewport.set.result",
+		"presentation.quality.set.result",
+		"presentation.cursor.set.result",
+		"recording.start.result",
+		"recording.stop.result",
+		"recording.cancel.result"
+	]),
+	requestId: Schema.String,
+	ok: Schema.Boolean,
+	code: Schema.optionalKey(Schema.String),
+	message: Schema.optionalKey(Schema.String),
+	targetId: Schema.optionalKey(Schema.String),
+	recording: Schema.optionalKey(Recording),
+	presentation: Schema.optionalKey(Presentation)
+});
+const LiveSessionServerMessage = Schema.Union([
+	Snapshot,
+	PresenceState,
+	InputState,
+	Cursor,
+	CursorClear,
+	Paint,
+	TargetsState,
+	RecordingsState,
+	PresentationState,
+	ErrorMessage,
+	CommandResult
+]);
+/** Decodes one JSON text frame from the server, or returns undefined when it is invalid. */
+const decodeServerMessage = Schema.decodeUnknownOption(Schema.fromJsonString(LiveSessionServerMessage), strictParseOptions);
+const RasterFrameHeader = Schema.Struct({
+	type: Schema.Literal("presentation.frame"),
+	targetId: Schema.String,
+	width: positive,
+	height: positive
+});
+//#endregion
+//#region src/viewport.ts
+const VIEWPORT_PRESETS = [
+	createViewportPreset(1280, 720, 1),
+	createViewportPreset(1440, 900, 1),
+	createViewportPreset(1920, 1080, 1),
+	createViewportPreset(2560, 1440, 1),
+	createViewportPreset(768, 1024, 1),
+	createViewportPreset(390, 844, 1)
+];
+const DEFAULT_VIEWPORT = VIEWPORT_PRESETS[0];
+const VIEWPORT_DEVICE_SCALE_FACTORS = [
+	1,
+	1.5,
+	2,
+	3
+];
+const STALE_FRAME_MS = 3e3;
+function createViewportPreset(width, height, deviceScaleFactor) {
+	return {
+		id: `${width}x${height}@${formatViewportScale(deviceScaleFactor)}`,
+		label: `${width}×${height}`,
+		width,
+		height,
+		deviceScaleFactor
+	};
+}
+function formatViewportScale(deviceScaleFactor) {
+	return Number.isInteger(deviceScaleFactor) ? String(deviceScaleFactor) : String(deviceScaleFactor).replace(/0+$/, "").replace(/\.$/, "");
+}
+function computeRenderMetrics(containerWidth, containerHeight, viewportWidth, viewportHeight) {
+	if (viewportWidth <= 0 || viewportHeight <= 0 || containerWidth <= 0 || containerHeight <= 0) return {
+		scale: 1,
+		offsetX: 0,
+		offsetY: 0,
+		renderedWidth: containerWidth,
+		renderedHeight: containerHeight
+	};
+	const scale = Math.min(containerWidth / viewportWidth, containerHeight / viewportHeight);
+	const renderedWidth = viewportWidth * scale;
+	const renderedHeight = viewportHeight * scale;
+	return {
+		scale,
+		offsetX: (containerWidth - renderedWidth) / 2,
+		offsetY: (containerHeight - renderedHeight) / 2,
+		renderedWidth,
+		renderedHeight
+	};
+}
+function mapClientToViewport(clientX, clientY, rect, viewportWidth, viewportHeight) {
+	const metrics = computeRenderMetrics(rect.width, rect.height, viewportWidth, viewportHeight);
+	const localX = clientX - rect.left - metrics.offsetX;
+	const localY = clientY - rect.top - metrics.offsetY;
+	if (localX < 0 || localY < 0 || localX > metrics.renderedWidth || localY > metrics.renderedHeight) return null;
+	return {
+		x: Math.round(localX / metrics.scale),
+		y: Math.round(localY / metrics.scale)
+	};
+}
+//#endregion
+//#region src/connection.ts
+var connection_exports = /* @__PURE__ */ __exportAll({
+	LiveSessionError: () => LiveSessionError,
+	make: () => make
+});
+/** A live session operation that could not complete. */
+var LiveSessionError = class extends Data.TaggedError("LiveSessionError") {};
+const SignalResponse = Schema.Union([
+	Schema.Struct({
+		version: Schema.Literal(1),
+		type: Schema.Literal("answer"),
+		sdp: Schema.String
+	}),
+	Schema.Struct({
+		version: Schema.Literal(1),
+		type: Schema.Literal("ice-candidate"),
+		candidate: Schema.Struct({
+			candidate: Schema.String,
+			sdpMid: Schema.optionalKey(Schema.NullOr(Schema.String)),
+			sdpMLineIndex: Schema.optionalKey(Schema.NullOr(Schema.Number.check(Schema.isInt()))),
+			usernameFragment: Schema.optionalKey(Schema.NullOr(Schema.String))
+		})
+	}),
+	Schema.Struct({
+		version: Schema.Literal(1),
+		type: Schema.Literal("error"),
+		error: Schema.Struct({
+			code: Schema.String,
+			message: Schema.String
+		})
+	})
+]);
+const decodeSignalResponse = Schema.decodeUnknownOption(Schema.fromJsonString(SignalResponse), strictParseOptions);
+const decodeRasterFrameHeader = Schema.decodeUnknownOption(Schema.fromJsonString(RasterFrameHeader), strictParseOptions);
+const WEBRTC_DEADLINE_MS = 5e3;
+const WEBSOCKET_RETRY_MS = 500;
+const WEBRTC_RETRY_MAX_MS = 15e3;
+/**
+* Opens a live session connection. It prefers WebRTC presentation, falls back to
+* WebSocket raster frames, and keeps retrying WebRTC in the background. Closing the scope
+* closes every transport and fails pending commands.
+*/
+const make = Effect.fnUntraced(function* (options) {
+	const { callbacks } = options;
+	const runFork = yield* FiberSet.makeRuntime();
+	const fork = (effect) => runFork(effect);
+	const after = (millis, f) => fork(Effect.sleep(millis).pipe(Effect.andThen(Effect.sync(f))));
+	let active = null;
+	let candidate = null;
+	let identity = null;
+	let preferredTransport = options.webrtcSupported ? "webrtc" : "websocket";
+	let transportRequest = null;
+	let disposed = false;
+	let retryTimer = null;
+	let webrtcRetryMs = 1e3;
+	let nextRequestId = 0;
+	let realtimeCounter = 0;
+	let inboundRealtimeCounter = 0;
+	let candidateMessages = [];
+	let candidateFrame = null;
+	const pendingCommands = /* @__PURE__ */ new Map();
+	const hello = () => ({
+		type: "session.hello",
+		...identity ?? options.identity
+	});
+	const transportCallbacks = {
+		hello,
+		message: (transport, message) => handleMessage(transport, message),
+		ready: (transport) => activate(transport),
+		failed: (transport, error) => transportFailed(transport, error),
+		frame: (transport, frame) => {
+			if (active === transport) callbacks.onFrame(frame);
+			else if (candidate === transport) candidateFrame = frame;
+		}
+	};
+	const dropCandidate = () => {
+		candidate?.close();
+		candidate = null;
+		candidateMessages = [];
+		candidateFrame = null;
+	};
+	const clearRetry = () => {
+		retryTimer?.interruptUnsafe();
+		retryTimer = null;
+	};
+	const rejectPending = (message) => {
+		const error = new LiveSessionError({ message });
+		for (const deferred of pendingCommands.values()) Deferred.doneUnsafe(deferred, Effect.fail(error));
+		pendingCommands.clear();
+	};
+	const rejectTransportRequest = (message) => {
+		if (!transportRequest) return;
+		const request = transportRequest;
+		transportRequest = null;
+		Deferred.doneUnsafe(request.deferred, Effect.fail(new LiveSessionError({ message })));
+	};
+	const startPreferredTransport = () => {
+		if (preferredTransport === "webrtc" && options.webrtcSupported) startWebRTC();
+		else startWebSocket();
+	};
+	const startWebRTC = () => {
+		if (disposed || candidate) return;
+		let transport;
+		try {
+			transport = new WebRTCSessionTransport({
+				baseUrl: options.baseUrl,
+				sessionId: options.sessionId,
+				credentials: options.credentials,
+				sessionToken: options.sessionToken,
+				iceServers: options.iceServers,
+				callbacks: transportCallbacks,
+				fork
+			});
+		} catch (cause) {
+			candidateFailed("webrtc", setupError(cause, "WebRTC setup failed"));
+			return;
+		}
+		candidate = transport;
+		candidateMessages = [];
+		candidateFrame = null;
+		transport.connect();
+		after(WEBRTC_DEADLINE_MS, () => {
+			if (candidate !== transport) return;
+			dropCandidate();
+			candidateFailed("webrtc", new LiveSessionError({ message: "WebRTC presentation timed out" }));
+		});
+	};
+	const startWebSocket = () => {
+		if (disposed || candidate) return;
+		let transport;
+		try {
+			transport = new WebSocketSessionTransport({
+				baseUrl: options.baseUrl,
+				sessionId: options.sessionId,
+				credentials: options.credentials,
+				sessionToken: options.sessionToken,
+				callbacks: transportCallbacks,
+				fork
+			});
+		} catch (cause) {
+			candidateFailed("websocket", setupError(cause, "WebSocket setup failed"));
+			return;
+		}
+		candidate = transport;
+		candidateMessages = [];
+		candidateFrame = null;
+		transport.connect();
+	};
+	const startWebSocketLater = (millis) => after(millis, () => {
+		if (!disposed && active === null && candidate === null) startWebSocket();
+	});
+	const activate = (transport) => {
+		if (disposed || candidate !== transport) {
+			transport.close();
+			return;
+		}
+		const previous = active;
+		const messages = candidateMessages;
+		const frame = candidateFrame;
+		if (previous && previous !== transport) rejectPending("live session transport replaced");
+		candidate = null;
+		candidateMessages = [];
+		candidateFrame = null;
+		active = transport;
+		realtimeCounter = 0;
+		inboundRealtimeCounter = 0;
+		webrtcRetryMs = 1e3;
+		callbacks.onPhase("connected");
+		callbacks.onTransport(transport.kind);
+		if (transportRequest?.kind === transport.kind) {
+			const request = transportRequest;
+			transportRequest = null;
+			Deferred.doneUnsafe(request.deferred, Effect.void);
+		}
+		if (transport instanceof WebRTCSessionTransport) {
+			callbacks.onFrame(null);
+			callbacks.onStream(transport.mediaStream());
+		} else {
+			callbacks.onStream(null);
+			if (frame) callbacks.onFrame(frame);
+		}
+		for (const message of messages) deliverMessage(message);
+		if (transport.kind === "websocket" && preferredTransport === "webrtc" && options.webrtcSupported) scheduleWebRTCRetry();
+		if (previous && previous !== transport) previous.close();
+	};
+	const transportFailed = (transport, error) => {
+		if (disposed) return;
+		if (candidate === transport) {
+			dropCandidate();
+			candidateFailed(transport.kind, error);
+			return;
+		}
+		if (active !== transport) return;
+		active = null;
+		transport.close();
+		rejectPending("live session transport was lost");
+		callbacks.onPhase("disconnected");
+		callbacks.onError(error.message);
+		callbacks.onFrame(null);
+		callbacks.onStream(null);
+		callbacks.onTransport(null);
+		startWebSocketLater(transport.kind === "webrtc" ? 0 : WEBSOCKET_RETRY_MS);
+	};
+	const handleMessage = (transport, message) => {
+		if (message.type === "error" && message.code === "resume_rejected" && candidate === transport && active === null) identity = null;
+		if (message.type === "session.snapshot") identity = {
+			clientId: message.clientId,
+			resumeSecret: message.resumeSecret
+		};
+		if (active !== transport) {
+			if (candidate !== transport) return;
+			candidateMessages.push(message);
+			if (message.type === "session.snapshot" && transport.kind === "websocket") activate(transport);
+			return;
+		}
+		deliverMessage(message);
+	};
+	const deliverMessage = (message) => {
+		if ("realtimeCounter" in message && message.realtimeCounter !== void 0) {
+			if (message.realtimeCounter <= inboundRealtimeCounter) return;
+			inboundRealtimeCounter = message.realtimeCounter;
+		}
+		if ("requestId" in message) {
+			const deferred = pendingCommands.get(message.requestId);
+			if (deferred) {
+				pendingCommands.delete(message.requestId);
+				Deferred.doneUnsafe(deferred, message.ok ? Effect.succeed(message) : Effect.fail(new LiveSessionError({ message: message.message ?? "live session command failed" })));
+			}
+		}
+		callbacks.onMessage(message);
+	};
+	const scheduleWebRTCRetry = () => {
+		if (disposed || preferredTransport !== "webrtc" || !options.webrtcSupported || active?.kind === "webrtc" || retryTimer !== null) return;
+		const delay = webrtcRetryMs;
+		webrtcRetryMs = Math.min(WEBRTC_RETRY_MAX_MS, webrtcRetryMs * 2);
+		retryTimer = after(delay, () => {
+			retryTimer = null;
+			startWebRTC();
+		});
+	};
+	const candidateFailed = (kind, error) => {
+		if (transportRequest?.kind === kind) {
+			rejectTransportRequest(error.message);
+			if (active) preferredTransport = active.kind;
+		}
+		if (active) {
+			if (active.kind === "websocket") scheduleWebRTCRetry();
+			return;
+		}
+		if (kind === "webrtc") {
+			startWebSocket();
+			return;
+		}
+		callbacks.onPhase("disconnected");
+		callbacks.onError(error.message);
+		startWebSocketLater(WEBSOCKET_RETRY_MS);
+	};
+	const sendReliable = (message) => active?.sendReliable(message) ?? false;
+	const sendRealtime = (message) => {
+		realtimeCounter += 1;
+		return active?.sendRealtime({
+			realtimeCounter,
+			...message
+		}) ?? false;
+	};
+	const close = () => {
+		disposed = true;
+		clearRetry();
+		dropCandidate();
+		active?.close();
+		active = null;
+		rejectTransportRequest("live session connection closed");
+		rejectPending("live session connection closed");
+		callbacks.onFrame(null);
+		callbacks.onStream(null);
+		callbacks.onTransport(null);
+	};
+	yield* Effect.addFinalizer(() => Effect.sync(close));
+	callbacks.onPhase("connecting");
+	startPreferredTransport();
+	return {
+		reconnect: Effect.sync(() => {
+			clearRetry();
+			dropCandidate();
+			active?.close();
+			active = null;
+			rejectTransportRequest("live session transport replaced");
+			rejectPending("live session transport replaced");
+			callbacks.onPhase("connecting");
+			startPreferredTransport();
+		}),
+		selectTransport: (kind) => Effect.suspend(() => {
+			if (kind === "webrtc" && !options.webrtcSupported) return Effect.fail(new LiveSessionError({ message: "WebRTC presentation is unavailable" }));
+			preferredTransport = kind;
+			clearRetry();
+			if (candidate && candidate.kind !== kind) dropCandidate();
+			rejectTransportRequest("presentation selection was replaced");
+			if (active?.kind === kind) return Effect.void;
+			const deferred = Deferred.makeUnsafe();
+			transportRequest = {
+				kind,
+				deferred
+			};
+			if (candidate === null) if (kind === "webrtc") startWebRTC();
+			else startWebSocket();
+			return Deferred.await(deferred);
+		}),
+		sendReliable,
+		sendRealtime,
+		command: (type, payload = {}) => Effect.suspend(() => {
+			nextRequestId += 1;
+			const requestId = `request-${nextRequestId}`;
+			const deferred = Deferred.makeUnsafe();
+			pendingCommands.set(requestId, deferred);
+			if (!sendReliable({
+				type,
+				requestId,
+				...payload
+			})) {
+				pendingCommands.delete(requestId);
+				return Effect.fail(new LiveSessionError({ message: "live session transport is unavailable" }));
+			}
+			return Deferred.await(deferred).pipe(Effect.onInterrupt(() => Effect.sync(() => pendingCommands.delete(requestId))));
+		})
+	};
+});
+function setupError(cause, fallback) {
+	return new LiveSessionError({ message: cause instanceof Error && cause.message ? cause.message : fallback });
+}
+var WebSocketSessionTransport = class {
+	kind = "websocket";
+	socket;
+	callbacks;
+	fork;
+	pendingRealtime = /* @__PURE__ */ new Map();
+	pendingRasterPacket = null;
+	rasterDecoder = null;
+	decodingRaster = false;
+	realtimeFrame = null;
+	closed = false;
+	constructor(options) {
+		this.callbacks = options.callbacks;
+		this.fork = options.fork;
+		this.socket = new WebSocket(sessionWebSocketURL(options.baseUrl, options.sessionId), sessionProtocols(options.credentials, options.sessionToken));
+		this.socket.binaryType = "blob";
+	}
+	connect() {
+		this.socket.addEventListener("open", () => {
+			this.sendReliable(this.callbacks.hello());
+		});
+		this.socket.addEventListener("message", (event) => {
+			if (typeof event.data === "string") {
+				const message = decodeServerMessage(event.data);
+				if (Option.isSome(message)) this.callbacks.message(this, message.value);
+				return;
+			}
+			if (event.data instanceof Blob) {
+				this.pendingRasterPacket = event.data;
+				if (!this.decodingRaster) {
+					this.decodingRaster = true;
+					this.rasterDecoder = this.fork(this.decodeRasterPackets());
+				}
+			}
+		});
+		this.socket.addEventListener("close", () => {
+			if (!this.closed) this.callbacks.failed(this, new LiveSessionError({ message: "WebSocket session transport closed" }));
+		});
+		this.socket.addEventListener("error", () => {
+			if (!this.closed) this.callbacks.failed(this, new LiveSessionError({ message: "WebSocket session transport failed" }));
+		});
+	}
+	sendReliable(message) {
+		this.flushRealtime();
+		return this.sendNow(message);
+	}
+	sendRealtime(message) {
+		if (this.socket.readyState !== WebSocket.OPEN) return false;
+		this.pendingRealtime.delete(message.type);
+		this.pendingRealtime.set(message.type, message);
+		if (this.realtimeFrame === null) this.realtimeFrame = window.requestAnimationFrame(() => {
+			this.realtimeFrame = null;
+			this.flushRealtime();
+		});
+		return true;
+	}
+	close() {
+		this.closed = true;
+		this.pendingRasterPacket = null;
+		this.rasterDecoder?.interruptUnsafe();
+		this.rasterDecoder = null;
+		if (this.realtimeFrame !== null) {
+			window.cancelAnimationFrame(this.realtimeFrame);
+			this.realtimeFrame = null;
+		}
+		this.pendingRealtime.clear();
+		this.socket.close();
+	}
+	decodeRasterPackets() {
+		return Effect.gen({ self: this }, function* () {
+			while (true) {
+				const packet = this.pendingRasterPacket;
+				if (packet === null || this.closed) {
+					this.decodingRaster = false;
+					return;
+				}
+				this.pendingRasterPacket = null;
+				const frame = yield* decodeRasterFrame(packet);
+				if (Option.isSome(frame) && !this.closed) this.callbacks.frame(this, frame.value);
+			}
+		});
+	}
+	flushRealtime() {
+		if (this.realtimeFrame !== null) {
+			window.cancelAnimationFrame(this.realtimeFrame);
+			this.realtimeFrame = null;
+		}
+		for (const message of this.pendingRealtime.values()) this.sendNow(message);
+		this.pendingRealtime.clear();
+	}
+	sendNow(message) {
+		if (this.socket.readyState !== WebSocket.OPEN) return false;
+		this.socket.send(JSON.stringify(message));
+		return true;
+	}
+};
+var WebRTCSessionTransport = class {
+	kind = "webrtc";
+	connection;
+	reliable;
+	realtime;
+	signal;
+	callbacks;
+	fork;
+	pendingCandidates = [];
+	reliableOpen = false;
+	realtimeOpen = false;
+	helloSent = false;
+	snapshotReceived = false;
+	stream = null;
+	streamReady = false;
+	closed = false;
+	constructor(options) {
+		this.callbacks = options.callbacks;
+		this.fork = options.fork;
+		this.connection = new RTCPeerConnection({ iceServers: options.iceServers.map((server) => ({
+			...server,
+			urls: [...server.urls]
+		})) });
+		this.reliable = this.connection.createDataChannel("application", { ordered: true });
+		this.realtime = this.connection.createDataChannel("application-realtime", {
+			ordered: false,
+			maxRetransmits: 0
+		});
+		this.connection.addTransceiver("video", { direction: "recvonly" });
+		this.signal = new WebSocket(signalWebSocketURL(options.baseUrl, options.sessionId), sessionProtocols(options.credentials, options.sessionToken));
+	}
+	connect() {
+		this.reliable.addEventListener("open", () => {
+			this.reliableOpen = true;
+			this.sendHello();
+		});
+		this.realtime.addEventListener("open", () => {
+			this.realtimeOpen = true;
+			this.sendHello();
+		});
+		this.reliable.addEventListener("message", (event) => this.handleApplicationMessage(event));
+		this.realtime.addEventListener("message", (event) => this.handleApplicationMessage(event));
+		for (const channel of [this.reliable, this.realtime]) {
+			channel.addEventListener("close", () => this.fail("WebRTC session channel closed"));
+			channel.addEventListener("error", () => this.fail("WebRTC session channel failed"));
+		}
+		this.connection.addEventListener("track", (event) => {
+			this.stream = event.streams[0] ?? new MediaStream([event.track]);
+			const ready = () => {
+				if (!this.stream) return;
+				this.streamReady = true;
+				this.maybeReady();
+			};
+			if (event.track.muted) event.track.addEventListener("unmute", ready, { once: true });
+			else ready();
+		});
+		this.connection.addEventListener("icecandidate", (event) => {
+			if (event.candidate && this.signal.readyState === WebSocket.OPEN) this.signal.send(JSON.stringify({
+				version: 1,
+				type: "ice-candidate",
+				candidate: event.candidate.toJSON()
+			}));
+		});
+		this.connection.addEventListener("connectionstatechange", () => {
+			if (this.connection.connectionState === "failed" || this.connection.connectionState === "closed") this.fail(`WebRTC ${this.connection.connectionState}`);
+		});
+		this.signal.addEventListener("open", () => {
+			this.fork(this.sendOffer().pipe(Effect.catchTag("LiveSessionError", (error) => Effect.sync(() => this.fail(error.message)))));
+		});
+		this.signal.addEventListener("message", (event) => this.handleSignal(event));
+		this.signal.addEventListener("close", () => this.fail("WebRTC signaling closed"));
+		this.signal.addEventListener("error", () => this.fail("WebRTC signaling failed"));
+	}
+	sendReliable(message) {
+		if (this.reliable.readyState !== "open") return false;
+		this.reliable.send(JSON.stringify(message));
+		return true;
+	}
+	sendRealtime(message) {
+		if (this.realtime.readyState !== "open") return false;
+		this.realtime.send(JSON.stringify(message));
+		return true;
+	}
+	close() {
+		this.closed = true;
+		this.reliable.close();
+		this.realtime.close();
+		this.connection.close();
+		this.signal.close();
+	}
+	mediaStream() {
+		return this.stream;
+	}
+	sendHello() {
+		if (this.helloSent || !this.reliableOpen || !this.realtimeOpen) return;
+		this.helloSent = this.sendReliable(this.callbacks.hello());
+	}
+	handleApplicationMessage(event) {
+		if (typeof event.data !== "string") return;
+		const message = decodeServerMessage(event.data);
+		if (Option.isNone(message)) {
+			this.fail("WebRTC session message is invalid");
+			return;
+		}
+		this.callbacks.message(this, message.value);
+		if (message.value.type === "session.snapshot") {
+			this.snapshotReceived = true;
+			this.maybeReady();
+		}
+	}
+	handleSignal(event) {
+		const decoded = typeof event.data === "string" ? decodeSignalResponse(event.data) : Option.none();
+		if (Option.isNone(decoded)) {
+			this.fail("WebRTC signaling message is invalid");
+			return;
+		}
+		const signal = decoded.value;
+		if (signal.type === "error") {
+			this.fail(signal.error.message);
+			return;
+		}
+		if (signal.type === "answer") {
+			this.fork(Effect.tryPromise(() => this.connection.setRemoteDescription({
+				type: "answer",
+				sdp: signal.sdp
+			})).pipe(Effect.andThen(Effect.suspend(() => Effect.forEach(this.pendingCandidates.splice(0), (candidate) => Effect.tryPromise(() => this.connection.addIceCandidate(candidate)), { discard: true }))), Effect.catch(() => Effect.sync(() => this.fail("WebRTC answer is invalid")))));
+			return;
+		}
+		if (!this.connection.remoteDescription) {
+			this.pendingCandidates.push(signal.candidate);
+			return;
+		}
+		this.fork(Effect.tryPromise(() => this.connection.addIceCandidate(signal.candidate)).pipe(Effect.catch(() => Effect.sync(() => this.fail("WebRTC ICE candidate is invalid")))));
+	}
+	sendOffer() {
+		return Effect.gen({ self: this }, function* () {
+			const negotiationFailed = (cause) => setupError(cause, "WebRTC negotiation failed");
+			const offer = yield* Effect.tryPromise({
+				try: () => this.connection.createOffer(),
+				catch: negotiationFailed
+			});
+			yield* Effect.tryPromise({
+				try: () => this.connection.setLocalDescription(offer),
+				catch: negotiationFailed
+			});
+			const sdp = this.connection.localDescription?.sdp;
+			if (!sdp) return yield* new LiveSessionError({ message: "WebRTC offer is unavailable" });
+			this.signal.send(JSON.stringify({
+				version: 1,
+				type: "offer",
+				sdp
+			}));
+		});
+	}
+	maybeReady() {
+		if (this.snapshotReceived && this.stream && this.streamReady) this.callbacks.ready(this);
+	}
+	fail(message) {
+		if (!this.closed) this.callbacks.failed(this, new LiveSessionError({ message }));
+	}
+};
+function decodeRasterFrame(packet) {
+	return Effect.gen(function* () {
+		if (packet.size < 4) return Option.none();
+		const prefix = yield* Effect.tryPromise(() => packet.slice(0, 4).arrayBuffer());
+		const headerLength = new DataView(prefix).getUint32(0);
+		if (headerLength === 0 || headerLength > packet.size - 4) return Option.none();
+		const header = decodeRasterFrameHeader(yield* Effect.tryPromise(() => packet.slice(4, 4 + headerLength).text()));
+		return Option.map(header, (value) => ({
+			targetId: value.targetId,
+			data: packet.slice(4 + headerLength, packet.size, "image/jpeg"),
+			width: value.width,
+			height: value.height
+		}));
+	}).pipe(Effect.orElseSucceed(() => Option.none()));
+}
+function sessionWebSocketURL(baseUrl, sessionId) {
+	return webSocketURL(baseUrl, `/sessions/${encodeURIComponent(sessionId)}/session`);
+}
+function signalWebSocketURL(baseUrl, sessionId) {
+	return webSocketURL(baseUrl, `/sessions/${encodeURIComponent(sessionId)}/webrtc/signal`);
+}
+function webSocketURL(baseUrl, path) {
+	const url = new URL(path, baseUrl ?? window.location.href);
+	url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+	return url.toString();
+}
+function sessionProtocols(credentials, sessionToken) {
+	const protocols = [LIVE_SESSION_PROTOCOL];
+	if (sessionToken) protocols.push(`authorization.bearer.${sessionToken}`);
+	else if (credentials.kind === "bearer") protocols.push(`authorization.bearer.${credentials.token}`);
+	const tenantId = resolveTenantHeader(credentials, "tenant-scoped");
+	if (tenantId) protocols.push(`x-aperture-tenant-id.${tenantId}`);
+	return protocols;
+}
+//#endregion
+export { DEFAULT_VIEWPORT, LIVE_SESSION_PROTOCOL, connection_exports as LiveSessionConnection, LiveSessionError, LiveSessionServerMessage, RasterFrameHeader, STALE_FRAME_MS, VIEWPORT_DEVICE_SCALE_FACTORS, VIEWPORT_PRESETS, computeRenderMetrics, createViewportPreset, decodeServerMessage, evdevKeycodeByCode, formatViewportScale, isPrintableKey, keyboardInputMessage, keyboardModifiers, mapClientToViewport, shouldForwardBrowserShortcut, strictParseOptions, windowsVirtualKeyCodeForCodeOrKey };
+
+//# sourceMappingURL=index.js.map