@thunderclap-engine/engine 0.0.0-stage → 1.1.0

package/dist/core/game.js

@@ -0,0 +1,530 @@
+/// <reference path="../platform/xr-types.d.ts" preserve="true" />
+/**
+ * `createGame` (D-041 Phase 1): the noun-free wiring every ThunderClap game starts from.
+ *
+ * It blocks browser zoom, boots WebGPU on a letterboxed surface and builds, in this order:
+ * renderer, post stack, particles, host, the game's save (if any), overlay and pad navigation,
+ * audio (mixer persisted through the host), the game's tick clock, input with its gestures (on
+ * that clock) and pointer router, the scene stack and the frame loop (frames come from the
+ * host). It also wires the page lifecycle (hide, pagehide and freeze stop frames and flush the
+ * save; show resumes), the host's app lifecycle (`background` stops frames and flushes the save,
+ * `active` resumes) and device loss (the reload screen, then loop, audio and captions halt for
+ * good).
+ *
+ * The surface letterboxes the design space; what the overlay's layout leaves free of UI is
+ * `ctx.ui.layout.freeRect`, and a 2D game frames its world into it with
+ * `ctx.camera.fitFreeRect(worldRect, ctx.ui.layout.freeRect, ctx.surface)`. Scenes draw through
+ * `ctx.camera` (`Scene.render(frame, camera, alpha)`); the loop calls
+ * `renderer.render(frame, ctx.camera)` once per frame.
+ *
+ * Two parts are opt-in, so a pure client of a server-authoritative game (VISION pillar 6) uses
+ * the same wiring: `save` (omit it and `ctx.save` is null, and nothing touches `host.storage`)
+ * and the fixed-step sim (`sim: false` runs the loop at render rate, `hooks.frame` each frame).
+ *
+ * Games add their nouns by extending the returned object (`Object.assign(ctx, { ... })`): the
+ * scene stack hands scenes this same object, so a scene typed against the game's own ctx sees
+ * them. Game logic plugs into the frame and the lifecycle through `ctx.hooks`.
+ *
+ * Headless (ws/core-8): given `gpu` (a fake device in a test) `createGame` skips the WebGPU
+ * boot and its fatal screens and mounts the surface without a GPU canvas context; with `clock`
+ * the game runs on that tick clock and with `host` on that host's frames. `root` may then be
+ * left out. The overlay still needs a DOM (happy-dom in Vitest). `@thunderclap-engine/engine/testing`
+ * `createTestGame` wires the fakes in.
+ *
+ * VR is one call (`ctx.xr.enter()`, ws/xr): frames then come from the session through an XR
+ * host, the scenes record once through the surface's head camera and the renderer draws each
+ * eye into the surface's HDR scene target and resolves it through the post stack into the
+ * session's layer (ws/xr-post); controllers and hands join `ctx.pointers`. Leaving (`exit()` or
+ * the session ending) puts everything back; a game that never enters runs the same code as before.
+ */
+import { AudioEngine, persistMixer } from '../audio/index.js';
+import { ParticleSystem } from '../fx/index.js';
+import { createWebHost, createXrHost, } from '../host/index.js';
+import { createGestures, createInputPlayback, createInputRecorder, createPointerRouter, createTickClock, Input, XrPointerSource, } from '../input/index.js';
+import { blockBrowserZoom, boot, mountSurface, watchLifecycle, XrSurface, } from '../platform/index.js';
+import { PostStack } from '../post/index.js';
+import { installGpuErrorLogging, Renderer, } from '../render/index.js';
+import { applyTextScale, createOverlay, followSafeArea, PadNav, } from '../ui/index.js';
+import { DetachedSurface, NO_DOM } from './detached-surface.js';
+import { GameLoop } from './loop.js';
+import { SceneStack } from './scene.js';
+/**
+ * Boots WebGPU and builds the engine ctx. Resolves `null` when WebGPU is unavailable: the
+ * engine has already shown the unsupported screen and there is nothing more to do.
+ *
+ * Nothing runs until the game calls `ctx.loop.start()`, except the lifecycle handlers (a show
+ * starts the loop) and resize, which keeps the renderer and overlay in step.
+ */
+export async function createGame(opts) {
+    const design = { width: opts.design?.width ?? 1920, height: opts.design?.height ?? 1080 };
+    const surfaceOpts = {
+        ...opts.surface,
+        logicalWidth: design.width,
+        logicalHeight: design.height,
+    };
+    // `overlay: false` (ws/core-9): no DOM is touched from here on.
+    const dom = opts.overlay !== false;
+    let res;
+    if (!dom) {
+        if (!opts.gpu || !opts.host) {
+            throw new Error('createGame: `overlay: false` needs `gpu` and `host` (it touches no DOM)');
+        }
+        res = gpuBoot(new DetachedSurface(surfaceOpts), opts.gpu);
+    }
+    else {
+        const root = opts.root ?? (opts.gpu ? globalThis.document?.createElement('div') : undefined);
+        if (!root) {
+            throw new Error('createGame: `root` is required (a headless game passes `gpu` and a DOM, or `overlay: false`)');
+        }
+        // Before boot, so it holds from the first frame (and on the fatal screens too).
+        if (opts.blockBrowserZoom !== false)
+            blockBrowserZoom(root.ownerDocument);
+        const booted = opts.gpu
+            ? gpuBoot(mountSurface(root, surfaceOpts), opts.gpu)
+            : await boot(root, {
+                ...surfaceOpts,
+                title: opts.title,
+                forceUnsupported: opts.forceUnsupported,
+            });
+        if (!booted.ok)
+            return null;
+        res = booted;
+    }
+    const { surface, gpu } = res;
+    opts.onGpuReady?.(gpu);
+    installGpuErrorLogging(gpu.device);
+    // ── GPU ────────────────────────────────────────────────────────────────
+    const renderer = new Renderer(gpu, {
+        logicalWidth: design.width,
+        logicalHeight: design.height,
+        aux: opts.aux,
+    });
+    const post = new PostStack(renderer, opts.post);
+    renderer.post = post;
+    const particles = new ParticleSystem(renderer, opts.particles);
+    // ── Host, save + overlay ───────────────────────────────────────────────
+    const host = opts.host ?? createWebHost();
+    // No save, no storage access: a pure client keeps nothing on the device.
+    const save = (opts.save ? opts.save(host) : null);
+    let ui = null;
+    if (dom) {
+        opts.styles?.(surface.root.ownerDocument);
+        // When a panel closes and its opener can't take focus back, focus returns to the canvas so
+        // keys keep reaching the game.
+        const overlay = createOverlay({
+            parent: surface.root,
+            designWidth: design.width,
+            designHeight: design.height,
+            layout: opts.layout,
+            focusHome: () => surface.canvas,
+            theme: opts.theme,
+            // `ui.anchors()` and `ui.floats()` without a camera follow the game's (ws/api-core).
+            camera: () => renderer.camera,
+        });
+        if (opts.textScale !== undefined && opts.textScale !== 1) {
+            applyTextScale(overlay.root, opts.textScale, (t) => overlay.setTheme(t));
+        }
+        // A host that knows the notch and home indicator pads the layout's regions by them.
+        if (host.safeArea)
+            followSafeArea(overlay.layout, host.safeArea);
+        ui = overlay;
+    }
+    // Input is blocked while a modal panel is up, so the pad drives panels through this. With no
+    // overlay there are no panels: the pad stays the game's.
+    const padNav = new PadNav(ui ? ui.stack : NO_PANELS, { getGamepads: opts.input.getGamepads });
+    surface.onResize(({ rect, backbuffer }) => {
+        renderer.resize(backbuffer.width, backbuffer.height);
+        ui?.setFrame(rect);
+    });
+    // ── Audio ──────────────────────────────────────────────────────────────
+    // Unlocks on the first gesture and pauses itself while the page is hidden (see attach).
+    // Without a DOM nothing unlocks it: it stays locked and silent.
+    const audio = new AudioEngine();
+    if (dom)
+        audio.attach();
+    if (opts.mixerKey)
+        persistMixer(audio, { game: opts.mixerKey, host });
+    // ── Input (blocked under modal panels) ─────────────────────────────────
+    const extraBlock = opts.input.blocked;
+    // Gestures and pointer rays link to the input: same block, same transform, same attach,
+    // advanced in `input.update()`. The rays go through whatever camera the renderer draws with:
+    // the head while a VR session runs (so a head-locked `WorldPanel` faces the headset).
+    // The gestures run on the game's tick clock (advanced by the loop below), so their timers
+    // are game time and a replay lands them on the same ticks.
+    const clock = opts.clock ?? createTickClock();
+    const gestures = createGestures({ magnify: opts.input.magnify, clock });
+    // While a session runs: its host (frames and the current `XRFrame`) and its surface (eyes).
+    let xrHost = null;
+    let xrSurface = null;
+    const pointers = createPointerRouter({
+        camera: () => xrSurface?.head ?? renderer.camera,
+        testers: opts.pointers?.testers,
+    });
+    const panels = ui?.stack;
+    const modal = panels ? () => panels.hasModal : () => false;
+    const input = new Input(opts.input.bindings, {
+        blocked: extraBlock ? () => modal() || extraBlock() : modal,
+        globalKeys: opts.input.globalKeys,
+        buttonKeys: opts.input.buttonKeys,
+        getGamepads: opts.input.getGamepads,
+        gestures,
+        pointers,
+    });
+    // A replay feeds the input itself: no DOM listeners, so a real key never leaks in (E-011).
+    // The playback drives the game's clock (ws/input-9): each fed tick advances it by the
+    // recording's tick spacing, so `playback.speed` above 1 keeps game time too.
+    const playback = opts.input.replay
+        ? createInputPlayback(input, opts.input.replay, { clock })
+        : null;
+    if (opts.input.record)
+        createInputRecorder(input);
+    // The recorded pointers are dispatched through a pointer target nothing real can reach (an
+    // element outside the page that keys are read from too), so the gestures, rays and any look
+    // see them on their recorded ticks and never a real pointer or key.
+    // Its box is the canvas's (ws/core-8), so a touch stick or touch zone, which measures the
+    // pointer against the box, replays where it was recorded.
+    // With `overlay: false` there is nothing to attach to: `detach()` only releases what is held.
+    const sink = dom ? surface.root.ownerDocument.createElement('div') : null;
+    const attachSink = sink
+        ? () => input.attach({ pointerTarget: sink, keyTarget: sink, bounds: surface.canvas })
+        : () => input.detach();
+    // Where the input lives outside a `ctx.replay`: the canvas, or the sink in replay mode.
+    const attachHome = playback || !sink ? attachSink : () => input.attach({ pointerTarget: surface.canvas });
+    attachHome();
+    input.setPointerTransform((x, y) => surface.clientToLogical(x, y));
+    // Overlay controls (ws/input-12): every button click reaches the input by its stable id, so a
+    // recording carries it; a replay's `ui` lane comes back as `'control'` and clicks the button
+    // with that id before the tick's update, on the tick it was clicked live.
+    if (ui) {
+        const overlay = ui;
+        overlay.onControl((id) => input.control(id));
+        input.on('control', (id) => {
+            overlay.activate(id);
+        });
+    }
+    /** The playback `ctx.replay` installed, until it ends or is stopped. */
+    let replaying = null;
+    /** Its `onEnd`, cleared by `stop()` so a stopped or replaced replay never reports an end. */
+    let replayEnd;
+    const replay = (recording, ropts = {}) => {
+        replaying?.stop();
+        input.playback?.detach();
+        // `attach` releases every key and button first, so nothing the player held leaks in.
+        attachSink();
+        // A live pointer source (the screen, an XR controller) is muted for the replay too: the
+        // sink stops the DOM ones, the mute the rest. Its remover lifts only this mute, so a mute
+        // the game set stays.
+        const unmute = pointers.mute();
+        const pb = createInputPlayback(input, recording, {
+            speed: ropts.speed,
+            tickMs: ropts.tickMs,
+            clock,
+        });
+        const uninstall = pb.detach;
+        pb.stop = pb.detach = () => {
+            uninstall();
+            unmute();
+            if (replaying !== pb)
+                return;
+            replaying = null;
+            replayEnd = undefined;
+            // Releases the recording's last held keys and buttons too.
+            attachHome();
+        };
+        replaying = pb;
+        replayEnd = ropts.onEnd;
+        return pb;
+    };
+    // ── Scenes + loop ──────────────────────────────────────────────────────
+    const hooks = {};
+    // The stack hands scenes this object on enter; the game fills in its nouns before then.
+    const ctx = {};
+    const stack = new SceneStack(ctx);
+    // With `sim: false` the loop calls update once per rendered frame with the real delta.
+    const fixed = opts.sim !== false;
+    const loop = new GameLoop({
+        update: (dt) => {
+            // A replay feeds this tick's events first: live, they arrived between the frames, while
+            // the clock still read the last tick. Then the clock moves by the step, before the
+            // input (and its gestures) update. A playback driving the clock has already moved it
+            // for each tick it fed; once the recording is done the step moves it again. The playback
+            // is read from the input each step, so one the game installs mid-session (a replay
+            // started from a menu: `createInputPlayback(ctx.input, rec, { clock: ctx.clock })`) is
+            // stepped here too, in the same order (ws/core-5).
+            // A `ctx.replay` whose recording ran out last step gives the input back here, before
+            // this step's update, so its last tick was updated with the replayed state (ws/core-6).
+            const pb = input.playback;
+            const fed = pb ? pb.step() : false;
+            if (!fed && replaying !== null && pb === replaying) {
+                const onEnd = replayEnd;
+                replaying.stop();
+                onEnd?.();
+            }
+            if (!fed || pb?.clock !== clock)
+                clock.advance(dt * 1000);
+            input.update();
+            padNav.update();
+            audio.update(dt);
+            if (fixed)
+                hooks.update?.(dt);
+            else
+                hooks.frame?.(dt);
+            particles.update(dt);
+            stack.update(dt);
+        },
+        render: (alpha, time) => {
+            hooks.beforeRender?.(time);
+            const frame = renderer.beginFrame(time.realTime, time.frameDt);
+            if (xrSurface && xrHost) {
+                // The scenes record once, through the head; each eye draws the record into the
+                // surface's HDR scene target and the post stack resolves it into the eye's part of
+                // the layer (ws/xr-post), so the headset sees what the screen would.
+                const xrFrame = xrHost.frame;
+                const eyes = xrFrame ? xrSurface.views(xrFrame) : NO_EYES;
+                stack.render(frame, xrSurface.head, alpha);
+                for (let i = 0; i < eyes.length; i++) {
+                    const eye = eyes[i];
+                    const scene = xrSurface.scene;
+                    renderer.render(frame, eye.camera, scene);
+                    renderer.resolve(scene, eye.target.color.view, eye.viewport);
+                }
+                renderer.endFrame({ present: false });
+            }
+            else {
+                // Read each frame: `ctx.setCamera` swaps it.
+                const camera = renderer.camera;
+                stack.render(frame, camera, alpha);
+                renderer.render(frame, camera);
+                renderer.endFrame();
+            }
+            hooks.afterRender?.(time);
+            ui?.updateAnchors();
+        },
+    }, { step: opts.sim ? opts.sim.step : undefined, fixed, frames: host });
+    // ── XR ─────────────────────────────────────────────────────────────────
+    let xrSession = null;
+    let xrEntering = null;
+    // Restores the page host, pointers and surface; set while a session runs, idempotent.
+    let leaveXr = null;
+    const xr = {
+        get active() {
+            return xrSession !== null;
+        },
+        get session() {
+            return xrSession;
+        },
+        get surface() {
+            return xrSurface;
+        },
+        async supported() {
+            const sys = globalThis.navigator?.xr;
+            if (!sys || !XrSurface.supported())
+                return false;
+            try {
+                return await sys.isSessionSupported('immersive-vr');
+            }
+            catch {
+                return false;
+            }
+        },
+        enter() {
+            if (xrSession)
+                return Promise.resolve();
+            if (xrEntering)
+                return xrEntering;
+            const sys = globalThis.navigator?.xr;
+            if (!sys || !XrSurface.supported()) {
+                return Promise.reject(new Error('WebXR with the WebGPU binding is not available here'));
+            }
+            const refType = opts.xr?.referenceSpace ?? 'local-floor';
+            xrEntering = (async () => {
+                const session = await sys.requestSession('immersive-vr', {
+                    requiredFeatures: ['webgpu', refType],
+                    optionalFeatures: ['hand-tracking'],
+                });
+                let referenceSpace;
+                try {
+                    referenceSpace = await session.requestReferenceSpace(refType);
+                }
+                catch (err) {
+                    await session.end().catch(() => { });
+                    throw err;
+                }
+                const surface = new XrSurface(session, gpu.device, {
+                    referenceSpace,
+                    scene: true,
+                    colorFormat: renderer.format,
+                    aux: opts.aux,
+                });
+                const sessionHost = createXrHost(session, host);
+                const source = new XrPointerSource(session, referenceSpace, () => sessionHost.frame);
+                const removeSource = pointers.addSource(source);
+                const onEnd = () => leaveXr?.();
+                leaveXr = () => {
+                    leaveXr = null;
+                    session.removeEventListener('end', onEnd);
+                    removeSource();
+                    loop.setFrames(host);
+                    xrHost = null;
+                    xrSurface = null;
+                    xrSession = null;
+                    surface.destroy();
+                    opts.xr?.onExit?.();
+                };
+                session.addEventListener('end', onEnd);
+                xrSession = session;
+                xrSurface = surface;
+                xrHost = sessionHost;
+                loop.setFrames(sessionHost);
+                opts.xr?.onEnter?.(session);
+            })().finally(() => {
+                xrEntering = null;
+            });
+            return xrEntering;
+        },
+        async exit() {
+            const session = xrSession;
+            if (!session)
+                return;
+            try {
+                await session.end();
+            }
+            finally {
+                // The `end` event normally restored everything; a session ending without it does here.
+                leaveXr?.();
+            }
+        },
+    };
+    // Hidden, pagehide (iOS app switch) or freeze (Android): stop drawing and persist now; a
+    // phone may kill a background tab without another word.
+    if (dom) {
+        watchLifecycle({
+            onHide: (reason) => {
+                loop.stop();
+                hooks.hide?.(reason);
+                save?.flush();
+            },
+            onShow: (reason) => {
+                if (loop.halted)
+                    return;
+                loop.start();
+                hooks.show?.(reason);
+            },
+        });
+    }
+    // ── Host lifecycle (ws/host-mobile) ────────────────────────────────────
+    // A host that knows the app's state (the web host from the page's visibility, a store app's
+    // from its shell): background stops frames and flushes the save, active resumes. On the web
+    // host the page events above have usually done both already (the loop is then stopped, so the
+    // flush is not repeated); a shell's state change without a page event does them here. Audio
+    // follows the document's visibility in `audio.attach`; a shell's background state also reaches
+    // it through `audio.background` (ws/audio-4), the same flag, so it is not suspended twice.
+    host.lifecycle?.watch((state) => {
+        audio.background(state === 'background');
+        if (state === 'background') {
+            if (loop.isRunning) {
+                loop.stop();
+                save?.flush();
+            }
+        }
+        else if (!loop.halted) {
+            loop.start();
+        }
+        hooks.lifecycle?.(state);
+    });
+    // Device lost: boot has shown the reload screen; stop all work behind it for good.
+    res.onDeviceLost((info) => {
+        loop.halt();
+        hooks.deviceLost?.(info);
+        void audio.halt();
+        ui?.caption.suspend(true);
+        save?.flush();
+    });
+    Object.assign(ctx, {
+        design,
+        surface,
+        gpu,
+        renderer,
+        camera: renderer.camera,
+        setCamera: (cam) => {
+            renderer.camera = cam;
+        },
+        post,
+        particles,
+        input,
+        clock,
+        replay,
+        gestures,
+        pointers,
+        padNav,
+        audio,
+        host,
+        save,
+        stack,
+        loop,
+        hooks,
+        onDeviceLost: res.onDeviceLost,
+        xr,
+    });
+    // `overlay: false`: `ctx.ui` throws instead of handing out an overlay that does not exist.
+    const liveUi = ui;
+    Object.defineProperty(ctx, 'ui', {
+        get: liveUi
+            ? () => liveUi
+            : () => {
+                throw new Error(NO_DOM('ctx.ui'));
+            },
+        enumerable: liveUi !== null,
+        configurable: true,
+    });
+    // `camera` follows `setCamera` (`Object.assign` copied a value).
+    Object.defineProperty(ctx, 'camera', {
+        get: () => renderer.camera,
+        enumerable: true,
+        configurable: true,
+    });
+    return ctx;
+}
+/**
+ * `boot` for a headless game (`CreateGameOptions.gpu`): the surface is the one given (mounted
+ * as usual, or detached with `overlay: false`), the GPU is the one given, and device loss comes
+ * from `gpu.device.lost` when the device has one (a reason of `destroyed` is an explicit
+ * `destroy()`, not a loss).
+ */
+function gpuBoot(surface, gpu) {
+    const listeners = new Set();
+    const lost = gpu.device.lost;
+    if (lost && typeof lost.then === 'function') {
+        void lost.then((info) => {
+            if (info.reason === 'destroyed')
+                return;
+            for (const fn of [...listeners]) {
+                try {
+                    fn(info);
+                }
+                catch (err) {
+                    console.error('[createGame] device-lost handler failed', err);
+                }
+            }
+        });
+    }
+    return {
+        ok: true,
+        surface,
+        gpu,
+        onDeviceLost(fn) {
+            listeners.add(fn);
+            return () => listeners.delete(fn);
+        },
+    };
+}
+/**
+ * `PadNav`'s stack with `overlay: false`: no panels, so the pad never leaves the game. PadNav
+ * reads only `padOwner` and `onPadOwnerChange`.
+ */
+const NO_PANELS = {
+    padOwner: 'game',
+    onPadOwnerChange: () => () => { },
+};
+/** What the XR render step iterates when the frame has no viewer pose. */
+const NO_EYES = [];

