@platless/axom-cli 0.5.9 → 0.6.52

package/dist/workstation/desktopControl/quicMedia.js

@@ -0,0 +1,240 @@
+import { spawn } from 'node:child_process';
+import { access } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { once } from 'node:events';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { bounded, DesktopQueue, NativeCommandError } from './helperProcess.js';
+import { mediaRequire } from './media.js';
+import { decodeQuicPathStats } from './networkEvidence.js';
+const safeU64 = (b, offset) => { const n = b.readBigUInt64BE(offset); mediaRequire(n <= BigInt(Number.MAX_SAFE_INTEGER)); return Number(n); };
+export function decodeQuicCutEvent(bytes) {
+    mediaRequire(bytes.length === 48 && bytes[0] === 1 && bytes[1] >= 1 && bytes[1] <= 6 && bytes[2] <= 7 && bytes[3] === 0 && bytes.readUInt32BE(20) === 0);
+    const value = { action: bytes[1], reason: bytes[2], epoch: bytes.readUInt32BE(4), cutId: safeU64(bytes, 8), pictureThrough: bytes.readUInt32BE(16), frameThrough: safeU64(bytes, 24), wireThrough: safeU64(bytes, 32), motionCommittedBytes: safeU64(bytes, 40) };
+    mediaRequire(value.epoch > 0 && (value.action === 1 || value.cutId > 0));
+    return value;
+}
+export class DesktopMediaAdmissionCancelled extends NativeCommandError {
+    cutId;
+    epoch;
+    pictureSequence;
+    constructor(cutId, epoch, pictureSequence) {
+        super('transport_failed');
+        this.cutId = cutId;
+        this.epoch = epoch;
+        this.pictureSequence = pictureSequence;
+    }
+}
+export const isQuicMediaQueueEvent = (kind) => kind === 1 || kind === 2 || kind === 3 || kind === 4;
+/** At most one unresolved ticket per lane, sharing the caller's existing bounded reservation. */
+export class DesktopQuicAdmission {
+    peer;
+    write;
+    pending = new Map();
+    nextId = 0n;
+    totals = new Map([[0, [0, 0, 0]]]);
+    epoch = 0;
+    dead = false;
+    cut;
+    constructor(peer, write) {
+        this.peer = peer;
+        this.write = write;
+    }
+    ownCut(id, epoch, pictureThrough) { mediaRequire(Number.isSafeInteger(id) && id > 0 && epoch > 0 && !this.cut); this.cut = { id, epoch, pictureThrough }; }
+    finishCut(id) { mediaRequire(this.cut?.id === id); this.cut = undefined; }
+    async send(kind, bytes) {
+        mediaRequire(!this.dead && (kind === 2 || kind === 3) && bytes.length > 0 && bytes.length <= 65600);
+        let lane = 255, epoch = 0, sequence = 0, payloadBytes = 0;
+        if (kind === 3) {
+            mediaRequire(bytes.length >= 65 && bytes.subarray(0, 5).equals(Buffer.from('AXDS\x01')));
+            lane = bytes[5] <= 2 ? 0 : bytes[5] <= 4 ? 1 : 2;
+            epoch = bytes.readUInt32BE(12);
+            sequence = bytes.readUInt32BE(20);
+            payloadBytes = bytes.length - 64;
+            mediaRequire(bytes[5] >= 1 && bytes[5] <= 5 && epoch > 0 && sequence > 0);
+            if (bytes[5] === 1) {
+                mediaRequire(epoch > this.epoch);
+                const oldest = [...this.totals.keys()].filter(e => e !== 0 && e !== this.epoch);
+                for (const old of oldest) {
+                    mediaRequire(![...this.pending.values()].some(p => p.epoch === old));
+                    this.totals.delete(old);
+                }
+                this.epoch = epoch;
+                if (!this.totals.has(epoch))
+                    this.totals.set(epoch, [0, 0, 0]);
+            }
+            else {
+                mediaRequire(epoch === this.epoch || this.epoch === 0);
+                if (!this.totals.has(epoch))
+                    this.totals.set(epoch, [0, 0, 0]);
+            }
+        }
+        mediaRequire(![...this.pending.values()].some(p => p.lane === lane));
+        const id = ++this.nextId;
+        mediaRequire(id <= BigInt(Number.MAX_SAFE_INTEGER));
+        const header = Buffer.alloc(21);
+        header.writeUInt32BE(bytes.length + 17);
+        header[4] = kind;
+        header.writeBigUInt64BE(this.peer, 5);
+        header.writeBigUInt64BE(id, 13);
+        return new Promise((resolve, reject) => {
+            const item = { id, kind, lane, epoch, sequence, payloadBytes, frame: Buffer.concat([header, bytes]), resolve, reject, busy: false, deadline: setTimeout(() => { this.close(new NativeCommandError('transport_failed')); }, 5000) };
+            this.pending.set(id, item);
+            void this.write(item.frame).catch(e => this.close(e));
+        });
+    }
+    accept(peer, bytes) {
+        mediaRequire(peer === this.peer && bytes.length === 32 && bytes.readUInt16BE(10) === 0 && bytes.readUInt32BE(20) === 0);
+        const id = bytes.readBigUInt64BE(), p = this.pending.get(id);
+        mediaRequire(p && bytes[8] >= 1 && bytes[8] <= 3 && bytes[9] === p.lane && bytes.readUInt32BE(12) === p.epoch && bytes.readUInt32BE(16) === p.sequence);
+        const total = safeU64(bytes, 24), previous = p.lane === 255 ? 0 : this.totals.get(p.epoch)[p.lane];
+        mediaRequire(total === previous + (bytes[8] === 1 ? p.payloadBytes : 0));
+        if (bytes[8] === 3) {
+            mediaRequire(!p.busy);
+            p.busy = true;
+            p.timer = setTimeout(() => { p.busy = false; if (this.pending.get(id) === p)
+                void this.write(p.frame).catch(e => this.close(e)); }, 10);
+            return;
+        }
+        if (bytes[8] === 2)
+            mediaRequire(p.lane === 0 && this.cut && p.epoch === this.cut.epoch && p.sequence <= this.cut.pictureThrough);
+        this.pending.delete(id);
+        clearTimeout(p.deadline);
+        clearTimeout(p.timer);
+        if (bytes[8] === 1) {
+            if (p.lane !== 255)
+                this.totals.get(p.epoch)[p.lane] = total;
+            p.resolve();
+        }
+        else
+            p.reject(new DesktopMediaAdmissionCancelled(this.cut.id, p.epoch, p.sequence));
+    }
+    close(error = new NativeCommandError('transport_failed')) { this.dead = true; for (const p of this.pending.values()) {
+        clearTimeout(p.deadline);
+        clearTimeout(p.timer);
+        p.reject(error);
+    } this.pending.clear(); }
+}
+/** The subprocess is a platform build of the same Rust engine embedded by native viewers. */
+export async function openQuicMedia(server, offer, signal, current) {
+    const packaged = fileURLToPath(new URL(`../../native/${process.platform}-${process.arch}/axom-quic`, import.meta.url));
+    const candidates = [...(process.env.AXOM_QUIC_BINARY ? [process.env.AXOM_QUIC_BINARY] : []), packaged, path.join(homedir(), '.axom/workstation/quic', `${process.platform}-${process.arch}`, 'axom-quic'), '/usr/local/bin/axom-quic'];
+    const executable = await (async () => { for (const file of candidates) {
+        try {
+            await access(file);
+            return file;
+        }
+        catch { }
+    } return undefined; })();
+    if (!executable)
+        return undefined;
+    const child = spawn(executable, [], { stdio: ['pipe', 'pipe', 'ignore'] });
+    const queue = new DesktopQueue();
+    const events = queue[Symbol.asyncIterator]();
+    let buffer = Buffer.alloc(0), peer = 0n, dead = false, transportBytes = 0;
+    let pathStats;
+    let admission;
+    const cuts = new DesktopQueue(16);
+    const close = () => { if (dead)
+        return; dead = true; child.stdin.destroy(); child.kill(); admission?.close(); queue.close(); cuts.close(); signal.removeEventListener('abort', close); };
+    const closed = new Promise(resolve => child.once('close', () => { close(); resolve(); }));
+    signal.addEventListener('abort', close, { once: true });
+    child.once('error', close);
+    child.stdin.on('error', close);
+    if (signal.aborted)
+        close();
+    child.stdout.on('data', (bytes) => {
+        try {
+            mediaRequire(buffer.length + bytes.length <= 2 * 65613);
+            buffer = Buffer.concat([buffer, bytes]);
+            while (buffer.length >= 4) {
+                const length = buffer.readUInt32BE();
+                mediaRequire(length >= 9 && length <= 65609);
+                if (buffer.length < length + 4)
+                    break;
+                const frame = buffer.subarray(4, 4 + length);
+                buffer = buffer.subarray(4 + length);
+                const kind = frame[0], eventPeer = frame.readBigUInt64BE(1), payload = Buffer.from(frame.subarray(9));
+                if (kind === 1) {
+                    mediaRequire(peer === 0n && eventPeer > 0n);
+                    peer = eventPeer;
+                }
+                if (kind === 9) {
+                    mediaRequire(eventPeer === peer && payload.length === 8);
+                    const total = safeU64(payload, 0);
+                    mediaRequire(total >= transportBytes);
+                    transportBytes = total;
+                }
+                else if (kind === 10) {
+                    mediaRequire(eventPeer === peer);
+                    const next = decodeQuicPathStats(payload, performance.now());
+                    mediaRequire(!pathStats || next.sequence > pathStats.sequence && next.pathGeneration >= pathStats.pathGeneration);
+                    pathStats = next;
+                }
+                else if (kind === 8) {
+                    mediaRequire(admission);
+                    admission.accept(eventPeer, payload);
+                }
+                else if (kind === 7) {
+                    mediaRequire(eventPeer === peer);
+                    cuts.push(decodeQuicCutEvent(payload));
+                }
+                else if (isQuicMediaQueueEvent(kind))
+                    queue.push({ kind, peer: eventPeer, bytes: payload });
+                // Native event extensions belong to their own lanes. Never let an
+                // unrecognized event become an AXDS media packet and retire the RD session.
+            }
+        }
+        catch {
+            close();
+        }
+    });
+    const write = async (bytes) => { mediaRequire(current() && !signal.aborted && !dead); if (!child.stdin.write(bytes))
+        await bounded(once(child.stdin, 'drain'), 2000); };
+    try {
+        const config = Buffer.from(JSON.stringify({ mode: 'client', host: new URL(server).hostname.replace(/^\[|\]$/g, ''), port: offer.port, certificate: offer.certificate }));
+        const header = Buffer.alloc(4);
+        header.writeUInt32BE(config.length);
+        await write(Buffer.concat([header, config]));
+        const ready = await bounded(events.next(), 1800);
+        mediaRequire(!ready.done && ready.value.kind === 1);
+        peer = ready.value.peer;
+        admission = new DesktopQuicAdmission(peer, write);
+    }
+    catch (error) {
+        close();
+        if (signal.aborted)
+            throw error;
+        return undefined;
+    }
+    const send = (kind, bytes) => admission.send(kind, bytes);
+    const sendAudio = async (bytes) => {
+        mediaRequire(bytes.length >= 41 && bytes.length <= 1040 && bytes.subarray(0, 4).equals(Buffer.from('AXDA')));
+        if (!current() || signal.aborted || dead || child.stdin.writableLength > 4096)
+            return false;
+        const frame = Buffer.alloc(21);
+        frame.writeUInt32BE(17 + bytes.length);
+        frame[4] = 12;
+        frame.writeBigUInt64BE(peer, 5);
+        child.stdin.write(Buffer.concat([frame, bytes]));
+        return true;
+    };
+    const cutCommand = async (kind, cutId, epoch, pictureThrough = 0, frameThrough = 0) => {
+        mediaRequire(Number.isSafeInteger(cutId) && cutId > 0 && Number.isInteger(epoch) && epoch > 0);
+        const payload = Buffer.alloc(kind === 9 ? 16 : 4);
+        payload.writeUInt32BE(epoch);
+        if (kind === 9) {
+            payload.writeUInt32BE(pictureThrough, 4);
+            payload.writeBigUInt64BE(BigInt(frameThrough), 8);
+            admission.ownCut(cutId, epoch, pictureThrough);
+        }
+        const frame = Buffer.alloc(21);
+        frame.writeUInt32BE(17 + payload.length);
+        frame[4] = kind;
+        frame.writeBigUInt64BE(peer, 5);
+        frame.writeBigUInt64BE(BigInt(cutId), 13);
+        await write(Buffer.concat([frame, payload]));
+    };
+    return { send, sendAudio, close, closed, transportCost: () => transportBytes, pathStats: () => pathStats, cutEvents: cuts, cutCommand, finishCut: (id) => admission.finishCut(id), receive: async (timeoutMs = 0) => { const event = timeoutMs ? await bounded(events.next(), timeoutMs) : await events.next(); if (event.done || event.value.kind === 4)
+            throw new NativeCommandError('transport_failed'); return event.value; } };
+}

