@driftengine/native-host 4.0.0

package/dist/dialogs.js

@@ -0,0 +1,85 @@
+/**
+ * Open and save dialogs from the desktop, since SDL 2 gives a window none.
+ *
+ * **The desktop's own dialog program, asked and waited for**: zenity, which GNOME and the GTK
+ * desktops carry, and kdialog where zenity is not installed. What comes back is what the desktop
+ * shell hands a game (`main/ipc.ts`): a picked file's name and bytes, `null` for a cancelled pick,
+ * and `false` for a cancelled save — a cancellation being exit code 1 for both programs.
+ *
+ * **A filter is the extensions the game named**, `.json` becoming `*.json`; a MIME type has no
+ * pattern either program takes, so it is left out rather than guessed at.
+ *
+ * What it gives up: Windows and macOS, which carry neither program and are Task 7's; the desktop
+ * portal, which is what a sandboxed Linux build would need and answers over D-Bus signals rather
+ * than an exit code; and where neither program is installed, `desktopFiles` answers null and the
+ * bridge reports every pick cancelled.
+ */
+import { spawn } from 'node:child_process';
+import { accessSync, constants } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { basename, delimiter, join } from 'node:path';
+const spawnRunner = (command, args) => new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'ignore'] });
+    let stdout = '';
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+        stdout += chunk;
+    });
+    child.once('error', reject);
+    child.once('close', (code) => resolve({ code: code ?? 1, stdout }));
+});
+/** Whether `name` is an executable on the search path. */
+function onPath(name) {
+    for (const directory of (process.env['PATH'] ?? '').split(delimiter)) {
+        try {
+            accessSync(join(directory, name), constants.X_OK);
+            return true;
+        }
+        catch {
+            /* Not in this one. */
+        }
+    }
+    return false;
+}
+const patternsOf = (accept) => accept.filter((entry) => entry.startsWith('.')).map((extension) => `*${extension}`);
+/** The chosen path, or null when the person cancelled; anything else is a fault and says so. */
+function chosen(command, answer) {
+    if (answer.code === 0)
+        return answer.stdout.replace(/\r?\n$/, '');
+    if (answer.code !== 1)
+        console.warn(`[driftengine] ${command} ended with code ${answer.code}`);
+    return null;
+}
+export function desktopFiles(available = onPath, run = spawnRunner) {
+    const command = available('zenity') ? 'zenity' : available('kdialog') ? 'kdialog' : null;
+    if (command === null)
+        return null;
+    const zenity = command === 'zenity';
+    return {
+        async openFile(accept) {
+            const patterns = patternsOf(accept);
+            const args = zenity
+                ? [
+                    '--file-selection',
+                    ...(patterns.length > 0
+                        ? [`--file-filter=${patterns.join(' ')} | ${patterns.join(' ')}`]
+                        : []),
+                ]
+                : ['--getopenfilename', '.', ...(patterns.length > 0 ? [patterns.join(' ')] : [])];
+            const path = chosen(command, await run(command, args));
+            if (path === null)
+                return null;
+            return { name: basename(path), bytes: new Uint8Array(await readFile(path)) };
+        },
+        async saveFile(name, bytes) {
+            const args = zenity
+                ? ['--file-selection', '--save', `--filename=${name}`]
+                : ['--getsavefilename', name];
+            const path = chosen(command, await run(command, args));
+            if (path === null)
+                return false;
+            await writeFile(path, bytes);
+            return true;
+        },
+    };
+}

package/dist/domEvents.d.ts

