windows-development-sandbox 1.9.0 → 1.11.3

package/dist/host/life/host-memory.js

@@ -19,6 +19,8 @@ export const HostMemorySchema = z.object({
     pageFile: z.enum(['auto', 'fixed', 'none']).catch('auto'),
     /** Fixed: the total of its maximum sizes (MB). */
     pageFileMaxMb: z.number().int().nonnegative().catch(0),
+    /** The disks' queue length now (all disks together); absent when this PC has no such counter. */
+    diskQueue: z.number().nonnegative().max(100000).optional().catch(undefined),
 });
 const TIMEOUT_MS = 20000;
 /** The parsed answer of memory-status, or null (not Windows, unreadable, nonsense). */
@@ -91,7 +93,8 @@ export function hostMemoryLine(memory, at = new Date()) {
         '/' +
         memory.commitLimitMb +
         ' | page file ' +
-        memory.pageFile);
+        memory.pageFile +
+        (memory.diskQueue === undefined ? '' : ' | disk queue ' + memory.diskQueue));
 }
 /**
  * Whether Windows Sandbox could push this PC past its commit limit (pure): the paging file is fixed or off and the

package/dist/host/life/watchdog.d.ts

@@ -3,9 +3,13 @@ import { type HostThresholds, type LoadProfile } from '../../shared/memory/index
 import { type HostMemory } from './host-memory.js';
 export interface WatchdogState {
     readonly low: boolean;
+    /** Nearly out of memory: the request asks for the governor's last step. */
+    readonly severe: boolean;
     readonly calm: number;
     /** Seconds the CPU has been above the limit. */
     readonly cpuHighSeconds: number;
+    /** Seconds the disk queue has been above the limit. */
+    readonly diskHighSeconds: number;
     /** Time (ms) the last request went out. */
     readonly lastSentAt: number;
 }
@@ -29,6 +33,8 @@ export interface WatchdogStep {
     readonly send: boolean;
     /** Why the PC is low (plain words), empty when it is not. */
     readonly reason: string;
+    /** Nearly out of memory: builds go to the governor's last step. */
+    readonly severe: boolean;
     /** The state changed (the log says so). */
     readonly changed: boolean;
 }