package/dist/core/hash.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Positional hashing (ws/core-3): a stable random value per lattice cell, for rolls that need a
+ * number per point rather than a field between points (a tree in this column, a speckle on this
+ * texel, a lantern on this floor). Noise is `createNoise`; a sequence is `createRandom`.
+ *
+ * The seed goes through `seedKey`, the same hash `createRandom` uses (an integer number seed is
+ * taken `>>> 0`, anything else is FNV-1a over UTF-8). Each coordinate is truncated toward zero
+ * and wrapped to 32 bits (`x | 0`), so `hash2(s, 2.9, -0.5)` is `hash2(s, 2, 0)`: floor first
+ * when a cell is `Math.floor(x)`. The key, tagged per dimension, and then each coordinate in turn
+ * are folded in with Wellons' lowbias32 finaliser (xor-shift-multiply, a bijection on 32 bits),
+ * so neighbouring cells share no bits and `hash3(s, x, 0, z)` is unrelated to `hash2(s, x, z)`.
+ *
+ * Pure integer arithmetic (`Math.imul`, shifts): the same uint32 on every engine. Nothing
+ * allocates; a string seed is rehashed per call, so a hot loop passes a number seed.
+ */
+import { type Seed } from './random.js';
+/** A uint32 for cell `(x, z)` under `seed`. */
+export declare function hash2(seed: Seed, x: number, z: number): number;
+/** A uint32 for cell `(x, y, z)` under `seed`. */
+export declare function hash3(seed: Seed, x: number, y: number, z: number): number;
+/** `hash2` as a float in [0, 1). */
+export declare function hash2f(seed: Seed, x: number, z: number): number;
+/** `hash3` as a float in [0, 1). */
+export declare function hash3f(seed: Seed, x: number, y: number, z: number): number;

