screen-relay 0.0.0 → 0.1.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +201 -0
- package/Makefile +165 -0
- package/README.md +112 -1
- package/THIRD-PARTY-NOTICES.md +75 -0
- package/dist/cli/client.d.ts +28 -0
- package/dist/cli/commands.d.ts +52 -0
- package/dist/cli/config.d.ts +32 -0
- package/dist/cli/format.d.ts +15 -0
- package/dist/cli/help.d.ts +5 -0
- package/dist/cli/host/common.d.ts +23 -0
- package/dist/cli/host/doctor.d.ts +2 -0
- package/dist/cli/host/packages.d.ts +13 -0
- package/dist/cli/host/session_commands.d.ts +8 -0
- package/dist/cli/host/setup.d.ts +22 -0
- package/dist/cli/host/state.d.ts +23 -0
- package/dist/cli/host/supervisor.d.ts +94 -0
- package/dist/cli/host/watcher.d.ts +4 -0
- package/dist/cli/host/windows.d.ts +82 -0
- package/dist/cli/main.d.ts +3 -0
- package/dist/cli/mode.d.ts +14 -0
- package/dist/cli/output.d.ts +24 -0
- package/dist/cli/parser.d.ts +6 -0
- package/dist/cli/relay.mjs +12631 -0
- package/dist/cli/skills.d.ts +21 -0
- package/dist/cli/theme.d.ts +14 -0
- package/dist/protocol/errors.d.ts +155 -0
- package/dist/protocol/index.d.ts +119 -0
- package/dist/protocol/index.js +418 -0
- package/dist/sdk/index.d.ts +78 -0
- package/dist/sdk/index.js +834 -0
- package/dist/sdk/transport.d.ts +20 -0
- package/dist/viewer/index.html +96 -0
- package/dist/viewer/viewer.js +1079 -0
- package/package.json +47 -7
- package/packages.tsv +38 -0
- package/skills/core/SKILL.md +171 -0
- package/skills/core/references/cli.md +119 -0
- package/skills/core/references/config.md +48 -0
- package/skills/core/references/macos.md +50 -0
- package/skills/core/references/sdk.md +69 -0
- package/skills/core/references/troubleshooting.md +33 -0
- package/skills/core/references/wayland.md +47 -0
- package/skills/screen-relay/SKILL.md +24 -0
- package/skills/vercel-sandbox/SKILL.md +68 -0
- package/src/engine/backends/linux/keycodes.hpp +35 -0
- package/src/engine/backends/linux/wayland/capture.cpp +298 -0
- package/src/engine/backends/linux/wayland/input.cpp +559 -0
- package/src/engine/backends/linux/wayland/keymap.cpp +118 -0
- package/src/engine/backends/linux/wayland/keymap.hpp +54 -0
- package/src/engine/backends/linux/wayland/protocols/virtual-keyboard-unstable-v1.xml +112 -0
- package/src/engine/backends/linux/wayland/protocols/wlr-screencopy-unstable-v1.xml +234 -0
- package/src/engine/backends/linux/wayland/protocols/wlr-virtual-pointer-unstable-v1.xml +152 -0
- package/src/engine/backends/linux/wayland/wayland.cpp +166 -0
- package/src/engine/backends/linux/wayland/wayland.hpp +60 -0
- package/src/engine/backends/linux/x11/capture.cpp +206 -0
- package/src/engine/backends/linux/x11/input.cpp +266 -0
- package/src/engine/backends/macos/capture.mm +367 -0
- package/src/engine/backends/macos/display.hpp +20 -0
- package/src/engine/backends/macos/display.mm +84 -0
- package/src/engine/backends/macos/input.mm +287 -0
- package/src/engine/backends/macos/keys.hpp +34 -0
- package/src/engine/backends/windows/capture.cpp +393 -0
- package/src/engine/backends/windows/input.cpp +274 -0
- package/src/engine/backends/windows/output.cpp +65 -0
- package/src/engine/backends/windows/output.hpp +26 -0
- package/src/engine/core/capture-bucket.hpp +40 -0
- package/src/engine/core/capture-source.hpp +59 -0
- package/src/engine/core/capture.cpp +565 -0
- package/src/engine/core/capture.hpp +58 -0
- package/src/engine/core/color.cpp +176 -0
- package/src/engine/core/color.hpp +16 -0
- package/src/engine/core/cpu-budget.hpp +196 -0
- package/src/engine/core/flow.hpp +317 -0
- package/src/engine/core/input.cpp +98 -0
- package/src/engine/core/input.hpp +115 -0
- package/src/engine/core/wait.cpp +125 -0
- package/src/engine/core/wait.hpp +41 -0
- package/src/engine/server/backend.cpp +65 -0
- package/src/engine/server/backend.hpp +18 -0
- package/src/engine/server/config.cpp +257 -0
- package/src/engine/server/config.hpp +24 -0
- package/src/engine/server/main.cpp +82 -0
- package/src/engine/server/metrics.cpp +47 -0
- package/src/engine/server/metrics.hpp +10 -0
- package/src/engine/server/screenshot.cpp +108 -0
- package/src/engine/server/screenshot.hpp +31 -0
- package/src/engine/server/server.cpp +535 -0
- package/src/engine/server/server.hpp +89 -0
- package/src/engine/server/wire.cpp +70 -0
- package/src/engine/server/wire.hpp +29 -0
- package/index.js +0 -2
|
@@ -0,0 +1,1079 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
var relayViewer = (() => {
|
|
3
|
+
var __defProp = Object.defineProperty;
|
|
4
|
+
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
5
|
+
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
6
|
+
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
7
|
+
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
8
|
+
var __export = (target, all) => {
|
|
9
|
+
for (var name in all)
|
|
10
|
+
__defProp(target, name, { get: all[name], enumerable: true });
|
|
11
|
+
};
|
|
12
|
+
var __copyProps = (to, from, except, desc) => {
|
|
13
|
+
if (from && typeof from === "object" || typeof from === "function") {
|
|
14
|
+
for (let key of __getOwnPropNames(from))
|
|
15
|
+
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
16
|
+
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
17
|
+
}
|
|
18
|
+
return to;
|
|
19
|
+
};
|
|
20
|
+
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
21
|
+
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
|
|
22
|
+
|
|
23
|
+
// viewer/main.ts
|
|
24
|
+
var main_exports = {};
|
|
25
|
+
__export(main_exports, {
|
|
26
|
+
capsLock: () => capsLock,
|
|
27
|
+
connect: () => connect,
|
|
28
|
+
reset: () => reset,
|
|
29
|
+
setScale: () => setScale,
|
|
30
|
+
setViewOnly: () => setViewOnly,
|
|
31
|
+
socket: () => socket,
|
|
32
|
+
toggleMeta: () => toggleMeta,
|
|
33
|
+
toggleSharp: () => toggleSharp,
|
|
34
|
+
watchDpr: () => watchDpr
|
|
35
|
+
});
|
|
36
|
+
|
|
37
|
+
// src/protocol/errors.ts
|
|
38
|
+
var ERROR_REASONS = {
|
|
39
|
+
invalid_input: { class: "usage", code: "INVALID_ARGUMENT", exitCode: 2 },
|
|
40
|
+
invalid_option: { class: "usage", code: "INVALID_ARGUMENT", exitCode: 2 },
|
|
41
|
+
unknown_command: { class: "usage", code: "INVALID_ARGUMENT", exitCode: 2 },
|
|
42
|
+
missing_input: { class: "missing_input", code: "INVALID_ARGUMENT", exitCode: 2 },
|
|
43
|
+
missing_command: { class: "missing_input", code: "INVALID_ARGUMENT", exitCode: 2 },
|
|
44
|
+
not_found: { class: "not_found", code: "NOT_FOUND", exitCode: 1 },
|
|
45
|
+
not_running: { class: "not_found", code: "NOT_FOUND", exitCode: 1 },
|
|
46
|
+
already_running: { class: "conflict", code: "BUSY", exitCode: 1 },
|
|
47
|
+
port_in_use: { class: "conflict", code: "BUSY", exitCode: 1 },
|
|
48
|
+
busy: { class: "conflict", code: "BUSY", exitCode: 1 },
|
|
49
|
+
unreachable: { class: "network", code: "NETWORK_ERROR", exitCode: 1 },
|
|
50
|
+
timeout: { class: "network", code: "TIMEOUT", exitCode: 1 },
|
|
51
|
+
disconnected: { class: "network", code: "DISCONNECTED", exitCode: 1 },
|
|
52
|
+
unauthorized: { class: "permission", code: "UNAUTHORIZED", exitCode: 1 },
|
|
53
|
+
forbidden: { class: "permission", code: "UNAUTHORIZED", exitCode: 1 },
|
|
54
|
+
unsupported_input: { class: "platform", code: "UNSUPPORTED", exitCode: 1 },
|
|
55
|
+
unsupported_platform: { class: "platform", code: "UNSUPPORTED", exitCode: 1 },
|
|
56
|
+
missing_dependency: { class: "platform", code: "UNSUPPORTED", exitCode: 1 },
|
|
57
|
+
component_failed: { class: "platform", code: "HTTP_ERROR", exitCode: 1 },
|
|
58
|
+
spawn_failed: { class: "platform", code: "IO_ERROR", exitCode: 1 },
|
|
59
|
+
io_error: { class: "platform", code: "IO_ERROR", exitCode: 1 },
|
|
60
|
+
protocol_error: { class: "platform", code: "PROTOCOL_ERROR", exitCode: 1 },
|
|
61
|
+
invalid_config: { class: "config", code: "CONFIG_ERROR", exitCode: 1 },
|
|
62
|
+
internal: { class: "bug", code: "INTERNAL", exitCode: 1 },
|
|
63
|
+
canceled: { class: "canceled", code: "CANCELED", exitCode: 130 }
|
|
64
|
+
};
|
|
65
|
+
var LEGACY_REASONS = {
|
|
66
|
+
INVALID_ARGUMENT: "invalid_input",
|
|
67
|
+
NOT_FOUND: "not_found",
|
|
68
|
+
BUSY: "busy",
|
|
69
|
+
NETWORK_ERROR: "unreachable",
|
|
70
|
+
TIMEOUT: "timeout",
|
|
71
|
+
DISCONNECTED: "disconnected",
|
|
72
|
+
UNAUTHORIZED: "unauthorized",
|
|
73
|
+
UNSUPPORTED: "unsupported_input",
|
|
74
|
+
HTTP_ERROR: "component_failed",
|
|
75
|
+
IO_ERROR: "io_error",
|
|
76
|
+
PROTOCOL_ERROR: "protocol_error",
|
|
77
|
+
CONFIG_ERROR: "invalid_config",
|
|
78
|
+
INTERNAL: "internal",
|
|
79
|
+
CANCELED: "canceled"
|
|
80
|
+
};
|
|
81
|
+
var RelayError = class extends Error {
|
|
82
|
+
constructor(reason, message, options = {}) {
|
|
83
|
+
super(message);
|
|
84
|
+
__publicField(this, "code");
|
|
85
|
+
__publicField(this, "reason");
|
|
86
|
+
__publicField(this, "class");
|
|
87
|
+
__publicField(this, "exitCode");
|
|
88
|
+
__publicField(this, "hint");
|
|
89
|
+
__publicField(this, "data");
|
|
90
|
+
__publicField(this, "next");
|
|
91
|
+
__publicField(this, "status");
|
|
92
|
+
__publicField(this, "label");
|
|
93
|
+
this.name = "RelayError";
|
|
94
|
+
this.reason = Object.hasOwn(ERROR_REASONS, reason) ? reason : Object.hasOwn(LEGACY_REASONS, reason) ? LEGACY_REASONS[reason] : "internal";
|
|
95
|
+
const definition = ERROR_REASONS[this.reason];
|
|
96
|
+
this.code = definition.code;
|
|
97
|
+
this.class = definition.class;
|
|
98
|
+
this.exitCode = definition.exitCode;
|
|
99
|
+
const details = typeof options === "string" ? { hint: options } : options;
|
|
100
|
+
this.hint = details.hint;
|
|
101
|
+
this.data = details.data;
|
|
102
|
+
this.next = details.next;
|
|
103
|
+
this.label = details.label;
|
|
104
|
+
this.status = details.status ?? "error";
|
|
105
|
+
}
|
|
106
|
+
};
|
|
107
|
+
|
|
108
|
+
// src/protocol/index.ts
|
|
109
|
+
var MAGIC = 1314081841;
|
|
110
|
+
var VERSION = 1;
|
|
111
|
+
var HEADER_SIZE = 20;
|
|
112
|
+
var INPUT_SIZE = 16;
|
|
113
|
+
var MAX_BYTES_IN_FLIGHT = 8388608;
|
|
114
|
+
var SUBPROTOCOL = "nsl1";
|
|
115
|
+
var MESSAGE_TYPES = { frame: 1, ack: 2, input: 3, controlReady: 4, inputResponse: 5, cursor: 6 };
|
|
116
|
+
var INPUT_TYPES = { keyDown: 1, keyUp: 2, pointerMove: 3, buttonDown: 4, buttonUp: 5, wheel: 6, releaseAll: 7, text: 8 };
|
|
117
|
+
function integer(value, min, max, name) {
|
|
118
|
+
if (!Number.isInteger(value) || value < min || value > max) throw new RelayError("invalid_input", `Invalid ${name}`);
|
|
119
|
+
return value;
|
|
120
|
+
}
|
|
121
|
+
function coordinate(value, name) {
|
|
122
|
+
if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) throw new RelayError("invalid_input", `Invalid ${name}`);
|
|
123
|
+
return Math.round(value * 65535);
|
|
124
|
+
}
|
|
125
|
+
function encodeInputRecord(event) {
|
|
126
|
+
if (!event || typeof event !== "object" || !Object.hasOwn(INPUT_TYPES, event.type)) throw new RelayError("invalid_input", "Unknown input type");
|
|
127
|
+
const bytes = new Uint8Array(INPUT_SIZE);
|
|
128
|
+
const view = new DataView(bytes.buffer);
|
|
129
|
+
view.setUint8(0, INPUT_TYPES[event.type]);
|
|
130
|
+
const buttons2 = integer(event.buttons ?? 0, 0, 31, "buttons");
|
|
131
|
+
const modifiers2 = integer(event.modifiers ?? 0, 0, 255, "modifiers");
|
|
132
|
+
if ((event.type === "releaseAll" || event.type === "text") && (buttons2 || modifiers2)) throw new RelayError("invalid_input", "Release and text events require zero masks");
|
|
133
|
+
view.setUint16(12, buttons2);
|
|
134
|
+
view.setUint16(14, modifiers2);
|
|
135
|
+
if (event.type === "pointerMove" || event.type === "buttonDown" || event.type === "buttonUp" || event.type === "wheel") {
|
|
136
|
+
view.setUint16(8, coordinate(event.x, "x"));
|
|
137
|
+
view.setUint16(10, coordinate(event.y, "y"));
|
|
138
|
+
}
|
|
139
|
+
if (event.type === "keyDown" || event.type === "keyUp") view.setUint16(2, integer(event.key, 0, 231, "key"));
|
|
140
|
+
if (event.type === "buttonDown" || event.type === "buttonUp") view.setUint16(2, integer(event.button, 1, 3, "button"));
|
|
141
|
+
if (event.type === "wheel") {
|
|
142
|
+
if (event.axis !== "vertical" && event.axis !== "horizontal") throw new RelayError("invalid_input", "Invalid wheel axis");
|
|
143
|
+
const delta = integer(event.delta, -1200, 1200, "wheel delta");
|
|
144
|
+
if (delta % 120) throw new RelayError("invalid_input", "Wheel delta must be a multiple of 120");
|
|
145
|
+
view.setUint16(2, event.axis === "horizontal" ? 1 : 0);
|
|
146
|
+
view.setInt32(4, delta);
|
|
147
|
+
}
|
|
148
|
+
if (event.type === "text") {
|
|
149
|
+
const codepoint = integer(event.codepoint, 1, 1114111, "Unicode scalar");
|
|
150
|
+
if (codepoint >= 55296 && codepoint <= 57343) throw new RelayError("invalid_input", "Invalid Unicode scalar");
|
|
151
|
+
view.setInt32(4, codepoint);
|
|
152
|
+
view.setUint16(8, 0);
|
|
153
|
+
view.setUint16(10, 0);
|
|
154
|
+
}
|
|
155
|
+
return bytes;
|
|
156
|
+
}
|
|
157
|
+
function header(type, generation2, sequence2, size) {
|
|
158
|
+
integer(type, 1, 6, "message type");
|
|
159
|
+
integer(generation2, 1, 4294967295, "generation");
|
|
160
|
+
integer(sequence2, 0, 4294967295, "sequence");
|
|
161
|
+
integer(size, 0, 8388620, "payload length");
|
|
162
|
+
const bytes = new Uint8Array(HEADER_SIZE + size);
|
|
163
|
+
const view = new DataView(bytes.buffer);
|
|
164
|
+
view.setUint32(0, MAGIC);
|
|
165
|
+
view.setUint8(4, VERSION);
|
|
166
|
+
view.setUint8(5, type);
|
|
167
|
+
view.setUint32(8, generation2);
|
|
168
|
+
view.setUint32(12, sequence2);
|
|
169
|
+
view.setUint32(16, size);
|
|
170
|
+
return bytes;
|
|
171
|
+
}
|
|
172
|
+
function encodeInput(event, generation2, sequence2) {
|
|
173
|
+
const bytes = header(MESSAGE_TYPES.input, generation2, sequence2, INPUT_SIZE);
|
|
174
|
+
bytes.set(encodeInputRecord(event), HEADER_SIZE);
|
|
175
|
+
return bytes;
|
|
176
|
+
}
|
|
177
|
+
function encodeAck(generation2, sequence2, viewerWaitMs) {
|
|
178
|
+
if (viewerWaitMs === void 0) return header(MESSAGE_TYPES.ack, generation2, sequence2, 0);
|
|
179
|
+
const bytes = header(MESSAGE_TYPES.ack, generation2, sequence2, 4);
|
|
180
|
+
const micros = Number.isFinite(viewerWaitMs) ? Math.min(4294967295, Math.max(0, Math.round(viewerWaitMs * 1e3))) : 0;
|
|
181
|
+
new DataView(bytes.buffer).setUint32(HEADER_SIZE, micros);
|
|
182
|
+
return bytes;
|
|
183
|
+
}
|
|
184
|
+
function parseHeader(bytes) {
|
|
185
|
+
const data = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
|
|
186
|
+
if (data.byteLength < HEADER_SIZE || data.byteLength > HEADER_SIZE + 12 + MAX_BYTES_IN_FLIGHT) throw new RelayError("protocol_error", "Invalid message length");
|
|
187
|
+
const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
|
|
188
|
+
const type = view.getUint8(5), flags = view.getUint16(6), generation2 = view.getUint32(8);
|
|
189
|
+
if (view.getUint32(0) !== MAGIC || view.getUint8(4) !== VERSION || type < 1 || type > 6 || flags > (type === MESSAGE_TYPES.frame ? 1 : 0) || !generation2 || view.getUint32(16) !== data.byteLength - HEADER_SIZE) {
|
|
190
|
+
throw new RelayError("protocol_error", "Invalid message envelope");
|
|
191
|
+
}
|
|
192
|
+
return { type, flags, generation: generation2, sequence: view.getUint32(12), payloadLength: view.getUint32(16) };
|
|
193
|
+
}
|
|
194
|
+
function parseMessage(bytes) {
|
|
195
|
+
const data = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
|
|
196
|
+
const { type, flags, generation: generation2, sequence: sequence2, payloadLength: size } = parseHeader(data);
|
|
197
|
+
const view = new DataView(data.buffer, data.byteOffset + HEADER_SIZE, size);
|
|
198
|
+
const invalid = (what) => new RelayError("protocol_error", `Invalid ${what}`);
|
|
199
|
+
if (type === MESSAGE_TYPES.frame) {
|
|
200
|
+
if (size < 13 || !sequence2) throw invalid("frame header");
|
|
201
|
+
const width = view.getUint16(0), height = view.getUint16(2), timestamp = view.getBigUint64(4);
|
|
202
|
+
if (!width || !height || timestamp > BigInt(Number.MAX_SAFE_INTEGER)) throw invalid("frame header");
|
|
203
|
+
return { type: "frame", generation: generation2, sequence: sequence2, keyframe: flags === 1, width, height, timestamp: Number(timestamp), data: data.subarray(HEADER_SIZE + 12) };
|
|
204
|
+
}
|
|
205
|
+
if (type === MESSAGE_TYPES.cursor) {
|
|
206
|
+
if (size < 8 || sequence2) throw invalid("cursor envelope");
|
|
207
|
+
const width = view.getUint16(0), height = view.getUint16(2), hotX = view.getUint16(4), hotY = view.getUint16(6);
|
|
208
|
+
if (width > 256 || height > 256 || size !== 8 + width * height * 4 || (width && height ? hotX >= width || hotY >= height : width || height || hotX || hotY)) throw invalid("cursor image");
|
|
209
|
+
return { type: "cursor", generation: generation2, width, height, hotX, hotY, pixels: new Uint8ClampedArray(data.buffer, data.byteOffset + HEADER_SIZE + 8, size - 8) };
|
|
210
|
+
}
|
|
211
|
+
if (type === MESSAGE_TYPES.controlReady) {
|
|
212
|
+
if (size !== 4 || sequence2 || !view.getUint16(0) || !view.getUint16(2)) throw invalid("ready message");
|
|
213
|
+
return { type: "controlReady", generation: generation2, width: view.getUint16(0), height: view.getUint16(2) };
|
|
214
|
+
}
|
|
215
|
+
if (type === MESSAGE_TYPES.inputResponse) {
|
|
216
|
+
if (size !== 1 || !sequence2 || view.getUint8(0) > 2) throw invalid("input response");
|
|
217
|
+
return { type: "inputResponse", generation: generation2, sequence: sequence2, status: view.getUint8(0) };
|
|
218
|
+
}
|
|
219
|
+
throw invalid("message type");
|
|
220
|
+
}
|
|
221
|
+
function h264Codec(bytes) {
|
|
222
|
+
for (let i = 0; i + 7 < bytes.length; i++) {
|
|
223
|
+
let n = 0;
|
|
224
|
+
if (bytes[i] === 0 && bytes[i + 1] === 0 && bytes[i + 2] === 1) n = i + 3;
|
|
225
|
+
else if (bytes[i] === 0 && bytes[i + 1] === 0 && bytes[i + 2] === 0 && bytes[i + 3] === 1) n = i + 4;
|
|
226
|
+
if (n && n + 3 < bytes.length && (bytes[n] & 31) === 7) {
|
|
227
|
+
return `avc1.${[bytes[n + 1], bytes[n + 2], bytes[n + 3]].map((v) => v.toString(16).padStart(2, "0")).join("")}`;
|
|
228
|
+
}
|
|
229
|
+
}
|
|
230
|
+
throw new RelayError("protocol_error", "Keyframe is missing SPS");
|
|
231
|
+
}
|
|
232
|
+
function socketTarget(origin, path, token) {
|
|
233
|
+
const url = new URL(path, origin);
|
|
234
|
+
url.protocol = origin.protocol === "https:" ? "wss:" : "ws:";
|
|
235
|
+
return { url, protocols: token ? [SUBPROTOCOL, `bearer.${token}`] : [SUBPROTOCOL] };
|
|
236
|
+
}
|
|
237
|
+
var HID_KEYS = {};
|
|
238
|
+
function assignKeys(first, names) {
|
|
239
|
+
names.forEach((name, index) => {
|
|
240
|
+
HID_KEYS[name] = first + index;
|
|
241
|
+
});
|
|
242
|
+
}
|
|
243
|
+
assignKeys(4, Array.from({ length: 26 }, (_, index) => `Key${String.fromCharCode(65 + index)}`));
|
|
244
|
+
assignKeys(30, "Digit1 Digit2 Digit3 Digit4 Digit5 Digit6 Digit7 Digit8 Digit9 Digit0".split(" "));
|
|
245
|
+
assignKeys(40, "Enter Escape Backspace Tab Space Minus Equal BracketLeft BracketRight Backslash".split(" "));
|
|
246
|
+
assignKeys(51, "Semicolon Quote Backquote Comma Period Slash CapsLock".split(" "));
|
|
247
|
+
assignKeys(58, Array.from({ length: 12 }, (_, index) => `F${index + 1}`));
|
|
248
|
+
assignKeys(70, "PrintScreen ScrollLock Pause Insert Home PageUp Delete End PageDown ArrowRight ArrowLeft ArrowDown ArrowUp NumLock".split(" "));
|
|
249
|
+
assignKeys(84, "NumpadDivide NumpadMultiply NumpadSubtract NumpadAdd NumpadEnter Numpad1 Numpad2 Numpad3 Numpad4 Numpad5 Numpad6 Numpad7 Numpad8 Numpad9 Numpad0 NumpadDecimal".split(" "));
|
|
250
|
+
HID_KEYS.IntlBackslash = 100;
|
|
251
|
+
HID_KEYS.ContextMenu = 101;
|
|
252
|
+
assignKeys(104, Array.from({ length: 12 }, (_, index) => `F${index + 13}`));
|
|
253
|
+
assignKeys(224, "ControlLeft ShiftLeft AltLeft MetaLeft ControlRight ShiftRight AltRight MetaRight".split(" "));
|
|
254
|
+
Object.freeze(HID_KEYS);
|
|
255
|
+
var MODIFIERS = Object.freeze({ ctrl: 224, control: 224, shift: 225, alt: 226, super: 227, meta: 227, cmd: 227, win: 227 });
|
|
256
|
+
var NAMED_KEYS = Object.freeze({
|
|
257
|
+
...Object.fromEntries(Object.entries(HID_KEYS).filter(([name]) => !name.startsWith("Key") && !name.startsWith("Digit")).map(([name, code]) => [name.toLowerCase(), code])),
|
|
258
|
+
return: 40,
|
|
259
|
+
esc: 41,
|
|
260
|
+
right: 79,
|
|
261
|
+
left: 80,
|
|
262
|
+
down: 81,
|
|
263
|
+
up: 82,
|
|
264
|
+
menu: 101
|
|
265
|
+
});
|
|
266
|
+
function isLoopback(hostname) {
|
|
267
|
+
return hostname === "localhost" || hostname === "127.0.0.1";
|
|
268
|
+
}
|
|
269
|
+
function validToken(token) {
|
|
270
|
+
return typeof token === "string" && /^[0-9a-f]{64}$/.test(token);
|
|
271
|
+
}
|
|
272
|
+
|
|
273
|
+
// viewer/main.ts
|
|
274
|
+
var keys = HID_KEYS;
|
|
275
|
+
var canvas = document.querySelector("#screen");
|
|
276
|
+
var ctx = canvas.getContext("2d");
|
|
277
|
+
var status = document.querySelector("#status");
|
|
278
|
+
var cursor = document.querySelector("#cursor");
|
|
279
|
+
var cursorContext = cursor.getContext("2d");
|
|
280
|
+
var accessToken = "";
|
|
281
|
+
var trustedPage = location.protocol === "https:" || isLoopback(location.hostname);
|
|
282
|
+
{
|
|
283
|
+
const fragmentToken = new URLSearchParams(location.hash.slice(1)).get("token");
|
|
284
|
+
if (fragmentToken !== null) {
|
|
285
|
+
history.replaceState(null, "", location.pathname + location.search);
|
|
286
|
+
if (validToken(fragmentToken) && trustedPage) accessToken = document.querySelector("#access-token").value = fragmentToken;
|
|
287
|
+
}
|
|
288
|
+
}
|
|
289
|
+
var cursorAvailable = false;
|
|
290
|
+
var cursorHotX = 0;
|
|
291
|
+
var cursorHotY = 0;
|
|
292
|
+
var pointerPosition;
|
|
293
|
+
function renderCursor() {
|
|
294
|
+
canvas.style.cursor = cursorAvailable && ready ? "none" : "default";
|
|
295
|
+
const r = canvas.getBoundingClientRect(), p = pointerPosition;
|
|
296
|
+
cursor.hidden = !cursorAvailable || !ready || !p || p.pointerType === "touch" || p.clientX < r.left || p.clientX >= r.right || p.clientY < r.top || p.clientY >= r.bottom;
|
|
297
|
+
if (cursor.hidden) return;
|
|
298
|
+
const sx = r.width / canvas.width, sy = r.height / canvas.height;
|
|
299
|
+
cursor.style.width = `${cursor.width * sx}px`;
|
|
300
|
+
cursor.style.height = `${cursor.height * sy}px`;
|
|
301
|
+
cursor.style.left = `${p.clientX - cursorHotX * sx}px`;
|
|
302
|
+
cursor.style.top = `${p.clientY - cursorHotY * sy}px`;
|
|
303
|
+
}
|
|
304
|
+
function receiveCursor({ generation: gen, width, height, hotX, hotY, pixels }) {
|
|
305
|
+
if (!generation || gen !== generation) throw new Error("Invalid cursor envelope");
|
|
306
|
+
cursorAvailable = width > 0;
|
|
307
|
+
cursorHotX = hotX;
|
|
308
|
+
cursorHotY = hotY;
|
|
309
|
+
cursor.width = width || 1;
|
|
310
|
+
cursor.height = height || 1;
|
|
311
|
+
if (cursorAvailable) cursorContext.putImageData(new ImageData(pixels, width, height), 0, 0);
|
|
312
|
+
renderCursor();
|
|
313
|
+
}
|
|
314
|
+
var stats = window.nativeStats = {
|
|
315
|
+
received: 0,
|
|
316
|
+
drawn: 0,
|
|
317
|
+
superseded: 0,
|
|
318
|
+
holdMs: 0,
|
|
319
|
+
bytes: 0,
|
|
320
|
+
decodeerrors: 0,
|
|
321
|
+
outstanding: 0,
|
|
322
|
+
pendingBytes: 0,
|
|
323
|
+
pendingHighWater: 0
|
|
324
|
+
};
|
|
325
|
+
var socket;
|
|
326
|
+
var decoder;
|
|
327
|
+
var retryTimer;
|
|
328
|
+
var deadline;
|
|
329
|
+
var frameHandle = 0;
|
|
330
|
+
var drawnThisFrame = false;
|
|
331
|
+
var transportBroken = false;
|
|
332
|
+
var generation = 0;
|
|
333
|
+
var sequence = 0;
|
|
334
|
+
var lastTimestamp = -1;
|
|
335
|
+
var ready = false;
|
|
336
|
+
var retry = 0;
|
|
337
|
+
var epoch = 0;
|
|
338
|
+
var backlogSince = null;
|
|
339
|
+
var lastCatchUp = -Infinity;
|
|
340
|
+
var CLOCK_WINDOW_MS = 5e3;
|
|
341
|
+
var JITTER_WINDOW_MS = 2e3;
|
|
342
|
+
var JITTER_QUANTILE = 0.95;
|
|
343
|
+
var MAX_HOLD_MS = 100;
|
|
344
|
+
var HOLD_DECAY = 0.05;
|
|
345
|
+
var CLOCK_JUMP_MS = 500;
|
|
346
|
+
var samples = [];
|
|
347
|
+
var lows = [];
|
|
348
|
+
var holdMs = 0;
|
|
349
|
+
var buttons = 0;
|
|
350
|
+
var modifiers = 0;
|
|
351
|
+
var x = 0;
|
|
352
|
+
var y = 0;
|
|
353
|
+
var viewOnly = true;
|
|
354
|
+
var capsLock = false;
|
|
355
|
+
var metaAsCtrl = stored("relay.metaCtrl") === null ? macos() : stored("relay.metaCtrl") === "1";
|
|
356
|
+
var pending = /* @__PURE__ */ new Map();
|
|
357
|
+
var decoded = [];
|
|
358
|
+
var held = /* @__PURE__ */ new Set();
|
|
359
|
+
var latched = /* @__PURE__ */ new Map();
|
|
360
|
+
var clamp = (value, low, high) => Math.max(low, Math.min(high, value));
|
|
361
|
+
function setStatus(message) {
|
|
362
|
+
if (status.textContent !== message) status.textContent = message;
|
|
363
|
+
}
|
|
364
|
+
function macos() {
|
|
365
|
+
const platform = globalThis.navigator?.userAgentData?.platform || globalThis.navigator?.platform || "";
|
|
366
|
+
return platform === "macOS" || platform === "MacIntel";
|
|
367
|
+
}
|
|
368
|
+
var SWAP_META_CONTROL = { 224: 227, 227: 224, 228: 231, 231: 228 };
|
|
369
|
+
function mapKey(code) {
|
|
370
|
+
return metaAsCtrl ? SWAP_META_CONTROL[code] ?? code : code;
|
|
371
|
+
}
|
|
372
|
+
function setModifier(code, down) {
|
|
373
|
+
if (code < 224 || code > 231) return;
|
|
374
|
+
modifiers = down ? modifiers | 1 << code - 224 : modifiers & ~(1 << code - 224);
|
|
375
|
+
}
|
|
376
|
+
function syncCaps(event) {
|
|
377
|
+
if (viewOnly) return;
|
|
378
|
+
const local = event.getModifierState("CapsLock");
|
|
379
|
+
if (local === capsLock) return;
|
|
380
|
+
if (sendInput({ type: "keyDown", key: keys.CapsLock }) && sendInput({ type: "keyUp", key: keys.CapsLock })) capsLock = local;
|
|
381
|
+
}
|
|
382
|
+
function clearLatched() {
|
|
383
|
+
for (const button of latched.values()) button.setAttribute("aria-pressed", "false");
|
|
384
|
+
latched.clear();
|
|
385
|
+
}
|
|
386
|
+
function releaseLatched() {
|
|
387
|
+
for (const code of latched.keys()) releaseKey(code);
|
|
388
|
+
clearLatched();
|
|
389
|
+
}
|
|
390
|
+
var authHeaders = () => accessToken ? { Authorization: `Bearer ${accessToken}` } : {};
|
|
391
|
+
function sendInput(event) {
|
|
392
|
+
if (!ready || socket?.readyState !== WebSocket.OPEN || viewOnly && event.type !== "releaseAll") return false;
|
|
393
|
+
socket.send(encodeInput({ ...event, buttons, modifiers }, generation, 0));
|
|
394
|
+
return true;
|
|
395
|
+
}
|
|
396
|
+
function holdKey(code) {
|
|
397
|
+
setModifier(code, true);
|
|
398
|
+
if (sendInput({ type: "keyDown", key: code })) return true;
|
|
399
|
+
setModifier(code, false);
|
|
400
|
+
return false;
|
|
401
|
+
}
|
|
402
|
+
function releaseKey(code) {
|
|
403
|
+
setModifier(code, false);
|
|
404
|
+
sendInput({ type: "keyUp", key: code });
|
|
405
|
+
}
|
|
406
|
+
function dropLatch(code) {
|
|
407
|
+
const button = latched.get(code);
|
|
408
|
+
if (!button) return false;
|
|
409
|
+
latched.delete(code);
|
|
410
|
+
button.setAttribute("aria-pressed", "false");
|
|
411
|
+
releaseKey(code);
|
|
412
|
+
return true;
|
|
413
|
+
}
|
|
414
|
+
function release() {
|
|
415
|
+
buttons = modifiers = 0;
|
|
416
|
+
if (ready) sendInput({ type: "releaseAll" });
|
|
417
|
+
held.clear();
|
|
418
|
+
clearLatched();
|
|
419
|
+
}
|
|
420
|
+
function reset() {
|
|
421
|
+
release();
|
|
422
|
+
ready = false;
|
|
423
|
+
cursorAvailable = false;
|
|
424
|
+
cursor.width = cursor.height = 1;
|
|
425
|
+
renderCursor();
|
|
426
|
+
clearTimeout(deadline);
|
|
427
|
+
cancelAnimationFrame(frameHandle);
|
|
428
|
+
frameHandle = 0;
|
|
429
|
+
drawnThisFrame = false;
|
|
430
|
+
backlogSince = null;
|
|
431
|
+
lastCatchUp = -Infinity;
|
|
432
|
+
samples = [];
|
|
433
|
+
lows = [];
|
|
434
|
+
holdMs = stats.holdMs = 0;
|
|
435
|
+
pending.clear();
|
|
436
|
+
for (const item of decoded) item.frame.close();
|
|
437
|
+
decoded.length = 0;
|
|
438
|
+
stats.outstanding = 0;
|
|
439
|
+
stats.pendingBytes = 0;
|
|
440
|
+
generation = 0;
|
|
441
|
+
capsLock = false;
|
|
442
|
+
sequence = 0;
|
|
443
|
+
lastTimestamp = -1;
|
|
444
|
+
if (decoder && decoder.state !== "closed") decoder.close();
|
|
445
|
+
decoder = void 0;
|
|
446
|
+
}
|
|
447
|
+
function fail(message) {
|
|
448
|
+
stats.decodeerrors++;
|
|
449
|
+
setStatus(message);
|
|
450
|
+
const old = socket;
|
|
451
|
+
reset();
|
|
452
|
+
if (old && old.readyState < WebSocket.CLOSING) old.close();
|
|
453
|
+
}
|
|
454
|
+
function watchPending(current) {
|
|
455
|
+
clearTimeout(deadline);
|
|
456
|
+
const oldest = pending.values().next().value;
|
|
457
|
+
if (oldest) {
|
|
458
|
+
deadline = setTimeout(() => {
|
|
459
|
+
if (current === epoch) fail("Decoder timed out; reconnecting");
|
|
460
|
+
}, Math.max(0, oldest.arrived + 5e3 - performance.now()));
|
|
461
|
+
}
|
|
462
|
+
}
|
|
463
|
+
function observeArrival(timestamp, arrivedMs) {
|
|
464
|
+
const offset = arrivedMs - timestamp / 1e3, last = samples.at(-1);
|
|
465
|
+
if (last && Math.abs(offset - last.offset) > CLOCK_JUMP_MS) {
|
|
466
|
+
samples = [];
|
|
467
|
+
lows = [];
|
|
468
|
+
holdMs = 0;
|
|
469
|
+
}
|
|
470
|
+
const previous = samples.at(-1)?.time ?? arrivedMs, sample = { time: arrivedMs, offset, late: 0 };
|
|
471
|
+
samples.push(sample);
|
|
472
|
+
while (lows.length && lows[lows.length - 1].offset >= offset) lows.pop();
|
|
473
|
+
lows.push(sample);
|
|
474
|
+
while (samples[0].time < arrivedMs - CLOCK_WINDOW_MS) {
|
|
475
|
+
if (lows[0] === samples[0]) lows.shift();
|
|
476
|
+
samples.shift();
|
|
477
|
+
}
|
|
478
|
+
const base = lows[0].offset, recent = [];
|
|
479
|
+
sample.late = offset - base;
|
|
480
|
+
for (let i = samples.length - 1; i >= 0 && samples[i].time >= arrivedMs - JITTER_WINDOW_MS; i--) recent.push(samples[i].late);
|
|
481
|
+
recent.sort((a, b) => a - b);
|
|
482
|
+
const target = Math.min(MAX_HOLD_MS, recent[Math.floor(JITTER_QUANTILE * (recent.length - 1))]);
|
|
483
|
+
holdMs = target >= holdMs ? target : Math.max(target, holdMs - (arrivedMs - previous) * HOLD_DECAY);
|
|
484
|
+
stats.holdMs = holdMs;
|
|
485
|
+
return base;
|
|
486
|
+
}
|
|
487
|
+
function isDue(item, now) {
|
|
488
|
+
return item.timestamp / 1e3 + item.base + holdMs <= now + 1e-6;
|
|
489
|
+
}
|
|
490
|
+
function dueCount(now) {
|
|
491
|
+
let count = 0;
|
|
492
|
+
while (count < decoded.length && isDue(decoded[count], now)) count++;
|
|
493
|
+
return count;
|
|
494
|
+
}
|
|
495
|
+
function schedulePresent() {
|
|
496
|
+
if (!frameHandle) frameHandle = requestAnimationFrame(present);
|
|
497
|
+
}
|
|
498
|
+
function ackFrame(item) {
|
|
499
|
+
try {
|
|
500
|
+
if (socket?.readyState !== WebSocket.OPEN) throw new Error("Connection closed before ACK");
|
|
501
|
+
socket.send(encodeAck(item.gen, item.seq, performance.now() - item.arrived));
|
|
502
|
+
return true;
|
|
503
|
+
} catch (error) {
|
|
504
|
+
fail(`ACK failed: ${error.message}`);
|
|
505
|
+
return false;
|
|
506
|
+
}
|
|
507
|
+
}
|
|
508
|
+
function retireDecoded() {
|
|
509
|
+
if (transportBroken || socket?.readyState !== WebSocket.OPEN) return;
|
|
510
|
+
for (const item of decoded) if (!ackFrame(item)) break;
|
|
511
|
+
}
|
|
512
|
+
function draw(item) {
|
|
513
|
+
try {
|
|
514
|
+
if (item.gen !== generation) throw new Error("Stale decoded frame");
|
|
515
|
+
ctx.drawImage(item.frame, 0, 0, canvas.width, canvas.height);
|
|
516
|
+
} catch (error) {
|
|
517
|
+
item.frame.close();
|
|
518
|
+
fail(`Draw failed: ${error.message}`);
|
|
519
|
+
return false;
|
|
520
|
+
}
|
|
521
|
+
item.frame.close();
|
|
522
|
+
stats.drawn++;
|
|
523
|
+
const wasReady = ready;
|
|
524
|
+
ready = true;
|
|
525
|
+
if (!wasReady) renderCursor();
|
|
526
|
+
retry = 0;
|
|
527
|
+
setStatus(viewOnly ? "Live \xB7 view only" : "Live \xB7 you have control");
|
|
528
|
+
drawnThisFrame = true;
|
|
529
|
+
return ackFrame(item);
|
|
530
|
+
}
|
|
531
|
+
function presenterPhase(due, draws, backlogMs, sinceCatchUpMs, headOverstayMs) {
|
|
532
|
+
if (due <= 2) return "idle";
|
|
533
|
+
if (due > 12 || headOverstayMs > 200) return "overrun";
|
|
534
|
+
if (due - draws <= 2) return "idle";
|
|
535
|
+
return backlogMs < 500 || sinceCatchUpMs < 250 ? "backlog" : "catchUp";
|
|
536
|
+
}
|
|
537
|
+
function trimDecoded(now, draws = 0) {
|
|
538
|
+
let due = dueCount(now);
|
|
539
|
+
const phase = presenterPhase(
|
|
540
|
+
due,
|
|
541
|
+
draws,
|
|
542
|
+
now - (backlogSince ?? now),
|
|
543
|
+
now - lastCatchUp,
|
|
544
|
+
decoded.length ? now - decoded[0].arrived - holdMs : 0
|
|
545
|
+
);
|
|
546
|
+
if (phase === "idle") {
|
|
547
|
+
backlogSince = null;
|
|
548
|
+
return true;
|
|
549
|
+
}
|
|
550
|
+
backlogSince ?? (backlogSince = now);
|
|
551
|
+
if (phase === "backlog") return true;
|
|
552
|
+
do {
|
|
553
|
+
const dropped = decoded.shift();
|
|
554
|
+
dropped.frame.close();
|
|
555
|
+
stats.superseded++;
|
|
556
|
+
due--;
|
|
557
|
+
if (!ackFrame(dropped)) return false;
|
|
558
|
+
} while (phase === "overrun" && due > 2);
|
|
559
|
+
if (due <= 2) backlogSince = null;
|
|
560
|
+
if (phase === "catchUp") lastCatchUp = now;
|
|
561
|
+
return true;
|
|
562
|
+
}
|
|
563
|
+
function presentDecoded(item) {
|
|
564
|
+
const now = performance.now(), immediate = !decoded.length && !drawnThisFrame;
|
|
565
|
+
decoded.push(item);
|
|
566
|
+
if (!trimDecoded(now)) return false;
|
|
567
|
+
if (immediate && isDue(decoded[0], now) && !draw(decoded.shift())) return false;
|
|
568
|
+
schedulePresent();
|
|
569
|
+
return true;
|
|
570
|
+
}
|
|
571
|
+
function present() {
|
|
572
|
+
frameHandle = 0;
|
|
573
|
+
drawnThisFrame = false;
|
|
574
|
+
const now = performance.now();
|
|
575
|
+
if (!trimDecoded(now, 1)) return;
|
|
576
|
+
let drew = false;
|
|
577
|
+
if (decoded.length && isDue(decoded[0], now)) {
|
|
578
|
+
if (!draw(decoded.shift())) return;
|
|
579
|
+
drew = true;
|
|
580
|
+
}
|
|
581
|
+
if (drew || decoded.length) schedulePresent();
|
|
582
|
+
}
|
|
583
|
+
function connect() {
|
|
584
|
+
clearTimeout(retryTimer);
|
|
585
|
+
epoch++;
|
|
586
|
+
const current = epoch;
|
|
587
|
+
if (socket && socket.readyState < WebSocket.CLOSING) {
|
|
588
|
+
release();
|
|
589
|
+
retireDecoded();
|
|
590
|
+
socket.close();
|
|
591
|
+
}
|
|
592
|
+
reset();
|
|
593
|
+
setStatus("Connecting\u2026");
|
|
594
|
+
if (!("VideoDecoder" in window) || !("EncodedVideoChunk" in window)) {
|
|
595
|
+
setStatus("WebCodecs unavailable in this browser");
|
|
596
|
+
return;
|
|
597
|
+
}
|
|
598
|
+
const target = socketTarget(new URL(`${location.protocol}//${location.host}`), viewOnly ? "/stream?view=1" : "/stream", accessToken);
|
|
599
|
+
socket = new WebSocket(target.url, target.protocols);
|
|
600
|
+
transportBroken = false;
|
|
601
|
+
loadCapabilities();
|
|
602
|
+
const ws = socket;
|
|
603
|
+
ws.binaryType = "arraybuffer";
|
|
604
|
+
ws.onopen = () => {
|
|
605
|
+
if (current === epoch) {
|
|
606
|
+
setStatus("Waiting for frame\u2026");
|
|
607
|
+
deadline = setTimeout(() => {
|
|
608
|
+
if (current === epoch) fail("First frame timed out; reconnecting");
|
|
609
|
+
}, 5e3);
|
|
610
|
+
}
|
|
611
|
+
};
|
|
612
|
+
ws.onmessage = (e) => {
|
|
613
|
+
if (current !== epoch || ws.readyState !== WebSocket.OPEN) return;
|
|
614
|
+
try {
|
|
615
|
+
if (!(e.data instanceof ArrayBuffer)) throw new Error("Invalid frame length");
|
|
616
|
+
const message = parseMessage(e.data);
|
|
617
|
+
if (message.type === "cursor") {
|
|
618
|
+
receiveCursor(message);
|
|
619
|
+
return;
|
|
620
|
+
}
|
|
621
|
+
if (message.type !== "frame") throw new Error("Invalid frame header");
|
|
622
|
+
const { generation: gen, sequence: seq, keyframe, width, height, timestamp, data } = message;
|
|
623
|
+
if (generation && gen < generation) throw new Error("Stale generation");
|
|
624
|
+
if (gen !== generation) {
|
|
625
|
+
reset();
|
|
626
|
+
generation = gen;
|
|
627
|
+
if (!keyframe || seq !== 1) {
|
|
628
|
+
throw new Error("Generation must start with a keyframe");
|
|
629
|
+
}
|
|
630
|
+
}
|
|
631
|
+
if (seq !== sequence + 1 || timestamp <= lastTimestamp || pending.size >= 360 || stats.pendingBytes + data.byteLength > MAX_BYTES_IN_FLIGHT) throw new Error("Unexpected frame sequence or queue limit");
|
|
632
|
+
sequence = seq;
|
|
633
|
+
lastTimestamp = timestamp;
|
|
634
|
+
stats.received++;
|
|
635
|
+
stats.bytes += data.byteLength;
|
|
636
|
+
const arrived = performance.now();
|
|
637
|
+
pending.set(timestamp, { gen, seq, bytes: data.byteLength, arrived, timestamp, base: observeArrival(timestamp, arrived) });
|
|
638
|
+
stats.outstanding = pending.size;
|
|
639
|
+
stats.pendingBytes += data.byteLength;
|
|
640
|
+
stats.pendingHighWater = Math.max(stats.pendingHighWater, pending.size);
|
|
641
|
+
watchPending(current);
|
|
642
|
+
if (!decoder) {
|
|
643
|
+
if (canvas.width !== width || canvas.height !== height) {
|
|
644
|
+
canvas.width = width;
|
|
645
|
+
canvas.height = height;
|
|
646
|
+
canvas.style.setProperty("--w", String(width));
|
|
647
|
+
canvas.style.setProperty("--h", String(height));
|
|
648
|
+
syncSize();
|
|
649
|
+
}
|
|
650
|
+
const config = { codec: h264Codec(data), codedWidth: width, codedHeight: height, optimizeForLatency: true };
|
|
651
|
+
const instance = new VideoDecoder({
|
|
652
|
+
output(frame) {
|
|
653
|
+
let retained = false;
|
|
654
|
+
try {
|
|
655
|
+
if (current !== epoch || decoder !== instance) return;
|
|
656
|
+
const item = pending.get(frame.timestamp);
|
|
657
|
+
if (!item || item.gen !== generation) {
|
|
658
|
+
throw new Error("Unexpected decoded frame");
|
|
659
|
+
}
|
|
660
|
+
retained = true;
|
|
661
|
+
pending.delete(frame.timestamp);
|
|
662
|
+
stats.pendingBytes -= item.bytes;
|
|
663
|
+
stats.outstanding = pending.size;
|
|
664
|
+
item.frame = frame;
|
|
665
|
+
if (!presentDecoded(item)) return;
|
|
666
|
+
watchPending(current);
|
|
667
|
+
} catch (error) {
|
|
668
|
+
fail(`Draw failed: ${error.message}`);
|
|
669
|
+
} finally {
|
|
670
|
+
if (!retained) frame.close();
|
|
671
|
+
}
|
|
672
|
+
},
|
|
673
|
+
error(error) {
|
|
674
|
+
if (current === epoch && decoder === instance) fail(`Decode failed: ${error.message}`);
|
|
675
|
+
}
|
|
676
|
+
});
|
|
677
|
+
decoder = instance;
|
|
678
|
+
decoder.configure(config);
|
|
679
|
+
}
|
|
680
|
+
decoder.decode(
|
|
681
|
+
new EncodedVideoChunk({ type: keyframe ? "key" : "delta", timestamp, data })
|
|
682
|
+
);
|
|
683
|
+
} catch (error) {
|
|
684
|
+
if (current === epoch) fail(error.message);
|
|
685
|
+
}
|
|
686
|
+
};
|
|
687
|
+
ws.onerror = () => {
|
|
688
|
+
if (current === epoch) {
|
|
689
|
+
transportBroken = true;
|
|
690
|
+
setStatus("Connection error");
|
|
691
|
+
}
|
|
692
|
+
};
|
|
693
|
+
ws.onclose = () => {
|
|
694
|
+
if (current !== epoch) return;
|
|
695
|
+
reset();
|
|
696
|
+
if (document.hidden) {
|
|
697
|
+
setStatus("Paused while hidden");
|
|
698
|
+
return;
|
|
699
|
+
}
|
|
700
|
+
if (retry >= 5) {
|
|
701
|
+
setStatus(status.textContent + " \xB7 reconnect manually");
|
|
702
|
+
return;
|
|
703
|
+
}
|
|
704
|
+
const delay = Math.min(1e3 * 2 ** retry++, 8e3);
|
|
705
|
+
setStatus(status.textContent + ` \xB7 retrying in ${delay / 1e3}s`);
|
|
706
|
+
retryTimer = setTimeout(connect, delay);
|
|
707
|
+
checkAccess(current);
|
|
708
|
+
};
|
|
709
|
+
}
|
|
710
|
+
function position(e) {
|
|
711
|
+
pointerPosition = { clientX: e.clientX, clientY: e.clientY, pointerType: e.pointerType };
|
|
712
|
+
renderCursor();
|
|
713
|
+
const r = canvas.getBoundingClientRect();
|
|
714
|
+
if (r.width <= 0 || r.height <= 0) return;
|
|
715
|
+
const px = clamp(Math.floor((e.clientX - r.left) * canvas.width / r.width), 0, canvas.width - 1);
|
|
716
|
+
const py = clamp(Math.floor((e.clientY - r.top) * canvas.height / r.height), 0, canvas.height - 1);
|
|
717
|
+
x = px / (canvas.width - 1);
|
|
718
|
+
y = py / (canvas.height - 1);
|
|
719
|
+
}
|
|
720
|
+
canvas.addEventListener("keydown", (e) => {
|
|
721
|
+
const code = mapKey(keys[e.code]);
|
|
722
|
+
if (!code) return;
|
|
723
|
+
e.preventDefault();
|
|
724
|
+
syncCaps(e);
|
|
725
|
+
if (e.code === "CapsLock") return;
|
|
726
|
+
if (e.repeat || held.has(code)) return;
|
|
727
|
+
if (!holdKey(code)) return;
|
|
728
|
+
held.add(code);
|
|
729
|
+
if (code < 224) releaseLatched();
|
|
730
|
+
});
|
|
731
|
+
canvas.addEventListener("keyup", (e) => {
|
|
732
|
+
const code = mapKey(keys[e.code]);
|
|
733
|
+
if (!code) return;
|
|
734
|
+
e.preventDefault();
|
|
735
|
+
syncCaps(e);
|
|
736
|
+
if (e.code === "CapsLock") return;
|
|
737
|
+
if (!held.delete(code)) return;
|
|
738
|
+
if (!dropLatch(code)) releaseKey(code);
|
|
739
|
+
});
|
|
740
|
+
canvas.addEventListener("pointermove", (e) => {
|
|
741
|
+
position(e);
|
|
742
|
+
sendInput({ type: "pointerMove", x, y });
|
|
743
|
+
});
|
|
744
|
+
canvas.addEventListener("pointerleave", () => {
|
|
745
|
+
pointerPosition = null;
|
|
746
|
+
renderCursor();
|
|
747
|
+
});
|
|
748
|
+
new ResizeObserver(renderCursor).observe(canvas);
|
|
749
|
+
window.addEventListener("scroll", renderCursor, { passive: true });
|
|
750
|
+
var buttonMap = { 0: 1, 1: 2, 2: 3 };
|
|
751
|
+
canvas.addEventListener("pointerdown", (e) => {
|
|
752
|
+
const button = buttonMap[e.button];
|
|
753
|
+
if (!button) return;
|
|
754
|
+
e.preventDefault();
|
|
755
|
+
canvas.focus();
|
|
756
|
+
position(e);
|
|
757
|
+
buttons |= 1 << button - 1;
|
|
758
|
+
canvas.setPointerCapture(e.pointerId);
|
|
759
|
+
sendInput({ type: "buttonDown", button, x, y });
|
|
760
|
+
});
|
|
761
|
+
canvas.addEventListener("pointerup", (e) => {
|
|
762
|
+
const button = buttonMap[e.button];
|
|
763
|
+
if (!button) return;
|
|
764
|
+
e.preventDefault();
|
|
765
|
+
position(e);
|
|
766
|
+
buttons &= ~(1 << button - 1);
|
|
767
|
+
sendInput({ type: "buttonUp", button, x, y });
|
|
768
|
+
if (!buttons && canvas.hasPointerCapture(e.pointerId)) {
|
|
769
|
+
canvas.releasePointerCapture(e.pointerId);
|
|
770
|
+
}
|
|
771
|
+
});
|
|
772
|
+
canvas.addEventListener("pointercancel", release);
|
|
773
|
+
canvas.addEventListener("lostpointercapture", () => {
|
|
774
|
+
if (buttons) release();
|
|
775
|
+
});
|
|
776
|
+
canvas.addEventListener("contextmenu", (e) => e.preventDefault());
|
|
777
|
+
var WHEEL_LINES_PER_NOTCH = 3;
|
|
778
|
+
var WHEEL_PIXELS_PER_NOTCH = 100;
|
|
779
|
+
var wheelRemainder = [0, 0];
|
|
780
|
+
function wheelNotches(e, axis) {
|
|
781
|
+
const legacy = axis ? e.wheelDeltaX : e.wheelDeltaY;
|
|
782
|
+
if (typeof legacy === "number" && legacy !== 0) return -legacy / 120;
|
|
783
|
+
const delta = axis ? e.deltaX : e.deltaY;
|
|
784
|
+
if (e.deltaMode === 1) return delta / WHEEL_LINES_PER_NOTCH;
|
|
785
|
+
if (e.deltaMode === 2) return delta;
|
|
786
|
+
return delta / WHEEL_PIXELS_PER_NOTCH;
|
|
787
|
+
}
|
|
788
|
+
canvas.addEventListener("wheel", (e) => {
|
|
789
|
+
e.preventDefault();
|
|
790
|
+
position(e);
|
|
791
|
+
for (const axis of [0, 1]) {
|
|
792
|
+
if (!(axis ? e.deltaX : e.deltaY)) continue;
|
|
793
|
+
const notches = wheelNotches(e, axis);
|
|
794
|
+
if (Math.sign(notches) !== Math.sign(wheelRemainder[axis])) wheelRemainder[axis] = 0;
|
|
795
|
+
wheelRemainder[axis] += notches;
|
|
796
|
+
const whole = Math.trunc(wheelRemainder[axis]);
|
|
797
|
+
if (!whole) continue;
|
|
798
|
+
wheelRemainder[axis] -= whole;
|
|
799
|
+
sendInput({ type: "wheel", axis: axis ? "horizontal" : "vertical", delta: clamp(whole * 120, -1200, 1200), x, y });
|
|
800
|
+
}
|
|
801
|
+
}, { passive: false });
|
|
802
|
+
canvas.addEventListener("blur", release);
|
|
803
|
+
window.addEventListener("blur", () => {
|
|
804
|
+
release();
|
|
805
|
+
pointerPosition = null;
|
|
806
|
+
renderCursor();
|
|
807
|
+
});
|
|
808
|
+
var METRICS_UNAVAILABLE = "Cgroup CPU (one core): unavailable \xB7 Cgroup RAM: unavailable";
|
|
809
|
+
var hudTimer;
|
|
810
|
+
var metricsRequest;
|
|
811
|
+
var configuredFps = 0;
|
|
812
|
+
function hudText(fps, mbps, metrics) {
|
|
813
|
+
const stream = `Stream ${canvas.width}x${canvas.height}${configuredFps ? ` @ ${configuredFps} fps` : ""}`;
|
|
814
|
+
return `${stream} \xB7 Drawn FPS: ${fps.toFixed(1)} \xB7 Stream Mbps: ${mbps.toFixed(2)} \xB7 ${metrics}`;
|
|
815
|
+
}
|
|
816
|
+
function loadCapabilities() {
|
|
817
|
+
fetch("/capabilities", { cache: "no-store", redirect: "error", headers: authHeaders() }).then((response) => response.ok ? response.json() : null).then((data) => {
|
|
818
|
+
if (Number.isFinite(data?.fps) && data.fps > 0) configuredFps = data.fps;
|
|
819
|
+
}).catch(() => {
|
|
820
|
+
});
|
|
821
|
+
}
|
|
822
|
+
function startHud() {
|
|
823
|
+
let previousTime = performance.now(), previousDrawn = stats.drawn, previousBytes = stats.bytes, previousCpu, previousCpuTime = 0, metrics = METRICS_UNAVAILABLE;
|
|
824
|
+
hudTimer = setInterval(() => {
|
|
825
|
+
const now = performance.now(), seconds = (now - previousTime) / 1e3;
|
|
826
|
+
const fps = (stats.drawn - previousDrawn) / seconds;
|
|
827
|
+
const mbps = (stats.bytes - previousBytes) * 8 / seconds / 1e6;
|
|
828
|
+
document.querySelector("#hud").textContent = hudText(fps, mbps, metrics);
|
|
829
|
+
previousTime = now;
|
|
830
|
+
previousDrawn = stats.drawn;
|
|
831
|
+
previousBytes = stats.bytes;
|
|
832
|
+
if (!metricsRequest && !document.querySelector("#stats").hidden) {
|
|
833
|
+
const controller = metricsRequest = new AbortController();
|
|
834
|
+
const timer = setTimeout(() => controller.abort(), 2e3);
|
|
835
|
+
fetch("/metrics", { cache: "no-store", signal: controller.signal, redirect: "error", headers: authHeaders() }).then((response) => {
|
|
836
|
+
if (!response.ok) throw new Error("Metrics unavailable");
|
|
837
|
+
return response.json();
|
|
838
|
+
}).then((data) => {
|
|
839
|
+
const time = performance.now();
|
|
840
|
+
if (![data.usage_usec, data.memory_current, data.inactive_file].every((n) => Number.isFinite(n) && n >= 0)) {
|
|
841
|
+
throw new Error("Invalid metrics");
|
|
842
|
+
}
|
|
843
|
+
const cpu = previousCpu !== void 0 && data.usage_usec >= previousCpu && time > previousCpuTime ? `${((data.usage_usec - previousCpu) / ((time - previousCpuTime) * 1e3) * 100).toFixed(1)}%` : "unavailable";
|
|
844
|
+
const ram = (Math.max(0, data.memory_current - data.inactive_file) / 1048576).toFixed(1);
|
|
845
|
+
metrics = `Cgroup CPU (one core): ${cpu} \xB7 Cgroup RAM: ${ram} MiB`;
|
|
846
|
+
previousCpu = data.usage_usec;
|
|
847
|
+
previousCpuTime = time;
|
|
848
|
+
}).catch(() => {
|
|
849
|
+
metrics = METRICS_UNAVAILABLE;
|
|
850
|
+
previousCpu = void 0;
|
|
851
|
+
}).finally(() => {
|
|
852
|
+
clearTimeout(timer);
|
|
853
|
+
if (metricsRequest === controller) metricsRequest = null;
|
|
854
|
+
});
|
|
855
|
+
}
|
|
856
|
+
}, 1e3);
|
|
857
|
+
}
|
|
858
|
+
document.addEventListener("visibilitychange", () => {
|
|
859
|
+
if (document.hidden) {
|
|
860
|
+
clearInterval(hudTimer);
|
|
861
|
+
metricsRequest?.abort();
|
|
862
|
+
metricsRequest = null;
|
|
863
|
+
document.querySelector("#hud").textContent = hudText(0, 0, METRICS_UNAVAILABLE);
|
|
864
|
+
release();
|
|
865
|
+
epoch++;
|
|
866
|
+
retireDecoded();
|
|
867
|
+
if (socket) socket.close();
|
|
868
|
+
reset();
|
|
869
|
+
clearTimeout(retryTimer);
|
|
870
|
+
setStatus("Paused while hidden");
|
|
871
|
+
} else {
|
|
872
|
+
startHud();
|
|
873
|
+
retry = 0;
|
|
874
|
+
connect();
|
|
875
|
+
}
|
|
876
|
+
});
|
|
877
|
+
function checkAccess(current) {
|
|
878
|
+
fetch("/capabilities", { cache: "no-store", redirect: "error", headers: authHeaders() }).then((response) => {
|
|
879
|
+
if (response.status !== 401 || current !== epoch) return;
|
|
880
|
+
clearTimeout(retryTimer);
|
|
881
|
+
setStatus(accessToken ? "Access token rejected" : "Access token required");
|
|
882
|
+
setExpanded(true);
|
|
883
|
+
showPanel("connection", true);
|
|
884
|
+
document.querySelector("#access-token").focus();
|
|
885
|
+
}).catch(() => {
|
|
886
|
+
});
|
|
887
|
+
}
|
|
888
|
+
function stored(key) {
|
|
889
|
+
try {
|
|
890
|
+
return localStorage.getItem(key);
|
|
891
|
+
} catch (error) {
|
|
892
|
+
return null;
|
|
893
|
+
}
|
|
894
|
+
}
|
|
895
|
+
function store(key, value) {
|
|
896
|
+
try {
|
|
897
|
+
localStorage.setItem(key, value);
|
|
898
|
+
} catch (error) {
|
|
899
|
+
}
|
|
900
|
+
}
|
|
901
|
+
var scaleButtons = {
|
|
902
|
+
fit: document.querySelector('[data-scale="fit"]'),
|
|
903
|
+
actual: document.querySelector('[data-scale="actual"]'),
|
|
904
|
+
sharp: document.querySelector('[data-scale="sharp"]')
|
|
905
|
+
};
|
|
906
|
+
var scaleMode = stored("relay.scale") === "actual" ? "actual" : "fit";
|
|
907
|
+
var sharpPixels = stored("relay.sharp") === "1";
|
|
908
|
+
var dprQuery;
|
|
909
|
+
function syncSize() {
|
|
910
|
+
if (scaleMode !== "actual") {
|
|
911
|
+
canvas.style.width = canvas.style.height = "";
|
|
912
|
+
return;
|
|
913
|
+
}
|
|
914
|
+
const ratio = window.devicePixelRatio || 1;
|
|
915
|
+
canvas.style.width = `${canvas.width / ratio}px`;
|
|
916
|
+
canvas.style.height = `${canvas.height / ratio}px`;
|
|
917
|
+
}
|
|
918
|
+
function applyScale() {
|
|
919
|
+
document.body.classList.toggle("actual", scaleMode === "actual");
|
|
920
|
+
canvas.style.imageRendering = sharpPixels ? "pixelated" : "";
|
|
921
|
+
scaleButtons.fit.setAttribute("aria-pressed", String(scaleMode === "fit"));
|
|
922
|
+
scaleButtons.actual.setAttribute("aria-pressed", String(scaleMode === "actual"));
|
|
923
|
+
scaleButtons.sharp.setAttribute("aria-pressed", String(sharpPixels));
|
|
924
|
+
syncSize();
|
|
925
|
+
renderCursor();
|
|
926
|
+
}
|
|
927
|
+
function setScale(mode) {
|
|
928
|
+
scaleMode = mode === "actual" ? "actual" : "fit";
|
|
929
|
+
store("relay.scale", scaleMode);
|
|
930
|
+
applyScale();
|
|
931
|
+
}
|
|
932
|
+
function toggleSharp() {
|
|
933
|
+
sharpPixels = !sharpPixels;
|
|
934
|
+
store("relay.sharp", sharpPixels ? "1" : "0");
|
|
935
|
+
applyScale();
|
|
936
|
+
}
|
|
937
|
+
function watchDpr() {
|
|
938
|
+
syncSize();
|
|
939
|
+
dprQuery?.removeEventListener?.("change", watchDpr);
|
|
940
|
+
dprQuery = window.matchMedia?.(`(resolution: ${window.devicePixelRatio || 1}dppx)`);
|
|
941
|
+
dprQuery?.addEventListener?.("change", watchDpr);
|
|
942
|
+
}
|
|
943
|
+
window.addEventListener("resize", watchDpr);
|
|
944
|
+
var metaButton = document.querySelector("#meta-ctrl");
|
|
945
|
+
function applyMeta() {
|
|
946
|
+
metaButton.setAttribute("aria-pressed", String(metaAsCtrl));
|
|
947
|
+
}
|
|
948
|
+
function toggleMeta() {
|
|
949
|
+
release();
|
|
950
|
+
metaAsCtrl = !metaAsCtrl;
|
|
951
|
+
store("relay.metaCtrl", metaAsCtrl ? "1" : "0");
|
|
952
|
+
applyMeta();
|
|
953
|
+
}
|
|
954
|
+
var toolbar = document.querySelector("#toolbar");
|
|
955
|
+
var toggle = document.querySelector("#toolbar-toggle");
|
|
956
|
+
var actions = document.querySelector("#toolbar-actions");
|
|
957
|
+
var dot = document.querySelector("#dot");
|
|
958
|
+
var panels = { keys: document.querySelector("#keys-panel"), connection: document.querySelector("#connection-panel") };
|
|
959
|
+
panels.scale = document.querySelector("#scale-panel");
|
|
960
|
+
function showPanel(name, open = panels[name]?.hidden) {
|
|
961
|
+
for (const [key, panel] of Object.entries(panels)) {
|
|
962
|
+
panel.hidden = !(key === name && open);
|
|
963
|
+
toolbar.querySelector(`[data-action="${key}"]`).setAttribute("aria-expanded", String(!panel.hidden));
|
|
964
|
+
}
|
|
965
|
+
}
|
|
966
|
+
function setExpanded(open) {
|
|
967
|
+
actions.hidden = !open;
|
|
968
|
+
toolbar.classList.toggle("open", open);
|
|
969
|
+
toggle.setAttribute("aria-expanded", String(open));
|
|
970
|
+
if (!open) showPanel(null);
|
|
971
|
+
}
|
|
972
|
+
function applyControl() {
|
|
973
|
+
const button = actions.querySelector('[data-action="control"]');
|
|
974
|
+
const label = viewOnly ? "Take control" : "Release control";
|
|
975
|
+
button.setAttribute("aria-pressed", String(!viewOnly));
|
|
976
|
+
button.setAttribute("aria-label", label);
|
|
977
|
+
button.setAttribute("title", label);
|
|
978
|
+
}
|
|
979
|
+
function setViewOnly(next) {
|
|
980
|
+
if (viewOnly === next) return;
|
|
981
|
+
release();
|
|
982
|
+
viewOnly = next;
|
|
983
|
+
applyControl();
|
|
984
|
+
connect();
|
|
985
|
+
}
|
|
986
|
+
function syncStatus() {
|
|
987
|
+
const text = status.textContent ?? "";
|
|
988
|
+
dot.className = "dot" + (text.startsWith("Live") ? " live" : /^(Connecting|Waiting|Paused)/.test(text) ? "" : " error");
|
|
989
|
+
toggle.setAttribute("title", text);
|
|
990
|
+
toggle.setAttribute("aria-label", `Viewer controls: ${text}`);
|
|
991
|
+
}
|
|
992
|
+
new MutationObserver(syncStatus).observe(status, { childList: true, characterData: true, subtree: true });
|
|
993
|
+
syncStatus();
|
|
994
|
+
toggle.addEventListener("click", () => setExpanded(actions.hidden));
|
|
995
|
+
canvas.addEventListener("pointerdown", () => showPanel(null));
|
|
996
|
+
var toolbarActions = {
|
|
997
|
+
fullscreen: () => (document.fullscreenElement ? document.exitFullscreen() : document.documentElement.requestFullscreen()).catch(() => {
|
|
998
|
+
}),
|
|
999
|
+
scale: () => showPanel("scale"),
|
|
1000
|
+
keys: () => showPanel("keys"),
|
|
1001
|
+
connection: () => showPanel("connection"),
|
|
1002
|
+
screenshot: () => canvas.toBlob((blob) => {
|
|
1003
|
+
if (!blob) return;
|
|
1004
|
+
const link = document.createElement("a");
|
|
1005
|
+
link.href = URL.createObjectURL(blob);
|
|
1006
|
+
link.download = `desktop-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.png`;
|
|
1007
|
+
link.click();
|
|
1008
|
+
setTimeout(() => URL.revokeObjectURL(link.href), 1e3);
|
|
1009
|
+
}, "image/png"),
|
|
1010
|
+
control: () => setViewOnly(!viewOnly),
|
|
1011
|
+
stats: (button) => {
|
|
1012
|
+
const panel = document.querySelector("#stats");
|
|
1013
|
+
panel.hidden = !panel.hidden;
|
|
1014
|
+
button.setAttribute("aria-pressed", String(!panel.hidden));
|
|
1015
|
+
}
|
|
1016
|
+
};
|
|
1017
|
+
actions.addEventListener("click", (e) => {
|
|
1018
|
+
const button = e.target.closest("[data-action]");
|
|
1019
|
+
if (button) toolbarActions[button.dataset.action](button);
|
|
1020
|
+
});
|
|
1021
|
+
document.addEventListener("fullscreenchange", () => {
|
|
1022
|
+
toolbar.querySelector('[data-action="fullscreen"]').setAttribute("aria-pressed", String(Boolean(document.fullscreenElement)));
|
|
1023
|
+
});
|
|
1024
|
+
panels.scale.addEventListener("click", (e) => {
|
|
1025
|
+
const button = e.target.closest("[data-scale]");
|
|
1026
|
+
if (!button) return;
|
|
1027
|
+
if (button.dataset.scale === "sharp") toggleSharp();
|
|
1028
|
+
else setScale(button.dataset.scale);
|
|
1029
|
+
});
|
|
1030
|
+
function keepCanvasFocus(e) {
|
|
1031
|
+
if (e.target.closest("[data-hold]") || e.target.closest("[data-keys]") || e.target.closest("#meta-ctrl")) e.preventDefault();
|
|
1032
|
+
}
|
|
1033
|
+
panels.keys.addEventListener("pointerdown", keepCanvasFocus);
|
|
1034
|
+
panels.keys.addEventListener("mousedown", keepCanvasFocus);
|
|
1035
|
+
panels.keys.addEventListener("click", (e) => {
|
|
1036
|
+
if (e.target.closest("#meta-ctrl")) {
|
|
1037
|
+
toggleMeta();
|
|
1038
|
+
canvas.focus();
|
|
1039
|
+
return;
|
|
1040
|
+
}
|
|
1041
|
+
const hold = e.target.closest("[data-hold]");
|
|
1042
|
+
if (hold) {
|
|
1043
|
+
const code = keys[hold.dataset.hold];
|
|
1044
|
+
if (!dropLatch(code) && holdKey(code)) {
|
|
1045
|
+
latched.set(code, hold);
|
|
1046
|
+
hold.setAttribute("aria-pressed", "true");
|
|
1047
|
+
}
|
|
1048
|
+
canvas.focus();
|
|
1049
|
+
return;
|
|
1050
|
+
}
|
|
1051
|
+
const button = e.target.closest("[data-keys]");
|
|
1052
|
+
if (!button) return;
|
|
1053
|
+
const codes = button.dataset.keys.split("+").map((name) => keys[name]);
|
|
1054
|
+
const pressed = [];
|
|
1055
|
+
for (const code of codes) if (!latched.has(code) && holdKey(code)) pressed.push(code);
|
|
1056
|
+
for (const code of pressed.reverse()) releaseKey(code);
|
|
1057
|
+
if (codes.some((code) => code < 224)) releaseLatched();
|
|
1058
|
+
showPanel(null);
|
|
1059
|
+
canvas.focus();
|
|
1060
|
+
});
|
|
1061
|
+
panels.connection.addEventListener("submit", (e) => {
|
|
1062
|
+
e.preventDefault();
|
|
1063
|
+
const value = document.querySelector("#access-token").value.trim();
|
|
1064
|
+
if (value && (!validToken(value) || !trustedPage)) {
|
|
1065
|
+
setStatus("Use a 64-character token over HTTPS or a localhost tunnel");
|
|
1066
|
+
return;
|
|
1067
|
+
}
|
|
1068
|
+
accessToken = value;
|
|
1069
|
+
retry = 0;
|
|
1070
|
+
connect();
|
|
1071
|
+
});
|
|
1072
|
+
if (!document.hidden) startHud();
|
|
1073
|
+
applyScale();
|
|
1074
|
+
applyMeta();
|
|
1075
|
+
applyControl();
|
|
1076
|
+
watchDpr();
|
|
1077
|
+
connect();
|
|
1078
|
+
return __toCommonJS(main_exports);
|
|
1079
|
+
})();
|