@driftengine/native-host 4.0.0

package/dist/audio.js

@@ -0,0 +1,193 @@
+/**
+ * Web Audio for a host with no browser: the Rust engine's contexts, with Opus decoded where it
+ * cannot, and underruns counted.
+ *
+ * **The engine's mix is Web Audio from end to end** — `AudioGraph` and `MixConsole` build nodes on a
+ * context and never touch a device — so the host's job is a Web Audio implementation, not a mixer.
+ * It is `node-web-audio-api` (IRCAM, BSD-3-Clause), `web-audio-api-rs` with prebuilt binaries,
+ * which plays through JACK on Linux, and PipeWire provides that. Chosen by the maintainer on
+ * 2026-09-19.
+ *
+ * **Opus is decoded here**, by libopus as WebAssembly (`ogg-opus-decoder`, MIT), because the Rust
+ * engine's decoder refuses it (measured: "unsupported audio codec") and Opus is the first format the
+ * engine's sound registry looks for. Anything else goes to the Rust engine's own decoder. A decode
+ * comes back at the context's sample rate, as the specification's `decodeAudioData` does: Opus is
+ * always 48 kHz, so a context at another rate has it resampled, by the same engine rendering it
+ * offline.
+ *
+ * **Sample rate and buffer size are the host's to ask for** — `sampleRate` and `latencyHint`, given
+ * to every context the engine creates, and what the device gave is reported once it runs; under
+ * JACK the server sets the buffer, so the latency asked for is a request. **An underrun is counted**
+ * from the context's `renderCapacity` and said once, rather than heard as a click and never
+ * reported.
+ *
+ * What it gives up: a browser's autoplay rule, which has no meaning here, so a context runs from
+ * the moment it is made; and the decoders' sample-for-sample agreement with Chrome's, which no
+ * gate compares yet.
+ */
+import { createRequire } from 'node:module';
+import { OggOpusDecoder } from 'ogg-opus-decoder';
+import { correctAutomation } from './audioParams.js';
+/* A native module published as CommonJS. */
+const webAudio = createRequire(import.meta.url)('node-web-audio-api');
+/** An Ogg stream whose first page carries an Opus header. */
+export function isOggOpus(bytes) {
+    const text = (at, length) => String.fromCharCode(...bytes.subarray(at, at + length));
+    return bytes.length > 36 && text(0, 4) === 'OggS' && text(28, 8) === 'OpusHead';
+}
+/**
+ * How many samples an Ogg Opus stream holds: its last page's granule position less the header's
+ * pre-skip. The decoder drops the pre-skip and hands back the last packet whole, so it runs long;
+ * a browser's decode ends where the stream says it does. Measured on the fixture: 24,312 decoded,
+ * 24,000 kept, and those are Chrome's samples at no offset, to within 9.5e-6 — two builds of libopus
+ * rounding differently, about −100 dB.
+ */
+function opusLength(bytes) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let granule = 0;
+    for (let at = 0; at + 27 <= bytes.length && view.getUint32(at) === 0x4f676753;) {
+        granule = Number(view.getBigInt64(at + 6, true));
+        const segments = bytes[at + 26];
+        let length = 0;
+        for (let s = 0; s < segments; s += 1)
+            length += bytes[at + 27 + s];
+        at += 27 + segments + length;
+    }
+    /* The header is the first page's packet, after its 27 bytes and its segment table. */
+    const preSkip = view.getUint16(27 + bytes[26] + 10, true);
+    return Math.max(0, granule - preSkip);
+}
+/** Opus to an `AudioBuffer` at `target`'s rate. */
+async function decodeOpus(bytes, target) {
+    const decoder = new OggOpusDecoder();
+    await decoder.ready;
+    try {
+        const decoded = await decoder.decodeFile(bytes);
+        if (decoded.errors.length > 0) {
+            throw new Error(`[driftengine] the Opus stream did not decode: ${decoded.errors[0]?.message ?? ''}`);
+        }
+        const channels = decoded.channelData.length;
+        const frames = Math.min(decoded.samplesDecoded, opusLength(bytes));
+        const at48 = new webAudio.AudioBuffer({
+            numberOfChannels: channels,
+            length: frames,
+            sampleRate: decoded.sampleRate,
+        });
+        decoded.channelData.forEach((samples, channel) => at48.copyToChannel(samples.subarray(0, frames), channel));
+        if (decoded.sampleRate === target.sampleRate)
+            return at48;
+        /*
+         * The length as Chrome works it out — divided by the ratio of the rates, truncated — which
+         * makes 24,000 samples at 48 kHz 22,049 at 44.1 kHz rather than 22,050, because the ratio is
+         * not exact in a double. Measured in Chrome's own decode of the fixture.
+         */
+        const length = Math.floor(frames / (decoded.sampleRate / target.sampleRate));
+        const resampler = new webAudio.OfflineAudioContext(channels, length, target.sampleRate);
+        const source = resampler.createBufferSource();
+        source.buffer = at48;
+        source.connect(resampler.destination);
+        source.start();
+        return await resampler.startRendering();
+    }
+    finally {
+        decoder.free();
+    }
+}
+/** `decodeAudioData`, in both of its shapes: a promise, and the two callbacks. */
+function decodeWith(context, engine, data, success, failure) {
+    const bytes = new Uint8Array(data);
+    const decoding = isOggOpus(bytes) ? decodeOpus(bytes, context) : engine(data);
+    return decoding.then((buffer) => {
+        success?.(buffer);
+        return buffer;
+    }, (error) => {
+        failure?.(error);
+        throw error;
+    });
+}
+/** Watches a context's render capacity and counts the updates in which it could not keep up. */
+export class UnderrunCounter {
+    underruns = 0;
+    constructor(capacity) {
+        capacity.addEventListener('update', (event) => {
+            if ((event.underrunRatio ?? 0) <= 0)
+                return;
+            this.underruns += 1;
+            if (this.underruns === 1) {
+                console.warn('[driftengine] audio underran: the output could not be fed in time. Counted from here on.');
+            }
+        });
+        capacity.start({ updateInterval: 1 });
+    }
+}
+/** The two context classes a page has, over the Rust engine, with the host's defaults. */
+export function hostAudioContexts(defaults = {}) {
+    /* The Rust engine's scheduled ramps, corrected to Chrome's (`audioParams.ts`). */
+    correctAutomation();
+    const options = {
+        ...(defaults.sampleRate === undefined ? {} : { sampleRate: defaults.sampleRate }),
+        ...(defaults.latencyHint === undefined ? {} : { latencyHint: defaults.latencyHint }),
+        ...(defaults.sink === 'none' ? { sinkId: { type: 'none' } } : {}),
+    };
+    class HostAudioContext extends webAudio.AudioContext {
+        underruns;
+        constructor(asked = {}) {
+            super({ ...options, ...asked });
+            /*
+             * Reported once the device has said what it gave, which it does a few milliseconds after the
+             * context starts: under JACK the server sets the buffer, so `latencyHint` is a request
+             * (measured here: 21 ms for either category, PipeWire's quantum). Asked for rather than
+             * listened for, because starting the render-capacity watch below starts the context before
+             * a `statechange` listener could hear it.
+             */
+            if (defaults.sink !== 'none') {
+                let tries = 0;
+                const report = () => {
+                    tries += 1;
+                    if (this.outputLatency <= 0 && tries < 50) {
+                        setTimeout(report, 20).unref();
+                        return;
+                    }
+                    const frames = Math.round(this.outputLatency * this.sampleRate);
+                    console.log(`[driftengine] audio: ${this.sampleRate} Hz, ${frames} frames of output latency (${(this.outputLatency * 1000).toFixed(1)} ms)`);
+                };
+                setTimeout(report, 20).unref();
+            }
+            /* Nothing renders against a clock with no device, so there is nothing to underrun. */
+            this.underruns =
+                defaults.sink === 'none'
+                    ? null
+                    : new UnderrunCounter(this
+                        .renderCapacity);
+        }
+        decodeAudioData(data, success, failure) {
+            return decodeWith(this, (bytes) => super.decodeAudioData(bytes), data, success, failure);
+        }
+    }
+    class HostOfflineAudioContext extends webAudio.OfflineAudioContext {
+        decodeAudioData(data, success, failure) {
+            return decodeWith(this, (bytes) => super.decodeAudioData(bytes), data, success, failure);
+        }
+    }
+    return {
+        AudioContext: HostAudioContext,
+        OfflineAudioContext: HostOfflineAudioContext,
+        AudioBuffer: webAudio.AudioBuffer,
+    };
+}
+/** Give the page its audio globals, and hand back what takes them away again. */
+export function installAudio(defaults = {}, scope = globalThis) {
+    const contexts = hostAudioContexts(defaults);
+    const held = ['AudioContext', 'OfflineAudioContext', 'AudioBuffer'].map((name) => [name, name in scope, scope[name]]);
+    scope['AudioContext'] = contexts.AudioContext;
+    scope['OfflineAudioContext'] = contexts.OfflineAudioContext;
+    scope['AudioBuffer'] = contexts.AudioBuffer;
+    return () => {
+        for (const [name, had, value] of held) {
+            if (had)
+                scope[name] = value;
+            else
+                delete scope[name];
+        }
+    };
+}