@@ -38,6 +44,11 @@ export interface WatchdogStep {
  * `scale` widens the limits (1.25 = the level it must climb back above).
  */
 export declare function lowReason(memory: HostMemory, reserveHostMb: number, t: HostThresholds, scale: number): string;
+/**
+ * Nearly out of memory on this PC: under 1.5 GB of RAM free, or commit within max(2 GB, 4 %) of its limit. Then the
+ * sandbox's builds go to the governor's last step at once (one compiler at a time, 15 % CPU) until it passes.
+ */
+export declare function severeHost(memory: HostMemory): boolean;
 /** One watchdog step. Hysteresis: low starts at the limits and ends above 1.25 times them for calmSamples samples. */
 export declare function watchdogStep(prev: WatchdogState, input: WatchdogInput): WatchdogStep;
 /** Total CPU use between two os.cpus() readings (percent). */

package/dist/host/life/watchdog.js

@@ -3,7 +3,14 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { HOST_THRESHOLDS } from '../../shared/memory/index.js';
 import { hostMemoryLine } from './host-memory.js';
-export const WATCHDOG_START = { low: false, calm: 0, cpuHighSeconds: 0, lastSentAt: 0 };
+export const WATCHDOG_START = {
+    low: false,
+    severe: false,
+    calm: 0,
+    cpuHighSeconds: 0,
+    diskHighSeconds: 0,
+    lastSentAt: 0,
+};
 /** The request is repeated this often while the PC stays low, and each one lasts a bit longer than that. */
 export const RESEND_MS = 30000;
 export const REQUEST_SECONDS = 90;
@@ -21,6 +28,17 @@ export function lowReason(memory, reserveHostMb, t, scale) {
         return 'only ' + memory.commitAvailableMb + ' MB of memory (RAM plus paging file) is left on this PC';
     return '';
 }
+/**
+ * Nearly out of memory on this PC: under 1.5 GB of RAM free, or commit within max(2 GB, 4 %) of its limit. Then the
+ * sandbox's builds go to the governor's last step at once (one compiler at a time, 15 % CPU) until it passes.
+ */
+export function severeHost(memory) {
+    return (memory.availableMb < SEVERE_AVAILABLE_MB ||
+        memory.commitAvailableMb < Math.max(SEVERE_COMMIT_MB, (memory.commitLimitMb * SEVERE_COMMIT_PERCENT) / 100));
+}
+const SEVERE_AVAILABLE_MB = 1536;
+const SEVERE_COMMIT_MB = 2048;
+const SEVERE_COMMIT_PERCENT = 4;
 /** One watchdog step. Hysteresis: low starts at the limits and ends above 1.25 times them for calmSamples samples. */
 export function watchdogStep(prev, input) {
     const t = HOST_THRESHOLDS[input.profile];
@@ -30,6 +48,10 @@ export function watchdogStep(prev, input) {
     const cpuHigh = input.cpuPercent !== null && input.cpuPercent >= t.cpuPercent ? prev.cpuHighSeconds + input.intervalSeconds : 0;
     if (!reason && cpuHigh >= t.cpuSeconds)
         reason = "this PC's CPU has been above " + t.cpuPercent + '% for ' + cpuHigh + ' seconds';
+    const diskQueue = input.memory?.diskQueue;
+    const diskHigh = diskQueue !== undefined && diskQueue >= t.diskQueue ? prev.diskHighSeconds + input.intervalSeconds : 0;
+    if (!reason && diskHigh >= t.diskSeconds)
+        reason = "this PC's disks have had a queue of " + diskQueue + ' for ' + diskHigh + ' seconds';
     const calmNow = input.memory ? lowReason(input.memory, input.reserveHostMb, t, 1.25) === '' : true;
     let low = prev.low;
     let calm = prev.calm;
@@ -38,17 +60,27 @@ export function watchdogStep(prev, input) {
         calm = 0;
     }
     else if (prev.low) {
-        calm = calmNow && cpuHigh === 0 ? prev.calm + 1 : 0;
+        calm = calmNow && cpuHigh === 0 && diskHigh === 0 ? prev.calm + 1 : 0;
         if (calm >= t.calmSamples) {
             low = false;
             calm = 0;
         }
     }
-    const send = low && input.nowMs - prev.lastSentAt >= RESEND_MS;
+    const severe = low && input.memory !== null && severeHost(input.memory);
+    // Getting severe is sent at once; otherwise the request is repeated every RESEND_MS while the PC stays low.
+    const send = low && (input.nowMs - prev.lastSentAt >= RESEND_MS || (severe && !prev.severe));
     return {
-        state: { low, calm, cpuHighSeconds: cpuHigh, lastSentAt: send ? input.nowMs : prev.lastSentAt },
+        state: {
+            low,
+            severe,
+            calm,
+            cpuHighSeconds: cpuHigh,
+            diskHighSeconds: diskHigh,
+            lastSentAt: send ? input.nowMs : prev.lastSentAt,
+        },
         send,
         reason: reason || (low ? 'this PC is still low' : ''),
+        severe,
         changed: low !== prev.low,
     };
 }

package/dist/host/sandbox/tasklist.d.ts

@@ -7,6 +7,12 @@ export interface TasklistRunners {
 export declare function useTasklistRunners(replacement?: TasklistRunners): void;
 /** While set, a synchronous read returns this copy (undefined: none yet, run tasklist). Null removes it. */
 export declare function useTasklistCache(read: (() => string | undefined) | null): void;
+/**
+ * For a long-running server (the web UI): questions within `freshMs` of the last run share its list; an older one
+ * (up to `staleMs`) is still answered from it while a new list is fetched in the background, so no request waits for
+ * tasklist. Nothing runs while nobody asks. Returns the function that stops it.
+ */
+export declare function keepTasklistFresh(freshMs?: number, staleMs?: number): () => void;
 /** The process list now: the cached copy when the menu keeps one, else a run of tasklist the caller waits for. */
 export declare function readTasklist(): string;
 /** The process list from a run of tasklist that does not block the program (the menu's background refresh). */

package/dist/host/sandbox/tasklist.js

@@ -37,6 +37,43 @@ export function useTasklistRunners(replacement = REAL_RUNNERS) {
 export function useTasklistCache(read) {
     cache = read;
 }
+/**
+ * For a long-running server (the web UI): questions within `freshMs` of the last run share its list; an older one
+ * (up to `staleMs`) is still answered from it while a new list is fetched in the background, so no request waits for
+ * tasklist. Nothing runs while nobody asks. Returns the function that stops it.
+ */
+export function keepTasklistFresh(freshMs = 2000, staleMs = 15000) {
+    let copy;
+    let at = 0;
+    let fetching = false;
+    const refresh = () => {
+        if (fetching)
+            return;
+        fetching = true;
+        void runners
+            .async()
+            .then((list) => {
+            copy = list;
+            at = Date.now();
+        })
+            .finally(() => {
+            fetching = false;
+        });
+    };
+    useTasklistCache(() => {
+        const age = Date.now() - at;
+        if (copy !== undefined && age < freshMs)
+            return copy;
+        if (copy !== undefined && age < staleMs) {
+            refresh();
+            return copy;
+        }
+        copy = runners.sync();
+        at = Date.now();
+        return copy;
+    });
+    return () => useTasklistCache(null);
+}
 /** The process list now: the cached copy when the menu keeps one, else a run of tasklist the caller waits for. */
 export function readTasklist() {
     return cache?.() ?? runners.sync();

package/dist/host/secrets/launch-secrets.d.ts

@@ -4,7 +4,8 @@ import type { GuestRequest } from '../../core/types.js';
 export declare function writeSecrets(dataPath: string, id: string, secrets: SecretsFile): string | null;
 /**
  * Removes whatever one-shot files are left (the sandbox did not start, or did not get to read them) and, from older
- * versions, a login copy in a launch folder. Called before a launch writes new ones and when the sandbox stops.
+ * versions, a login copy in a launch folder. Called before a launch writes new ones, and when a launch fails before
+ * its sandbox starts.
  */
 export declare function clearSecrets(storageRoot: string, dataPath: string): number;
 /**

package/dist/host/secrets/launch-secrets.js

@@ -12,7 +12,8 @@ export function writeSecrets(dataPath, id, secrets) {
         !Object.keys(secrets.projectHarnessEnvironment ?? {}).length &&
         !secrets.claudeCredentials &&
         !secrets.vpn &&
-        !secrets.wireguardConfig;
+        !secrets.wireguardConfig &&
+        !secrets.githubToken;
     if (empty)
         return null;
     const run = new RunDir(dataPath);
@@ -23,7 +24,8 @@ export function writeSecrets(dataPath, id, secrets) {
 }
 /**
  * Removes whatever one-shot files are left (the sandbox did not start, or did not get to read them) and, from older
- * versions, a login copy in a launch folder. Called before a launch writes new ones and when the sandbox stops.
+ * versions, a login copy in a launch folder. Called before a launch writes new ones, and when a launch fails before
+ * its sandbox starts.
  */
 export function clearSecrets(storageRoot, dataPath) {
     let removed = 0;

package/dist/host/vpn/status.js

@@ -17,8 +17,16 @@ export function vpnLine(status, hostIp = null) {
     if (!status)
         return { level: 'warn', text: 'The sandbox has not reported on the VPN.' };
     const message = safeText(status.message).slice(0, 300);
+    const leaky = status.killSwitch && status.killSwitchHeld === false;
     if (status.state === 'up') {
         const same = hostIp !== null && status.publicIp === hostIp;
+        if (!same && leaky)
+            return {
+                level: 'warn',
+                text: 'VPN up' +
+                    (status.publicIp ? ', the sandbox appears as ' + safeText(status.publicIp) : '') +
+                    ', but the kill switch did not hold: if the tunnel drops, traffic goes out through your normal connection.',
+            };
         return same
             ? {
                 level: 'bad',
@@ -40,9 +48,11 @@ export function vpnLine(status, hostIp = null) {
             level: 'bad',
             text: 'VPN failed: ' +
                 message +
-                (status.killSwitch
-                    ? ' The kill switch is on, so the sandbox has no internet.'
-                    : ' The kill switch is off, so the sandbox uses your normal connection.'),
+                (leaky
+                    ? ' The kill switch did not hold, so the sandbox is ONLINE through your normal connection, without the VPN.'
+                    : status.killSwitch
+                        ? ' The kill switch is on, so the sandbox has no internet.'
+                        : ' The kill switch is off, so the sandbox uses your normal connection.'),
         };
     return { level: 'warn', text: 'VPN ' + status.state + (message ? ': ' + message : '') };
 }

package/dist/host/web/backend.d.ts

@@ -1,5 +1,5 @@
 import type { Endpoint } from '../../shared/pty/index.js';
-import type { NewSessionRequest, WebInfo, WebSession } from '../../shared/web/index.js';
+import type { WebInfo, WebSession } from '../../shared/web/index.js';
 export interface WebBackend {
     info(): Promise<WebInfo>;
     /** Sessions as the browser may see them: never an attach token or address. */
@@ -9,6 +9,4 @@ export interface WebBackend {
      * running session, the sandbox is not shared with this user, or it has no address on this PC's sandbox network.
      */
     endpoint(sessionId: string): Endpoint | null;
-    /** Starts an agent in a project of the running sandbox and waits until it runs. */
-    create(request: NewSessionRequest): Promise<WebSession>;
 }

package/dist/host/web/index.d.ts

@@ -4,7 +4,8 @@ export { openBrowser, openIssuePage } from './browser.js';
 export { TerminalBridge } from './bridge.js';
 export { WebControl, type WebStatus } from './control.js';
 export { WebRunner } from './runner.js';
+export { LiveHub, type LiveListener } from './live.js';
 export { RpcSession } from './rpc.js';
-export { WebServer, CONTENT_SECURITY_POLICY, RPC_PATH, type WebServerOptions } from './server.js';
+export { WebServer, CONTENT_SECURITY_POLICY, IDLE_EXIT_MS, RPC_PATH, type WebServerOptions } from './server.js';
 export { StaticFiles } from './static-files.js';
 export { WebStore, WebStateSchema, type WebState } from './state.js';

package/dist/host/web/index.js

@@ -3,7 +3,8 @@ export { openBrowser, openIssuePage } from './browser.js';
 export { TerminalBridge } from './bridge.js';
 export { WebControl } from './control.js';
 export { WebRunner } from './runner.js';
+export { LiveHub } from './live.js';
 export { RpcSession } from './rpc.js';
-export { WebServer, CONTENT_SECURITY_POLICY, RPC_PATH } from './server.js';
+export { WebServer, CONTENT_SECURITY_POLICY, IDLE_EXIT_MS, RPC_PATH } from './server.js';
 export { StaticFiles } from './static-files.js';
 export { WebStore, WebStateSchema } from './state.js';

package/dist/host/web/live.d.ts

@@ -0,0 +1,23 @@
+import type { RpcHost } from '../../app/kernel/index.js';
+export type LiveListener = (event: {
+    readonly output: unknown;
+} | {
+    readonly error: unknown;
+}) => void;
+export declare class LiveHub {
+    private readonly host;
+    private readonly polls;
+    constructor(host: RpcHost);
+    /** How many polls run (for tests and the idle check). */
+    get size(): number;
+    /**
+     * Starts listening; the listener gets the current answer (at once when one is known) and every change. Returns the
+     * function that stops listening.
+     */
+    watch(query: string, input: unknown, listener: LiveListener): () => void;
+    /** Something changed (an operation ran): every query reads again now, at its own pace. */
+    poke(): void;
+    private schedule;
+    private isLive;
+    private read;
+}

package/dist/host/web/live.js

@@ -0,0 +1,107 @@
+import { NO_QUESTIONS } from '../../app/kernel/index.js';
+/** A query unchanged this many reads in a row is read less often... */
+const CALM_READS = 4;
+/** ...down to this many times its own interval. */
+const SLOWEST = 4;
+export class LiveHub {
+    host;
+    polls = new Map();
+    constructor(host) {
+        this.host = host;
+    }
+    /** How many polls run (for tests and the idle check). */
+    get size() {
+        return this.polls.size;
+    }
+    /**
+     * Starts listening; the listener gets the current answer (at once when one is known) and every change. Returns the
+     * function that stops listening.
+     */
+    watch(query, input, listener) {
+        const key = query + '\u0000' + JSON.stringify(input ?? null);
+        let poll = this.polls.get(key);
+        if (!poll) {
+            poll = {
+                query,
+                input,
+                everyMs: this.host.liveMs(query) ?? 0,
+                listeners: new Set(),
+                timer: undefined,
+                busy: false,
+                last: undefined,
+                lastOutput: undefined,
+                calm: 0,
+                again: false,
+            };
+            this.polls.set(key, poll);
+            void this.read(poll);
+        }
+        else if (poll.last !== undefined)
+            listener({ output: poll.lastOutput });
+        else if (!poll.busy)
+            void this.read(poll); // the last read failed: try again for the newcomer
+        poll.listeners.add(listener);
+        const p = poll;
+        return () => {
+            p.listeners.delete(listener);
+            if (p.listeners.size)
+                return;
+            clearTimeout(p.timer);
+            this.polls.delete(key);
+        };
+    }
+    /** Something changed (an operation ran): every query reads again now, at its own pace. */
+    poke() {
+        for (const poll of this.polls.values()) {
+            poll.calm = 0;
+            void this.read(poll);
+        }
+    }
+    schedule(poll) {
+        clearTimeout(poll.timer);
+        if (!poll.everyMs || !this.isLive(poll))
+            return;
+        const factor = poll.calm >= CALM_READS ? Math.min(SLOWEST, 1 + Math.floor(poll.calm / CALM_READS)) : 1;
+        poll.timer = setTimeout(() => void this.read(poll), poll.everyMs * factor);
+        poll.timer.unref?.();
+    }
+    isLive(poll) {
+        return [...this.polls.values()].includes(poll);
+    }
+    async read(poll) {
+        if (poll.busy) {
+            poll.again = true;
+            return;
+        }
+        poll.busy = true;
+        clearTimeout(poll.timer);
+        try {
+            const output = await this.host.run(poll.query, poll.input, NO_QUESTIONS);
+            const text = JSON.stringify(output);
+            if (text === poll.last)
+                poll.calm++;
+            else {
+                poll.calm = 0;
+                poll.last = text;
+                poll.lastOutput = output;
+                for (const l of [...poll.listeners])
+                    l({ output });
+            }
+        }
+        catch (error) {
+            poll.calm = 0;
+            poll.last = undefined;
+            for (const l of [...poll.listeners])
+                l({ error });
+        }
+        finally {
+            poll.busy = false;
+        }
+        if (poll.again) {
+            poll.again = false;
+            void this.read(poll);
+            return;
+        }
+        this.schedule(poll);
+    }
+}

package/dist/host/web/rpc.d.ts

@@ -1,12 +1,17 @@
 import type { WebSocket } from 'ws';
 import { type RpcHost } from '../../app/kernel/index.js';
+import { LiveHub } from './live.js';
 export declare class RpcSession {
     private readonly ws;
     private readonly host;
+    /** Shared by every socket of the server (one poll per query); a socket of its own by default. */
+    private readonly live;
     private readonly calls;
     private readonly subscriptions;
     private closed;
-    constructor(ws: WebSocket, host: RpcHost);
+    constructor(ws: WebSocket, host: RpcHost, 
+    /** Shared by every socket of the server (one poll per query); a socket of its own by default. */
+    live?: LiveHub);
     start(): void;
     private send;
     /** A browser that sends something that is not one of our messages is closed. */

package/dist/host/web/rpc.js

@@ -1,4 +1,5 @@
-import { ANSWER_SCHEMAS, ClientMessageSchema, MAX_OPEN_PER_SOCKET, NO_QUESTIONS, ioFromAsker, toWireError, } from '../../app/kernel/index.js';
+import { ANSWER_SCHEMAS, ClientMessageSchema, MAX_OPEN_PER_SOCKET, ioFromAsker, toWireError, } from '../../app/kernel/index.js';
+import { LiveHub } from './live.js';
 /** What a question gets when the browser goes away before answering: no. */
 function declined(q) {
     return q.kind === 'confirm' ? false : undefined;
@@ -6,12 +7,16 @@ function declined(q) {
 export class RpcSession {
     ws;
     host;
+    live;
     calls = new Map();
     subscriptions = new Map();
     closed = false;
-    constructor(ws, host) {
+    constructor(ws, host, 
+    /** Shared by every socket of the server (one poll per query); a socket of its own by default. */
+    live = new LiveHub(host)) {
         this.ws = ws;
         this.host = host;
+        this.live = live;
     }
     start() {
         this.ws.on('message', (data, binary) => this.receive(data, binary));
@@ -86,7 +91,12 @@ export class RpcSession {
         this.host
             .run(op, input, io)
             .then((output) => this.send({ t: 'result', id, output }), (e) => this.send({ t: 'error', id, error: toWireError(e) }))
-            .finally(() => this.calls.delete(id));
+            .finally(() => {
+            this.calls.delete(id);
+            // An operation may have changed what the live queries show: they read again now.
+            if (this.host.kind(op) === 'operation')
+                this.live.poke();
+        });
     }
     answer(id, value) {
         const waiting = this.calls.get(id);
@@ -103,38 +113,20 @@ export class RpcSession {
             this.send({ t: 'error', id, error: { kind: 'invalid', message: 'There is no ' + query + ' here.' } });
             return;
         }
-        const sub = { timer: undefined, last: undefined, busy: false };
-        this.subscriptions.set(id, sub);
-        const read = async () => {
-            if (sub.busy)
+        const stop = this.live.watch(query, input, (event) => {
+            if (this.subscriptions.get(id) !== stop)
                 return;
-            sub.busy = true;
-            try {
-                const output = await this.host.run(query, input, NO_QUESTIONS);
-                const text = JSON.stringify(output);
-                if (text !== sub.last && this.subscriptions.get(id) === sub) {
-                    sub.last = text;
-                    this.send({ t: 'data', id, output });
-                }
-            }
-            catch (e) {
-                sub.last = undefined;
-                this.send({ t: 'error', id, error: toWireError(e) });
-            }
-            finally {
-                sub.busy = false;
-            }
-        };
-        void read();
-        const every = this.host.liveMs(query);
-        if (every)
-            sub.timer = setInterval(() => void read(), every);
+            if ('output' in event)
+                this.send({ t: 'data', id, output: event.output });
+            else
+                this.send({ t: 'error', id, error: toWireError(event.error) });
+        });
+        this.subscriptions.set(id, stop);
     }
     unsubscribe(id) {
-        const sub = this.subscriptions.get(id);
-        if (sub?.timer)
-            clearInterval(sub.timer);
+        const stop = this.subscriptions.get(id);
         this.subscriptions.delete(id);
+        stop?.();
     }
     /** The browser went away: subscriptions stop, and questions still open are answered no. */
     close() {

package/dist/host/web/runner.d.ts

@@ -6,6 +6,10 @@ export interface WebRunOptions {
     readonly backend: WebBackend;
     readonly rpc?: RpcHost;
     readonly staticRoot: string;
+    /** This program's version, kept in the state file. */
+    readonly version: string;
+    /** End after this long unused while no sandbox runs (WebServerOptions.idleExitMs). */
+    readonly idleExitMs?: number;
 }
 export declare class WebRunner {
     private readonly options;

package/dist/host/web/runner.js

@@ -1,4 +1,5 @@
 import { fail } from '../../core/util/index.js';
+import { keepTasklistFresh } from '../sandbox/index.js';
 import { newToken } from './auth.js';
 import { WebServer } from './server.js';
 import { WebStore } from './state.js';
@@ -20,6 +21,7 @@ export class WebRunner {
             backend: this.options.backend,
             rpc: this.options.rpc,
             staticRoot: this.options.staticRoot,
+            idleExitMs: this.options.idleExitMs,
             onStop: stop,
         });
         try {
@@ -30,13 +32,22 @@ export class WebRunner {
                 fail('Port ' + this.options.port + ' is taken by another program.', 'Pick another with the web.port setting, then run sandbox web start again.');
             throw e;
         }
-        this.store.write({ pid: process.pid, port: server.port, token, startedAt: new Date().toISOString() });
+        this.store.write({
+            pid: process.pid,
+            port: server.port,
+            token,
+            startedAt: new Date().toISOString(),
+            version: this.options.version,
+        });
         process.once('SIGINT', stop);
         process.once('SIGTERM', stop);
+        // Every browser's status reads share one process list instead of each running tasklist.
+        const stopTasklist = keepTasklistFresh();
         try {
             await stopped;
         }
         finally {
+            stopTasklist();
             this.store.clear();
             await server.stop();
         }

package/dist/host/web/server.d.ts

@@ -4,6 +4,8 @@ import type { Endpoint } from '../../shared/pty/index.js';
 import type { WebBackend } from './backend.js';
 /** No inline script: the page and its script are files from this server. Inline styles are what xterm.js needs. */
 export declare const CONTENT_SECURITY_POLICY: string;
+/** The server ends after this long with no request, no socket and no sandbox running (it starts again with one). */
+export declare const IDLE_EXIT_MS: number;
 export declare const RPC_PATH = "/api/rpc";
 export interface WebServerOptions {
     /** 0 picks a free port (tests). */
@@ -18,6 +20,16 @@ export interface WebServerOptions {
     readonly dial?: (endpoint: Endpoint) => Promise<net.Socket>;
     /** The shared core's operations and queries the browser may run (none: /api/rpc is not served). */
     readonly rpc?: RpcHost;
+    /** End by itself (onStop) after this long unused while no sandbox runs; 0 or missing: never (tests). */
+    readonly idleExitMs?: number;
+    /** Heartbeat period (tests make it short). */
+    readonly heartbeatMs?: number;
+}
+/** A browser's socket: which kind, whether it answered the last ping, and when it was opened. */
+interface Tracked {
+    readonly kind: 'terminal' | 'rpc';
+    readonly opened: number;
+    alive: boolean;
 }
 export declare class WebServer {
     private readonly options;
@@ -25,12 +37,27 @@ export declare class WebServer {
     private readonly sockets;
     private readonly auth;
     private readonly files;
-    private terminals;
-    private rpcSockets;
+    private readonly tracked;
+    /** One poll per live query for all browsers together. */
+    private readonly live;
     private actualPort;
+    private lastUsed;
+    private heartbeat;
+    private idleCheck;
     constructor(options: WebServerOptions);
     get port(): number;
     start(): Promise<void>;
+    /** How many browser sockets are open, by kind. */
+    openSockets(kind: Tracked['kind']): number;
+    /**
+     * Drops sockets that did not answer the last ping (a tab that went away without closing: sleep, a killed browser),
+     * so they never hold a slot or a session connection.
+     */
+    private beat;
+    /** Nothing has used the server for a while and no sandbox runs: it ends (the next launch starts it again). */
+    private checkIdle;
+    /** Counts a new socket; at the limit, the oldest of its kind makes room (a new tab always works). */
+    private track;
     stop(): Promise<void>;
     private headers;
     private json;
@@ -45,3 +72,4 @@ export declare class WebServer {
     /** The RPC socket (after the same Origin and cookie checks as a terminal). */
     private upgradeRpc;
 }
+export {};