@decartai/sdk 0.1.14 → 0.1.16

package/dist/realtime/browser/glass-to-glass.js

@@ -1,212 +0,0 @@
-import { createFrameTransformPump } from "./mirror-stream.js";
-import { MAX_MARKER_HEIGHT, MIN_MARKER_WIDTH, read, stamp } from "./pixel-marker.js";
-//#region src/realtime/browser/glass-to-glass.ts
-/** Bound on in-flight seqs; a seq that ages out unmatched is an end-to-end drop. Cf. server `_MAX_PENDING`. */
-const MAX_PENDING = 256;
-/** Rolling window for the latency percentiles (≈10s at 30fps). */
-const LATENCY_WINDOW = 300;
-/** Rolling window of delivered/dropped outcomes for the drop ratio. */
-const OUTCOME_WINDOW = 300;
-/** Don't report a drop ratio until this many outcomes exist (head-of-stream frames are still in flight). */
-const DROP_MIN_OUTCOMES = 30;
-/** Discard implausible deltas (clock weirdness, seq wrap collisions). */
-const MAX_PLAUSIBLE_MS = 6e4;
-/**
-* After the first frame, ignore this long before counting steady-state samples.
-* The first frames after a cold start run slow while the pipeline warms; folding
-* them into the mid-stream median would inflate it. (TTFF still captures the
-* first frame.)
-*/
-const MID_STREAM_WARMUP_MS = 2e3;
-/**
-* Matches outgoing stamp times to incoming render times. Shared by the stamp
-* pump (writer) and the marker reader (matcher); owned by `RealtimeObservability`.
-*
-* Tracks two latencies: TTFF (start → first frame) and mid-stream median (steady
-* state, after a warm-up). Call `markStart()` at the beginning of each connect
-* attempt so TTFF measures the full setup→first-frame wait.
-*/
-var SeqTracker = class {
-	stampTimes = /* @__PURE__ */ new Map();
-	latencies = [];
-	/** true = delivered (matched), false = dropped (aged out unmatched). */
-	outcomes = [];
-	nextSeq = 0;
-	startMs = null;
-	firstMatchMs = null;
-	ttffMs = null;
-	/** Mark the start of a connect attempt; resets measurement state. TTFF is measured from here. */
-	markStart(nowMs) {
-		this.reset();
-		this.startMs = nowMs;
-	}
-	/** Allocate the next seq for an outgoing frame and record its stamp time. Returns the 16-bit seq. */
-	stampNext(nowMs) {
-		const seq = this.nextSeq & 65535;
-		this.nextSeq = this.nextSeq + 1 & 65535;
-		this.stampTimes.set(seq, nowMs);
-		if (this.stampTimes.size > MAX_PENDING) {
-			const oldest = this.stampTimes.keys().next();
-			if (!oldest.done) {
-				this.stampTimes.delete(oldest.value);
-				if (this.isPastWarmup(nowMs)) this.recordOutcome(false);
-			}
-		}
-		return seq;
-	}
-	/** Match a seq read off an inbound rendered frame. Ignores unknown/duplicate seqs. */
-	recordInbound(seq, nowMs) {
-		const stampedAt = this.stampTimes.get(seq);
-		if (stampedAt === void 0) return;
-		this.stampTimes.delete(seq);
-		const g2g = nowMs - stampedAt;
-		if (g2g < 0 || g2g > MAX_PLAUSIBLE_MS) return;
-		if (this.firstMatchMs === null) {
-			this.firstMatchMs = nowMs;
-			if (this.startMs !== null) this.ttffMs = nowMs - this.startMs;
-			for (const [key, stampTime] of this.stampTimes) if (stampTime < stampedAt) this.stampTimes.delete(key);
-			else break;
-		}
-		if (!this.isPastWarmup(nowMs)) return;
-		this.latencies.push(g2g);
-		if (this.latencies.length > LATENCY_WINDOW) this.latencies.shift();
-		this.recordOutcome(true);
-	}
-	snapshot() {
-		const sorted = [...this.latencies].sort((a, b) => a - b);
-		const n = sorted.length;
-		const medianMs = n === 0 ? null : n % 2 === 0 ? Math.round((sorted[n / 2 - 1] + sorted[n / 2]) / 2) : Math.round(sorted[(n - 1) / 2]);
-		const p90Ms = n === 0 ? null : Math.round(sorted[Math.min(n - 1, Math.floor(.9 * n))]);
-		let dropRatio = null;
-		if (this.outcomes.length >= DROP_MIN_OUTCOMES) dropRatio = this.outcomes.reduce((acc, delivered) => acc + (delivered ? 0 : 1), 0) / this.outcomes.length;
-		return {
-			ttffMs: this.ttffMs,
-			medianMs,
-			p90Ms,
-			sampleCount: n,
-			dropRatio
-		};
-	}
-	/** Clear measurement state. Keeps `nextSeq` monotonic to avoid stale collisions. */
-	reset() {
-		this.stampTimes.clear();
-		this.latencies.length = 0;
-		this.outcomes.length = 0;
-		this.startMs = null;
-		this.firstMatchMs = null;
-		this.ttffMs = null;
-	}
-	isPastWarmup(nowMs) {
-		return this.firstMatchMs !== null && nowMs >= this.firstMatchMs + MID_STREAM_WARMUP_MS;
-	}
-	recordOutcome(delivered) {
-		this.outcomes.push(delivered);
-		if (this.outcomes.length > OUTCOME_WINDOW) this.outcomes.shift();
-	}
-};
-/**
-* Wrap `input` so every published video frame carries a fresh marker (drawn into
-* the bottom-left band). Built on the shared frame-transform pump; no-ops when
-* there's no video track or the frame is too small to hold the marker.
-*/
-function createStampPump(input, opts) {
-	const { tracker, fps } = opts;
-	const stampIntervalMs = 1e3 / fps;
-	let lastStampMs = 0;
-	let currentSeq = null;
-	return createFrameTransformPump(input, {
-		fps,
-		transform: (ctx, source, w, h) => {
-			ctx.drawImage(source, 0, 0, w, h);
-			if (w < MIN_MARKER_WIDTH || h < 32) return;
-			const now = performance.now();
-			if (currentSeq === null || now - lastStampMs >= stampIntervalMs - 1) {
-				currentSeq = tracker.stampNext(now);
-				lastStampMs = now;
-			}
-			const band = ctx.getImageData(0, h - 32, w, 32);
-			stamp(band, currentSeq);
-			ctx.putImageData(band, 0, h - 32);
-		}
-	});
-}
-/**
-* Drives `onFrame` once per rendered video frame. Prefers
-* `requestVideoFrameCallback` (fires per decoded frame) over `requestAnimationFrame`
-* (fires at display refresh — ~2× the work on a 30fps stream shown at 60Hz).
-* The `typeof` guard keeps the rAF fallback for browsers that lack rVFC.
-*/
-function createFrameScheduler(video, onFrame) {
-	const supportsRvfc = typeof video.requestVideoFrameCallback === "function";
-	let handle = null;
-	let running = false;
-	const schedule = () => {
-		if (!running) return;
-		handle = supportsRvfc ? video.requestVideoFrameCallback(tick) : requestAnimationFrame(tick);
-	};
-	const tick = () => {
-		if (!running) return;
-		onFrame();
-		schedule();
-	};
-	return {
-		start: () => {
-			if (running) return;
-			running = true;
-			schedule();
-		},
-		stop: () => {
-			running = false;
-			if (handle === null) return;
-			if (supportsRvfc) video.cancelVideoFrameCallback(handle);
-			else cancelAnimationFrame(handle);
-			handle = null;
-		}
-	};
-}
-/**
-* Passively read markers off the rendered remote video. Uses a hidden `<video>`
-* fed by the same track (a track can drive multiple sinks), reading only the
-* bottom band per rendered frame — never consumes or re-encodes the displayed track.
-*/
-function createMarkerReader(tracker) {
-	if (typeof document === "undefined") return {
-		attach: () => {},
-		dispose: () => {}
-	};
-	const video = document.createElement("video");
-	video.muted = true;
-	video.playsInline = true;
-	video.autoplay = true;
-	const canvas = document.createElement("canvas");
-	const ctx = canvas.getContext("2d", { willReadFrequently: true });
-	let attachedTrack = null;
-	const readFrame = () => {
-		const w = video.videoWidth;
-		const h = video.videoHeight;
-		if (w === 0 || h === 0 || !ctx) return;
-		const band = Math.min(h, MAX_MARKER_HEIGHT);
-		if (canvas.width !== w) canvas.width = w;
-		if (canvas.height !== band) canvas.height = band;
-		ctx.drawImage(video, 0, h - band, w, band, 0, 0, w, band);
-		const seq = read(ctx.getImageData(0, 0, w, band));
-		if (seq !== null) tracker.recordInbound(seq, performance.now());
-	};
-	const scheduler = createFrameScheduler(video, readFrame);
-	return {
-		attach: (track) => {
-			if (track === attachedTrack) return;
-			attachedTrack = track;
-			video.srcObject = new MediaStream([track]);
-			video.play().catch(() => {});
-			scheduler.start();
-		},
-		dispose: () => {
-			scheduler.stop();
-			attachedTrack = null;
-			video.srcObject = null;
-		}
-	};
-}
-//#endregion
-export { SeqTracker, createMarkerReader, createStampPump };