package/dist/audioParams.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A defect in `node-web-audio-api` 2.2.0's automation, corrected for the engine's ramps until it is
+ * fixed upstream.
+ *
+ * **The defect, measured against Chrome on 2026-09-19.** A `setTargetAtTime` whose start is past
+ * the first render quantum, following an event that has *settled* — the value simply set, a
+ * `setValueAtTime`, the end of a linear or exponential ramp — renders garbage from the second
+ * quantum until it starts: 31.1 for a gain holding at 1, 10.5 for one a ramp left at 0.5, a
+ * low-pass at −839,731 Hz. From its start on it is Chrome's to four places, and following another
+ * `setTargetAtTime` it is right throughout. Every other shape the engine schedules was compared
+ * and agrees. The engine's every level and cutoff move is this shape (`mix/inserts.ts`, `ramp`), so
+ * the reference mix came out 28 dB hot in its second second.
+ *
+ * **The correction is what the specification says the value already is.** Before a target starts,
+ * a parameter holds the value its last settled event left; so a `setValueAtTime` of exactly that
+ * value is placed at the target's start, which changes nothing a browser computes and gives this
+ * engine the event it renders correctly. To know that value, each parameter's scheduled events are
+ * written down as they are made. Where that record cannot say — a curve spanning the start, a
+ * `cancelAndHoldAtTime`, a value set while events are pending — nothing is added, rather than a
+ * guess.
+ *
+ * Remove this with the dependency's fix: `audioParams.test.ts` is Chrome's numbers and will say.
+ */
+/** Correct the Rust engine's parameters, once, for every context made after or before. */
+export declare function correctAutomation(): void;