package/dist/workstation/desktopControl/rateController.js

@@ -0,0 +1,226 @@
+import { DesktopNetworkEvidence } from './networkEvidence.js';
+export class DesktopRateController {
+    min;
+    max;
+    maxFps;
+    networkEvidence = new DesktopNetworkEvidence();
+    target;
+    fps;
+    lastNow = -Infinity;
+    lastWindow = -Infinity;
+    lastRateChange = -Infinity;
+    lastFpsChange = -Infinity;
+    lastReopen = -Infinity;
+    cooldown = -Infinity;
+    reopens = [];
+    networkPressure = 0;
+    processingPressure = 0;
+    networkHealthy = 0;
+    headroom = 0;
+    recoveryWindows = 0;
+    recoveryFps;
+    fpsTrialUntil = -Infinity;
+    fpsRecoveryAfter = -Infinity;
+    paused = false;
+    demandBps = 0;
+    demandKnown = false;
+    windowHadActivity = false;
+    windowHadProgress = false;
+    windowHadProbeEvidence = false;
+    processingSamples = [];
+    encodeSamples = [];
+    lastEncodeObservation = -Infinity;
+    lastDecodeObservation = -Infinity;
+    lastNetworkPolicySample;
+    lastPath;
+    snapshot = { networkState: 'unknown',
+        networkQueueMs: 0, observedPayloadBps: 0, processingP95Ms: 0, encodeP95Ms: 0, receiverBudgetMs: 0, reasons: [] };
+    constructor(options = {}) {
+        const min = options.minBps ?? 500_000, max = options.maxBps ?? 20_000_000;
+        if (![min, max, options.targetBps ?? 4_000_000].every(Number.isFinite) || min < 500_000 || max > 20_000_000)
+            throw new Error('invalid rate bounds');
+        this.min = Math.ceil(min / 4000) * 4000;
+        this.max = Math.floor(max / 4000) * 4000;
+        if (this.min > this.max)
+            throw new Error('unrepresentable rate bounds');
+        this.target = this.quantize(options.targetBps ?? 4_000_000);
+        this.maxFps = options.maxFps ?? options.fpsCeiling ?? 60;
+        this.fps = options.fpsCeiling ?? this.maxFps;
+        this.recoveryFps = this.fps;
+        if (![15, 30, 60].includes(this.fps) || ![15, 30, 60].includes(this.maxFps) || this.fps > this.maxFps)
+            throw new Error('invalid fps bounds');
+    }
+    get diagnostics() { return { ...this.snapshot, reasons: [...this.snapshot.reasons] }; }
+    quantize(rate) {
+        return Math.max(this.min, Math.min(this.max, Math.floor(rate / 4000) * 4000));
+    }
+    sample(s, runtimeRateReconfigure = false) {
+        const optional = [s.rttBaselineMs, s.deliveryDelayMs, s.deliveryObservedAtMs, s.encodeObservedAtMs, s.decodeObservedAtMs];
+        if (![s.nowMs, s.activeBytes, s.excessRttMs, s.queueAgeMs, s.queuedSendMs, s.encodeMs, s.decodeMs]
+            .every(value => Number.isFinite(value) && value >= 0) ||
+            optional.some(value => value !== undefined && (!Number.isFinite(value) || value < 0)) ||
+            s.nowMs < this.lastNow)
+            throw new Error('invalid rate sample');
+        const elapsed = Number.isFinite(this.lastNow) ? s.nowMs - this.lastNow : 1000;
+        if (elapsed > 0) {
+            const observed = Math.min(this.max * 4, s.activeBytes * 8000 / elapsed);
+            const weight = -Math.expm1(-elapsed / 1000);
+            this.demandBps = this.demandKnown ? this.demandBps + (observed - this.demandBps) * weight : observed;
+            this.demandKnown = true;
+        }
+        this.lastNow = s.nowMs;
+        const window = Math.floor(s.nowMs / 1000);
+        const contiguous = window === this.lastWindow + 1;
+        const activeWindow = s.activeBytes > 0 || (contiguous && this.windowHadActivity);
+        const freshnessMs = Math.max(1500, (s.rttBaselineMs ?? 0) * 3);
+        const progress = s.deliveryObservedAtMs !== undefined
+            ? s.deliveryObservedAtMs <= s.nowMs && s.nowMs - s.deliveryObservedAtMs <= freshnessMs
+            : s.deliveryDelayMs !== undefined && s.deliveryDelayMs <= 40;
+        const progressWindow = progress || contiguous && this.windowHadProgress;
+        this.windowHadActivity = window === this.lastWindow ? this.windowHadActivity || s.activeBytes > 0 : s.activeBytes > 0;
+        this.windowHadProgress = window === this.lastWindow ? this.windowHadProgress || progress : progress;
+        if (s.queuedSendMs > 100)
+            this.paused = true;
+        else if (s.queuedSendMs === 0)
+            this.paused = false;
+        const evidence = this.networkEvidence.sample(s.nowMs, s.network, this.demandBps);
+        const probeEvidence = progress && (evidence.state === 'usable' || evidence.state === 'unknown' &&
+            s.deliveryDelayMs !== undefined && s.deliveryDelayMs <= 40);
+        const probeWindow = probeEvidence || contiguous && this.windowHadProbeEvidence;
+        this.windowHadProbeEvidence = window === this.lastWindow ? this.windowHadProbeEvidence || probeEvidence : probeEvidence;
+        const path = s.network ? `${s.network.id}:${s.network.pathGeneration}` : undefined;
+        if (path !== this.lastPath) {
+            this.networkPressure = this.networkHealthy = 0;
+            this.lastNetworkPolicySample = undefined;
+            this.lastPath = path;
+        }
+        const sampleKey = s.network ? `${path}:${s.network.sequence}` : undefined;
+        const freshNetworkWindow = sampleKey !== undefined && sampleKey !== this.lastNetworkPolicySample;
+        if (window !== this.lastWindow && !contiguous) {
+            this.processingSamples = [];
+            this.encodeSamples = [];
+        }
+        const encodeAt = s.encodeObservedAtMs ?? (s.encodeMs > 0 ? s.nowMs : undefined);
+        const decodeAt = s.decodeObservedAtMs ?? (s.decodeMs > 0 ? s.nowMs : undefined);
+        const costs = [];
+        if (encodeAt !== undefined && encodeAt > this.lastEncodeObservation && encodeAt <= s.nowMs && s.nowMs - encodeAt <= freshnessMs) {
+            this.lastEncodeObservation = encodeAt;
+            costs.push(s.encodeMs);
+            this.encodeSamples.push(s.encodeMs);
+        }
+        if (decodeAt !== undefined && decodeAt > this.lastDecodeObservation && decodeAt <= s.nowMs && s.nowMs - decodeAt <= freshnessMs) {
+            this.lastDecodeObservation = decodeAt;
+            costs.push(s.decodeMs);
+        }
+        if (costs.length)
+            this.processingSamples.push(Math.max(...costs));
+        if (this.processingSamples.length > 128)
+            this.processingSamples.shift();
+        if (this.encodeSamples.length > 128)
+            this.encodeSamples.shift();
+        this.snapshot = { ...this.snapshot, networkState: evidence.state, networkQueueMs: evidence.queueMs,
+            observedPayloadBps: Math.round(this.demandBps), reasons: this.paused ? ['sender-backpressure'] : [] };
+        const decision = (reopenEpoch = false) => ({ targetBps: this.target,
+            fpsCeiling: this.fps, pauseCapture: this.paused, reopenEpoch });
+        if (window === this.lastWindow)
+            return decision();
+        this.lastWindow = window;
+        if (!contiguous)
+            this.networkPressure = this.processingPressure = this.networkHealthy = this.headroom = this.recoveryWindows = 0;
+        const costsInWindow = this.processingSamples.sort((left, right) => left - right);
+        this.processingSamples = [];
+        const cost = costsInWindow[Math.max(0, Math.ceil(costsInWindow.length * 0.95) - 1)] ?? 0;
+        this.snapshot.processingP95Ms = cost;
+        const encodeCosts = this.encodeSamples.sort((left, right) => left - right);
+        this.encodeSamples = [];
+        const encodeCost = encodeCosts[Math.max(0, Math.ceil(encodeCosts.length * 0.95) - 1)] ?? 0;
+        const receiverBudget = Math.max(80, 3000 / this.fps);
+        this.snapshot.encodeP95Ms = encodeCost;
+        this.snapshot.receiverBudgetMs = receiverBudget;
+        if (!activeWindow) {
+            this.networkPressure = this.processingPressure = this.networkHealthy = this.headroom = this.recoveryWindows = 0;
+            this.snapshot.reasons.push('content-idle');
+            return decision();
+        }
+        const net = evidence.state === 'congested' && freshNetworkWindow;
+        this.lastNetworkPolicySample = sampleKey;
+        const receiverPressure = costsInWindow.length > 0 && cost > 0.8 * 1000 / this.fps && s.queueAgeMs > receiverBudget;
+        const sourcePressure = encodeCosts.length > 0 && encodeCost > 0.8 * 1000 / this.fps;
+        const processing = sourcePressure || receiverPressure;
+        this.networkPressure = net ? this.networkPressure + 1 : 0;
+        this.processingPressure = processing ? this.processingPressure + 1 : 0;
+        this.networkHealthy = !net && probeWindow && progressWindow && !this.paused ? this.networkHealthy + 1 : 0;
+        const nextFps = Math.min(this.maxFps, this.fps === 15 ? 30 : 60);
+        this.headroom = encodeCosts.length > 0 && !processing && s.queueAgeMs <= 40 && !this.paused &&
+            encodeCost < 0.6 * 1000 / nextFps ? this.headroom + 1 : 0;
+        this.recoveryWindows = nextFps > this.fps && nextFps <= this.recoveryFps && encodeCosts.length > 0 &&
+            progressWindow && !net && s.queueAgeMs <= 40 && !this.paused && encodeCost < 0.8 * 1000 / nextFps
+            ? this.recoveryWindows + 1 : 0;
+        if (net)
+            this.snapshot.reasons.push('sender-path-congestion');
+        if (processing)
+            this.snapshot.reasons.push('processing-pressure');
+        if (sourcePressure)
+            this.snapshot.reasons.push('source-encode-pressure');
+        if (receiverPressure)
+            this.snapshot.reasons.push('receiver-backlog');
+        if (evidence.state === 'unknown')
+            this.snapshot.reasons.push('network-unknown');
+        if (this.fps < this.recoveryFps && s.nowMs < this.fpsRecoveryAfter)
+            this.snapshot.reasons.push('fps-recovery-backoff');
+        if (s.nowMs < this.cooldown)
+            return decision();
+        let target = this.target, fps = this.fps;
+        if (this.networkPressure >= 2 && s.nowMs - this.lastRateChange >= 2000) {
+            target = this.quantize(Math.min(target * 0.85, evidence.bandwidthBps ? evidence.bandwidthBps * 0.9 : target));
+        }
+        else if (this.networkHealthy >= 3 && s.nowMs - this.lastRateChange >= (runtimeRateReconfigure ? 2000 : 10000) &&
+            this.demandBps >= target * 0.25) {
+            target = this.quantize(target * (runtimeRateReconfigure ? evidence.state === 'usable' ? 1.5 : 1.2 : 1.1));
+            if (target > this.target)
+                this.snapshot.reasons.push('bandwidth-probe');
+        }
+        if (this.processingPressure >= 2 && s.nowMs - this.lastFpsChange >= 2000)
+            fps = fps === 60 ? 30 : 15;
+        else if ((this.headroom >= 3 || this.recoveryWindows >= 5) && s.nowMs >= this.fpsRecoveryAfter &&
+            s.nowMs - this.lastFpsChange >= (runtimeRateReconfigure ? 2000 : 10000)) {
+            fps = nextFps;
+            if (fps > this.fps && this.headroom < 3)
+                this.snapshot.reasons.push('fps-recovery-probe');
+        }
+        if (target === this.max)
+            this.snapshot.reasons.push('policy-limit');
+        if (target === this.target && fps === this.fps)
+            return decision();
+        if (!runtimeRateReconfigure && s.nowMs - this.lastReopen < 2000)
+            return decision();
+        this.reopens = this.reopens.filter(at => s.nowMs - at < 10000);
+        if (!runtimeRateReconfigure && this.reopens.length === 2) {
+            fps = 15;
+            this.cooldown = s.nowMs + 10000;
+        }
+        if (target !== this.target) {
+            this.lastRateChange = s.nowMs;
+            this.networkPressure = this.networkHealthy = 0;
+        }
+        if (fps !== this.fps) {
+            if (fps < this.fps) {
+                this.recoveryFps = Math.max(this.recoveryFps, this.fps);
+                if (s.nowMs <= this.fpsTrialUntil)
+                    this.fpsRecoveryAfter = s.nowMs + 30000;
+                this.fpsTrialUntil = -Infinity;
+            }
+            else
+                this.fpsTrialUntil = s.nowMs + 10000;
+            this.lastFpsChange = s.nowMs;
+            this.processingPressure = this.headroom = this.recoveryWindows = 0;
+        }
+        this.target = target;
+        this.fps = fps;
+        if (!runtimeRateReconfigure) {
+            this.reopens.push(s.nowMs);
+            this.lastReopen = s.nowMs;
+        }
+        return decision(!runtimeRateReconfigure);
+    }
+}