@@ -0,0 +1,37 @@
+/**
+ * What SDL tells a window, as the events a page hears: keys, the mouse, the wheel, focus,
+ * visibility, resizing and closing.
+ *
+ * **The engine's input is not changed for this host.** `InputSource` listens on `window`,
+ * `document` and its canvas for the events a browser sends, and so do the scenes, so they are sent
+ * here in that shape: each the browser's class (`uiEvents.ts`), a key by its `code` and with the
+ * character the layout typed (`keyEvents.ts`), a button in the browser's numbering, the wheel in
+ * the browser's direction. Each is dispatched at the canvas, or at what has the focus, and the tree
+ * (`domTree.ts`) captures and bubbles it as a browser's does.
+ *
+ * The mouse is `mouseEvents.ts`, which says what Chrome sends for it; keys are `keyEvents.ts`.
+ *
+ * Fingers are `touchEvents.ts`.
+ */
+import type { NativeCanvas } from './canvas.ts';
+import { type EventMouse } from './mouseEvents.ts';
+import type { HostPage } from './page.ts';
+export type { EventMouse } from './mouseEvents.ts';
+/** What this reads of an SDL window: its events, where it is on the screen, and its size. */
+export interface EventWindow {
+    on(type: string, listener: (event: never) => void): unknown;
+    off(type: string, listener: (event: never) => void): unknown;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    /** Whether SDL has the window fullscreen, and the way to ask; a window without them has none. */
+    readonly fullscreen?: boolean;
+    setFullscreen?(on: boolean): void;
+}
+export interface EventOptions {
+    /** The clock clicks are counted against, in milliseconds. */
+    readonly now?: () => number;
+}
+/** Connect `window`'s events to `page` and `canvas`, and hand back what disconnects them. */
+export declare function connectDomEvents(window: EventWindow, mouse: EventMouse, page: HostPage, canvas: NativeCanvas, options?: EventOptions): () => void;

package/dist/domEvents.js