package/dist/audioParams.js

@@ -0,0 +1,128 @@
+/**
+ * A defect in `node-web-audio-api` 2.2.0's automation, corrected for the engine's ramps until it is
+ * fixed upstream.
+ *
+ * **The defect, measured against Chrome on 2026-09-19.** A `setTargetAtTime` whose start is past
+ * the first render quantum, following an event that has *settled* — the value simply set, a
+ * `setValueAtTime`, the end of a linear or exponential ramp — renders garbage from the second
+ * quantum until it starts: 31.1 for a gain holding at 1, 10.5 for one a ramp left at 0.5, a
+ * low-pass at −839,731 Hz. From its start on it is Chrome's to four places, and following another
+ * `setTargetAtTime` it is right throughout. Every other shape the engine schedules was compared
+ * and agrees. The engine's every level and cutoff move is this shape (`mix/inserts.ts`, `ramp`), so
+ * the reference mix came out 28 dB hot in its second second.
+ *
+ * **The correction is what the specification says the value already is.** Before a target starts,
+ * a parameter holds the value its last settled event left; so a `setValueAtTime` of exactly that
+ * value is placed at the target's start, which changes nothing a browser computes and gives this
+ * engine the event it renders correctly. To know that value, each parameter's scheduled events are
+ * written down as they are made. Where that record cannot say — a curve spanning the start, a
+ * `cancelAndHoldAtTime`, a value set while events are pending — nothing is added, rather than a
+ * guess.
+ *
+ * Remove this with the dependency's fix: `audioParams.test.ts` is Chrome's numbers and will say.
+ */
+import { createRequire } from 'node:module';
+/** Each parameter's events, time-ordered, or `null` once the record cannot be trusted. */
+const records = new WeakMap();
+function recordOf(param) {
+    let record = records.get(param);
+    if (record === undefined) {
+        record = [];
+        records.set(param, record);
+    }
+    return record;
+}
+function add(param, event) {
+    const record = recordOf(param);
+    if (record === null)
+        return;
+    let at = record.length;
+    while (at > 0 && record[at - 1].time > event.time)
+        at -= 1;
+    record.splice(at, 0, event);
+}
+let installed = false;
+/** Correct the Rust engine's parameters, once, for every context made after or before. */
+export function correctAutomation() {
+    if (installed)
+        return;
+    installed = true;
+    const { AudioParam: Param } = createRequire(import.meta.url)('node-web-audio-api');
+    const proto = Param.prototype;
+    const original = {
+        setValueAtTime: proto.setValueAtTime,
+        linearRampToValueAtTime: proto.linearRampToValueAtTime,
+        exponentialRampToValueAtTime: proto.exponentialRampToValueAtTime,
+        setTargetAtTime: proto.setTargetAtTime,
+        setValueCurveAtTime: proto.setValueCurveAtTime,
+        cancelScheduledValues: proto.cancelScheduledValues,
+        cancelAndHoldAtTime: proto.cancelAndHoldAtTime,
+    };
+    const value = Object.getOwnPropertyDescriptor(proto, 'value');
+    proto.setValueAtTime = function (next, time) {
+        add(this, { time, settled: true, value: next });
+        return original.setValueAtTime.call(this, next, time);
+    };
+    proto.linearRampToValueAtTime = function (next, time) {
+        add(this, { time, settled: true, value: next });
+        return original.linearRampToValueAtTime.call(this, next, time);
+    };
+    proto.exponentialRampToValueAtTime = function (next, time) {
+        add(this, { time, settled: true, value: next });
+        return original.exponentialRampToValueAtTime.call(this, next, time);
+    };
+    proto.setValueCurveAtTime = function (values, start, duration) {
+        add(this, { time: start + duration, settled: true, value: values[values.length - 1] ?? 0 });
+        /* A curve spans its duration, and a target starting inside it has no settled value to hold. */
+        add(this, { time: start, settled: false, value: Number.NaN });
+        return original.setValueCurveAtTime.call(this, values, start, duration);
+    };
+    proto.cancelScheduledValues = function (time) {
+        const record = recordOf(this);
+        if (record !== null) {
+            while (record.length > 0 && record[record.length - 1].time >= time)
+                record.pop();
+        }
+        return original.cancelScheduledValues.call(this, time);
+    };
+    proto.cancelAndHoldAtTime = function (time) {
+        records.set(this, null);
+        return original.cancelAndHoldAtTime.call(this, time);
+    };
+    proto.setTargetAtTime = function (target, start, constant) {
+        const record = recordOf(this);
+        if (record !== null) {
+            let last;
+            for (const event of record)
+                if (event.time <= start)
+                    last = event;
+            /* Nothing before it: what it holds is the value the parameter was simply given. */
+            const held = last === undefined
+                ? this.value
+                : last.settled
+                    ? last.value
+                    : null;
+            if (held !== null && Number.isFinite(held)) {
+                add(this, { time: start, settled: true, value: held });
+                original.setValueAtTime.call(this, held, start);
+            }
+        }
+        add(this, { time: start, settled: false, value: target });
+        return original.setTargetAtTime.call(this, target, start, constant);
+    };
+    if (value?.set !== undefined && value.get !== undefined) {
+        const { get, set } = value;
+        Object.defineProperty(proto, 'value', {
+            configurable: true,
+            enumerable: value.enumerable ?? false,
+            get,
+            set(next) {
+                /* With events pending, a value set now is an event at a time this cannot see. */
+                const record = records.get(this);
+                if (record !== undefined && record !== null && record.length > 0)
+                    records.set(this, null);
+                set.call(this, next);
+            },
+        });
+    }
+}

