windows-development-sandbox 1.13.2 → 1.14.0

package/dist/selftest/support/vhdx.d.ts

@@ -0,0 +1,14 @@
+/** Mixed-endian GUID bytes, as VHDX (and .NET's Guid) store them. */
+export declare function guidBytes(text: string): Buffer;
+/** CRC-32C (Castagnoli), the checksum of a VHDX header. */
+export declare function crc32c(data: Buffer): number;
+/**
+ * `gb`: the virtual size; `parent`: a parent locator item (a differencing disk); `log`: the current header names a log
+ * to replay; `staleLog`: only the older header names one (fine).
+ */
+export declare function fakeVhdx(file: string, o: {
+    gb: number;
+    parent?: boolean;
+    log?: boolean;
+    staleLog?: boolean;
+}): void;

package/dist/selftest/support/vhdx.js

@@ -0,0 +1,72 @@
+// A file with the parts of a VHDX the contained-storage checks read (the signature, the two headers with their CRC-32C,
+// the region table and the metadata table), shared by the script tests and the storage helper tests. Nothing here is a
+// usable disk.
+import fs from 'node:fs';
+/** Mixed-endian GUID bytes, as VHDX (and .NET's Guid) store them. */
+export function guidBytes(text) {
+    const hex = text.replace(/-/g, '');
+    const raw = Buffer.from(hex, 'hex');
+    return Buffer.concat([
+        Buffer.from(raw.subarray(0, 4)).reverse(),
+        Buffer.from(raw.subarray(4, 6)).reverse(),
+        Buffer.from(raw.subarray(6, 8)).reverse(),
+        raw.subarray(8, 16),
+    ]);
+}
+const CRC_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let i = 0; i < 256; i++) {
+        let c = i;
+        for (let k = 0; k < 8; k++)
+            c = c & 1 ? 0x82f63b78 ^ (c >>> 1) : c >>> 1;
+        table[i] = c >>> 0;
+    }
+    return table;
+})();
+/** CRC-32C (Castagnoli), the checksum of a VHDX header. */
+export function crc32c(data) {
+    let crc = 0xffffffff;
+    for (const byte of data)
+        crc = CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function header(sequence, log) {
+    const h = Buffer.alloc(4096);
+    h.write('head', 0, 'ascii');
+    h.writeBigUInt64LE(BigInt(sequence), 8);
+    if (log)
+        guidBytes('11111111-2222-3333-4444-555555555555').copy(h, 48);
+    h.writeUInt32LE(crc32c(h), 4);
+    return h;
+}
+/**
+ * `gb`: the virtual size; `parent`: a parent locator item (a differencing disk); `log`: the current header names a log
+ * to replay; `staleLog`: only the older header names one (fine).
+ */
+export function fakeVhdx(file, o) {
+    const buf = Buffer.alloc(2 * 1024 * 1024);
+    buf.write('vhdxfile', 0, 'ascii');
+    header(2, o.log === true).copy(buf, 65536);
+    header(1, o.staleLog === true).copy(buf, 131072);
+    const table = 196608;
+    buf.write('regi', table, 'ascii');
+    buf.writeUInt32LE(1, table + 8);
+    guidBytes('8b7ca206-4790-4b9a-b8fe-575f050f886e').copy(buf, table + 16);
+    buf.writeBigUInt64LE(BigInt(1048576), table + 32);
+    buf.writeUInt32LE(65536, table + 40);
+    const md = 1048576;
+    buf.write('metadata', md, 'ascii');
+    const items = [
+        { guid: '2fa54224-cd1b-4876-b211-5dbed83bf4b8', offset: 65536 },
+        ...(o.parent ? [{ guid: 'a8d35f2d-b30b-454d-abf7-d3d84834ab0c', offset: 65600 }] : []),
+    ];
+    buf.writeUInt16LE(items.length, md + 10);
+    items.forEach((item, i) => {
+        const at = md + 32 + 32 * i;
+        guidBytes(item.guid).copy(buf, at);
+        buf.writeUInt32LE(item.offset, at + 16);
+        buf.writeUInt32LE(8, at + 20);
+    });
+    buf.writeBigUInt64LE(BigInt(o.gb) * 1024n ** 3n, md + 65536);
+    fs.writeFileSync(file, buf);
+}

package/dist/selftest/web.test.js

@@ -9,7 +9,7 @@ import { cancelled } from '../app/kernel/index.js';
 import { webSession } from '../cli/services/index.js';
 import { fail } from '../core/util/index.js';
 import { cookieValue, csrfOk, hostAllowed, LiveHub, originAllowed, sameSecret, StaticFiles, WebAuth, WebServer, WebStore, } from '../host/web/index.js';
-import { encodeFrame, FrameReader, FrameType } from '../shared/pty/index.js';
+import { encodeFrame, FrameReader, FrameType, MOUSE_OFF } from '../shared/pty/index.js';
 import { CSRF_HEADER, CSRF_VALUE, parseClientMessage } from '../shared/web/index.js';
 const TOKEN = 'a'.repeat(64);
 const ATTACH_TOKEN = 'SECRET-ATTACH-TOKEN';
@@ -249,7 +249,7 @@ export const webSuite = {
         }
         t.section('an unused server ends by itself (no process left behind)');
         {
-            const idleServer = async (sandbox, limits) => {
+            const idleServer = async (sandbox, limits, sleepMs = 0) => {
                 let ended = false;
                 const idle = new WebServer({
                     port: 0,
@@ -272,6 +272,16 @@ export const webSuite = {
                     onStop: () => (ended = true),
                 });
                 await idle.start();
+                if (sleepMs) {
+                    // The PC "sleeps": no timer runs, then the overdue check fires at once on waking.
+                    const until = Date.now() + sleepMs;
+                    while (Date.now() < until)
+                        ;
+                    await new Promise((r) => setTimeout(r, 20));
+                    const endedOnWaking = ended;
+                    await idle.stop();
+                    return endedOnWaking;
+                }
                 await new Promise((r) => setTimeout(r, 1500));
                 await idle.stop();
                 return ended;
@@ -279,6 +289,7 @@ export const webSuite = {
             t.check(await idleServer('stopped', { exit: 60_000, quiet: 200 }), 'no browser and no sandbox: it ends after the short wait');
             t.check(!(await idleServer('running', { exit: 60_000, quiet: 200 })), 'a sandbox runs: the short wait does not end it');
             t.check(await idleServer('running', { exit: 300, quiet: 200 }), 'no browser for the long wait: it ends even while a sandbox runs');
+            t.check(!(await idleServer('stopped', { exit: 60_000, quiet: 200 }, 1200)), 'after the PC slept, it does not end on waking: open pages get time to reconnect');
         }
         t.section('the server');
         const fake = new FakePtyHost();
@@ -373,6 +384,7 @@ export const webSuite = {
             tab.socket.send(Buffer.from('x'));
             await t.waitFor(() => tab.closeCode !== null, 5000);
             t.check(tab.texts.includes('{"t":"exit","code":3}'), 'EXIT reaches the browser with its code');
+            t.check(Buffer.concat(tab.binary).toString('latin1').endsWith(MOUSE_OFF), "before it, the browser's terminal is told to stop tracking the mouse (a drag selects text again)");
             t.equal(tab.closeCode, 1000, 'and the socket closes cleanly');
             const rude = new Tab(url, { Origin: origin, Cookie });
             await t.waitFor(() => rude.binary.length > 0, 5000);

package/dist/shared/channel/run-dir.d.ts

@@ -17,12 +17,18 @@ export declare class RunDir {
     readonly projectsDir: string;
     /** audit.processes: programs the sandbox started, in small .jsonl files the host takes in and deletes. */
     readonly auditDir: string;
+    /**
+     * Each running session's process tree, recorded by its ptyhost (guest only: the daemon ends what a ptyhost that was
+     * itself ended left running).
+     */
+    readonly treesDir: string;
     /** One-shot secrets the host hands over (see secrets.ts). Next to run, not in it: shared-use users can change run. */
     readonly secretsDir: string;
     constructor(dataDir: string);
     requestFile(id: string): string;
     responseFile(id: string): string;
     sessionFile(id: string): string;
+    treeFile(id: string): string;
     projectFile(name: string): string;
     secretFile(id: string): string;
     readSandboxStatus(): SandboxStatus | null;

package/dist/shared/channel/run-dir.js

@@ -44,6 +44,11 @@ export class RunDir {
     projectsDir;
     /** audit.processes: programs the sandbox started, in small .jsonl files the host takes in and deletes. */
     auditDir;
+    /**
+     * Each running session's process tree, recorded by its ptyhost (guest only: the daemon ends what a ptyhost that was
+     * itself ended left running).
+     */
+    treesDir;
     /** One-shot secrets the host hands over (see secrets.ts). Next to run, not in it: shared-use users can change run. */
     secretsDir;
     constructor(dataDir) {
@@ -57,6 +62,7 @@ export class RunDir {
         this.sessionsDir = path.join(this.root, 'sessions');
         this.projectsDir = path.join(this.root, 'projects');
         this.auditDir = path.join(this.root, 'audit');
+        this.treesDir = path.join(this.root, 'trees');
         this.secretsDir = path.join(dataDir, 'secrets');
     }
     requestFile(id) {
@@ -68,6 +74,9 @@ export class RunDir {
     sessionFile(id) {
         return path.join(this.sessionsDir, safeId(id) + '.json');
     }
+    treeFile(id) {
+        return path.join(this.treesDir, safeId(id) + '.json');
+    }
     projectFile(name) {
         return path.join(this.projectsDir, safeId(name) + '.json');
     }

package/dist/shared/pty/index.d.ts

@@ -1,6 +1,8 @@
 export { FrameType, HelloFlag, PING_INTERVAL_MS, type Frame, DETACH_KEY, encodeFrame, helloFrame, resizeFrame, MAX_FRAME_BYTES, FrameReader, } from './protocol.js';
 export { type Endpoint, connect, sendControl, type Viewers, queryViewers } from './client.js';
-export { type ClientResult, MOUSE_OFF, fixWindowsKeys, runTerminalClient } from './terminal.js';
+export { type ClientResult, MOUSE_OFF, runTerminalClient } from './terminal.js';
+export { fixWindowsKeys, KeyGate } from './key-gate.js';
+export { MouseModes } from './mouse-modes.js';
 export { JOIN_MS, InputJoiner } from './input-joiner.js';
 export { CTRL_C_CONFIRM_MS, CTRL_C_HINT, CtrlCGuard } from './ctrl-c.js';
 export { type VtInput, enableVtInput } from './console-input.js';

package/dist/shared/pty/index.js

@@ -1,6 +1,8 @@
 export { FrameType, HelloFlag, PING_INTERVAL_MS, DETACH_KEY, encodeFrame, helloFrame, resizeFrame, MAX_FRAME_BYTES, FrameReader, } from './protocol.js';
 export { connect, sendControl, queryViewers } from './client.js';
-export { MOUSE_OFF, fixWindowsKeys, runTerminalClient } from './terminal.js';
+export { MOUSE_OFF, runTerminalClient } from './terminal.js';
+export { fixWindowsKeys, KeyGate } from './key-gate.js';
+export { MouseModes } from './mouse-modes.js';
 export { JOIN_MS, InputJoiner } from './input-joiner.js';
 export { CTRL_C_CONFIRM_MS, CTRL_C_HINT, CtrlCGuard } from './ctrl-c.js';
 export { enableVtInput } from './console-input.js';

package/dist/shared/pty/key-gate.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Node on Windows reads keys through the console API, where Backspace is ^H and Ctrl+Backspace is DEL: the reverse of
+ * what terminals send. ConPTY reads ^H as Ctrl+Backspace (delete a word), so swap them back.
+ */
+export declare function fixWindowsKeys(chunk: Buffer): Buffer;
+/**
+ * Typed input before the console's mode is settled. Once ENABLE_VIRTUAL_TERMINAL_INPUT is on (enableVtInput), the
+ * console hands over the terminal's own bytes (DEL for Backspace, ^H for Ctrl+Backspace) and nothing may be swapped;
+ * only when it could not be turned on are keys read as console key records and swapped (fixWindowsKeys). Turning it
+ * on takes a moment (a PowerShell helper), and input read meanwhile used to be swapped although it was the terminal's
+ * own: a Backspace pressed then reached the agent as ^H and deleted a word. So input waits here until the mode is
+ * known.
+ */
+export declare class KeyGate {
+    private pending;
+    private decided;
+    private swap;
+    /** windowsConsole: input comes from a Windows console in raw mode (its mode is decided later); else it goes as is. */
+    constructor(windowsConsole: boolean);
+    /** The bytes to send now (empty while the mode is not known yet). */
+    push(data: Buffer): Buffer;
+    /** The console's mode is known: what was held, ready to send. Later calls only change how new input is read. */
+    decide(vtInput: boolean): Buffer;
+}

package/dist/shared/pty/key-gate.js

@@ -0,0 +1,45 @@
+// Windows: holds what you type until the client knows how the console hands keys over, so Backspace stays Backspace.
+/**
+ * Node on Windows reads keys through the console API, where Backspace is ^H and Ctrl+Backspace is DEL: the reverse of
+ * what terminals send. ConPTY reads ^H as Ctrl+Backspace (delete a word), so swap them back.
+ */
+export function fixWindowsKeys(chunk) {
+    if (!chunk.includes(0x08) && !chunk.includes(0x7f))
+        return chunk;
+    return Buffer.from(chunk.map((b) => (b === 0x08 ? 0x7f : b === 0x7f ? 0x08 : b)));
+}
+/**
+ * Typed input before the console's mode is settled. Once ENABLE_VIRTUAL_TERMINAL_INPUT is on (enableVtInput), the
+ * console hands over the terminal's own bytes (DEL for Backspace, ^H for Ctrl+Backspace) and nothing may be swapped;
+ * only when it could not be turned on are keys read as console key records and swapped (fixWindowsKeys). Turning it
+ * on takes a moment (a PowerShell helper), and input read meanwhile used to be swapped although it was the terminal's
+ * own: a Backspace pressed then reached the agent as ^H and deleted a word. So input waits here until the mode is
+ * known.
+ */
+export class KeyGate {
+    pending = [];
+    decided;
+    swap = false;
+    /** windowsConsole: input comes from a Windows console in raw mode (its mode is decided later); else it goes as is. */
+    constructor(windowsConsole) {
+        this.decided = !windowsConsole;
+    }
+    /** The bytes to send now (empty while the mode is not known yet). */
+    push(data) {
+        if (!data.length)
+            return data;
+        if (!this.decided) {
+            this.pending.push(data);
+            return Buffer.alloc(0);
+        }
+        return this.swap ? fixWindowsKeys(data) : data;
+    }
+    /** The console's mode is known: what was held, ready to send. Later calls only change how new input is read. */
+    decide(vtInput) {
+        this.swap = !vtInput;
+        this.decided = true;
+        const held = Buffer.concat(this.pending);
+        this.pending = [];
+        return this.swap ? fixWindowsKeys(held) : held;
+    }
+}

package/dist/shared/pty/mouse-modes.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Follows the private modes a program turns on and off in its output (DECSET / DECRST, kept across chunks: mouse
+ * tracking 9, 1000, 1002, 1003, the encodings 1005 and 1015, bracketed paste 2004 ...) and drops the mouse reports it
+ * did not ask for: none without tracking, motion only with 1002 (while a button is held: a drag) or 1003 (every move).
+ * Your terminal reports what the program's modes say; what is dropped is what was still on its way when the program
+ * turned tracking off, exited or restarted, and would reach it as text.
+ */
+export declare class MouseModes {
+    private readonly on;
+    /** 0 text, 1 after ESC, 2 after ESC[, 3 in ESC[? parameters, 4 after ESC[! */
+    private state;
+    private params;
+    /** Reads the program's output (after OutputFilter): the mode changes in it. */
+    watch(output: Buffer): void;
+    /** The program is gone (exited or restarting): its modes went with it. */
+    reset(): void;
+    /** True while the program tracks the mouse in any way. */
+    tracking(): boolean;
+    /** True while the program has a mode on (2004: bracketed paste). */
+    has(mode: number): boolean;
+    /** The mode numbers on now (for the report and tests). */
+    modes(): number[];
+    /** `input` without the mouse reports the program has not asked for. Sequences must be whole (InputJoiner). */
+    filter(input: Buffer): Buffer;
+    private allows;
+    private apply;
+}

package/dist/shared/pty/mouse-modes.js

@@ -0,0 +1,155 @@
+// The mouse tracking a program asked for, read from its output, and the mouse reports it may receive.
+/** X10 compatibility (press only), normal (press/release/wheel), button-event (+ drag), any-event (+ every motion). */
+const TRACKING = [9, 1000, 1002, 1003];
+/** Longest DECSET / DECRST parameter list followed; anything longer is not a mode change. */
+const MAX_PARAMS = 64;
+/** Button code bits of a mouse report: motion (drag or move), and "no button" in the low two bits. */
+const MOTION = 32;
+const NO_BUTTON = 3;
+/**
+ * Follows the private modes a program turns on and off in its output (DECSET / DECRST, kept across chunks: mouse
+ * tracking 9, 1000, 1002, 1003, the encodings 1005 and 1015, bracketed paste 2004 ...) and drops the mouse reports it
+ * did not ask for: none without tracking, motion only with 1002 (while a button is held: a drag) or 1003 (every move).
+ * Your terminal reports what the program's modes say; what is dropped is what was still on its way when the program
+ * turned tracking off, exited or restarted, and would reach it as text.
+ */
+export class MouseModes {
+    on = new Set();
+    /** 0 text, 1 after ESC, 2 after ESC[, 3 in ESC[? parameters, 4 after ESC[! */
+    state = 0;
+    params = '';
+    /** Reads the program's output (after OutputFilter): the mode changes in it. */
+    watch(output) {
+        for (const b of output) {
+            if (b === 0x1b) {
+                this.state = 1;
+                continue;
+            }
+            if (this.state === 1) {
+                // RIS (ESC c), a full reset, turns every mode off.
+                if (b === 0x63)
+                    this.on.clear();
+                this.state = b === 0x5b ? 2 : 0;
+            }
+            else if (this.state === 2) {
+                // DECSTR (ESC[!p), a soft reset, turns mouse tracking off too.
+                this.state = b === 0x3f ? 3 : b === 0x21 ? 4 : 0;
+                this.params = '';
+            }
+            else if (this.state === 4) {
+                if (b === 0x70)
+                    this.on.clear();
+                this.state = 0;
+            }
+            else if (this.state === 3) {
+                if ((b >= 0x30 && b <= 0x39) || b === 0x3b) {
+                    this.params += String.fromCharCode(b);
+                    if (this.params.length > MAX_PARAMS)
+                        this.state = 0;
+                }
+                else {
+                    if (b === 0x68 || b === 0x6c)
+                        this.apply(this.params, b === 0x68);
+                    this.state = 0;
+                }
+            }
+        }
+    }
+    /** The program is gone (exited or restarting): its modes went with it. */
+    reset() {
+        this.on.clear();
+        this.state = 0;
+        this.params = '';
+    }
+    /** True while the program tracks the mouse in any way. */
+    tracking() {
+        return TRACKING.some((m) => this.on.has(m));
+    }
+    /** True while the program has a mode on (2004: bracketed paste). */
+    has(mode) {
+        return this.on.has(mode);
+    }
+    /** The mode numbers on now (for the report and tests). */
+    modes() {
+        return [...this.on].sort((a, b) => a - b);
+    }
+    /** `input` without the mouse reports the program has not asked for. Sequences must be whole (InputJoiner). */
+    filter(input) {
+        if (!input.includes(0x1b))
+            return input;
+        const parts = [];
+        let from = 0;
+        let i = input.indexOf(0x1b);
+        while (i !== -1) {
+            const report = mouseReport(input, i, this.on.has(1005), this.on.has(1015));
+            if (report && !this.allows(report.button)) {
+                parts.push(input.subarray(from, i));
+                from = i + report.length;
+                i = input.indexOf(0x1b, from);
+            }
+            else
+                i = input.indexOf(0x1b, i + 1);
+        }
+        if (from === 0)
+            return input;
+        parts.push(input.subarray(from));
+        return Buffer.concat(parts);
+    }
+    allows(button) {
+        if (!this.tracking())
+            return false;
+        if ((button & MOTION) === 0)
+            return true;
+        if (this.on.has(1003))
+            return true;
+        return this.on.has(1002) && (button & NO_BUTTON) !== NO_BUTTON;
+    }
+    apply(params, set) {
+        for (const p of params.split(';')) {
+            const mode = Number(p);
+            if (!p || !Number.isSafeInteger(mode))
+                continue;
+            if (set)
+                this.on.add(mode);
+            else
+                this.on.delete(mode);
+        }
+    }
+}
+/**
+ * The mouse report starting at `at`: SGR (ESC[<b;x;yM or m, 1006), urxvt (ESC[b;x;yM, 1015, b offset by 32; only while
+ * 1015 is on) or X10
+ * (ESC[M and three bytes; not with UTF-8 coordinates, 1005, where its length cannot be told). Null when there is none.
+ */
+function mouseReport(data, at, utf8, urxvt) {
+    if (data[at + 1] !== 0x5b)
+        return null;
+    const sgr = data[at + 2] === 0x3c;
+    if (sgr || (urxvt && data[at + 2] >= 0x30 && data[at + 2] <= 0x39)) {
+        let i = at + (sgr ? 3 : 2);
+        let digits = '';
+        let fields = 1;
+        for (; i < data.length && i - at < 32; i++) {
+            const b = data[i];
+            if (b >= 0x30 && b <= 0x39) {
+                if (fields === 1)
+                    digits += String.fromCharCode(b);
+            }
+            else if (b === 0x3b)
+                fields++;
+            else
+                break;
+        }
+        if (i >= data.length || fields !== 3 || !digits)
+            return null;
+        if (sgr ? data[i] !== 0x4d && data[i] !== 0x6d : data[i] !== 0x4d)
+            return null;
+        const button = Number(digits) - (sgr ? 0 : 32);
+        return button >= 0 ? { button, length: i - at + 1 } : null;
+    }
+    if (data[at + 2] === 0x4d && !utf8 && data.length - at >= 6) {
+        const button = data[at + 3] - 32;
+        return button >= 0 ? { button, length: 6 } : null;
+    }
+    return null;
+}

package/dist/shared/pty/terminal.d.ts

@@ -13,11 +13,6 @@ export type ClientResult = {
  * urxvt).
  */
 export declare const MOUSE_OFF = "\u001B[?1000l\u001B[?1002l\u001B[?1003l\u001B[?1005l\u001B[?1006l\u001B[?1015l";
-/**
- * Node on Windows reads keys through the console API, where Backspace is ^H and Ctrl+Backspace is DEL: the reverse of
- * what terminals send. ConPTY reads ^H as Ctrl+Backspace (delete a word), so swap them back.
- */
-export declare function fixWindowsKeys(chunk: Buffer): Buffer;
 /**
  * Bridges this process's terminal to the remote program until it exits, the connection drops, or the user presses
  * the detach key. Restores the terminal before resolving.

package/dist/shared/pty/terminal.js

@@ -3,20 +3,37 @@ import { OutputFilter } from './output-filter.js';
 import { enableVtInput } from './console-input.js';
 import { InputJoiner, JOIN_MS } from './input-joiner.js';
 import { CTRL_C_CONFIRM_MS, CtrlCGuard } from './ctrl-c.js';
+import { KeyGate } from './key-gate.js';
+import { MouseModes } from './mouse-modes.js';
 /**
  * Turns off every mouse tracking mode a program may have turned on in your terminal (normal, button, any, UTF-8, SGR,
  * urxvt).
  */
 export const MOUSE_OFF = '\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1005l\x1b[?1006l\x1b[?1015l';
-/**
- * Node on Windows reads keys through the console API, where Backspace is ^H and Ctrl+Backspace is DEL: the reverse of
- * what terminals send. ConPTY reads ^H as Ctrl+Backspace (delete a word), so swap them back.
- */
-export function fixWindowsKeys(chunk) {
-    if (!chunk.includes(0x08) && !chunk.includes(0x7f))
-        return chunk;
-    return Buffer.from(chunk.map((b) => (b === 0x08 ? 0x7f : b === 0x7f ? 0x08 : b)));
+/** After leaving: mouse reports still on their way are dropped until input is this quiet (at most SETTLE_MAX_MS). */
+const SETTLE_QUIET_MS = 50;
+const SETTLE_MAX_MS = 300;
+/** Waits until `stream` has been quiet for SETTLE_QUIET_MS (or SETTLE_MAX_MS passed), dropping what it reads. */
+function drainInput(stream) {
+    return new Promise((done) => {
+        let quiet;
+        const end = () => {
+            clearTimeout(quiet);
+            clearTimeout(cap);
+            stream.off('data', onData);
+            done();
+        };
+        const onData = () => {
+            clearTimeout(quiet);
+            quiet = setTimeout(end, SETTLE_QUIET_MS);
+        };
+        const cap = setTimeout(end, SETTLE_MAX_MS);
+        stream.on('data', onData);
+        onData();
+    });
 }
+/** Longest wait for the console's input mode before typed keys are sent anyway (it normally takes about 2 s). */
+const VT_WAIT_MS = 10000;
 /**
  * Bridges this process's terminal to the remote program until it exits, the connection drops, or the user presses
  * the detach key. Restores the terminal before resolving.
@@ -32,8 +49,8 @@ options = {}) {
         const [c, r] = stdout.isTTY ? stdout.getWindowSize() : [0, 0];
         return [c || 120, r || 30];
     };
-    // Until the console passes the terminal's input through as it is (enableVtInput), Node turns Backspace into ^H.
-    let swapKeys = process.platform === 'win32' && stdin.isTTY;
+    // Until the console's input mode is known (enableVtInput), what is typed waits: see KeyGate.
+    const keys = new KeyGate(process.platform === 'win32' && Boolean(stdin.isTTY));
     return new Promise((resolve) => {
         let done = false;
         const reader = new FrameReader();
@@ -42,7 +59,10 @@ options = {}) {
         let resizeTimer;
         // Set once raw mode is on (below); finish() may run before that.
         // eslint-disable-next-line prefer-const
-        let vtInput;
+        let vtInput, vtTimer;
+        // The agent's mouse modes, read from its output; only known when it is passed through (conpty.dll, see below).
+        const mouse = new MouseModes();
+        let passthrough = false;
         const finish = (result) => {
             if (done)
                 return;
@@ -54,11 +74,16 @@ options = {}) {
             clearInterval(sizeWatch);
             clearTimeout(joinTimer);
             clearTimeout(hintTimer);
+            clearTimeout(vtTimer);
             socket.destroy();
-            // The agent's mouse tracking ends with it: your terminal's wheel scrolls again (and clicks select text).
-            stdout.write('\x1b[0m\x1b[?25h' + MOUSE_OFF + '\r\n');
+            // The agent's mouse tracking ends with it: your terminal's wheel scrolls again (and clicks select text). Reports
+            // the terminal sent before it read that are dropped here, or they would reach your shell as text.
+            const tracked = mouse.tracking();
+            const reset = '\x1b[0m\x1b[?25h' + MOUSE_OFF + (mouse.has(2004) ? '\x1b[?2004l' : '') + '\r\n';
+            const flushed = new Promise((written) => stdout.write(reset, () => written()));
+            const settled = tracked ? flushed.then(() => drainInput(stdin)) : Promise.resolve();
             // Wait for a console-mode change still in progress, then give the console back in its normal mode.
-            void (vtInput?.stop() ?? Promise.resolve()).then(() => {
+            void Promise.all([settled, vtInput?.stop()]).then(() => {
                 if (stdin.isTTY)
                     stdin.setRawMode(false);
                 stdin.pause();
@@ -67,10 +92,12 @@ options = {}) {
         };
         const joiner = new InputJoiner();
         let joinTimer;
-        const sendInput = (data) => {
+        const write = (data) => {
             if (data.length && !done)
-                socket.write(encodeFrame(FrameType.Input, swapKeys ? fixWindowsKeys(data) : data));
+                socket.write(encodeFrame(FrameType.Input, data));
         };
+        // Mouse reports the agent has not asked for (motion without 1002/1003 ...) are dropped: see MouseModes.
+        const sendInput = (data) => write(keys.push(passthrough ? mouse.filter(data) : data));
         const guard = options.confirmCtrlC ? new CtrlCGuard() : null;
         let hintTimer;
         const onInput = (chunk) => {
@@ -99,7 +126,6 @@ options = {}) {
         // repaints racing each other left the screen garbled. Wait until the size settles, clear what this terminal
         // reflowed on its own, then let ptyhost repaint everything once at the new size. With conpty.dll (passthrough)
         // nothing is repainted: this terminal's own reflow and scrollback stay, and the program redraws what it needs.
-        let passthrough = false;
         const sendSize = () => {
             const [c, r] = size();
             if (c === sent[0] && r === sent[1])
@@ -134,13 +160,16 @@ options = {}) {
             for (const frame of frames) {
                 if (frame.type === FrameType.Output) {
                     const out = filter.push(frame.payload);
+                    mouse.watch(out);
                     guard?.watchOutput(out.toString('latin1'));
                     stdout.write(out);
                 }
                 else if (frame.type === FrameType.Console)
                     passthrough = frame.payload.toString('latin1') === 'conpty.dll';
-                else if (frame.type === FrameType.Restarting)
+                else if (frame.type === FrameType.Restarting) {
+                    mouse.reset();
                     stdout.write(MOUSE_OFF + '\x1b[2J\x1b[3J\x1b[H');
+                }
                 else if (frame.type === FrameType.Exit)
                     finish({ reason: 'exit', exitCode: frame.payload.length >= 4 ? frame.payload.readInt32LE(0) : 1 });
                 else if (frame.type === FrameType.Error)
@@ -163,9 +192,11 @@ options = {}) {
         // After setRawMode (which sets the console mode): mouse reports, focus and keys then arrive as the terminal sent
         // them.
         vtInput = enableVtInput();
+        // A helper that hangs must not hold the keyboard: after VT_WAIT_MS keys go as console keys until it is done.
+        vtTimer = setTimeout(() => write(keys.decide(false)), VT_WAIT_MS);
         void vtInput.ready.then((on) => {
-            if (on)
-                swapKeys = false;
+            clearTimeout(vtTimer);
+            write(keys.decide(on));
         });
         stdin.on('data', onInput);
         stdin.resume();

package/dist/sync/watcher.js

@@ -137,7 +137,7 @@ export class Watcher {
     /** Contained storage of this data set (only when a mounted image is on record), else null. */
     contained() {
         try {
-            const storage = new ContainedStorage(realContainedDeps(this.storageRoot, 64), setNameOf(this.dataPath));
+            const storage = new ContainedStorage(realContainedDeps(this.storageRoot, 64, Boolean(this.resume.config)), setNameOf(this.dataPath));
             return storage.isRecorded() ? storage : null;
         }
         catch {

package/dist/web/index.html

@@ -6,7 +6,7 @@
     <title>Sandbox</title>
     <link rel="icon" href="data:," />
     <link rel="stylesheet" href="/main-UAQPI5XD.css" />
-    <script type="module" src="/main-NBQ3LF4E.js"></script>
+    <script type="module" src="/main-6XNBTJLT.js"></script>
   </head>
   <body>
     <div id="root"></div>