@@ -0,0 +1,145 @@
+/**
+ * What SDL tells a window, as the events a page hears: keys, the mouse, the wheel, focus,
+ * visibility, resizing and closing.
+ *
+ * **The engine's input is not changed for this host.** `InputSource` listens on `window`,
+ * `document` and its canvas for the events a browser sends, and so do the scenes, so they are sent
+ * here in that shape: each the browser's class (`uiEvents.ts`), a key by its `code` and with the
+ * character the layout typed (`keyEvents.ts`), a button in the browser's numbering, the wheel in
+ * the browser's direction. Each is dispatched at the canvas, or at what has the focus, and the tree
+ * (`domTree.ts`) captures and bubbles it as a browser's does.
+ *
+ * The mouse is `mouseEvents.ts`, which says what Chrome sends for it; keys are `keyEvents.ts`.
+ *
+ * Fingers are `touchEvents.ts`.
+ */
+import { KeyEvents } from './keyEvents.js';
+import { MouseModel } from './mouseEvents.js';
+import { TouchModel } from './touchEvents.js';
+const ESCAPE = 41;
+/** The modifier keys by scancode, both sides of each, as the bits `modifiers` keeps. */
+const MODIFIER = new Map([
+    [224, 1],
+    [228, 1],
+    [225, 2],
+    [229, 2],
+    [226, 4],
+    [230, 4],
+    [227, 8],
+    [231, 8],
+]);
+/** Connect `window`'s events to `page` and `canvas`, and hand back what disconnects them. */
+export function connectDomEvents(window, mouse, page, canvas, options = {}) {
+    const keys = new KeyEvents(() => page.keyTarget(), () => page.userActivation.notify());
+    /*
+     * **Leaving puts the window back as it was**, not into a window: one already fullscreen before the
+     * page asked — a game packaged fullscreen, or put there by the shell's bridge — stays so, as a
+     * browser under F11 stays fullscreen when a page's element leaves.
+     */
+    let before = false;
+    page.setFullscreener((on) => {
+        if (window.setFullscreen === undefined)
+            return false;
+        try {
+            if (on)
+                before = window.fullscreen === true;
+            window.setFullscreen(on || before);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    /* Which modifiers are down, so a pointer event can say, as a browser's does. */
+    let modifiers = 0;
+    const held = () => ({
+        ctrlKey: (modifiers & 1) !== 0,
+        shiftKey: (modifiers & 2) !== 0,
+        altKey: (modifiers & 4) !== 0,
+        metaKey: (modifiers & 8) !== 0,
+    });
+    const now = options.now ?? (() => performance.now());
+    const pointer = new MouseModel(window, mouse, page, canvas, held, now);
+    const fingers = new TouchModel(window, page, canvas, held, now);
+    canvas.cursorer = (css) => pointer.cursor(css);
+    /* SDL makes a mouse of every finger, which the finger's own events have already said. */
+    const mouseOnly = (handle) => (event) => {
+        if (event.touch !== true)
+            handle(event);
+    };
+    const listeners = [
+        [
+            'keyDown',
+            (event) => {
+                /* Escape is the browser's before it is the page's: it lets go of the lock and fullscreen. */
+                if (event.scancode === ESCAPE && pointer.isLocked)
+                    page.unlock();
+                if (event.scancode === ESCAPE)
+                    void page.document.exitFullscreen().catch(() => undefined);
+                modifiers |= MODIFIER.get(event.scancode) ?? 0;
+                keys.down(event);
+            },
+        ],
+        ['textInput', ({ text }) => keys.text(text)],
+        [
+            'keyUp',
+            (event) => {
+                modifiers &= ~(MODIFIER.get(event.scancode) ?? 0);
+                keys.up(event);
+            },
+        ],
+        ['mouseMove', mouseOnly((event) => pointer.move(event))],
+        ['mouseButtonDown', mouseOnly((event) => pointer.down(event))],
+        ['mouseButtonUp', mouseOnly((event) => pointer.up(event))],
+        ['mouseWheel', mouseOnly((event) => pointer.wheel(event))],
+        ['fingerDown', (event) => fingers.down(event)],
+        ['fingerMove', (event) => fingers.move(event)],
+        ['fingerUp', (event) => fingers.up(event)],
+        ['hover', () => pointer.hover()],
+        ['leave', () => pointer.leave()],
+        ['focus', () => page.setFocused(true)],
+        [
+            'blur',
+            () => {
+                page.unlock();
+                /* A key released in another window is never heard here. */
+                modifiers = 0;
+                page.setFocused(false);
+            },
+        ],
+        ['minimize', () => page.setVisible(false)],
+        ['hide', () => page.setVisible(false)],
+        ['restore', () => page.setVisible(true)],
+        ['show', () => page.setVisible(true)],
+        ['maximize', () => page.setVisible(true)],
+        /* After the host's own listener has resized the canvas, which it registered first. */
+        [
+            'resize',
+            () => {
+                /* Taken out of fullscreen by something other than the page: the element leaves with it. */
+                if (window.fullscreen === false)
+                    page.fullscreen.lost();
+                page.window.dispatchEvent(new Event('resize'));
+                /* A query about the window's size or shape may now answer otherwise. */
+                page.media.changed();
+            },
+        ],
+        ['beforeClose', () => page.window.dispatchEvent(new Event('beforeunload'))],
+    ];
+    /* A key held for its text is sent before anything that happened after it. */
+    for (const entry of listeners) {
+        const [type, listener] = entry;
+        if (type === 'keyDown' || type === 'textInput')
+            continue;
+        entry[1] = (event) => {
+            keys.flush();
+            listener(event);
+        };
+    }
+    for (const [type, listener] of listeners)
+        window.on(type, listener);
+    return () => {
+        for (const [type, listener] of listeners)
+            window.off(type, listener);
+    };
+}

package/dist/domTree.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The three nodes a host's page has — window, document and canvas, each the parent of the next —
+ * and a browser's dispatch across them: capture from the window down, the target, then bubbling
+ * back up.
+ *
+ * **Node's `EventTarget` has no tree**, so an event sent to each node in turn reaches a window's
+ * capture listener last rather than first, tells a listener on the window that the window was its
+ * target, and lets a passive listener cancel it. Each of those is a page behaving differently here
+ * than in Chrome — the engine's own `requestFullscreenOnGesture` listens on the window in the
+ * capture phase — so dispatch is the DOM's, for the one shape of tree this host has.
+ *
+ * **Event handler attributes are listeners**, as the HTML specification makes them: `onclick`
+ * assigned is added to the list at that moment, keeps its place when reassigned, and a handler
+ * returning `false` cancels the event. A page reached for them — `canvas.ondblclick` — and on a
+ * bare `EventTarget` an assignment is a property nothing reads.
+ *
+ * What it gives up: no shadow roots, no `composed`, and no retargeting, none of which a canvas
+ * with nothing inside it can need.
+ */
+/** The `on…` attributes for `Types`, as a class declares them for the checker. */
+export type Handlers<Types extends string> = {
+    [Type in Types as `on${Type}`]: ((event: Event) => unknown) | null;
+};
+export declare class HostNode implements EventTarget {
+    parentNode: HostNode | null;
+    private readonly listeners;
+    private readonly handlers;
+    addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
+    dispatchEvent(event: Event): boolean;
+    /** `on<type>`, for each type given: a listener held in place, replaced by assignment. */
+    protected static handles(prototype: object, types: readonly string[]): void;
+    private invoke;
+}

package/dist/domTree.js

@@ -0,0 +1,194 @@
+/**
+ * The three nodes a host's page has — window, document and canvas, each the parent of the next —
+ * and a browser's dispatch across them: capture from the window down, the target, then bubbling
+ * back up.
+ *
+ * **Node's `EventTarget` has no tree**, so an event sent to each node in turn reaches a window's
+ * capture listener last rather than first, tells a listener on the window that the window was its
+ * target, and lets a passive listener cancel it. Each of those is a page behaving differently here
+ * than in Chrome — the engine's own `requestFullscreenOnGesture` listens on the window in the
+ * capture phase — so dispatch is the DOM's, for the one shape of tree this host has.
+ *
+ * **Event handler attributes are listeners**, as the HTML specification makes them: `onclick`
+ * assigned is added to the list at that moment, keeps its place when reassigned, and a handler
+ * returning `false` cancels the event. A page reached for them — `canvas.ondblclick` — and on a
+ * bare `EventTarget` an assignment is a property nothing reads.
+ *
+ * What it gives up: no shadow roots, no `composed`, and no retargeting, none of which a canvas
+ * with nothing inside it can need.
+ */
+const CAPTURING = 1;
+const AT_TARGET = 2;
+const BUBBLING = 3;
+const dispatches = new WeakMap();
+function optionsOf(options) {
+    if (typeof options === 'boolean')
+        return { capture: options, once: false, passive: false };
+    return {
+        capture: options?.capture === true,
+        once: options?.once === true,
+        passive: options?.passive === true,
+        signal: options?.signal,
+    };
+}
+/** Give `event` the accessors a dispatch answers, once; Node's own are read-only slots. */
+function adopt(event, dispatch) {
+    const known = dispatches.has(event);
+    dispatches.set(event, dispatch);
+    if (known)
+        return;
+    const own = (name, get) => Object.defineProperty(event, name, { get, configurable: true });
+    const now = () => dispatches.get(event);
+    own('target', () => now().target);
+    own('srcElement', () => now().target);
+    own('currentTarget', () => now().current);
+    own('eventPhase', () => now().phase);
+    Object.defineProperty(event, 'composedPath', {
+        value: () => (now().current === null ? [] : [...now().path]),
+        configurable: true,
+    });
+    const stop = event.stopPropagation.bind(event);
+    const stopNow = event.stopImmediatePropagation.bind(event);
+    Object.defineProperty(event, 'stopPropagation', {
+        value: () => {
+            now().stopped = true;
+            stop();
+        },
+        configurable: true,
+    });
+    Object.defineProperty(event, 'stopImmediatePropagation', {
+        value: () => {
+            now().stopped = true;
+            now().stoppedNow = true;
+            stopNow();
+        },
+        configurable: true,
+    });
+}
+export class HostNode {
+    parentNode = null;
+    listeners = new Map();
+    handlers = new Map();
+    addEventListener(type, callback, options) {
+        if (callback === null)
+            return;
+        const { capture, once, passive, signal } = optionsOf(options);
+        if (signal?.aborted === true)
+            return;
+        const list = this.listeners.get(type) ?? [];
+        if (list.some((l) => l.callback === callback && l.capture === capture))
+            return;
+        list.push({ callback, capture, once, passive, removed: false });
+        this.listeners.set(type, list);
+        signal?.addEventListener('abort', () => this.removeEventListener(type, callback, capture));
+    }
+    removeEventListener(type, callback, options) {
+        const capture = typeof options === 'boolean' ? options : options?.capture === true;
+        const list = this.listeners.get(type);
+        const at = list?.findIndex((l) => l.callback === callback && l.capture === capture) ?? -1;
+        if (list === undefined || at < 0)
+            return;
+        list[at].removed = true;
+        list.splice(at, 1);
+    }
+    dispatchEvent(event) {
+        const path = [];
+        for (let node = this; node !== null; node = node.parentNode)
+            path.push(node);
+        const dispatch = {
+            target: this,
+            current: null,
+            phase: 0,
+            path,
+            stopped: false,
+            stoppedNow: false,
+        };
+        adopt(event, dispatch);
+        for (let at = path.length - 1; at > 0 && !dispatch.stopped; at -= 1) {
+            path[at].invoke(event, dispatch, CAPTURING, true);
+        }
+        if (!dispatch.stopped)
+            this.invoke(event, dispatch, AT_TARGET, true);
+        if (!dispatch.stopped)
+            this.invoke(event, dispatch, AT_TARGET, false);
+        for (let at = 1; at < path.length && event.bubbles && !dispatch.stopped; at += 1) {
+            path[at].invoke(event, dispatch, BUBBLING, false);
+        }
+        dispatch.current = null;
+        dispatch.phase = 0;
+        return !event.defaultPrevented;
+    }
+    /** `on<type>`, for each type given: a listener held in place, replaced by assignment. */
+    static handles(prototype, types) {
+        for (const type of types) {
+            Object.defineProperty(prototype, `on${type}`, {
+                configurable: true,
+                get() {
+                    return this.handlers.get(type)?.value ?? null;
+                },
+                set(value) {
+                    const held = this.handlers.get(type);
+                    if (typeof value !== 'function') {
+                        if (held !== undefined)
+                            this.removeEventListener(type, held.listener);
+                        this.handlers.delete(type);
+                        return;
+                    }
+                    if (held !== undefined) {
+                        held.value = value;
+                        return;
+                    }
+                    const slot = {
+                        value,
+                        listener: (event) => {
+                            const result = slot.value.call(this, event);
+                            if (result === false)
+                                event.preventDefault();
+                        },
+                    };
+                    this.handlers.set(type, slot);
+                    this.addEventListener(type, slot.listener);
+                },
+            });
+        }
+    }
+    invoke(event, dispatch, phase, capture) {
+        const list = this.listeners.get(event.type);
+        if (list === undefined)
+            return;
+        dispatch.current = this;
+        dispatch.phase = phase;
+        for (const listener of [...list]) {
+            if (listener.removed || listener.capture !== capture)
+                continue;
+            if (listener.once)
+                this.removeEventListener(event.type, listener.callback, capture);
+            const passive = listener.passive;
+            if (passive)
+                Object.defineProperty(event, 'preventDefault', {
+                    value: () => undefined,
+                    configurable: true,
+                });
+            try {
+                const { callback } = listener;
+                if (typeof callback === 'function')
+                    callback.call(this, event);
+                else
+                    callback.handleEvent(event);
+            }
+            catch (error) {
+                /*
+                 * Reported, and the rest still run: a browser logs an uncaught error in a listener and
+                 * carries on dispatching, where a rethrow here would end the host's process.
+                 */
+                console.error(error);
+            }
+            finally {
+                if (passive)
+                    delete event.preventDefault;
+            }
+            if (dispatch.stoppedNow)
+                return;
+        }
+    }
+}

package/dist/dualRumble.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A pad's `vibrationActuator`, the standard's `dual-rumble` effect, driven through SDL's rumble.
+ *
+ * The strong magnitude drives the low-frequency motor and the weak one the high-frequency motor,
+ * the pair every rumbling pad has. A later effect preempts the one playing, whose promise then
+ * settles `preempted`, as the standard describes; one that runs its course settles `complete`.
+ */
+/** What this drives of an SDL pad, a controller's or a joystick's. */
+export interface Rumbler {
+    rumble(low: number, high: number, durationMs: number): void;
+    stopRumble(): void;
+}
+export interface DualRumble {
+    readonly type: 'dual-rumble';
+    readonly effects: readonly string[];
+    playEffect(type: string, params: Readonly<Record<string, number>>): Promise<string>;
+    reset(): Promise<string>;
+}
+export declare function dualRumble(motors: Rumbler): DualRumble;

package/dist/dualRumble.js

@@ -0,0 +1,47 @@
+/**
+ * A pad's `vibrationActuator`, the standard's `dual-rumble` effect, driven through SDL's rumble.
+ *
+ * The strong magnitude drives the low-frequency motor and the weak one the high-frequency motor,
+ * the pair every rumbling pad has. A later effect preempts the one playing, whose promise then
+ * settles `preempted`, as the standard describes; one that runs its course settles `complete`.
+ */
+export function dualRumble(motors) {
+    let settle = null;
+    let timer = null;
+    const finish = (result) => {
+        if (timer !== null)
+            clearTimeout(timer);
+        timer = null;
+        const settling = settle;
+        settle = null;
+        settling?.(result);
+    };
+    return {
+        type: 'dual-rumble',
+        effects: ['dual-rumble'],
+        playEffect(type, params) {
+            if (type !== 'dual-rumble') {
+                return Promise.reject(new Error(`[driftengine] the native host plays no ${type} effect`));
+            }
+            finish('preempted');
+            const duration = params['duration'] ?? 0;
+            const delay = params['startDelay'] ?? 0;
+            return new Promise((resolve) => {
+                settle = resolve;
+                const start = () => {
+                    motors.rumble(params['strongMagnitude'] ?? 0, params['weakMagnitude'] ?? 0, duration);
+                    timer = setTimeout(() => finish('complete'), duration);
+                };
+                if (delay > 0)
+                    timer = setTimeout(start, delay);
+                else
+                    start();
+            });
+        },
+        reset() {
+            finish('preempted');
+            motors.stopRumble();
+            return Promise.resolve('complete');
+        },
+    };
+}

package/dist/eventClasses.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Put the browser's input event classes on the global a page reads them from, where the runtime
+ * has none, and hand back what takes them away again. Node has `Event` and none of these.
+ */
+/** A pad arriving or leaving, as `gamepadconnected` and `gamepaddisconnected` carry it. */
+export declare class GamepadEvent extends Event {
+    readonly gamepad: unknown;
+    constructor(type: string, init: EventInit & {
+        gamepad: unknown;
+    });
+}
+export declare function installEventClasses(scope?: Record<string, unknown>): () => void;

package/dist/eventClasses.js

@@ -0,0 +1,35 @@
+/**
+ * Put the browser's input event classes on the global a page reads them from, where the runtime
+ * has none, and hand back what takes them away again. Node has `Event` and none of these.
+ */
+import { FocusEvent, KeyboardEvent, MouseEvent, PointerEvent, UIEvent, WheelEvent, } from './uiEvents.js';
+import { Touch, TouchEvent, TouchList } from './uiTouch.js';
+/** A pad arriving or leaving, as `gamepadconnected` and `gamepaddisconnected` carry it. */
+export class GamepadEvent extends Event {
+    gamepad;
+    constructor(type, init) {
+        super(type, init);
+        this.gamepad = init.gamepad;
+    }
+}
+const CLASSES = {
+    UIEvent,
+    FocusEvent,
+    MouseEvent,
+    WheelEvent,
+    PointerEvent,
+    KeyboardEvent,
+    Touch,
+    TouchList,
+    TouchEvent,
+    GamepadEvent,
+};
+export function installEventClasses(scope = globalThis) {
+    const added = Object.entries(CLASSES).filter(([name]) => !(name in scope));
+    for (const [name, value] of added)
+        scope[name] = value;
+    return () => {
+        for (const [name] of added)
+            delete scope[name];
+    };
+}

package/dist/files.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The page's own files, answered from disk: the `fetch` a scene calls, under a host.
+ *
+ * **A published scene fetches by a path relative to its page**: the showroom's model, the voxel
+ * sandbox's tiles. A browser resolves that against the server that sent the page, and a host has no
+ * server — so it answers those paths from the directory the dev server serves (`demo/dev/public`),
+ * and a `file:` URL, which is what `new URL(path, import.meta.url)` makes, as the file it names.
+ * Anything carrying a scheme of its own is the network's, and goes to the platform's `fetch`.
+ *
+ * **A missing file is a 404, not a throw**, because that is what the scenes already handle: the
+ * sandbox paints a missing tile magenta, and the showroom asks with `HEAD` whether a model is there.
+ * A path that climbs out of the served directory is a 404 too, as it would be from a server.
+ */
+type Fetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export declare function hostFetch(root: string, network: Fetch): Fetch;
+export {};