@driftengine/core 3.61.0

package/dist/host/lifecycle.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Focus, and the end of the process.
+ *
+ * The engine needs to know when it stopped being looked at — a paused simulation, a muted mixer —
+ * and a shell additionally needs to be told to close. **A browser cannot close its own tab**, so
+ * `requestQuit` warns rather than silently doing nothing: a silent no-op reads as a working call,
+ * which is the failure `AGENTS.md` names where an unimplemented capability returns a plausible
+ * answer instead of a defined one.
+ *
+ * Every subscription returns its own unsubscribe. Nothing here is called per frame.
+ */
+export interface Lifecycle {
+    /**
+     * Whether `requestQuit` will actually end the process.
+     *
+     * **This is what an exit button should be drawn from.** A browser cannot close its own tab and
+     * iOS applications do not exit programmatically, so a menu that always shows Exit has a button
+     * that does nothing on two of the platforms a game ships to — and a game that instead branches
+     * on "am I in a shell" has hard-coded an assumption that stops being true. Ask the capability.
+     */
+    readonly canQuit: boolean;
+    onFocusChange(handler: (focused: boolean) => void): () => void;
+    /**
+     * The shell is closing and the game may finish what it is doing.
+     *
+     * A shell calls the handler on a window-close request and waits; a browser never calls it,
+     * because a tab closing gives nothing that can be waited on.
+     */
+    onQuitRequest(handler: () => void): () => void;
+    requestQuit(): void;
+}
+export declare class BrowserLifecycle implements Lifecycle {
+    /** False: no page may close the tab it is in. An exit button here is a button that lies. */
+    readonly canQuit = false;
+    onFocusChange(handler: (focused: boolean) => void): () => void;
+    /**
+     * A browser is never asked to quit, so this handler is never called here.
+     *
+     * The unsubscribe is real rather than the handler being rejected: a consumer registers the
+     * same handler on both platforms and must be able to drop it on both, and code that has to
+     * ask which platform it is on has lost the point of the seam.
+     */
+    onQuitRequest(handler: () => void): () => void;
+    requestQuit(): void;
+}

package/dist/host/lifecycle.js

@@ -0,0 +1,28 @@
+export class BrowserLifecycle {
+    /** False: no page may close the tab it is in. An exit button here is a button that lies. */
+    canQuit = false;
+    onFocusChange(handler) {
+        const focused = () => handler(true);
+        const blurred = () => handler(false);
+        window.addEventListener('focus', focused);
+        window.addEventListener('blur', blurred);
+        return () => {
+            window.removeEventListener('focus', focused);
+            window.removeEventListener('blur', blurred);
+        };
+    }
+    /**
+     * A browser is never asked to quit, so this handler is never called here.
+     *
+     * The unsubscribe is real rather than the handler being rejected: a consumer registers the
+     * same handler on both platforms and must be able to drop it on both, and code that has to
+     * ask which platform it is on has lost the point of the seam.
+     */
+    onQuitRequest(handler) {
+        void handler;
+        return () => undefined;
+    }
+    requestQuit() {
+        console.warn('[driftengine] requestQuit: a browser cannot close its own tab; a shell can');
+    }
+}

package/dist/host/platformServices.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A store's own features: achievements, presence, and whatever a platform adds to them.
+ *
+ * **Opt-in, and there is deliberately no default implementation.** A consumer that never asks for
+ * an achievement must not acquire a store SDK, must not ship one to a browser, and must not have
+ * to explain one in a privacy policy. That is the same promise SDF text makes, and it is the
+ * reason this interface has no `BrowserPlatformServices` beside it: there is nothing honest for
+ * one to do.
+ *
+ * A consumer that wants these supplies them from its shell. A consumer that does not passes
+ * nothing and the engine never calls them.
+ *
+ * **Both methods return nothing and neither may throw.** An achievement that fails to unlock is
+ * not a reason for a frame to stop, and a store that is offline is an ordinary state — an
+ * implementation that wants to report a failure logs it.
+ *
+ * **What would make this wrong** is a platform feature the engine itself needs in order to draw,
+ * which none of these is.
+ */
+export interface PlatformServices {
+    unlockAchievement(id: string): void;
+    setRichPresence(text: string): void;
+}

package/dist/host/platformServices.js

@@ -0,0 +1 @@
+export {};

package/dist/host/screen.d.ts