package/dist/bridge.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The shell's bridge, `globalThis.__driftHost`, answered by this host.
+ *
+ * **A packaged game reaches its platform through `createHost()`**, from `@driftengine/package`, which
+ * takes the shell's implementations whenever it finds this bridge — and the engine's splash stands
+ * aside for a shell. The desktop shell's preload puts one there over Electron's IPC; this host puts
+ * its own there over SDL and the filesystem, so a game packaged for one runs on the other with no
+ * change. Each member makes the decision the desktop shell's main process makes (`main/ipc.ts`), for
+ * the same reasons, written beside it.
+ *
+ * - **The store** is one file, read whole before the game boots and replaced whole a quarter of a
+ *   second after the last write — `storeFile.ts`, which the desktop shell uses too — and written at
+ *   once, synchronously, on the way out, because a debounce that loses its last write loses exactly
+ *   the setting somebody changed before quitting.
+ * - **Fullscreen** is read back after it is asked for, since a window manager may refuse, and a
+ *   size is refused while the window covers a display.
+ * - **Closing** asks a game that registered to be asked, and waits for it at most three seconds; a
+ *   game that did not is closed at once.
+ *
+ * What it gives up: SDL 2 reports no scale for a display, so a display the window is not on reads
+ * 1; the store has no cloud; and `platform` answers that no store's features are here.
+ */
+import type { DriftHostBridge } from '@driftengine/package/bridge';
+/** A display, as SDL reports one. */
+export interface BridgeDisplay {
+    readonly name: string | null;
+    readonly frequency: number;
+    readonly geometry: {
+        readonly x: number;
+        readonly y: number;
+        readonly width: number;
+        readonly height: number;
+    };
+}
+/** What the bridge reads and drives of the SDL window. */
+export interface BridgeWindow {
+    readonly width: number;
+    readonly height: number;
+    readonly pixelWidth: number;
+    readonly fullscreen: boolean;
+    readonly display: BridgeDisplay;
+    setFullscreen(on: boolean): void;
+    setSize(width: number, height: number): void;
+    on(type: 'focus' | 'blur' | 'beforeClose', listener: (event: {
+        prevent?: () => void;
+    }) => void): unknown;
+    off(type: 'focus' | 'blur' | 'beforeClose', listener: (event: {
+        prevent?: () => void;
+    }) => void): unknown;
+}
+export interface NativeFiles {
+    openFile(accept: readonly string[]): Promise<{
+        name: string;
+        bytes: Uint8Array;
+    } | null>;
+    saveFile(name: string, bytes: Uint8Array): Promise<boolean>;
+}
+export interface NativeBridgeOptions {
+    readonly window: BridgeWindow;
+    readonly displays: () => readonly BridgeDisplay[];
+    readonly storePath: string;
+    /** End the session: the host stops drawing and closes the window. */
+    readonly quit: () => void;
+    readonly files?: NativeFiles;
+}
+/** The bridge, and what writes its store now. */
+export interface NativeBridge extends DriftHostBridge {
+    flushSync(): void;
+}
+export declare function nativeBridge(options: NativeBridgeOptions): NativeBridge;

