@rezkam/browser-tools 1.0.4 → 1.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.
@@ -0,0 +1,42 @@
1
+ #!/usr/bin/env node
2
+ /**
3
+ * Serves tabs of one shared Chrome to every client that leases one (see tab-broker.mjs).
4
+ *
5
+ * Usage: serve.mjs [--max-tabs <n>] [--tab-seconds <n>] [--headless] [--proxy-server <url>]
6
+ * [--chrome-arg <arg>]... [--port <n>] [--until-stdin-closes]
7
+ *
8
+ * Prints {"url": ...} on stdout once it listens, and one JSON log line per event on stderr.
9
+ */
10
+
11
+ import { browserToolsChromeBin, hasFlag, parsePositiveIntegerOption, requiredOptionValue } from './browser-control.mjs';
12
+ import { DEFAULT_MAX_TABS, DEFAULT_TAB_SECONDS, serveTabs } from './tab-broker.mjs';
13
+
14
+ const args = process.argv.slice(2);
15
+ const chromeArgs = args.flatMap((arg, index) => (args[index - 1] === '--chrome-arg' ? [arg] : []));
16
+
17
+ const served = await serveTabs({
18
+ chromeBin: browserToolsChromeBin(),
19
+ chromeArgs,
20
+ headless: hasFlag(args, '--headless'),
21
+ proxyServer: requiredOptionValue(args, '--proxy-server'),
22
+ maxTabs: parsePositiveIntegerOption(args, '--max-tabs', DEFAULT_MAX_TABS),
23
+ tabSeconds: parsePositiveIntegerOption(args, '--tab-seconds', DEFAULT_TAB_SECONDS),
24
+ port: parsePositiveIntegerOption(args, '--port', 0),
25
+ });
26
+ process.stdout.write(`${JSON.stringify({ url: served.url })}\n`);
27
+
28
+ function stop() {
29
+ // The served instance owns idempotent shutdown, not a second CLI-local stopping flag.
30
+ void served.close().then(() => process.exit(0), (error) => {
31
+ console.error(error.message);
32
+ process.exit(1);
33
+ });
34
+ }
35
+ process.on('SIGTERM', stop);
36
+ process.on('SIGINT', stop);
37
+ // A parent that holds our stdin and dies, even by SIGKILL, closes it, so the browser goes with it.
38
+ if (hasFlag(args, '--until-stdin-closes')) {
39
+ process.stdin.on('end', stop);
40
+ process.stdin.on('close', stop);
41
+ process.stdin.resume();
42
+ }
@@ -0,0 +1,284 @@
1
+ /**
2
+ * One Chrome shared by every client on the machine, handing out at most `maxTabs` tabs at a time.
3
+ *
4
+ * A client leases a tab with an HTTP request that the broker answers with one JSON line once a tab is
5
+ * free and then holds open. The tab lives in a browser context of its own, so tabs share no cookies or
6
+ * storage, and the context is disposed when the client closes the connection (or exits), or when the
7
+ * tab has been held for `tabSeconds`.
8
+ */
9
+
10
+ import { spawn } from 'node:child_process';
11
+ import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync } from 'node:fs';
12
+ import { createServer, get as httpGet } from 'node:http';
13
+ import { tmpdir } from 'node:os';
14
+ import { join } from 'node:path';
15
+ import { connectOwnBrowser } from './browser-control.mjs';
16
+ import { createTabPool } from './tab-pool.mjs';
17
+
18
+ export const DEFAULT_MAX_TABS = 4;
19
+ export const DEFAULT_TAB_SECONDS = 120;
20
+ export const DEFAULT_SAMPLE_SECONDS = 15;
21
+ const CHROME_START_TIMEOUT_MS = 30_000;
22
+ const CHROME_STOP_TIMEOUT_MS = 5_000;
23
+
24
+ // Everything a fresh profile would start in the background is off: tabs are the only work.
25
+ export const LEAN_CHROME_ARGS = [
26
+ '--no-first-run',
27
+ '--no-default-browser-check',
28
+ '--no-startup-window',
29
+ '--disable-sync',
30
+ '--disable-extensions',
31
+ '--disable-component-extensions-with-background-pages',
32
+ '--disable-component-update',
33
+ '--disable-default-apps',
34
+ '--disable-background-networking',
35
+ '--disable-domain-reliability',
36
+ '--disable-client-side-phishing-detection',
37
+ '--disable-breakpad',
38
+ '--disable-crash-reporter',
39
+ '--no-service-autorun',
40
+ '--password-store=basic',
41
+ '--mute-audio',
42
+ '--disable-blink-features=AutomationControlled',
43
+ // A closed tab's renderer would otherwise stay alive for the back-forward cache, and a spare
44
+ // renderer is kept warm for the next navigation.
45
+ '--disable-features=BackForwardCache,SpareRendererForSitePerProcess,Translate,MediaRouter,OptimizationHints,InterestFeedContentSuggestions,AutofillServerCommunication',
46
+ ];
47
+
48
+ function defaultLog(line) {
49
+ process.stderr.write(`${JSON.stringify(line)}\n`);
50
+ }
51
+
52
+ export async function serveTabs({
53
+ chromeBin,
54
+ chromeArgs = [],
55
+ headless = false,
56
+ proxyServer = null,
57
+ maxTabs = DEFAULT_MAX_TABS,
58
+ tabSeconds = DEFAULT_TAB_SECONDS,
59
+ sampleSeconds = DEFAULT_SAMPLE_SECONDS,
60
+ host = '127.0.0.1',
61
+ port = 0,
62
+ log = defaultLog,
63
+ }) {
64
+ if (!chromeBin) throw new Error('chromeBin is required');
65
+ if (!Number.isInteger(maxTabs) || maxTabs < 1) throw new Error('maxTabs must be a positive integer');
66
+ if (!(tabSeconds > 0)) throw new Error('tabSeconds must be positive');
67
+
68
+
69
+ async function launchChrome() {
70
+ const profile = mkdtempSync(join(tmpdir(), 'browser-tools-tabs-'));
71
+ const args = [...LEAN_CHROME_ARGS, `--user-data-dir=${profile}`, '--remote-debugging-address=127.0.0.1', '--remote-debugging-port=0'];
72
+ if (headless) args.push('--headless=new');
73
+ if (proxyServer) {
74
+ // Chrome sends loopback addresses around a proxy unless told otherwise, and WebRTC around it
75
+ // over UDP, either of which would let a page reach what the proxy refuses.
76
+ args.push(`--proxy-server=${proxyServer}`, '--proxy-bypass-list=<-loopback>', '--webrtc-ip-handling-policy=disable_non_proxied_udp');
77
+ }
78
+ args.push(...chromeArgs);
79
+ const child = spawn(chromeBin, args, { stdio: ['ignore', 'ignore', 'pipe'] });
80
+ let stderr = '';
81
+ child.stderr.on('data', (chunk) => {
82
+ stderr = (stderr + chunk).slice(-2000);
83
+ });
84
+ let processState = { phase: 'starting' };
85
+ child.once('error', (error) => { processState = { phase: 'failed', error }; });
86
+ const exited = new Promise((resolve) => child.once('close', (code, signal) => {
87
+ const previous = processState.phase;
88
+ if (previous !== 'failed') processState = { phase: 'exited', code, signal };
89
+ rmSync(profile, { recursive: true, force: true });
90
+ if (previous === 'running') log({ event: 'browser_exit', code, signal });
91
+ resolve({ code, signal });
92
+ }));
93
+ let browser;
94
+ try {
95
+ const portFile = join(profile, 'DevToolsActivePort');
96
+ const deadline = Date.now() + CHROME_START_TIMEOUT_MS;
97
+ while (!existsSync(portFile) || readFileSync(portFile, 'utf8').split('\n').length < 2) {
98
+ if (processState.phase === 'failed') throw processState.error;
99
+ if (processState.phase === 'exited') throw new Error(`Chrome exited while starting (${processState.signal ?? processState.code}): ${stderr.trim().slice(-500)}`);
100
+ if (Date.now() > deadline) throw new Error(`Chrome did not start within ${CHROME_START_TIMEOUT_MS}ms`);
101
+ await new Promise((resolve) => setTimeout(resolve, 50));
102
+ }
103
+ const [cdpPort, path] = readFileSync(portFile, 'utf8').split('\n');
104
+ const cdpUrl = `ws://127.0.0.1:${cdpPort}${path}`;
105
+ browser = await connectOwnBrowser(cdpUrl, { targetFilter: () => false });
106
+ const session = await browser.target().createCDPSession();
107
+ processState = { phase: 'running' };
108
+ log({ event: 'browser_start', pid: child.pid });
109
+ return {
110
+ child, browser, session, cdpUrl, cdpPort: Number(cdpPort), exited,
111
+ async close() {
112
+ if (processState.phase === 'exited' || processState.phase === 'failed') return;
113
+ processState = { phase: 'stopping' };
114
+ // Do not let an unresponsive CDP connection prevent the bounded process shutdown.
115
+ void session.send('Browser.close').catch(() => {});
116
+ let timer;
117
+ const stopped = await Promise.race([
118
+ exited.then(() => true),
119
+ new Promise((resolve) => { timer = setTimeout(() => resolve(false), CHROME_STOP_TIMEOUT_MS); }),
120
+ ]);
121
+ clearTimeout(timer);
122
+ if (!stopped) { child.kill('SIGKILL'); await exited; }
123
+ await browser.disconnect().catch(() => {});
124
+ },
125
+ };
126
+ } catch (error) {
127
+ await browser?.disconnect().catch(() => {});
128
+ if (processState.phase !== 'exited' && processState.phase !== 'failed') child.kill('SIGKILL');
129
+ await exited;
130
+ throw error;
131
+ }
132
+ }
133
+
134
+ const pool = createTabPool({ launchChrome, maxTabs, tabSeconds, proxyServer, log });
135
+
136
+ const server = createServer((request, response) => {
137
+ const url = new URL(request.url, 'http://broker');
138
+ if (request.method !== 'GET' || url.pathname !== '/lease') {
139
+ response.writeHead(404).end();
140
+ return;
141
+ }
142
+ pool.add(response, url.searchParams.get('client') || 'unnamed');
143
+ });
144
+ server.requestTimeout = 0;
145
+ await new Promise((resolve, reject) => {
146
+ server.once('error', reject);
147
+ server.listen(port, host, resolve);
148
+ });
149
+
150
+ const sampler =
151
+ process.platform === 'linux'
152
+ ? setInterval(() => {
153
+ if (!pool.running) return;
154
+ const sample = chromeMemory(pool.running.child.pid);
155
+ if (sample) log({ event: 'browser_memory', ...sample, ...pool.counts });
156
+ }, sampleSeconds * 1000)
157
+ : null;
158
+ sampler?.unref();
159
+
160
+ const address = server.address();
161
+ return {
162
+ url: `http://${host}:${address.port}`,
163
+ get cdpPort() {
164
+ return pool.running?.cdpPort ?? null;
165
+ },
166
+ async close() {
167
+ if (sampler) clearInterval(sampler);
168
+ const closing = pool.close();
169
+ const transportClosed = new Promise((resolve) => server.close(resolve));
170
+ server.closeAllConnections();
171
+ await Promise.all([transportClosed, closing]);
172
+ },
173
+ };
174
+ }
175
+
176
+ const PROCESS_TYPES = { renderer: 'renderer', 'gpu-process': 'gpu', utility: 'utility', zygote: 'zygote' };
177
+
178
+ /** Proportional set size of Chrome's process tree, by process type, from /proc. */
179
+ export function chromeMemory(rootPid) {
180
+ const children = new Map();
181
+ for (const name of readdirSync('/proc')) {
182
+ if (!/^\d+$/.test(name)) continue;
183
+ try {
184
+ const stat = readFileSync(`/proc/${name}/stat`, 'utf8');
185
+ const ppid = Number(stat.slice(stat.lastIndexOf(')') + 2).split(' ')[1]);
186
+ if (!children.has(ppid)) children.set(ppid, []);
187
+ children.get(ppid).push(Number(name));
188
+ } catch {
189
+ // The process exited while the table was read.
190
+ }
191
+ }
192
+ const pss = { browser: 0, renderer: 0, gpu: 0, utility: 0, zygote: 0, other: 0 };
193
+ let processes = 0;
194
+ let renderers = 0;
195
+ const pending = [rootPid];
196
+ while (pending.length > 0) {
197
+ const pid = pending.pop();
198
+ pending.push(...(children.get(pid) ?? []));
199
+ try {
200
+ const rollup = readFileSync(`/proc/${pid}/smaps_rollup`, 'utf8');
201
+ const kib = Number(/^Pss:\s+(\d+)/m.exec(rollup)?.[1] ?? 0);
202
+ const type = /--type=([\w-]+)/.exec(readFileSync(`/proc/${pid}/cmdline`, 'utf8').replaceAll('\0', ' '))?.[1];
203
+ const key = pid === rootPid ? 'browser' : (PROCESS_TYPES[type] ?? 'other');
204
+ pss[key] += kib;
205
+ processes += 1;
206
+ if (key === 'renderer') renderers += 1;
207
+ } catch {
208
+ // The process exited while it was read.
209
+ }
210
+ }
211
+ if (processes === 0) return null;
212
+ const mib = (kib) => Math.round(kib / 1024);
213
+ return {
214
+ total_mib: mib(Object.values(pss).reduce((sum, kib) => sum + kib, 0)),
215
+ pss_mib: Object.fromEntries(Object.entries(pss).map(([key, kib]) => [key, mib(kib)])),
216
+ processes,
217
+ renderers,
218
+ };
219
+ }
220
+
221
+ /**
222
+ * Waits for a tab from the broker at `brokerUrl`. The tab is the client's until `release()` is called
223
+ * or the process exits; `ended` settles with 'expired' if the broker took the tab back first.
224
+ * The tab is the page at `tabUrl` in the browser at `cdpUrl`.
225
+ */
226
+ export function leaseTab(brokerUrl, { client = 'unnamed' } = {}) {
227
+ return new Promise((resolve, reject) => {
228
+ let state = { phase: 'waiting' };
229
+ let resolveEnded;
230
+ const ended = new Promise((resolve) => { resolveEnded = resolve; });
231
+ const finish = (reason, error = null) => {
232
+ if (state.phase === 'ended') return;
233
+ if (state.phase === 'waiting') reject(error ?? new Error(`the tab broker ${reason} the lease before granting a tab`));
234
+ state = { phase: 'ended', reason };
235
+ resolveEnded(reason);
236
+ };
237
+ const request = httpGet(`${brokerUrl}/lease?client=${encodeURIComponent(client)}`, { agent: false }, (response) => {
238
+ if (response.statusCode !== 200) {
239
+ response.resume();
240
+ finish('error', new Error(`the tab broker refused the lease with HTTP ${response.statusCode}`));
241
+ request.destroy();
242
+ return;
243
+ }
244
+ response.setEncoding('utf8');
245
+ let buffer = '';
246
+ response.on('data', (chunk) => {
247
+ buffer += chunk;
248
+ for (let index = buffer.indexOf('\n'); index >= 0; index = buffer.indexOf('\n')) {
249
+ if (state.phase === 'ended') return;
250
+ try {
251
+ const line = JSON.parse(buffer.slice(0, index));
252
+ buffer = buffer.slice(index + 1);
253
+ if (line.error) {
254
+ finish('error', new Error(`the tab broker could not open a tab: ${line.error}`));
255
+ request.destroy();
256
+ } else if (line.ended) {
257
+ finish(line.ended);
258
+ request.destroy();
259
+ } else if (state.phase === 'waiting') {
260
+ if (!line.cdp_url || !line.target_id || !line.tab_url || !Number.isFinite(line.deadline)) {
261
+ throw new Error('the tab broker sent an invalid lease grant');
262
+ }
263
+ state = { phase: 'active' };
264
+ resolve({
265
+ cdpUrl: line.cdp_url,
266
+ targetId: line.target_id,
267
+ tabUrl: line.tab_url,
268
+ deadline: line.deadline,
269
+ ended,
270
+ release: () => { finish('released'); request.destroy(); },
271
+ });
272
+ }
273
+ } catch (error) {
274
+ finish('error', error);
275
+ request.destroy();
276
+ }
277
+ }
278
+ });
279
+ response.on('error', (error) => finish('released', error));
280
+ response.on('close', () => finish('released', new Error('the tab broker closed the lease before granting a tab')));
281
+ });
282
+ request.on('error', (error) => finish('released', error));
283
+ });
284
+ }
@@ -0,0 +1,195 @@
1
+ import { randomUUID } from 'node:crypto';
2
+
3
+ // Transport-independent owner of the service, lazy browser, and individual lease lifecycles.
4
+ // Queued leases hold no slot. Allocating leases keep their slot until late resources are disposed.
5
+ export function createTabPool({ launchChrome, maxTabs, tabSeconds, proxyServer, log }) {
6
+ const waiting = [];
7
+ const held = new Set();
8
+ const allocations = new Set();
9
+ const releases = new Set();
10
+ let service = { phase: 'open' };
11
+ let browser = { phase: 'idle' };
12
+
13
+ function track(set, task) {
14
+ set.add(task);
15
+ task.then(() => set.delete(task), () => set.delete(task));
16
+ return task;
17
+ }
18
+
19
+ function stopBrowser(running) {
20
+ const stopping = { phase: 'stopping', value: running };
21
+ stopping.result = Promise.resolve().then(() => running.close()).then(() => {
22
+ if (browser === stopping) browser = { phase: 'idle' };
23
+ }, (error) => {
24
+ // Retain a live owner for retry, but never resurrect a browser after its verified exit.
25
+ if (browser === stopping) browser = { phase: 'running', value: running };
26
+ throw error;
27
+ });
28
+ browser = stopping;
29
+ return stopping.result;
30
+ }
31
+
32
+ async function ensureChrome() {
33
+ if (service.phase !== 'open') throw new Error('The tab broker is closed');
34
+ if (browser.phase === 'running') {
35
+ const running = browser.value;
36
+ if (running.browser.connected && running.child.exitCode === null && running.child.signalCode === null) return running;
37
+ await stopBrowser(running);
38
+ return ensureChrome();
39
+ }
40
+ if (browser.phase === 'stopping') {
41
+ await browser.result;
42
+ return ensureChrome();
43
+ }
44
+ if (browser.phase === 'idle') {
45
+ const result = Promise.resolve().then(launchChrome).then((running) => {
46
+ browser = { phase: 'running', value: running };
47
+ running.exited.then(({ code, signal }) => {
48
+ if (browser.value === running) browser = { phase: 'idle' };
49
+ for (const lease of [...held]) {
50
+ if (lease.chrome !== running) continue;
51
+ lease.error = `Chrome exited (${signal ?? code})`;
52
+ end(lease, 'error');
53
+ // Verified exit settles failed cleanup, but allocations must still dispose late contexts.
54
+ if (lease.cleanup.phase !== 'pending') release(lease);
55
+ }
56
+ });
57
+ return running;
58
+ }, (error) => {
59
+ browser = { phase: 'idle' };
60
+ throw error;
61
+ });
62
+ browser = { phase: 'starting', result };
63
+ }
64
+ return browser.result;
65
+ }
66
+
67
+ function pump() {
68
+ if (service.phase !== 'open') return;
69
+ for (const lease of held) {
70
+ if (lease.cleanup.phase === 'failed') void dispose(lease);
71
+ }
72
+ while (held.size < maxTabs && waiting.length > 0) {
73
+ const lease = waiting.shift();
74
+ lease.state = { phase: 'allocating' };
75
+ held.add(lease);
76
+ track(allocations, grant(lease));
77
+ }
78
+ }
79
+
80
+ function write(lease, line) {
81
+ if (!lease.response.writableEnded && !lease.response.destroyed) lease.response.write(`${JSON.stringify(line)}\n`);
82
+ }
83
+
84
+ function release(lease) {
85
+ lease.cleanup = { phase: 'disposed' };
86
+ if (held.delete(lease)) pump();
87
+ }
88
+
89
+ function dispose(lease) {
90
+ if (lease.cleanup.phase === 'disposed') return Promise.resolve();
91
+ if (lease.cleanup.phase === 'disposing') return lease.cleanup.result;
92
+ const result = Promise.resolve().then(async () => {
93
+ if (lease.cleanup.phase === 'disposed') return;
94
+ if (lease.context) {
95
+ try {
96
+ await lease.chrome.session.send('Target.disposeBrowserContext', { browserContextId: lease.context });
97
+ } catch {
98
+ if (lease.cleanup.phase === 'disposed') return;
99
+ // An unconfirmed disposal must not free capacity while its browser can still own the tab.
100
+ if (browser.phase === 'running' && browser.value === lease.chrome) await stopBrowser(lease.chrome);
101
+ else if (browser.phase === 'stopping' && browser.value === lease.chrome) await browser.result;
102
+ }
103
+ }
104
+ }).then(() => release(lease), (error) => {
105
+ if (lease.cleanup.phase !== 'disposed') lease.cleanup = { phase: 'failed', error };
106
+ throw error;
107
+ });
108
+ lease.cleanup = { phase: 'disposing', result };
109
+ return track(releases, result);
110
+ }
111
+
112
+ function end(lease, reason) {
113
+ const previous = lease.state.phase;
114
+ if (previous === 'ended') return;
115
+ lease.state = { phase: 'ended', reason };
116
+ clearTimeout(lease.timer);
117
+ const queued = waiting.indexOf(lease);
118
+ if (queued >= 0) waiting.splice(queued, 1);
119
+ log({
120
+ event: 'tab_lease',
121
+ client: lease.client,
122
+ waited_ms: (lease.granted ?? Date.now()) - lease.asked,
123
+ held_ms: lease.granted ? Date.now() - lease.granted : 0,
124
+ ended: reason,
125
+ tabs: [...held].filter((candidate) => candidate.state.phase !== 'ended').length,
126
+ waiting: waiting.length,
127
+ });
128
+ if (reason !== 'released') write(lease, reason === 'error' ? { error: lease.error } : { ended: reason });
129
+ lease.response.end();
130
+ if (previous === 'active') void dispose(lease);
131
+ // An allocating lease is disposed by grant's finally, even if the context arrives after end.
132
+ }
133
+
134
+ async function grant(lease) {
135
+ try {
136
+ const running = await ensureChrome();
137
+ if (lease.state.phase !== 'allocating') return;
138
+ lease.chrome = running;
139
+ const { browserContextId } = await running.session.send('Target.createBrowserContext', {
140
+ disposeOnDetach: false,
141
+ ...(proxyServer ? { proxyServer, proxyBypassList: '<-loopback>' } : {}),
142
+ });
143
+ lease.context = browserContextId;
144
+ if (lease.state.phase !== 'allocating') return;
145
+ await running.session.send('Browser.setDownloadBehavior', { behavior: 'deny', browserContextId });
146
+ if (lease.state.phase !== 'allocating') return;
147
+ const tabUrl = `about:blank#${randomUUID()}`;
148
+ const { targetId } = await running.session.send('Target.createTarget', { url: tabUrl, browserContextId });
149
+ if (lease.state.phase !== 'allocating') return;
150
+ lease.state = { phase: 'active' };
151
+ lease.granted = Date.now();
152
+ lease.timer = setTimeout(() => end(lease, 'expired'), tabSeconds * 1000);
153
+ write(lease, { cdp_url: running.cdpUrl, target_id: targetId, tab_url: tabUrl, deadline: lease.granted + tabSeconds * 1000 });
154
+ } catch (error) {
155
+ lease.error = error instanceof Error ? error.message : String(error);
156
+ end(lease, 'error');
157
+ } finally {
158
+ if (lease.state.phase === 'ended') await dispose(lease);
159
+ }
160
+ }
161
+
162
+ function close() {
163
+ if (service.phase === 'closing' || service.phase === 'closed') return service.result;
164
+ // Publish closing before ending responses, whose close handlers can reenter the pool.
165
+ const result = Promise.resolve().then(async () => {
166
+ if (browser.phase === 'starting') await browser.result.catch(() => {});
167
+ // Closing Chrome breaks stalled CDP work. Waiting for allocations first could deadlock.
168
+ if (browser.phase === 'running') await stopBrowser(browser.value);
169
+ else if (browser.phase === 'stopping') await browser.result;
170
+ await Promise.allSettled([...allocations]);
171
+ await Promise.allSettled([...releases]);
172
+ }).then(() => { service = { phase: 'closed', result }; }, (error) => {
173
+ service = { phase: 'close-failed', error };
174
+ throw error;
175
+ });
176
+ service = { phase: 'closing', result };
177
+ for (const lease of [...held, ...waiting]) end(lease, 'closed');
178
+ return result;
179
+ }
180
+
181
+ return {
182
+ get running() { return browser.phase === 'running' ? browser.value : null; },
183
+ get counts() { return { tabs: held.size, waiting: waiting.length }; },
184
+ add(response, client) {
185
+ if (service.phase !== 'open') { response.writeHead(503).end(); return; }
186
+ const lease = { state: { phase: 'queued' }, cleanup: { phase: 'pending' }, client, asked: Date.now(), response };
187
+ response.writeHead(200, { 'content-type': 'application/x-ndjson', 'cache-control': 'no-store' });
188
+ response.flushHeaders();
189
+ response.on('close', () => end(lease, 'released'));
190
+ waiting.push(lease);
191
+ pump();
192
+ },
193
+ close,
194
+ };
195
+ }