package/dist/core/hash.js

@@ -0,0 +1,49 @@
+/**
+ * Positional hashing (ws/core-3): a stable random value per lattice cell, for rolls that need a
+ * number per point rather than a field between points (a tree in this column, a speckle on this
+ * texel, a lantern on this floor). Noise is `createNoise`; a sequence is `createRandom`.
+ *
+ * The seed goes through `seedKey`, the same hash `createRandom` uses (an integer number seed is
+ * taken `>>> 0`, anything else is FNV-1a over UTF-8). Each coordinate is truncated toward zero
+ * and wrapped to 32 bits (`x | 0`), so `hash2(s, 2.9, -0.5)` is `hash2(s, 2, 0)`: floor first
+ * when a cell is `Math.floor(x)`. The key, tagged per dimension, and then each coordinate in turn
+ * are folded in with Wellons' lowbias32 finaliser (xor-shift-multiply, a bijection on 32 bits),
+ * so neighbouring cells share no bits and `hash3(s, x, 0, z)` is unrelated to `hash2(s, x, z)`.
+ *
+ * Pure integer arithmetic (`Math.imul`, shifts): the same uint32 on every engine. Nothing
+ * allocates; a string seed is rehashed per call, so a hot loop passes a number seed.
+ */
+import { seedKey } from './random.js';
+const INV_2_32 = 1 / 4294967296;
+/** Per-dimension tags folded into the key first, so 2D and 3D hashes of one seed differ. */
+const TAG2 = 0x6a09e667;
+const TAG3 = 0xbb67ae85;
+/** lowbias32 (Chris Wellons, hash-prospector): a well-mixed bijection on uint32. */
+function mix(h) {
+    h ^= h >>> 16;
+    h = Math.imul(h, 0x7feb352d);
+    h ^= h >>> 15;
+    h = Math.imul(h, 0x846ca68b);
+    return (h ^ (h >>> 16)) >>> 0;
+}
+/** A uint32 for cell `(x, z)` under `seed`. */
+export function hash2(seed, x, z) {
+    let h = mix(seedKey(seed) ^ TAG2);
+    h = mix(h ^ (x | 0));
+    return mix(h ^ (z | 0));
+}
+/** A uint32 for cell `(x, y, z)` under `seed`. */
+export function hash3(seed, x, y, z) {
+    let h = mix(seedKey(seed) ^ TAG3);
+    h = mix(h ^ (x | 0));
+    h = mix(h ^ (y | 0));
+    return mix(h ^ (z | 0));
+}
+/** `hash2` as a float in [0, 1). */
+export function hash2f(seed, x, z) {
+    return hash2(seed, x, z) * INV_2_32;
+}
+/** `hash3` as a float in [0, 1). */
+export function hash3f(seed, x, y, z) {
+    return hash3(seed, x, y, z) * INV_2_32;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,17 @@
+export type { EventMap } from './events.js';
+export { Emitter } from './events.js';
+export { hash2, hash2f, hash3, hash3f } from './hash.js';
+export type { FixedStepperOptions, GameLoopOptions, LoopCallbacks, Time } from './loop.js';
+export { FixedStepper, GameLoop } from './loop.js';
+export type { Mat4 } from './math.js';
+export { mat4 } from './math.js';
+export type { FbmOptions, Noise, NoiseFn } from './noise.js';
+export { createNoise } from './noise.js';
+export type { Pool, PoolOptions } from './pool.js';
+export { createPool } from './pool.js';
+export type { NumberSink, Random, Seed } from './random.js';
+export { createRandom, seedKey } from './random.js';
+export type { Scene, TransitionListener, TransitionPhase } from './scene.js';
+export { SceneStack } from './scene.js';
+export type { Cooldown, EveryOptions, Scheduler, TimerHandle } from './timer.js';
+export { createScheduler } from './timer.js';

package/dist/core/index.js

@@ -0,0 +1,9 @@
+export { Emitter } from './events.js';
+export { hash2, hash2f, hash3, hash3f } from './hash.js';
+export { FixedStepper, GameLoop } from './loop.js';
+export { mat4 } from './math.js';
+export { createNoise } from './noise.js';
+export { createPool } from './pool.js';
+export { createRandom, seedKey } from './random.js';
+export { SceneStack } from './scene.js';
+export { createScheduler } from './timer.js';