package/dist/realtime/browser/pixel-marker.js

@@ -1,144 +0,0 @@
-//#region src/realtime/browser/pixel-marker.ts
-const SYNC = [
-	200,
-	50,
-	200,
-	50
-];
-const SYNC_LEN = SYNC.length;
-const DATA_BITS = 16;
-const CHECKSUM_BITS = 4;
-/** 4 sync + 16 data + 4 checksum logical columns. */
-const TOTAL_LOGICAL = SYNC_LEN + DATA_BITS + CHECKSUM_BITS;
-/** Redundant logical rows, majority-voted on read. */
-const MARKER_ROWS = 4;
-/** Physical pixels per logical pixel when stamping (native resolution). */
-const BLOCK_SIZE = 8;
-/**
-* Candidate received block sizes, ordered by likelihood (nominal 8, no transport
-* scaling). Smaller values appear when WebRTC BWE downscales the stream; larger
-* when the sender upscales pre-encode. Mirrors `_CANDIDATE_BLOCK_SIZES`.
-*/
-const CANDIDATE_BLOCK_SIZES = [
-	8,
-	4,
-	6,
-	2,
-	12,
-	10,
-	16,
-	5,
-	7,
-	14,
-	3
-];
-/** Smallest frame that can hold the marker at nominal block size. */
-const MIN_MARKER_WIDTH = TOTAL_LOGICAL * BLOCK_SIZE;
-MARKER_ROWS * BLOCK_SIZE;
-/** Tallest the marker can be in a received frame (largest auto-detect block size). */
-const MAX_MARKER_HEIGHT = MARKER_ROWS * Math.max(...CANDIDATE_BLOCK_SIZES);
-/** BT.601 luma approximation (integer, matches a >=128 threshold either way). */
-function luma(r, g, b) {
-	return 77 * r + 150 * g + 29 * b >> 8;
-}
-const isHigh = (v) => v >= 128;
-/** XOR of the four 4-bit nibbles of the 16-bit seq (matches the server). */
-function checksumNibbles(seq) {
-	let checksum = 0;
-	for (let i = 0; i < DATA_BITS; i += 4) checksum ^= seq >> i & 15;
-	return checksum;
-}
-/** The TOTAL_LOGICAL grayscale values for one logical row encoding `seq`. */
-function rowValues(seq) {
-	const masked = seq & 65535;
-	const values = [...SYNC];
-	for (let i = 0; i < DATA_BITS; i++) values.push(masked >> DATA_BITS - 1 - i & 1 ? 200 : 50);
-	const checksum = checksumNibbles(masked);
-	for (let i = 0; i < CHECKSUM_BITS; i++) values.push(checksum >> CHECKSUM_BITS - 1 - i & 1 ? 200 : 50);
-	return values;
-}
-/**
-* Stamp `seq` into the bottom-left of `img` as grayscale blocks (mutates in
-* place). Returns false (no-op) if the frame is too small to hold the marker.
-* Always stamps at BLOCK_SIZE=8, matching the server's native-resolution stamp.
-*/
-function stamp(img, seq) {
-	const { width, height, data } = img;
-	if (width < MIN_MARKER_WIDTH || height < 32) return false;
-	const values = rowValues(seq);
-	for (let logRow = 0; logRow < MARKER_ROWS; logRow++) {
-		const rowStart = height - (MARKER_ROWS - logRow) * BLOCK_SIZE;
-		for (let by = 0; by < BLOCK_SIZE; by++) {
-			const y = rowStart + by;
-			if (y < 0 || y >= height) continue;
-			for (let logCol = 0; logCol < TOTAL_LOGICAL; logCol++) {
-				const v = values[logCol];
-				const xStart = logCol * BLOCK_SIZE;
-				const xEnd = Math.min(xStart + BLOCK_SIZE, width);
-				for (let x = xStart; x < xEnd; x++) {
-					const o = (y * width + x) * 4;
-					data[o] = v;
-					data[o + 1] = v;
-					data[o + 2] = v;
-					data[o + 3] = 255;
-				}
-			}
-		}
-	}
-	return true;
-}
-function syncMatches(rowValues) {
-	for (let i = 0; i < SYNC_LEN; i++) if (isHigh(SYNC[i]) !== isHigh(rowValues[i])) return false;
-	return true;
-}
-/**
-* Read the marker seq from the bottom of `img`, or null if absent/unreadable.
-* Auto-detects the received block size so it works at any received resolution
-* (the transport may uniformly scale the frame after the server stamped it).
-*/
-function read(img) {
-	const { width, height, data } = img;
-	const sample = (row, col) => {
-		const o = (row * width + col) * 4;
-		return luma(data[o], data[o + 1], data[o + 2]);
-	};
-	for (const blockSize of CANDIDATE_BLOCK_SIZES) {
-		if (width < TOTAL_LOGICAL * blockSize || height < MARKER_ROWS * blockSize) continue;
-		const seq = decodeAtBlockSize(sample, width, height, blockSize);
-		if (seq !== null) return seq;
-	}
-	return null;
-}
-function decodeAtBlockSize(sample, width, height, blockSize) {
-	const half = blockSize >> 1;
-	const validRows = [];
-	for (let logRow = 0; logRow < MARKER_ROWS; logRow++) {
-		let row = height - (MARKER_ROWS - logRow) * blockSize + half;
-		row = Math.max(0, Math.min(row, height - 1));
-		const rv = [];
-		for (let logCol = 0; logCol < TOTAL_LOGICAL; logCol++) {
-			let col = logCol * blockSize + half;
-			col = Math.max(0, Math.min(col, width - 1));
-			rv.push(sample(row, col));
-		}
-		if (syncMatches(rv)) validRows.push(rv);
-	}
-	if (validRows.length === 0) return null;
-	const threshold = validRows.length / 2;
-	let seq = 0;
-	for (let i = 0; i < DATA_BITS; i++) {
-		let votes = 0;
-		for (const rv of validRows) if (isHigh(rv[SYNC_LEN + i])) votes++;
-		if (votes > threshold) seq |= 1 << DATA_BITS - 1 - i;
-	}
-	const expectedChecksum = checksumNibbles(seq);
-	let actualChecksum = 0;
-	for (let i = 0; i < CHECKSUM_BITS; i++) {
-		let votes = 0;
-		for (const rv of validRows) if (isHigh(rv[SYNC_LEN + DATA_BITS + i])) votes++;
-		if (votes > threshold) actualChecksum |= 1 << CHECKSUM_BITS - 1 - i;
-	}
-	return expectedChecksum === actualChecksum ? seq : null;
-}
-//#endregion
-export { MAX_MARKER_HEIGHT, MIN_MARKER_WIDTH, read, stamp };