package/dist/bridge.js

@@ -0,0 +1,170 @@
+/**
+ * The shell's bridge, `globalThis.__driftHost`, answered by this host.
+ *
+ * **A packaged game reaches its platform through `createHost()`**, from `@driftengine/package`, which
+ * takes the shell's implementations whenever it finds this bridge — and the engine's splash stands
+ * aside for a shell. The desktop shell's preload puts one there over Electron's IPC; this host puts
+ * its own there over SDL and the filesystem, so a game packaged for one runs on the other with no
+ * change. Each member makes the decision the desktop shell's main process makes (`main/ipc.ts`), for
+ * the same reasons, written beside it.
+ *
+ * - **The store** is one file, read whole before the game boots and replaced whole a quarter of a
+ *   second after the last write — `storeFile.ts`, which the desktop shell uses too — and written at
+ *   once, synchronously, on the way out, because a debounce that loses its last write loses exactly
+ *   the setting somebody changed before quitting.
+ * - **Fullscreen** is read back after it is asked for, since a window manager may refuse, and a
+ *   size is refused while the window covers a display.
+ * - **Closing** asks a game that registered to be asked, and waits for it at most three seconds; a
+ *   game that did not is closed at once.
+ *
+ * What it gives up: SDL 2 reports no scale for a display, so a display the window is not on reads
+ * 1; the store has no cloud; and `platform` answers that no store's features are here.
+ */
+import { readStoreFile, writeStoreFile, writeStoreFileSync } from '@driftengine/package/store';
+/** The desktop shell's figures (`main/ipc.ts`), for the same reasons. */
+const WRITE_DEBOUNCE_MS = 250;
+const QUIT_GRACE_MS = 3000;
+const idOf = (display) => `${display.name ?? ''}@${display.geometry.x},${display.geometry.y}`;
+/**
+ * No file dialog on this desktop: a cancelled pick and a refused save, which a game already handles,
+ * and one line saying why, so a player whose picker never opens is told what to install.
+ */
+function noFiles() {
+    let said = false;
+    const say = () => {
+        if (said)
+            return;
+        said = true;
+        console.warn('[driftengine] this desktop has no file dialog for the native host: install zenity');
+    };
+    return {
+        openFile: () => {
+            say();
+            return Promise.resolve(null);
+        },
+        saveFile: () => {
+            say();
+            return Promise.resolve(false);
+        },
+    };
+}
+export function nativeBridge(options) {
+    const { window, storePath } = options;
+    const snapshot = readStoreFile(storePath);
+    const entries = new Map(Object.entries(snapshot));
+    let pending = null;
+    const flush = () => {
+        pending = null;
+        void writeStoreFile(storePath, entries).catch((cause) => console.error('[driftengine] could not write the store:', cause));
+    };
+    const schedule = () => {
+        if (pending === null)
+            pending = setTimeout(flush, WRITE_DEBOUNCE_MS);
+    };
+    const flushSync = () => {
+        if (pending === null)
+            return;
+        clearTimeout(pending);
+        pending = null;
+        try {
+            writeStoreFileSync(storePath, entries);
+        }
+        catch (cause) {
+            console.error('[driftengine] could not write the store on the way out:', cause);
+        }
+    };
+    /* One decision for the two members that need it, as the desktop shell's `resizable` is. */
+    const resizable = () => !window.fullscreen;
+    const quitHandlers = new Set();
+    let grace = null;
+    const quit = () => {
+        if (grace !== null)
+            clearTimeout(grace);
+        grace = null;
+        flushSync();
+        options.quit();
+    };
+    window.on('beforeClose', (event) => {
+        if (quitHandlers.size === 0) {
+            quit();
+            return;
+        }
+        event.prevent?.();
+        for (const handler of quitHandlers)
+            handler();
+        /* A ceiling, not a wait: a game that answers with `requestQuit` closes at once. */
+        grace ??= setTimeout(quit, QUIT_GRACE_MS);
+    });
+    const files = options.files ?? noFiles();
+    return {
+        storeSnapshot: snapshot,
+        writeKey(key, value) {
+            entries.set(key, value);
+            schedule();
+        },
+        removeKey(key) {
+            entries.delete(key);
+            schedule();
+        },
+        flushSync,
+        setFullscreen(on) {
+            window.setFullscreen(on);
+            return Promise.resolve();
+        },
+        isFullscreen: () => window.fullscreen,
+        refreshHz: () => (window.display.frequency > 0 ? window.display.frequency : null),
+        mode: () => (window.fullscreen ? 'fullscreen' : 'windowed'),
+        setMode(mode) {
+            window.setFullscreen(mode === 'fullscreen');
+            /* Read back rather than assumed: a window manager may refuse. */
+            return Promise.resolve(window.fullscreen === (mode === 'fullscreen'));
+        },
+        size: () => ({ width: window.width, height: window.height }),
+        canSetSize: resizable,
+        setSize(width, height) {
+            if (!resizable())
+                return Promise.resolve(false);
+            window.setSize(Math.round(width), Math.round(height));
+            return Promise.resolve(true);
+        },
+        displays() {
+            const on = idOf(window.display);
+            return options.displays().map((display, at) => ({
+                id: idOf(display),
+                /* A size where there is no name, which is what somebody choosing a monitor recognises. */
+                label: display.name !== null && display.name.length > 0
+                    ? display.name
+                    : `${display.geometry.width}x${display.geometry.height}`,
+                width: display.geometry.width,
+                height: display.geometry.height,
+                scale: idOf(display) === on ? window.pixelWidth / window.width : 1,
+                refreshHz: display.frequency > 0 ? display.frequency : null,
+                /* SDL lists the primary display first. */
+                primary: at === 0,
+            }));
+        },
+        onFocusChange(handler) {
+            const focus = () => handler(true);
+            const blur = () => handler(false);
+            window.on('focus', focus);
+            window.on('blur', blur);
+            return () => {
+                window.off('focus', focus);
+                window.off('blur', blur);
+            };
+        },
+        onQuitRequest(handler) {
+            quitHandlers.add(handler);
+            return () => quitHandlers.delete(handler);
+        },
+        canQuit: true,
+        requestQuit: quit,
+        openFile: (accept) => files.openFile(accept),
+        saveFile: (name, bytes) => files.saveFile(name, bytes),
+        platform: {
+            available: false,
+            unlockAchievement: () => undefined,
+            setRichPresence: () => undefined,
+        },
+    };
+}