@@ -0,0 +1,49 @@
+/**
+ * What a phone has instead of a window.
+ *
+ * A handset has no window mode, no window size a game may choose and no second display, so
+ * `DisplayControl` has almost nothing to offer it. What it has instead is an **orientation** it
+ * may rotate out of, a **safe area** that a notch, a camera cut-out or a gesture bar has taken
+ * from the screen, and a **screen that wants to sleep** while somebody is holding a controller
+ * rather than touching the glass. Those are the three, and they are here rather than folded into
+ * the display seam because a desktop shell has no use for any of them.
+ *
+ * **Every one of them can be refused, and each says so.** iOS will not lock an orientation at
+ * all; Android will not lock one outside fullscreen; a browser with no Wake Lock API cannot keep
+ * a screen awake. A game that is told `false` can lay itself out for either orientation, or warn,
+ * or carry on — what it cannot do is find out later from a player.
+ *
+ * Not a hot path: a layout reads the safe area on a resize, not on a frame.
+ */
+export type ScreenOrientation = 'portrait' | 'landscape';
+/** Logical pixels the platform has taken from each edge. Zero where it has taken nothing. */
+export interface SafeAreaInsets {
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+    readonly left: number;
+}
+export interface ScreenPresentation {
+    orientation(): ScreenOrientation;
+    /** `null` unlocks. `false` where the platform refused, which iOS always does. */
+    lockOrientation(orientation: ScreenOrientation | null): Promise<boolean>;
+    safeArea(): SafeAreaInsets;
+    /** `false` where the platform has no wake lock, or refused this one. */
+    keepAwake(on: boolean): Promise<boolean>;
+}
+export declare class BrowserScreenPresentation implements ScreenPresentation {
+    private held;
+    /**
+     * Installs one stylesheet, once, and that is the only side effect in this file.
+     *
+     * `env(safe-area-inset-*)` cannot be read from script directly — it is only valid inside a CSS
+     * declaration — so the values are copied into custom properties on the root element and read
+     * back through `getComputedStyle`. The alternative is a hidden probe element whose padding is
+     * measured, which costs a layout on every read and a node in every consumer's tree.
+     */
+    constructor();
+    orientation(): ScreenOrientation;
+    lockOrientation(orientation: ScreenOrientation | null): Promise<boolean>;
+    safeArea(): SafeAreaInsets;
+    keepAwake(on: boolean): Promise<boolean>;
+}

package/dist/host/screen.js

@@ -0,0 +1,90 @@
+/** The four properties the style below defines, read back through the cascade. */
+const INSET_PROPERTIES = ['top', 'right', 'bottom', 'left'];
+/** Marks the one style element this installs, so a second instance does not add another. */
+const STYLE_ID = 'drift-safe-area';
+export class BrowserScreenPresentation {
+    held = null;
+    /**
+     * Installs one stylesheet, once, and that is the only side effect in this file.
+     *
+     * `env(safe-area-inset-*)` cannot be read from script directly — it is only valid inside a CSS
+     * declaration — so the values are copied into custom properties on the root element and read
+     * back through `getComputedStyle`. The alternative is a hidden probe element whose padding is
+     * measured, which costs a layout on every read and a node in every consumer's tree.
+     */
+    constructor() {
+        try {
+            if (document.getElementById?.(STYLE_ID) != null)
+                return;
+            const style = document.createElement('style');
+            style.setAttribute('id', STYLE_ID);
+            style.textContent = `:root{${INSET_PROPERTIES.map((edge) => `--drift-safe-${edge}:env(safe-area-inset-${edge},0px)`).join(';')}}`;
+            document.head.appendChild(style);
+        }
+        catch {
+            /* No document, or a head that will not take a child. The insets then read zero, which is
+               the same answer a platform with no cut-out gives, and is never worth failing a boot for. */
+        }
+    }
+    orientation() {
+        const type = window.screen?.orientation?.type;
+        if (typeof type === 'string')
+            return type.startsWith('portrait') ? 'portrait' : 'landscape';
+        /* No orientation API: every desktop browser, and iOS Safari for most of its life. The shape
+           of the window is the same answer the platform would have given. */
+        return window.innerHeight >= window.innerWidth ? 'portrait' : 'landscape';
+    }
+    async lockOrientation(orientation) {
+        const screen = window.screen?.orientation;
+        if (screen === undefined)
+            return false;
+        try {
+            if (orientation === null) {
+                screen.unlock?.();
+                return true;
+            }
+            if (typeof screen.lock !== 'function')
+                return false;
+            await screen.lock(orientation);
+            return true;
+        }
+        catch {
+            /* iOS refuses outright; Android refuses outside fullscreen. Both are ordinary. */
+            return false;
+        }
+    }
+    safeArea() {
+        const read = (edge) => {
+            try {
+                const raw = getComputedStyle(document.documentElement).getPropertyValue(`--drift-safe-${edge}`);
+                const value = Number.parseFloat(raw);
+                return Number.isFinite(value) ? value : 0;
+            }
+            catch {
+                return 0;
+            }
+        };
+        return { top: read('top'), right: read('right'), bottom: read('bottom'), left: read('left') };
+    }
+    async keepAwake(on) {
+        const wakeLock = navigator.wakeLock;
+        try {
+            if (!on) {
+                if (this.held === null)
+                    return true;
+                await this.held.release();
+                this.held = null;
+                return true;
+            }
+            if (wakeLock === undefined)
+                return false;
+            this.held = await wakeLock.request('screen');
+            return true;
+        }
+        catch {
+            /* A lock is dropped whenever the page is hidden, and re-requesting it is the caller's
+               business. A failure here is not worth a throw. */
+            return false;
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,289 @@
+/*! DriftEngine | Copyright 2026 Drift Technologies | Apache-2.0 | https://github.com/drftrun/driftengine */
+/** Public engine surface. Game code imports from '@driftengine/core' only. */
+export { startLoop } from './core/loop.ts';
+export type { LoopHooks, FrameSource, LoopOptions } from './core/loop.ts';
+export { StepBudget } from './core/stepBudget.ts';
+export type { StepBudgetOptions } from './core/stepBudget.ts';
+export { hashToUnit, mulberry32, pickBySeed, savableMulberry32 } from './core/rng.ts';
+export { exactAcos, exactCos, exactExp, exactSin } from './math/exact.ts';
+export type { SavableRandom } from './core/rng.ts';
+export { TickTrace } from './core/tickTrace.ts';
+export type { TickTraceLike } from './core/tickTrace.ts';
+export { BrowserStore, MemoryStore, defaultStore } from './core/storage.ts';
+export type { KeyValueStore } from './core/storage.ts';
+export { RemoteSaveStore, defaultSaveTimer } from './core/remoteSave.ts';
+export type { RemoteSaveOptions, SaveBackend, SaveStatus, SaveTimer } from './core/remoteSave.ts';
+export { BrowserDisplay } from './host/display.ts';
+export type { DisplayControl, DisplayInfo, WindowMode } from './host/display.ts';
+export { BrowserScreenPresentation } from './host/screen.ts';
+export type { SafeAreaInsets, ScreenOrientation, ScreenPresentation } from './host/screen.ts';
+export { BrowserLifecycle } from './host/lifecycle.ts';
+export type { Lifecycle } from './host/lifecycle.ts';
+export { BrowserFileDialogs } from './host/files.ts';
+export type { FileDialogs, OpenedFile } from './host/files.ts';
+export type { PlatformServices } from './host/platformServices.ts';
+export { PreferenceStore, loadPreferences, savePreferences } from './core/preferences.ts';
+export type { PreferenceSchema } from './core/preferences.ts';
+export { OnceSet } from './core/onceSet.ts';
+export { MAX_TIME_CURVE_AMOUNT, curveOffsetSec, curveSpanSec, linearCurve, timeCurve, } from './core/timeCurve.ts';
+export type { TimeCurve, TimeCurveKind, TimeCurveOptions } from './core/timeCurve.ts';
+export { CinematicPlayer } from './cinematic/player.ts';
+export { defineCinematic, validateCinematic } from './cinematic/script.ts';
+export type { CameraKeyframe, CinematicLine, CinematicScript, CinematicShot, } from './cinematic/script.ts';
+export { MessageQueue } from './core/messageQueue.ts';
+export type { MessageQueueOptions, QueuedMessage } from './core/messageQueue.ts';
+export { celestialStateAt, createCelestialState, moonIllumination, } from './environment/celestialClock.ts';
+export type { CelestialSite, CelestialState } from './environment/celestialClock.ts';
+export { TAU, DEG_TO_RAD, clamp, lerp, smoothstep, damp, dampTracking, angleDelta, dampAngle, wrapAngle, lerpAngle, } from './math/scalar.ts';
+export { hslToRgb, mixColor, mixColorInto, scaleColor } from './math/color.ts';
+export type { Vec3 } from './math/color.ts';
+export { Camera } from './render/camera.ts';
+export { ThirdPersonCamera } from './render/thirdPersonCamera.ts';
+export { CinematicCamera } from './render/cinematicCamera.ts';
+export type { ShotKind, ShotParams } from './render/cinematicCamera.ts';
+export type { BoomObstruction, ThirdPersonCameraOptions } from './render/thirdPersonCamera.ts';
+export { Boom, DEFAULT_BOOM_TIMING } from './render/boom.ts';
+export type { BoomTiming } from './render/boom.ts';
+export { billboardMatrix, billboardMatrixY } from './render/billboard.ts';
+export { Mesh } from './render/mesh.ts';
+export type { MeshData } from './render/mesh.ts';
+export { UPLOAD_BYTES_PER_STEP } from './render/uploadStep.ts';
+export { MAX_DEPTH_LAYER, Renderer, WebGL2Renderer } from './render/backend/webgl2/renderer.ts';
+export type { Environment, FilmOptions, LightVolumeDrawOptions, SkyColors, TranslucentMeshOptions, } from './render/backend/webgl2/renderer.ts';
+export { PickableSet } from './render/pickable.ts';
+export type { PickHit, PickableSource } from './render/pickable.ts';
+export { boundsOfBox, boundsOfPositions, createBounds } from './math/bounds.ts';
+export type { Bounds } from './math/bounds.ts';
+export { createFrustum, frustumFromViewProjection, sphereInFrustum } from './math/frustum.ts';
+export type { Frustum } from './math/frustum.ts';
+export { boundsVisible } from './render/visibility.ts';
+export { apparentSize, lodForBounds } from './render/lod.ts';
+export { SceneNode } from './scene/node.ts';
+export { MAX_JOINTS, MAX_MORPH_TARGETS, SKIN_PALETTE_TEXTURE_UNIT, morphTexelIndex, paletteTextureWidth, } from './render/skinPalette.ts';
+export { createVisitResult, visitVisible } from './scene/visit.ts';
+export type { VisitResult } from './scene/visit.ts';
+export type { PassContext, PassDefinition, PassDevice, PassHandle, PrepareContext, } from './render/pass.ts';
+export type { PassAttachmentOptions, PassTarget } from './render/passTarget.ts';
+export { createPassAttachment } from './render/passTarget.ts';
+export type { FrameResource } from './render/frame/index.ts';
+export type { OcclusionOptions } from './render/occlusion.ts';
+export { OcclusionBuffer } from './render/occlusion.ts';
+export type { ComputeContext, ComputeDefinition, ComputeDevice, ComputeHandle, } from './render/compute.ts';
+export { createRenderer } from './render/backend/createRenderer.ts';
+export type { CreatedRenderer, CreateRendererOptions } from './render/backend/createRenderer.ts';
+export { GRADE_PLACEHOLDER_SIZE, MAX_GRADE_SIZE, identityGradeLut } from './render/colourGrade.ts';
+export type { ColourGradeLut } from './render/colourGrade.ts';
+export { probeDevice } from './render/backend/probe.ts';
+export type { ProbeVerdict } from './render/backend/probe.ts';
+export type { BoltHandle, CausticsHandle, FlockHandle, IncrementalMeshHandle, LineHandle, MeshHandle, MeshOptions, RenderBackend, RendererApi, ParticleHandle, PlumeHandle, ScatterHandle, InstancedHandle, SdfTextHandle, SurfaceTextureHandle, TextHandle, WaterHandle, WindStreakHandle, } from './render/backend/api.ts';
+/**
+ * What a frame asked of a backend, against the ceilings that backend imposes.
+ *
+ * Exported because a consumer's own headless check is the intended reader: `frameBudget.dropped`
+ * is the boolean to fail on, and typing the walk over `lines` needs the two shapes.
+ */
+export type { BudgetLine, FrameBudget } from './render/backend/budget.ts';
+export type { FrameTimer } from './render/backend/timer.ts';
+export type { SceneCasterMaterial, SceneCasters, ShadowCasterSink, ShadowCasters, } from './render/shadowCasters.ts';
+export type { Atmosphere, UnderwaterAtmosphere } from './render/atmosphere.ts';
+export { createImageTexelDecoder } from './render/imageTexels.ts';
+export type { ImageTexelDecoder, ImageTexels } from './render/imageTexels.ts';
+export { DEFAULT_RENDER_QUALITY, resolveRenderQuality } from './render/renderQuality.ts';
+/**
+ * The global medium's own arithmetic, so a consumer can clamp its numbers the way the engine will.
+ *
+ * The pass itself is not exported and should not be: `setGlobalMedium` is the whole surface, and a
+ * consumer holding a `GlobalMediumPass` would own a target the renderer already owns. What is here
+ * is the type the setter takes and the two bounds a settings screen has to know about.
+ */
+export { DEFAULT_GLOBAL_MEDIUM, MAX_GLOBAL_MEDIUM_STEPS, WEAK_GPU_MEDIUM_STEPS, resolveGlobalMedium, } from './render/globalMedium.ts';
+export type { GlobalMediumOptions } from './render/globalMedium.ts';
+export { equirectToCubeFaces } from './render/equirectToCube.ts';
+export type { EquirectSource } from './render/equirectToCube.ts';
+export { IRRADIANCE_EDGE, PREFILTER_SAMPLE_COUNTS, ggxMaxLevelFor, irradianceLevelFor, octahedralEdgeFor, roughnessForLevel, } from './render/prefilterEnvMap.ts';
+/**
+ * Where probes stand, and which of them light a point.
+ *
+ * Exported because placement is a consumer's decision and because a consumer sizing its own
+ * storage needs `MAX_ENV_PROBES` — every probe is one layer of one array texture, so the budget is
+ * memory rather than texture units. `nearestProbes` is the same trilinear blend the shader
+ * computes from three uniforms, which is what makes a consumer's bake ordering agree with what the
+ * lit pass will read.
+ */
+export { MAX_ENV_PROBES, ProbeGrid, createProbeBlend, nearestProbes } from './render/probeGrid.ts';
+export type { ProbeBlend, ProbeGridOptions } from './render/probeGrid.ts';
+export { IES_ATLAS_WIDTH, packIesAtlas } from './render/iesProfile.ts';
+export { MAX_AREA_LIGHTS, createAreaLightBuffer, selectAreaLights } from './render/areaLights.ts';
+export type { AreaLightBuffer, AreaLightSource } from './render/areaLights.ts';
+/**
+ * A rectangle's occlusion. Exported because a consumer sizing its own storage budget needs the
+ * layer arithmetic, and because `castingRange` is the one predicate that decides whether a
+ * declaration will actually cast — a consumer asserting that its fixtures do should ask the engine
+ * rather than re-implement the two conditions.
+ */
+export { areaShadowLayerCount, castingRange, firstAreaShadowLayer, } from './render/areaShadowSet.ts';
+export type { PhotometricProfile } from './render/iesProfile.ts';
+export type { PrefilterQuality } from './render/prefilterEnvMap.ts';
+/**
+ * What a probe bake is for: the reflection alone, or the reflection and the scene's ambient.
+ *
+ * Exported because declining the second half is a decision only a consumer can make — see
+ * `ProbeBakeOptions`, which is the whole of the reasoning.
+ */
+export type { ProbeBakeOptions } from './render/reflectionProbe.ts';
+export type { DirectionalShadowDepthLayers, OutputTransform, RenderQuality, RenderQualityOptions, ShadowFilterTaps, WaterReflectionFilterTaps, } from './render/renderQuality.ts';
+export { MAX_POINT_LIGHTS, SURFACE_TEXTURE_UNIT } from './render/lightBudget.ts';
+export { SurfaceTexture } from './render/surfaceTexture.ts';
+export type { SurfaceMaterial, SurfaceTextureOptions } from './render/surfaceTexture.ts';
+export { DEFAULT_GOVERNOR_LIMITS, ResolutionGovernor } from './render/resolutionGovernor.ts';
+export type { GovernorLimits } from './render/resolutionGovernor.ts';
+export { isWeakGpuFamily } from './render/gpuCapability.ts';
+/**
+ * The same question `isWeakGpuFamily` answers, asked early enough to choose a profile with.
+ *
+ * `RendererApi.rendererName` and `CreatedRenderer.rendererName` are this answer after the fact,
+ * which is the right time for a boot log and too late for a decision.
+ */
+export { describeGpu } from './render/gpuCapability.ts';
+export type { GpuIdentity, DescribeGpuOptions } from './render/gpuCapability.ts';
+export { DEFAULT_POINT_LIGHT_VIEW_RANGE, createPointLightBuffer, selectPointLights, } from './render/pointLightSelection.ts';
+export type { PointLightBuffer, PointLightSource } from './render/pointLightSelection.ts';
+export { computeLightMatrix } from './render/lightMatrix.ts';
+export { PlumeRenderer } from './render/plumeRenderer.ts';
+export { createEnvironment } from './render/backend/webgl2/renderer.ts';
+export type { InsetRect } from './render/backend/webgl2/renderer.ts';
+export { TrampleField, TRAMPLE_SLOTS } from './render/trample.ts';
+export type { PlumePlacement, PlumeOptions, PlumeBlend } from './render/plumeRenderer.ts';
+export type { PlumeMaterial } from './render/plumeMaterial.ts';
+export type { ParticleMaterial } from './render/particleMaterial.ts';
+export { setUniformStrictMode } from './render/shader.ts';
+export { LoadTracker } from './core/loadTracker.ts';
+export type { LoadTask, LoadSummary } from './core/loadTracker.ts';
+export { buildShellFill, shellSkin, shellFillMatrix, DEFAULT_SHELL_PROFILE, } from './geometry/shellFill.ts';
+export type { ShellStation, ShellFillOptions } from './geometry/shellFill.ts';
+export { OUTPUT_TRANSFORM_GLSL } from './render/shaders/outputTransform.ts';
+export { PLUME_VERT, FIRE_FRAG } from './render/shaders/fire.ts';
+export { ARCANE_FRAG } from './render/shaders/arcane.ts';
+export { SMOKE_FRAG } from './render/shaders/smoke.ts';
+export { WaterRenderer } from './render/waterRenderer.ts';
+export type { WaterBody, WaterBounds, WaterSettings } from './render/waterRenderer.ts';
+export { MeshBuilder } from './geometry/meshBuilder.ts';
+export { generateTangents } from './geometry/tangents.ts';
+export type { MeshBuildOptions } from './geometry/meshBuilder.ts';
+export { Spline, createSplineSample } from './geometry/spline.ts';
+export type { SplinePoint, SplineSample } from './geometry/spline.ts';
+export { RIBBON_COLLIDER_GIVE_M, RIBBON_STEP_M } from './geometry/ribbon.ts';
+export { buildRibbon } from './geometry/ribbon.ts';
+export { buildFilmPatch } from './geometry/filmPatch.ts';
+export { buildLightVolume } from './geometry/lightVolume.ts';
+export type { LightVolumeOptions } from './geometry/lightVolume.ts';
+export { buildTextMesh, textMeshHeightM, textMeshWidthM } from './geometry/textMesh.ts';
+export type { TextMeshStyle } from './geometry/textMesh.ts';
+export { CausticsRenderer } from './render/causticsRenderer.ts';
+export type { CausticSheet } from './render/causticsRenderer.ts';
+export { buildSheets } from './render/surfaceSheet.ts';
+export type { SheetMesh, SheetSpan } from './render/surfaceSheet.ts';
+export type { FilmPatchOptions } from './geometry/filmPatch.ts';
+export type { RibbonHole, RibbonMesh, RibbonOptions } from './geometry/ribbon.ts';
+export { RibbonSurface, createSurfaceHit } from './physics/ribbonSurface.ts';
+export type { GroundSurface, RibbonSurfaceOptions, SurfaceHit } from './physics/ribbonSurface.ts';
+export { CompositeSurface } from './physics/compositeSurface.ts';
+export { colliderSurface } from './physics/colliderSurface.ts';
+export { DEPTH_CLEAR, DEPTH_COMPARE, DEPTH_COMPARE_EQUAL, DEPTH_FORMAT, DEPTH_OFFSET_SIGN, REVERSED_DEPTH, conventionalDepth, } from './render/depthConvention.ts';
+export type { ColliderSurfaceOptions } from './physics/colliderSurface.ts';
+export { BoxSurface } from './physics/boxSurface.ts';
+export { heightSurface } from './physics/heightSurface.ts';
+export { DebugLines } from './render/debugLines.ts';
+export { GIZMO_GROUP_ACTIVE, GIZMO_GROUP_COLORS, GIZMO_GROUP_COUNT, GIZMO_GROUP_NEUTRAL, GIZMO_GROUP_X, GIZMO_GROUP_Y, GIZMO_GROUP_Z, GIZMO_NONE, GIZMO_ROTATE_X, GIZMO_ROTATE_Y, GIZMO_ROTATE_Z, GIZMO_SCALE_UNIFORM, GIZMO_SCALE_X, GIZMO_SCALE_Y, GIZMO_SCALE_Z, GIZMO_TRANSLATE_X, GIZMO_TRANSLATE_XY, GIZMO_TRANSLATE_Y, GIZMO_TRANSLATE_YZ, GIZMO_TRANSLATE_Z, GIZMO_TRANSLATE_ZX, Gizmo, gizmoScaleFor, } from './render/gizmo.ts';
+export type { GizmoMode, GizmoSpace } from './render/gizmo.ts';
+export { RainField } from './render/rainField.ts';
+export type { RainFieldOptions } from './render/rainField.ts';
+export { coveredAbove } from './physics/heightSurface.ts';
+export { buildNavGraph, nearestNavNode } from './nav/navGraph.ts';
+export type { NavEdge, NavGraph } from './nav/navGraph.ts';
+export { NavSearch } from './nav/navSearch.ts';
+export { NavPath, createNavSteer } from './nav/navPath.ts';
+export { BehaviorRunner, FAILURE, RUNNING, SUCCESS, buildBehaviorTree, } from './behavior/behaviorTree.ts';
+export { projectDecal } from './geometry/decal.ts';
+export type { DecalOptions } from './geometry/decal.ts';
+export { DecalProjector } from './render/decalProjector.ts';
+export type { DecalBox, DecalProjectorOptions } from './render/decalProjector.ts';
+export { ReflectiveSurface } from './render/screenSpaceReflection.ts';
+export type { ReflectiveSurfaceOptions } from './render/screenSpaceReflection.ts';
+export type { BehaviorSpec, BehaviorStatus, BehaviorTasks, BehaviorTree, } from './behavior/behaviorTree.ts';
+export type { NavPathOptions, NavSteer } from './nav/navPath.ts';
+export type { HeightField, HeightSurfaceOptions } from './physics/heightSurface.ts';
+export type { SurfaceBox } from './physics/boxSurface.ts';
+export * from '@driftengine/physics';
+export { AXIS_X, AXIS_Y, AXIS_Z, ColliderSet, aabbFromCenter, bodyBounds, boxCollider, boxShape, capsuleShape, colliderFromShape, createBodyBounds, cylinderShape, createMassProperties, ejectFromSolid, faceCount, faceVertices, fingerprintBodies, fingerprintColliders, hullShape, moveAxis, segmentHit, shapeBounds, shapeMassProperties, sphereShape, } from '@driftengine/physics';
+export { InputSource } from './input/input.ts';
+export { isTypingTarget } from './input/typingTarget.ts';
+export type { TouchPoint, InputCallbacks } from './input/input.ts';
+export type { GamepadIdentity, GamepadView, InputOptions, InputSourceName } from './input/input.ts';
+export type { InputDevice } from './input/activeDevice.ts';
+export type { GamepadFamily } from './input/gamepadIdentity.ts';
+export { DEFAULT_DEADZONE } from './input/gamepadMapping.ts';
+export { MAX_RUMBLE_MS } from './input/rumble.ts';
+export type { GamepadAxis, GamepadButton } from './input/gamepadMapping.ts';
+export { ActionMap } from './input/actionMap.ts';
+export type { ActionDefinition, AnalogAction, Binding, DigitalAction } from './input/actionMap.ts';
+export { TouchControls } from './input/touchControls.ts';
+export type { TouchControlsOptions } from './input/touchControls.ts';
+export { pixelCursor } from './ui/pixelCursor.ts';
+export { fullscreenWanted, requestFullscreenOnGesture } from './ui/fullscreen.ts';
+export type { FullscreenConditions } from './ui/fullscreen.ts';
+export { SPLASH_FADE_MS, SPLASH_HARD_CAP_MS, SPLASH_MIN_MS, forcedSplash, mountSplash, splashDecision, splashWanted, } from './ui/splash.ts';
+export type { MountedSplash, SplashConditions, SplashDecision, SplashOptions, } from './ui/splash.ts';
+export { DEFAULT_CLIP_FPS, FrameRecorder, offerClip } from './ui/frameRecorder.ts';
+export { stillFrame } from './ui/stillFrame.ts';
+export { describeClipMime, supportedClipMimeType } from './ui/clipMime.ts';
+export type { ClipMimeDescription } from './ui/clipMime.ts';
+export { EXPORT_FALLBACK_SCALE, ExportTarget, clipBitrate, exportAspect, exportSizeExact, isDuplicateFrame, CLIP_FPS_LADDER, clipFpsFor, exportSizeFor, } from './ui/exportTarget.ts';
+export type { ExportSize, ExportTargetOptions, LockableSurface } from './ui/exportTarget.ts';
+export { FramePacer } from './ui/framePacer.ts';
+export type { FramePacingReport } from './ui/framePacer.ts';
+export { bakeOverlay, drawPixelText, pixelTextCells, pixelTextSize } from './ui/frameOverlay.ts';
+export type { FrameOverlay, OverlayImage, OverlayImageSource, OverlayText, } from './ui/frameOverlay.ts';
+export type { FrameRecorderOptions } from './ui/frameRecorder.ts';
+export type { PixelCursorOptions } from './ui/pixelCursor.ts';
+export { FpsMeter } from './dev/fpsMeter.ts';
+export type { FpsMeterOptions } from './dev/fpsMeter.ts';
+export { CONTACT_LIMIT, createContactReports, describeContacts } from './dev/contactProbe.ts';
+export type { ContactReport } from './dev/contactProbe.ts';
+export { GPU_SLOTS, GpuTimer } from './render/gpuTimer.ts';
+export type { GpuSample, GpuSlot } from './render/gpuTimer.ts';
+export { classifyRightGesture } from './input/rightGesture.ts';
+export type { RightGesture, RightGestureOptions } from './input/rightGesture.ts';
+export { createWindState, sampleWind } from './render/wind.ts';
+export { advanceWindField, createWindField } from './render/windField.ts';
+export type { WindField } from './render/windField.ts';
+export { seaStateForAgitation, seaStateForWind } from './render/seaState.ts';
+export type { SeaState } from './render/seaState.ts';
+export { InstancedMesh, createInstanceData, writeInstance } from './render/instancedMesh.ts';
+export { createMeshInstances, packInstances, INSTANCE_FLOATS, INSTANCE_STRIDE, } from './render/instances.ts';
+export { ParticlePool } from './render/particlePool.ts';
+export type { ParticlePoolOptions, ParticleInstances } from './render/particlePool.ts';
+export { ParticleBatch } from './render/particleBatch.ts';
+export type { ParticleBatchOptions, ParticleBlend, ParticleFacing, } from './render/particleBatch.ts';
+export { PARTICLE_MOTE_FRAG, PARTICLE_SMOKE_FRAG, PARTICLE_SPARK_FRAG, PARTICLE_VERT, } from './render/shaders/particle.ts';
+export { BoltPool } from './render/boltPool.ts';
+export type { BoltPoolOptions, BoltSegments, BoltColors } from './render/boltPool.ts';
+export { BoltBatch } from './render/boltBatch.ts';
+export { createLineSegments, setPolyline } from './render/linePoints.ts';
+export type { LineSegments } from './render/linePoints.ts';
+export { FlockRenderer } from './render/flockRenderer.ts';
+export { DEFAULT_TEXT_STYLE, textHeightPx, textWidthPx } from './render/textLayout.ts';
+export type { TextStyle } from './render/textLayout.ts';
+export { GLYPH_HEIGHT, GLYPH_SPACING, GLYPH_WIDTH, countCells, forEachCell, forEachRun, glyphRows, hasGlyph, measureText, } from './geometry/pixelFont.ts';
+export { parseSdfFont } from './render/sdfFont.ts';
+export type { SdfFont, SdfGlyph } from './render/sdfFont.ts';
+export { DEFAULT_SDF_TEXT_STYLE, SdfTextLayout } from './render/sdfTextLayout.ts';
+export type { SdfTextStyle } from './render/sdfTextLayout.ts';
+export { WindStreakRenderer } from './render/windStreakRenderer.ts';
+export type { WindStreakOptions } from './render/windStreakRenderer.ts';
+export type { FlockParams } from './render/flockRenderer.ts';
+export { buildTree } from './geometry/treeBuilder.ts';
+export type { TreeParams, TreeGeometry } from './geometry/treeBuilder.ts';
+export type { InstanceData } from './render/instancedMesh.ts';
+export type { MeshInstances } from './render/instances.ts';
+export type { WindProfile, WindState } from './render/wind.ts';