All symbols A-Z

Structural type for an axis-aligned bounding box given as min/max extents. This is the canonical AABB contract across the eng…

Base class for all text rendering nodes. Owns the string, the style and layout references, the on-demand dirty protocol, and…

Any action kind an ActionMap can hold.

Shared contract of every action kind. An action owns a BINDING DESCRIPTOR (what the developer declared, or what a player late…

Any binding descriptor an action can be rebound with - the second argument of ActionMap.rebind. Deliberately the union of eve…

Which action kind a SerializedActionBinding belongs to.

A constructed action map together with its actions.

Construction options for an ActionMap.

Options shared by every action.

The shape an ActionMap is built from.

Fades only the alpha channel over a particle's lifetime, leaving RGB untouched. Pair with a spawn-time tint or a separate `Co…

Normals derived from a texture's own alpha channel, computed once. ```ts crate.material = new LitMaterial({ lighting, normals…

Shadows from a texture's own silhouette, traced once. ```ts lighting.occludeFrom(new AlphaOccluder(tree)); ``` Pass the drawa…

A drawable whose own texture, frame and layout box describe where its silhouette belongs. Core's `Sprite` - and therefore `An…

Tuning for AlphaOccluder.

Thrown when `unload(Target)` is called with `options.instance` omitted while more than one activation (active, retained, and/…

A Sprite that advances through a sequence of texture-frame Rectangles over time to produce frame-based animation. Multiple na…

Definition for a single animation clip registered on an AnimatedSprite.

Per-call options passed to AnimatedSprite.play.

Owns and advances the AnimatedSprites whose frame playback is currently running, driving them once per frame from Application…

Any action map, whatever actions it declares - the type a collection of maps (an InputScope, a scope stack) is written agains…

Any typed catalog, whatever its definition record - the constraint Assets.compose accepts its arguments under, and the one to…

Any AssetType, whatever its source, resource, option and stored types - the element type of an Extension's `assets` list. The…

A material of any uniform schema. The bare `Material` type describes the untyped path, so a typed material is not one of them…

A mesh material of any uniform schema - what a consumer that only needs to draw with it should accept, since the bare class d…

A SceneConstructor for any activation-data type - used for registry storage and navigation targets whose `Data` is not static…

A shader source with any uniform declaration - what a consumer that only reads its text should accept, since the bare class d…

Discriminated union of the concrete shape kinds. Narrow via the literal `shape.type` discriminant (`'circle'` → CircleShape,…

A sprite material of any uniform schema - what a consumer that only needs to draw with it should accept, since the bare class…

Top-level engine instance. Owns the canvas, render backend, scene-stack controller, the core systems (input, interaction, aud…

Anything that resolves to a concrete Application instance type: the instance itself, its constructor, or `typeof` an already-…

Normalizes an ApplicationLike to its concrete `Application` instance type, letting Scene's second generic accept an `Applicat…

Lifecycle state of an Application, in the same vocabulary SceneState uses for a scene. | State | Meaning | |---|---| | `Stopp…

Adds a constant 2D acceleration to every live particle's velocity each frame. Use for gravity (`new ApplyForce(0, 980)`), win…

Free functions and constants exported from @codexo/exojs-aseprite.

Aseprite JSON export in array mode - frames is an ordered array.

Aseprite JSON exports, together with the packed sheet they reference. The image URL is read from `meta.image` and resolved ag…

Union of both Aseprite JSON export formats. Use isAsepriteArrayData to discriminate between array and hash mode.

Playback direction of an Aseprite frame tag animation.

Thrown when an Aseprite JSON document does not match the expected shape. `source` is the URL of the file being parsed.

A single animation frame in the Aseprite JSON export.

A named animation range defined via Aseprite frame tags. `from` and `to` are inclusive zero-based frame indices.

Aseprite JSON export in hash mode - frames is an object keyed by frame name.

A single layer entry in the Aseprite JSON metadata (`meta.layers`). Only `name` is guaranteed. `opacity` and `blendMode` desc…

Metadata block of an Aseprite JSON export.

Pixel region rectangle used throughout the Aseprite JSON format.

Parsed representation of an Aseprite JSON sprite sheet export. `AsepriteSheet.parse(data, texture)` converts the raw JSON doc…

Width/height size descriptor used in Aseprite metadata.

A named slice defined in the Aseprite editor.

Bounds of a named slice at a specific frame.

A typed, loadable asset reference. Holds config only - no loaded resource.

The application's caching configuration: which stores exist, which asset types use which of them, and in what order the cache…

Structured asset-cache failure. Raised by a CacheStore for every operation it could not carry out, and dispatched on Loader.o…

Construction options for an AssetCacheError.

Debug layer that reports what the application's Loader currently holds: ready / pending / failed counts, estimated resident b…

Raised when a cache-only acquisition found no record. A distinct type from AssetCacheError on purpose: an absent entry is the…

The cache operation that failed. Carried by AssetCacheError.operation so callers can branch on the failure class - a failed `…

Construction options for an AssetCache.

Any abstract or concrete constructor whose instances are the resource an asset type produces (e.g. `typeof Texture`, `typeof…

Raised when bytes that were successfully obtained cannot be turned into a resource: a malformed container index, an XML docum…

Construction options for an AssetDecodeError.

Every built-in asset type, keyed by its id, plus whatever extension packages declaration-merge into it. An entry declares the…

The seam through which a factory acquires the assets its resource depends on. Everything loaded through it is owned by the re…

One entry of an Extension's `assets` list: a first-class AssetType. The type carries its own stable identity, identity hooks,…

Builds one kind of runtime resource from normalized source data. A factory owns construction and teardown, and nothing else:…

What a factory is told about the one resource it is building. There is deliberately no network, cache store or cache policy h…

The two identities a request resolves to, as reported by Loader.identify.

What an asset type hands out for one of its assets inside a catalog, before the payload has arrived. `'ref'` hands out a defe…

A canonicalized asset source: `url:` followed by the fully resolved URL, with the loader base path applied, `.` and `..` coll…

The packs a deployment holds, addressed by logical name. A pack file is named after the hash of its own bytes, so its URL cha…

How a manifest is fetched.

Structured asset-network failure. Raised whenever the network leg of a load fails - either because the request never complete…

Construction options for an AssetNetworkError.

One row of Loader.inspect's diagnostic snapshot: everything a developer needs to reason about a single canonical asset withou…

Deferred handle for value assets (parsed JSON, text, CSV rows, ...), returned by `loader.get(Asset.type('json', src))` / a ba…

One request for an asset of a given type, as an identity hook sees it.

A reusable, typed asset container. Each field is materialized as a handle-hybrid leaf: a resource type's leaf IS a usable pla…

One resident asset, sized, as reported by AssetStats.largest.

Turns an acquired representation into the normalized source an AssetFactory builds a resource from. The contract is deliberat…

Aggregate view of what a loader currently holds, for HUDs and memory dashboards that want counters rather than the per-asset…

Uniform, read-only load-status contract surfaced by every asset handle and ref. A public projection of the handle's internal…

A first-class asset type: everything the loader needs to know about one kind of asset, in one value. An instance is an immuta…

The name a request dispatches on: a built-in AssetDefinitions key, or the stable AssetType.id of a type installed on this app…

Residency totals for one asset type, as reported by AssetStats.byType.

One candidate representation of a logical asset source. A candidate is eligible when every condition it states holds for the…

What the running device can accept, as variant rules see it. Filled from the live render backend once it is up - `textureForm…

Per-device selection between several files that stand for one logical asset. Without this layer a path is a path: one URL, on…

Atlas rendering mode. Determines texture format and rasterization strategy. `'sdf'` uses a single-channel R8 DataTexture with…

A single texture page within a GlyphAtlas. Glyphs are packed into the page using a shelf-bin algorithm. In `'sdf'` mode the p…

Requires at least one property of `T` to be present. Used to reject empty composite bindings such as `new AxisAction({})` at…

PhysicsWorld.attach convenience options: a body type plus a single collider, attached to a scene node in one call.

Pulls every live particle toward a fixed point in the system's local coordinate space. Acceleration magnitude is `strength` (…

Scalar component type used by a geometry vertex attribute.

Lightweight visualisation analyser backed by a Web Audio AnalyserNode. Accepts any of: AudioBus, Voice, MediaStream, AudioNod…

Construction options for AudioAnalyser.

Hierarchical mixer node in the engine's audio routing graph. Each bus owns three Web Audio nodes (input gain, optional effect…

Construction options for AudioBus.

Abstract base for all insertable audio effects in ExoJS. Each effect exposes stable inputNode and outputNode AudioNodes that…

Procedural tone generator - produces audio from an `OscillatorNode` without any decoded asset. Good for prototyping, game-jam…

Construction options for AudioGenerator.

A live audio capture source - a microphone or WebRTC `MediaStream` obtained via `getUserMedia`. **Not a Playable**: you don't…

Options for AudioInput.open - forwarded to `getUserMedia` audio constraints.

Observer position that spatial voices of one Application are panned against. Read each frame from AudioListener.target when o…

Anything AudioListener.target can be set to. The listener reads its world-space position from the target each frame: - SceneN…

Converts between audio-context time and the `performance.now()` timeline, so that audio scheduled in one can be lined up with…

One correlated reading of the audio clock against the `performance.now()` timeline.

A parallel tap from one voice's output into an AudioBus, at its own level. A send is what an insert effect cannot express: th…

Named sub-region of an AudioBuffer used as an audio sprite sheet. `start` / `end` are seconds into the buffer; `loop` makes t…

Streaming long-form audio backed by an `HTMLAudioElement` - background tracks, voice-over, **and internet radio** (same mecha…

Per-Application owner of the audio mix: three pre-configured AudioBus instances (`master` ← `music` + `sound`), a single Audi…

Raised when the host environment provides no Web Audio API at all - a missing `AudioContext`, `OfflineAudioContext`, or `getU…

A region of the world that contributes a parallel send while the listener is inside it - a reverb zone, a muffled corridor, a…

A circular zone footprint: a centre on the world plane plus a radius.

Construction options for AudioZone.

Where an AudioZone applies - an axis-aligned Rectangle or a circle.

Options for autoTile and refreshCell.

Auto-wah effect that uses an amplitude envelope follower to modulate a bandpass filter, creating the characteristic "wah" swe…

Construction options for AutoWahEffect.

A named signed axis in -1..1, fed by a stick, by two opposing button groups, or by several such bindings at once. Alternative…

A directly signed source (a stick axis) or a composite built from two button groups.

Two opposing groups of sources forming one signed axis. `negative` and `positive` are the generic one-dimensional terms - use…

A low-level, backend-only render command. Implement this for custom passes that need direct RenderBackend access (custom shad…

Real-time tempo + beat tracker. Splits work between the audio-rendering thread (an AudioWorklet that runs onset detection, te…

Dispatch token for binary data loading. `loader.load(Asset.type('binary', 'data.bin'))` returns `Promise<ArrayBuffer>`.

Arbitrary binary files, handed over as the bytes that arrived.

One channel bound by more than one action of the same map.

A player's rebindings, as the persistable delta against the developer's defaults. A profile stores ONLY the actions a player…

Wire format BindingProfile.toJSON produces and BindingProfile.fromJSON accepts.

Native biquad filter effect backed by a single `BiquadFilterNode` - the most common audio-shaping need, covering `lowpass` /…

Construction options for BiquadEffect.

Lo-fi bit-crusher effect implemented as a WorkletEffect. Applies two classic degradation stages in series: 1. **Bit-depth red…

Text node that renders from an offline-generated atlas - either a BMFont (AngelCode .fnt + .png) or an MSDF atlas (msdf-atlas…

Compositing blend modes applied when drawing a Drawable over the current render target. Modes 0-4 are implemented as fixed-fu…

A Filter that adds a soft glow around the bright parts of its input - bloom, in the engine's ordinary sRGB path. Pixels whose…

Construction-time options for a BloomFilter.

Gaussian blur Filter, run as two separable passes. The input is swept along X into a scratch target, then that scratch is swe…

Construction-time options for a BlurFilter.

A loaded BMFont asset: the parsed descriptor plus all page textures. Loaded by the built-in BMFont factory - no extra setup r…

Adapts BmFontData to the GlyphProvider interface consumed by layoutText. - `getGlyph()` maps BMFont metrics to GlyphInfo usin…

AngelCode BMFont descriptors (`.fnt`, text format) together with their page textures. The pages are claimed by the font's own…

Per-character metrics from a BMFont descriptor.

Parsed representation of a BMFont (.fnt) descriptor.

Construction options for a body.

Simulation role of a PhysicsBody. - `dynamic` - fully simulated (finite mass); moved by the solver once dynamics ship, and by…

Debug layer that draws a bounding-box outline around every visible RenderNode in the scene. Colours cycle by zIndex (HSL hue)…

Mutable axis-aligned bounding box accumulator. Starts as the empty bounds (`-Infinity..Infinity` reversed) and grows monotoni…

Random point inside an axis-aligned box. With `mode: 'edge'` the result lies on the perimeter (uniform along all four edges c…

Axis-aligned box of `width × height` centred on the collider's local origin - a convenience over PolygonShape. The result is…

Convenience alias for the non-null element type returned by `navigator.getGamepads()`.

The PlatformAdapter backed by the browser: a canvas element for the drawing surface, `window` for keyboard and blur, `documen…

GPU buffer binding targets. Values are WebGL2 GLenum constants used when calling `gl.bindBuffer`.

Hints describing expected buffer access pattern, allowing the driver to optimise allocation. Values are WebGL2 GLenum constan…

Immutable compile-time build metadata for `@codexo/exojs`. `development` mirrors the `__DEV__` compile-time constant and is s…

Burst trigger schedule. The module fires at `time` seconds (since registration), spawning `count` particles in one frame.

Discrete-burst spawner. Fires at scheduled times with a fixed count per burst. Useful for explosions, hit-impacts, level-up e…

Spawn configuration for BurstSpawn: the burst schedule plus the shared per-property fields.

Clickable button with a rounded background, a centered label, hover/pressed visual states, and keyboard activation (Enter / S…

A named on/off input, fed by one source or by several interchangeable ones. Sources may be digital (a key) or analog (a trigg…

Sources a ButtonAction accepts: one channel, or several interchangeable ones.

Shared mechanism behind every action that reduces a set of bound channels to a single on/off `active`/`pressed`/`released` (p…

The states a button's skin can be stated for.

The operations a CachePolicy may perform on one acquisition. Deliberately narrow. A policy decides ORDERING - read before fet…

Reads the cache first and only fetches when it misses. The default policy, and the right one for content that does not change…

How one acquired representation is laid out in persistent storage. This is the boundary between what an asset's source data I…

The store operations a CacheLayout may use, scoped to one acquisition. A layout addresses its own records by name and never c…

Reads the cache and never touches the network. For a shipped or pre-warmed cache, and for offline modes that must fail loudly…

Decides in which order a cache and the network are consulted for one acquisition. This is the extension point for custom cach…

What a CachePolicyResolver is told about the acquisition it is choosing a policy for.

Chooses the CachePolicy for one acquisition, at the moment it starts. A route is configured with a policy or with a resolver.…

Either shape a route accepts for its policy.

The outcome of reading one cache record. A miss and a failure are deliberately different things: a miss resolves to `{ hit: f…

The identity of one persisted cache record. A SourceKey alone is deliberately not enough. It carries no asset type - two type…

One caching rule: which asset types it covers, which stores it uses, and in what order the cache and the network are consulte…

Construction options for a CacheRoute.

Physical storage for cache records. A store is asset-agnostic by contract: it never sees an asset type, a factory, a codec or…

Runs a user callback as one pass. The callback receives a PassContext scoped to the active target: `pass.render(node)`, `pass…

Options for CallbackRenderPass.

How the finished frame composites against the page behind the canvas. - `'opaque'`: the canvas has no alpha channel. Whatever…

Strategy that decides how a canvas is sized and, where it lives in a document, how it follows its surroundings. An instance o…

What a CanvasSizing is given to work with, and the one channel through which it changes the canvas. A context describes the a…

The size of the element a sizing policy tracks, in CSS pixels.

One complete description of how the canvas is sized, in the three axes the engine keeps apart. `cssWidth`/`cssHeight` are the…

Frozen snapshot of host-environment feature support: which renderer backends are available, which input modalities are presen…

Scales the canvas to its parent and lets the render resolution follow it downwards, but never above the base resolution. The…

A capsule: the set of points within `radius` of the segment between two local-space endpoints. Exact geometry, never a polygo…

Options for RenderingContext.capture - allocates a new RenderTexture.

A single catalog field input: a bare path string, an `Asset.type(...)` descriptor, or an explicit config.

A resource type's catalog leaf: the heal-in-place placeholder resource itself (`Texture`, `Sound`, ...), branded. Stays assig…

A value type's catalog leaf: a deferred AssetRef, branded with the DECODED payload type - which is what loading it resolves t…

A connected boundary through a run of local-space vertices: level outlines, terrain, the ground of a side-scroller. Open (a p…

Construction options for a ChainShape.

Tuple type for `change()`'s single options parameter: present-and-required whenever `ChangeSceneOptions<Data>` has a required…

Options for SceneDirector.change. Carries the activation `data` (when `Data` is not `void`), `suspendCurrent`, and an optiona…

Base offsets of each input category inside the unified channels buffer. Add a per-key/per-slot value to one of these to get a…

Slot-count constants for the unified channels buffer. The buffer is split into three categories (`Keyboard`, `Pointers`, `Gam…

Options shared by the two-state controls (Checkbox, Toggle).

Base class of the two-state controls (Checkbox, Toggle): an interaction state machine like Button's, an orthogonal `checked`…

A box that is either ticked or not, with an optional label beside it. Clicking it, tapping it, or pressing Enter or Space whi…

Options for Checkbox.

Button-like action active while every channel in a chord is held at once - `Control+S`, a modifier held alongside a gamepad b…

A binding accepted by ChordAction: a `'+'`/`'|'` string of case-insensitive Keyboard token names (`'Control+S'`, `'Control+S|…

Chorus effect using native WebAudio nodes (no worklet required). The signal splits into a dry path and a wet path. The wet pa…

Construction options for ChorusEffect.

A signed chunk coordinate pair.

A chunk payload ready to install into a import('./TileLayer').TileLayer via import('./TileLayer').TileLayer._adoptChunk - the…

The inclusive range of chunk coordinates that intersect a bounded TileLayer. `null` for an unbounded layer (no range limit).

Supplies chunk data for one import('./TileLayer').TileLayer on demand, keyed by signed chunk coordinates - the abstraction a…

Drives TileLayer._adoptChunk/TileLayer._evictChunk calls from a View's position: chunks near the view are requested from a Ch…

Options for a ChunkStreamer. All optional.

Mutable circle shape defined by a centre position and radius. Implements Collidable for use in the collision pipeline. For SA…

Random point on or inside a circle of radius `radius`, centred at `(centerX, centerY)`. With `mode: 'edge'` the result lies e…

Structural type for any object that describes a circle via a centre point and radius.

A circle of the given `radius` centred on the collider's local origin. The cheapest shape for both broad- and narrow-phase.

High-precision clock that accumulates elapsed time while running. Reads the host's monotonic clock unless a TimeSource is sup…

Structural interface for value types that support a deep clone and an in-place copy from a same-type source. Implemented by C…

Binary codec facade, grouped as a namespace so the public API carries no loose codec functions.

Contract for objects that participate in collision detection. Implemented by all concrete shape classes as well as `SceneNode…

Geometry attached to a PhysicsBody: a Shape plus a body-local offset/rotation, material (friction/restitution/density) and a…

Collider settings shared by every generated collider unless overridden.

Construction options for a collider.

Shape-vs-shape collision queries, grouped as a namespace so the public API carries no loose `intersection*`/`getCollision*` f…

Immutable per-dispatch snapshot describing a solid (non-sensor) contact. Frozen: it is safe to read during the callback and t…

Per-collider collision filter. A pair is considered for collision only when each collider's mask includes the other's categor…

Result of a successful Collidable.collidesWith call. Contains the two participating shapes, the penetration depth, containmen…

Discriminant tag carried by every Collidable so that intersection and collision routines can dispatch to the correct algorith…

32-bit RGBA color value with channel-wise accessors. Red, green, and blue are integers in 0..255; alpha is a float in 0..1. O…

Piecewise-linear color gradient sampled by lifetime ratio `t` in `[0, 1]`. Keyframes are stored sorted by `t`; sampling outsi…

A keyframe in a ColorGradient: color at lifetime ratio `t` in `[0, 1]`.

Anything Color.from accepts. A number is always `0xRRGGBB` and never carries alpha - see Color.from for why the packed form s…

A 4×5 row-major colour matrix: four rows of `[r, g, b, a, offset]`.

A Filter that runs one affine colour transform over everything it is given: `RGBA' = M·RGBA + bias`, carried as a 4×5 row-maj…

Per-frame, per-particle color sampler. Each live particle's tint is set to the gradient evaluated at the particle's current `…

Per-frame, per-particle color sampler driven by velocity magnitude rather than lifetime ratio. Each live particle's tint is s…

Color attachment format for an offscreen RenderTexture - the TextureFormat subset that can be rendered into. The float format…

Progress of a host-side composition (an IME candidate). While one is in flight its text lives only here; it merges into the v…

Block geometry of a compressed format: the texel footprint of one block and how many bytes that block occupies. Both backends…

A Texture constructed directly from a compressed payload. Convenience only: a compressed payload is something a plain `Textur…

A block-compressed GPU texture format. These are hardware formats: the GPU samples the compressed blocks directly, so a compr…

One mip level of a compressed texture payload: the block bytes exactly as the container stored them, plus the texel extent th…

Construction options for CompressedTexture.

A texture payload already in a hardware block-compressed format, as carried by Texture.compressed. The saving is real in both…

Dynamic-range compressor backed by a Web Audio `DynamicsCompressorNode`. Reduces the volume of loud signals above a threshold…

Construction options for CompressorEffect. All values are clamped to their valid ranges on assignment.

Thrown when `change`/`restore` is called while another Scene switch, restore, or transition session is already in flight - na…

Random unit vector inside a cone, scaled by a speed magnitude. The cone is centred on `directionAngle` (in radians, 0 = +X, π…

Whether the application should reach the network at all, right now. Two separate questions, deliberately never equated: - sta…

Routes acquisitions through the cache alone whenever the application is not allowed to reach the network, and through the con…

Construction options for a ConnectivityPolicyResolver.

What the environment appears to provide. `'unknown'` is a real answer, not a placeholder: a host that reports nothing about r…

Distribution that always returns the same value. Implements both Distribution and LifetimeFunction so it can stand in whereve…

Extracts the Scene subclass constructor a SceneRegistration resolves to - unwraps the descriptor form, passes a bare construc…

Called once per solid contact per fixed step, after contact generation and before the solver runs, to adjust that contact for…

A solid contact as the world's ContactModifier sees it: the pair that produced it, the contact normal, and the three per-step…

A single contact point on a CollisionEvent. World space.

Scene-graph node that owns child RenderNodes. Renders its subtree in document order with local `zIndex` ordering resolved ins…

One independently compressed run of the data section. Blocks tile the uncompressed section in order and without gaps, and a b…

Where a reader keeps container blocks between visits. A block is addressed by its hash, never by the pack it came from, so tw…

How a block's stored bytes are encoded. `deflate-raw` decodes through the browser's `DecompressionStream` with no dependency…

One asset in a container's head. `offset` and `length` address the asset's own bytes within the uncompressed data section. `t…

Reads assets out of a `.exoa` container, fetching only the blocks it needs. A container's data section is tiled by independen…

How a ContainerReader is opened.

A request to show a context menu, in design-space coordinates. Right-click, the keyboard context-menu key, and Shift+F10 all…

Convolution effect that convolves the input signal with a user-supplied impulse response (IR). Unlike ReverbEffect, which gen…

Construction options for ConvolutionEffect.

Handle for work handed to a CoroutineSystem. Poll Coroutine.status, Coroutine.progress and Coroutine.result from frame code,…

Work a CoroutineSystem advances one step per frame: a generator function whose every `yield` hands control back to the frame.…

Lifecycle of a Coroutine. `queued` until its first step, `running` from then on, and exactly one of the three terminal states…

Advances generator-based coroutines a step at a time in the frame's leftover capacity, so heavy work (world generation, batch…

Continuous blend between the outgoing scene (frozen as a snapshot at session start) and the incoming scene (rendered live to…

Options for CrossFadeSceneTransition.

Dispatch token for CSV loading. `loader.load(Asset.type('csv', 'table.csv'))` returns `Promise<string[][]>`. Each inner array…

Options accepted by an asset of the built-in `csv` type.

CSV and TSV tables, parsed into rows of raw field strings.

Piecewise-linear keyframe curve sampled by lifetime ratio `t` in `[0, 1]`. Keyframes are stored sorted by `t` and clamped at…

A keyframe in a Curve: value `v` at lifetime ratio `t` in `[0, 1]`.

Low-level key/value database abstraction with a declared schema. Data is organised into named object stores (`type`) that act…

A 2D texture whose pixels live in a CPU-side typed array. Mutate the `buffer` directly and call commit to upload the whole ar…

Buffer typed-array kind for a given format.

A region of the buffer marked for upload by the next backend sync. Bounds are pixel coordinates with origin at the top-left.…

Pixel format for DataTexture - the TextureFormat subset that can be uploaded from a typed array. Excludes `Rgba16F`, which ha…

Construction options for DataTexture.

Per-particle hook invoked exactly once after a particle expires, carrying its state at the moment it died. Use for sub-emitte…

Abstract base for a single diagnostic overlay layer. Subclasses produce a visual (outlines, text panels, sparklines, etc.) th…

Determines the coordinate space a DebugLayer renders into. `'screen'` uses the overlay's pixel-space view; `'world'` uses the…

Canvas-native debug overlay. Instantiate AFTER Application is constructed: import { DebugOverlay } from '@codexo/exojs/debug'…

A decoded raster image: an ImageBitmap where the environment supports one.

Compression formats supported by the native `DecompressionStream`.

Marks every property of `T` `readonly`, recursively: nested objects, arrays, tuples, `Map` and `Set` are all rewritten, so a…

Echo/delay effect using a Web Audio `DelayNode` with a feedback loop and dry/wet mix. The feedback path feeds the delayed sig…

Construction options for DelayEffect.

The depth attachment of a render target, bindable as a named texture of a custom MeshMaterial or SpriteMaterial. It is create…

Tuning for deriveNormalsFromAlpha.

Context handed to NodeSerializer.read. Mirror of SerializeContext for the inverse direction: child recursion and asset lookup…

Structural interface for anything that holds resources requiring explicit release. ExoJS value types tend to implement this e…

Ownership container for Destroyable resources. Items registered with track are destroyed in reverse registration order when t…

How diagonal steps are allowed on a GridSpace. - `never` - four-connected movement only. - `no-corner-cutting` - a diagonal s…

A Filter that offsets every fragment's source position by a direction read out of a texture - heat haze, water refraction, gl…

Construction-time options for a DisplacementFilter.

Holds the anchor points on two bodies at a target length along their connecting axis. With `hertz === 0` it is rigid; with `h…

Construction options for a DistanceJoint.

Distance-attenuation model used by spatial sounds. Mirrors Web Audio's `PannerNode.distanceModel`: - `'linear'` - `v = 1 - ro…

Distortion effect built from native Web Audio nodes - no worklet required. The input signal is split into a dry path and a we…

Construction options for DistortionEffect.

Value distribution sampled at particle spawn time. Each `sample()` call may return a different value - used to randomize spaw…

Layout container that pins children to the edges of its box and gives the remaining space to the centre. Each edge child is s…

Where a DockContainer places a child.

Exponential velocity damping. Each frame multiplies every live particle's velocity by `(1 - drag * dt)`, simulating linear ai…

Base class for every renderable scene object. Extends RenderNode with a per-object tint colour, blend mode, and the normalize…

Options for RenderingContext.drawBatch.

The shared rendering verbs that act on the active render target. Implemented by the frame-level RenderingContext (active targ…

Options for RenderingContext.drawGeometry.

A closed control showing the current selection that opens a list of alternatives. Clicking it, or pressing Enter or Space whi…

One selectable entry of a Dropdown.

Options for Dropdown.

A Filter that draws a soft, offset silhouette of its input behind the input itself - the classic drop shadow. The shadow is t…

Construction-time options for a DropShadowFilter.

Sidechain compressor (ducker) implemented as an WorkletEffect. Attenuates the main audio signal whenever the `sidechain` Audi…

Construction options for DuckingEffect. `sidechain` is required.

Thrown (dev builds only) when `ApplicationOptions.scenes` registers the same constructor under more than one key.

Boundless, incrementally-updated bounding-volume hierarchy over fat AABBs (Box2D b2DynamicTree-style). Generic sibling of Qua…

Standard Robert Penner easing functions. Each function accepts a normalized time `t` in [0, 1] and returns a value that equal…

Mutable axis-aligned ellipse shape defined by a centre position and separate horizontal (`rx`) and vertical (`ry`) half-radii…

Structural type for any object that describes an axis-aligned ellipse via a centre point and half-radii.

An ellipse inscribed in `[x, y, width, height]`.

ADSR (Attack-Decay-Sustain-Release) envelope generator. Schedules a gain curve on a target `AudioParam`: attack: 0 → 1.0 (pea…

Three-band equalizer (low shelf / peaking mid / high shelf) built from a series chain of `BiquadFilterNode` instances. Gain v…

Construction options for EqualizerEffect.

An ExoJS extension: an immutable descriptor that contributes renderer bindings, asset bindings, serializer bindings and/or ap…

Undoes one Extension.install call, for the one Application that call was made against. Returned by `install`, held by that Ap…

Type-level twin of the built-in suffix table: file suffix to asset type, for bare-string path inference in `Assets.from()`/`g…

Fade to a color, switch scenes, fade back in. `placement: 'screen'`, `currentFrame: 'direct'`, `outgoingFrame: 'none'` - the…

Options for FadeSceneTransition.

Abstract base class for post-process filters applied to a drawable's render output. Filters are rendered into a temporary Ren…

Runs a Filter or a chain of them from a source texture into a destination, as one pass inside a RenderPipeline. ```ts pipelin…

Options for FilterPass.

Options for Pathfinder.findPath and Pathfinder.findPathBetween.

Scales the canvas to its parent while the render resolution stays exactly at the base resolution. The CSS box is the largest…

Type-safe bitfield utility for managing sets of numeric enum flags. `T` should be a numeric const-enum or a type whose values…

Flanger effect using native WebAudio nodes (no worklet required). A flanger is a very short LFO-modulated delay (1-10 ms) wit…

Construction options for FlangerEffect.

Options for Pathfinder.floodFrom.

Result of Pathfinder.floodFrom: every node reached, with its cost.

A direction for spatial focus navigation - see InteractionSystem.focusInDirection.

Which nodes the arrow keys and the D-pad may move focus to - see InteractionSystem.focusNavigation. - `'ui'` restricts naviga…

Dispatch token for font loading. `loader.load(Asset.type('font', 'font.woff2', { family: 'MyFont' }))` returns `Promise<FontF…

Options accepted by an asset of the built-in `font` type.

Web fonts (WOFF, WOFF2, TTF, OTF) parsed into a loaded `FontFace`.

A CSS font-family string. When FontRegistry has entries the type narrows to registered names ∪ arbitrary strings (for unregis…

Open interface for compile-time font-family autocomplete via declaration merging. Register loaded font families in your app's…

CSS font-style values accepted by Canvas 2D. `'oblique'` slants an upright face by a fixed angle. Where a family ships a real…

The typeface a glyph source draws from: a family, and the slant and weight selected within it. A loaded FontFace replaces eve…

CSS font-variant-caps values the glyph rasterizer honours. `'small-caps'` renders lowercase letters as reduced capitals - fro…

Everything that decides which glyphs a text run is drawn from. Named rather than positional because the four values are all s…

Font weight values accepted by CSS / Canvas 2D.

Lighting shaded inside the sprite fragment stage, against one packed light texture. ```ts const lighting = new ForwardLightin…

What ForwardLighting takes whether or not it was given a host.

Per-language count of the color attachments a fragment stage declares an output for, as reflected from the shader source. `nu…

How much of the running frame is still unspent, handed to the SystemMethods.postFrame phase. Modelled on the platform's `Idle…

What LightmapLighting and RadianceLighting both take.

Display-synchronised frame scheduling. The timestamp handed to the callback shares its origin with TimeSource.now, so the two…

Free functions and constants exported from @codexo/exojs.

One of four stable gamepad slots. Lives for the entire `Application` lifetime even when no physical pad is attached - a "mail…

Single mappable analog axis on a physical gamepad. Holds the raw browser `Gamepad.axes[]` index, the canonical channel the va…

Branded literal-union type identifying a canonical analog axis-style gamepad input channel. Members are absolute offsets into…

Construction options for a GamepadAxis.

Single mappable button on a physical gamepad. Holds the raw browser `Gamepad.buttons[]` index, the canonical channel the valu…

Branded literal-union type identifying a canonical button-style gamepad input channel. Members are absolute offsets into the…

Construction options for a GamepadButton.

A rule that matches one or more physical gamepads and produces a GamepadMapping. `ids` is an optional allow-list of vendor ID…

Value a GamepadDefinition.resolve callback may return. Return a bare GamepadMapping to accept the device with the definition'…

Parsed metadata extracted from a browser `Gamepad.id` string. `vendorId` and `productId` are four-hex-digit strings (e.g. `"0…

Identity metadata for a connected gamepad. Populated from a ResolvedGamepadDefinition.

Translation layer between the browser's raw Gamepad API indices and ExoJS-canonical input channels. The engine selects one wh…

One device layout, as data. This is the whole definition of a controller as far as the engine is concerned - no subclassing i…

Device family a GamepadMapping belongs to. The value a game keys its own button-glyph or controller-artwork set on: `icons[ga…

Which index space a GamepadMapping's button and axis indices live in. Almost every mapping is written against the W3C "standa…

Named controls that can appear in an in-game prompt or button-hint UI. Intentionally a subset of GamepadButton channels - cov…

Static utility that drives in-game controller-prompt UI. Provides the canonical set of prompt controls, their normalised [x,…

Slot a gamepad channel is resolved against. Runtime context supplied by the owning ActionMap, never part of a binding or of p…

Strategy used by InputSystem when assigning physical gamepads to slot indices in InputSystem.gamepads. - `'sticky'` (default)…

Effect parameters for Gamepad.vibrate.

Non-renderable geometry data object used by advanced rendering paths. Geometry owns only vertex/index data and its layout met…

Descriptor for one attribute in an interleaved vertex layout. Offsets and stride are expressed in bytes.

Construction options for Geometry.

GPU buffer ownership strategy used by geometry-aware render paths. - `static` - immutable after creation; eligible for shared…

A per-font-variant glyph atlas with automatic multi-page growth. In `'sdf'` mode (default) each atlas page is a single-channe…

Cached glyph data stored in an atlas page after rasterization.

A key that uniquely identifies a glyph within a GlyphAtlas. Format: `${char}:${size}`

The LOGICAL typographic metrics of one font variant - advances and kerning, in logical pixels, at the logical font size. This…

A single glyph's quad placement in local text space. Origin is the top-left of the first line.

Provider of per-character glyph metrics, consumed by layoutText. GlyphAtlas implements this for runtime-rasterized text. `BmF…

CPU-rasterized gradient base. A Color-like paint value (not a Drawable): it owns a normalized list of color stops plus subcla…

Discriminant identifying the concrete gradient kind (`gradient.type`).

Granular synthesis filter - slices input into small Hann-windowed grains and replays them with randomized parameters. Use cas…

Immediate-mode 2D shape API backed by Mesh children. Each draw call (e.g. `drawCircle`, `drawRectangle`, `drawLine`) appends…

A reusable 2D path: a sequence of subpaths built from lines, Bézier curves and arcs, kept as commands rather than as vertices…

A rectangular window of weighted, optionally blocked cells. The window is finite by construction: everything outside it is bl…

Construction options for GridSpace.

Anything that can produce an axis-aligned bounding Rectangle.

High-pass filter backed by a `BiquadFilterNode` in `highpass` mode. Attenuates frequencies below the cutoff and passes everyt…

Construction options for HighpassFilter.

Acceptable shapes for RenderNode.hitArea, expressed in the node's own local space: a Rectangle, Circle, Ellipse or Polygon, o…

Debug layer that draws outlines around interactive scene nodes. - Magenta: interactive but idle. - Yellow: currently hovered.…

Which kind of global scope the probes ran in. Capabilities are realm-local: the same browser reports different answers on its…

Text node that renders arbitrary HTML+CSS into a canvas texture via an SVG `<foreignObject>` pass and displays the result as…

Dispatch token for image loading. `loader.load(Asset.type('image', 'img.png'))` returns `Promise<HTMLImageElement>`.

Options accepted by an asset of the built-in `image` type.

Raster images decoded without a Texture wrapper - an `ImageBitmap` where the environment has one. It claims no file suffixes:…

A data-only image layer: a single image (texture + resolved URL) placed as a background or foreground layer. The layer itself…

A scene node that renders one Tiled ImageLayer as a single RepeatingSprite wrapped in a Container. The layer's pixel `offset`…

Construction options for an ImageLayer.

Database implementation backed by the browser's IndexedDB API. Each object store is created with a `keyPath` of `"name"`, so…

KeyValueStore over IndexedDB, using the **structured-clone** algorithm. Unlike WebStorageStore, values are stored *directly*…

Construction options for IndexedDbKeyValueStore.

CacheStore that persists acquired asset representations in IndexedDB. ```ts const app = new Application({ loader: { cache: ne…

Construction options for IndexedDbStore.

The LOADED payload a CatalogEntry resolves to - what a `loader.load(catalog)` result map holds, as opposed to the handle-hybr…

Maps each key of a catalog DEFINITION record to its resolved runtime resource type. Keyed on CatalogEntry, not `AssetInput`:…

Extracts the activation-data type a SceneConstructor expects.

Runs a worker from a JavaScript source string instead of a separate script file, and owns the lifetime of the object URL that…

Options for InlineWorker.

One SequenceAction step (or the whole binding a ChordAction accepts) satisfied by any ONE of several alternatives rather than…

One subscription to one or more input channels. Tracks active state, fires the onStart / onActive / onStop / onTrigger Signal…

Raised when serialized binding data cannot be read: a profile whose shape or version this build does not understand, a bindin…

Construction options shared by every binding factory method.

Channel a single InputBinding can subscribe to.

One SequenceAction step requiring every listed channel simultaneously - the array-form equivalent of a `'+'`-joined chord tok…

One input context: the action maps that are in charge while it is the topmost scope on a SceneInputs stack. A scope claims ex…

An ordered list of SequenceAction pattern steps. Each entry is a single InputChannel (a one-channel step), a nested InputChor…

Owns the unified input pipeline for an Application: keyboard events, pointer (mouse/touch/pen) events with multi-touch slot m…

Stable, persistable identifier for one input control. A token is lowercase ASCII, uses `.` as the namespace separator and `-`…

Live control handle for an AudioInput (microphone / WebRTC stream), created via AudioSystem.open. Unlike a Playable voice it…

DOM-Event-shaped envelope dispatched by InteractionSystem to interactive scene nodes. Bubbles up the *entire* parent chain -…

String literal union of every interaction event the InteractionSystem can deliver to a RenderNode. Handlers attach via the no…

Handle returned by SceneInteraction.observe. Detaches the observed root from interaction dispatch - call InteractionObservati…

Handle returned by SceneInteraction.scope. While active, pointer hit-testing and Tab traversal are confined to the scoped roo…

Routes pointer events from the InputSystem to interactive scene-graph nodes via DOM-style event bubbling. Maintains a persist…

A closed scalar interval `[min, max]` used by the SAT collision solver to represent the projection of a shape onto a separati…

Thrown (dev builds only) when `ApplicationOptions.scenes` contains a value that is not a SceneRegistration - neither a Scene…

Base class for a two-body constraint solved alongside contacts in the sub-step loop. Concrete joints (distance, revolute, wel…

Options every joint accepts, whatever it constrains.

Dispatch token for generic JSON loading. `loader.load(Asset.type('json', 'config.json'))` returns `Promise<unknown>`. Narrow…

JSON documents, parsed on read and stored as the text that arrived.

Channel indices for keyboard keys, addressed by PHYSICAL key position. Pass any value to the Input constructor to react to th…

Envelope dispatched by `app.interaction` to the focused RenderNode for keyboard input, then bubbled up its entire parent chai…

Keyboard phase delivered to a focused node.

Async key/value store for application data - game saves, settings, profiles, cached payloads. A single, uniform surface so ca…

The asset type inferred from a path literal, or `never` when unregistered.

Text label widget. Wraps a Text node and keeps the widget's layout size in sync with the measured text, so it anchors and sta…

Controls text flow and overflow - separate from TextStyle which describes visual appearance. Pass to Text or layoutText.

Free functions and constants exported from @codexo/exojs-ldtk.

Root LDtk JSON document (`*.ldtk`).

Top-level definitions block (`defs`).

An entity instance placed in an Entities layer.

The `__type` LDtk writes for an enum-valued field: the enum's identifier qualified by where it is defined. The `__value` is t…

A field value on an entity or level instance, discriminated by `__type`. `Array<T>` fields (e.g. `Array<Int>`, `Array<Point>`…

Thrown when an LDtk JSON document does not match the expected shape. `source` is the URL of the file being parsed; `path` is…

An IntGrid value definition (maps a raw int to a named, coloured entry).

Layer definition from `defs.layers`.

A layer instance within a level.

Discriminant string for a layer instance type.

A level in the LDtk world.

One entry of a level's `__neighbours` array: an adjacency to another level, plus the direction code LDtk assigned it.

A parsed LDtk world document: holds the raw JSON data and the converted runtime TileMap for each level. `LdtkMap` is the pars…

A fully assembled LDtk world: every referenced tileset image loaded, every externalized `.ldtkl` level resolved, and one runt…

A loaded LDtk project, prepared for streaming: world layout and tileset atlases are resident, level payloads are not. This is…

The streaming entry point: an LDtk world's layout and tileset atlases, with no level payload loaded. It claims no suffix, so…

Options for LdtkProject.createRuntime.

A single tile placed in a Tiles or AutoLayer layer instance.

Tileset definition from `defs.tilesets`.

Options for ldtkToTileMap.

A single world in a multi-world LDtk project (`root.worlds[]`, populated when the project has "Multi-Worlds" enabled in its a…

How a LdtkWorldData's levels are spatially organised. `null` is a valid LDtk value (unset), same as the other nullable enum-i…

Lifetime-parameterised function that produces a deterministic `T` for a given lifetime ratio `t` in `[0, 1]`. Used by per-fra…

Base class for every light: a scene node that emits rather than draws. Being a node is the point. A light parents to whatever…

What a lighting system does with lights, materials and occluders, whichever renderer turns them into pixels. ```ts const ligh…

Intermediate to draw instead of the shaded frame. `null` shades normally. - `'light'` shows the accumulated light field on it…

What a lighting system needs of the application whose frame it lights. A renderer that composes the frame reads the drawn fra…

What every lighting system takes, whichever renderer it is.

Which renderer shades the scene, as Lighting.quality reports it. A scene never names one: it constructs the system it wants -…

Lighting accumulated into a target of its own and multiplied onto the frame. ```ts const lighting = new LightmapLighting(app,…

Construction options for LightmapLighting.

Options every light shares. Each field is also mutable afterwards.

Brick-wall limiter backed by a Web Audio `DynamicsCompressorNode` configured for hard limiting: a fixed high ratio (~20), zer…

Construction options for LimiterEffect.

Mutable line segment defined by two endpoint positions. Implements Collidable for intersection tests against all shape types.…

Linear gradient in UV space projected from `start` to `end`.

A segment that emits: a neon tube, a light strip, a laser. Falloff is measured from the nearest point on the segment, so the…

Construction options for LineLight. Every field is also mutable afterwards.

Structural type for any object that describes a line segment via start and end coordinates.

Random point on a line segment between `(x0, y0)` and `(x1, y1)`. Uniform parameter distribution: `t = Math.random()` then `l…

How a laid-out line is turned into something placeable when the engine has to hand the whole line to the browser's text engin…

Makes a sprite respond to the lights of a Lighting system. ```ts crate.material = new LitMaterial({ lighting }); hero.materia…

Construction options for LitMaterial.

Any abstract or concrete constructor that can be used as an asset type token with Loader.load and related methods.

How Loader.loadContainer fetches a container.

Construction options for Loader. `basePath` is prepended to relative asset paths at fetch time. `concurrency` caps the number…

An owner of asset claims with an explicit lifetime. Assets acquired through a scope stay resident for as long as that scope h…

What a claim scope represents, for diagnostics only. Ownership never varies by kind: every scope holds and releases claims id…

Options for Loader.createScope and LoaderScope.createScope.

An awaitable, progress-aware load operation. Implements `PromiseLike<T>` so it can be `await`ed directly and composed with `P…

How Loader.loadManifest fetches a manifest.

Options for the catalog/asset/leaf Loader.load forms.

How urgently a Loader.load call should fetch what it adopts. An enum rather than a boolean because priority is the axis a res…

Load lifecycle of a seamless asset handle. Directly constructed assets are `'ready'`; a catalog leaf awaiting adoption is `'i…

The normalized record dispatched to every LogSink.

Engine-wide log dispatcher. Below `LogSeverity.Error`, calls are dropped outright in production builds (`__DEV__` is `false`)…

Per-call metadata for Logger.debug/Logger.info/Logger.warn/Logger.error. - `source` renders as `[ExoJS][source]` in the defau…

A subscriber invoked with every dispatched LogEntry.

A voice whose source can loop.

Low-pass filter backed by a `BiquadFilterNode` in `lowpass` mode. Attenuates frequencies above the cutoff and passes everythi…

Construction options for LowpassFilter.

A Filter that maps every pixel of the input through a Look-Up Table texture. Two storage modes: - **RGB 1D LUT** (`N×1`, defa…

Construction options for LutFilter.

Storage layout for a Look-Up Table texture.

One pack a manifest carries.

Hands the canvas geometry to whoever is hosting it. Nothing is observed, no CSS is written and no size ever changes on its ow…

An axis-aligned rectangle in world pixel space (+Y down).

Immutable metadata for one level of a MapWorld - everything needed to decide whether to load it, without loading it.

Options for a MapWorldRuntime.loadLevel that spawns nothing.

What a MapLevelProvider is given for one level load.

Options for a MapWorldRuntime.loadLevel that also spawns the level's map objects. `spawner` and `context` travel together: th…

One adjacency edge from a level to another level in the same MapWorld.

Produces the runtime TileMap for one level - the single seam where a source format meets the format-neutral world runtime. An…

One loaded level and everything that load produced. Created by MapWorldRuntime.loadLevel; destroying it unloads the level. Th…

Side discriminant for a MapLevelNeighbour.

A format-neutral view of one map object, as handed to a import('./MapObjectSpawner').MapObjectFactory. The descriptor is what…

Dispatch key to factory. Keys are matched against the spawner's `identify` result.

Creates one runtime object from one map object, or `null` to deliberately create nothing for it. `signal` aborts with the spa…

Turns the objects authored in a map into game objects. A spawner owns its own dispatch table, so several games, tests, editor…

Options for MapObjectSpawner.

A spawn failed. The whole spawn is rolled back before this is thrown - no partial session exists. For `'factory-failed'` the…

Why a MapSpawnError was raised.

Options for MapObjectSpawner.spawn.

The objects one spawn produced, and their shared lifetime. A session is handed out by import('./MapObjectSpawner').MapObjectS…

A format-neutral description of how levels are laid out in a world. A `MapWorld` holds metadata only - no tiles, no textures,…

Construction options for a MapWorld.

The live side of a MapWorld: loads and unloads levels on demand, each with its own asset scope and its own lifetime. ExoJS pr…

Options for MapWorldRuntime.

Acceptable mask sources for RenderNode.mask. - `Rectangle` - solid axis-aligned mask. The fastest path: implemented internall…

Describes the look of a renderable - shader, uniforms, textures, blend mode, and sampling state - independent of its geometry…

Construction options shared by every Material. Only `shader` is required. What `uniforms` means follows from the shader sourc…

A uniform name the raw path accepts; `never` once a schema is declared.

What Material.uniformBlocks exposes for a named-block schema.

What Material.uniforms exposes: typed accessors when the shader source declares `uniforms`, the mutable value record when it…

Starting values accepted for the declared uniforms.

Mutable 3×3 row-major affine transformation matrix used throughout the rendering and physics pipeline. Layout (row, column):…

Options shared by the streaming media factories.

What a media resource is built from. A URL is streamed by the browser, which owns the transfer for the whole life of the elem…

Value for a media element's `crossorigin` attribute. `'anonymous'` is the default for URL-backed media: without it a cross-or…

CacheStore that keeps records in a `Map` for the lifetime of the process. Holds values BY REFERENCE - no cloning, no serializ…

In-memory KeyValueStore backed by a `Map`. Holds values **by reference** - no cloning, no serialization - so it accepts any v…

Arbitrary 2D triangle-mesh primitive. `Mesh` lives alongside Sprite as a public Drawable: it has the same transform (position…

CPU mesh-geometry builders, grouped as a namespace so the public API carries no loose `build*` functions. Named `MeshBuilder`…

Raw mesh data produced by geometry builders. `vertices` is a flat `Float32Array` of `(x, y)` pairs, `indices` is a triangle l…

The typed-array kinds a mesh index stream can be supplied as.

Width of a mesh's index stream. `'uint16'` is the default and the cheaper one - half the index bytes to upload and to keep re…

Material specialization for Mesh drawables. Carries the mesh contract conceptually: fixed vertex attribute locations (0 = pos…

Construction options for a MeshMaterial.

Shadows from a triangle mesh's own silhouette. ```ts lighting.occludeFrom(new MeshOccluder(platform)); ``` Only edges one tri…

Tuning for MeshOccluder.

Construction-time options for a Mesh. Provide the geometry in exactly one of two forms: - **Convenience form** - a flat `vert…

One caller-supplied mesh per particle, drawn as a single instanced draw. The cheap counterpart to `RibbonParticles`: the rela…

Construction options for MeshParticles.

A length of time in milliseconds. The unit the platform speaks - `performance.now()`, frame timestamps, Web Audio scheduling.…

Softly pulls a single body's grab point toward a movable **target** point (typically the mouse cursor). The grab point is fix…

Construction options for a MouseJoint.

An off-screen render target with several colour attachments, written in one pass. One draw can produce more than one image: a…

Construction options for MultiRenderTarget.

Options accepted by an asset of the built-in `music` type.

Streaming audio backed by an `<audio>` element.

Strips `readonly` modifiers from every property of `T`.

The search core's view of a world: integer node ids, a neighbour relation and a heuristic. GridSpace and WaypointGraph implem…

Fetches first and only falls back to the cache when the network failed. For content that changes behind a stable URL and shou…

What a host reports about network reachability. `'unknown'` is an answer, not a missing one: a host that cannot say whether a…

Anything that can report network reachability and say when it changed. A PlatformAdapter satisfies it, and so does the standa…

What the application allows. `'auto'` follows Connectivity.state. `'online'` and `'offline'` are the application's own decisi…

Always fetches, and neither reads nor writes any cache. For sources that must always be fresh - a live configuration file, a…

Source-space or destination-space per-edge insets.

Per-section fill mode overrides for a nine-slice sprite.

Constructor options for NineSliceSprite.

A scalable nine-slice (9-patch) sprite. Corners stay pixel-perfect; edges/center fill by stretch, repeat, or mirror-repeat.

Bidirectional serializer for one scene-graph node type. Registered against a type name + constructor in a SerializationRegist…

Which way up a tangent-space normal map's green channel is authored. `opengl` is the canonical input convention of this packa…

An authored tangent-space normal map. ```ts hero.material = new LitMaterial({ lighting, normals: new NormalMap(heroNormals) }…

Construction options for NormalMap.

Where a LitMaterial takes its surface normals from. An object rather than a name, so a source carries its own parameters and…

A registered drawable and the normals it contributes.

A drawable whose own texture, frame and layout box say where its normals belong on screen. Core's `Sprite` - and therefore `A…

One static body built from one object, paired with its source.

Options for buildObjectLayerColliders.

Geometry discriminant for a TileMapObject.

A data-only layer of TileMapObjects - spawn points, trigger zones, collision regions, markers. Object layers are not rendered…

Construction options for an ObjectLayer.

A point in object-layer space (pixels, relative to the object).

Filter for ObjectLayer.query. Unspecified fields match everything.

A developer-declared mapping from object `type`/class strings to the property shape an object of that type is expected to car…

A Size subclass that fires a callback whenever `width` or `height` changes. Used internally by layout-aware types to invalida…

An AbstractVector subclass that notifies an owner whenever its components change. Used internally by Rectangle, `SceneNode`,…

What PhysicsOccluder reads off one collider.

The local-space geometry an occluder reads off a collider shape. Every field but `type` is present only for the kinds that ha…

A collider's world placement, as physics stores it: a translation plus the precomputed sine and cosine of its rotation.

A scene node offered whole, for a field that can rasterise a silhouette instead of tracing one. What blocks light is the node…

What MeshOccluder reads off a mesh: a flat `(x, y)` vertex stream in local space, its triangle list, and the transform that p…

What PhysicsOccluder needs of a physics world: an AABB query over its live colliders. Structural on purpose. `@codexo/exojs-p…

Something whose world transform places an occluder outline. Any scene node satisfies it, which is how an outline authored in…

Where an OccluderSource writes what blocks light. The main channel is line segments in world space: an occluder has no thickn…

Something that can say which edges block light in a region. Occluders are registered sources rather than a flag on a drawable…

One occupied cell of a tile layer, as TilemapOccluder walks them.

What TilemapOccluder needs of a tile layer: its cell metrics, a way to walk the cells of a region, and a revision that change…

The PlatformAdapter for a render surface with no document around it: an `OffscreenCanvas`, whether it stayed on the main thre…

Where the surface is displayed, in the coordinate space the forwarded pointer events use.

A single value or a list of alternatives. Actions accept one binding directly and several as an array - there are no variadic…

Applies a tangential acceleration around a center point - perpendicular to the radial vector `(particle − center)`. Combined…

A hint source that also owns the listeners it installed.

Opaque packed tile data stored in a TileChunk's compact array. 0 means "empty cell". Any non-zero value encodes localTileId,…

Rectangular background container with rounded corners and an optional border. The base building block for HUD boxes, dialogs,…

Result of parseContainer: the validated head plus where the block area begins.

The live particles of one system, addressed by semantic channel. This is the bulk surface an UpdateModule and a ParticleRende…

Describes the interleaved buffer a render mode's `build()` fills each frame. Deliberately not a `Geometry`. A `Geometry` requ…

Construction options for ParticleBufferLayout.

The state of one particle at the moment it expired. A snapshot, not a view: it is copied out of the simulation when the parti…

The emitting face of a particle system: the only supported way to bring particles into existence. Emission is the one per-par…

Material specialization for particle render modes. `Material`'s constructor is protected, so every material family declares a…

Thrown when two GPU-eligible update modules on one system contribute the same WgslContribution.key. A key names exactly one s…

Turns a particle system's SoA storage into drawable vertex data. A mode owns the whole "how": the vertex layout, the shader p…

The rotation channel: current angle and the speed integrated into it each frame.

Free functions and constants exported from @codexo/exojs-particles.

Immutable compile-time build metadata for `@codexo/exojs-particles`. `development` mirrors the `__DEV__` compile-time constan…

Options for createParticlesExtension.

Per-property spawn configuration shared by the built-in spawners. Every entry is a Distribution sampled once per emitted part…

The central coordinator of the particle pipeline. `ParticleSystem` is a Drawable that owns: - **Particle storage** - one chan…

Options for ParticleSystem's constructor - orthogonal config that's independent of the texture source. Texture / frames / spr…

The timing channel: seconds since spawn, and total seconds before expiry.

A two-component particle channel, one array per component. The arrays are the simulation's own storage rather than a copy: wr…

Writable two-component channel of a single particle.

A single freshly emitted particle, addressed by name. Every field starts at its default - zero position, velocity, rotation a…

Pass-scoped DrawContext: the active render target and view for a CallbackRenderPass callback. `clear`/`render`/`renderTo` rou…

One flattened subpath produced by GraphicsPath.contours.

One traversal step of a path, as described by the space it came from. Spaces that model traversal kinds - WaypointGraph is th…

Runs path queries against any NavigationSpace. One pathfinder owns the search buffers and reuses them across every query, inc…

Result of Pathfinder.findPath and Pathfinder.findPathBetween.

Outcome of a path query. - `found` - a complete path from start to goal (or, with `snapToNearest`, to the reachable node clos…

A voice that can be paused and resumed in place.

User Timing helpers (`performance.mark`/`measure`), grouped as a namespace so the public API carries no loose `perf*` functio…

Debug layer that renders a compact screen-space HUD (top-left) showing rolling-average FPS, per-frame time in milliseconds, G…

Single-class `enter()`/`exit()` authoring layer over the full SceneTransition contract - covers the common case (fade, slide,…

Construction options for PhasedSceneTransition and its subclasses.

Phaser effect implemented with native Web Audio nodes (no worklet required). The wet signal passes through a cascade of allpa…

Construction options for PhaserEffect.

Free functions and constants exported from @codexo/exojs-physics.

A link between a PhysicsBody and a SceneNode. The body's world position **and rotation** are written onto the node (the body'…

A rigid body: a world transform plus mass properties aggregated from its colliders. Dynamic bodies integrate under gravity, a…

Immutable compile-time build metadata for `@codexo/exojs-physics`. `development` mirrors the `__DEV__` compile-time constant…

Shadows from physics colliders. ```ts lighting.occludeFrom(new PhysicsOccluder(world)); ``` Static colliders only by default,…

Tuning for PhysicsOccluder.

The collision/query world: owns bodies, colliders, the detection backend, bindings, the query engine and the fixed-step accum…

Construction options for a PhysicsWorld.

Stereo ping-pong delay effect using two cross-fed DelayNodes that bounce the signal alternately between left and right channe…

Construction options for PingPongDelayEffect.

Real-time pitch shifter (WorkletEffect) using SOLA - synchronized overlap-add. Each synthesis grain is realigned by waveform…

The pixels RenderingContext.readPixels read, shaped for `ImageData`.

One read handed out by PixelReader.request: poll it from the frame loop, take its pixels once ready, then release it. A read…

A standing, non-blocking readback of one rectangle of one render texture, for callers who read repeatedly: a picker, an analy…

Options for RenderingContext.createPixelReader.

Render-only pixel-snapping policy for a Drawable. - `None` - no snapping; rendered transform and geometry use existing behavi…

Everything the engine touches outside its own state: the drawing surface's focus, cursor, touch-action and geometry, pointer…

The part of a host event the input pipeline can act on: suppressing the host's own default handling of it. Both calls are the…

The data half of a platform event: every field, none of the suppression calls. Structured-cloneable, so this is the shape an…

A key transition, identified by physical position (`code`) rather than by the character the active layout produces. `repeat`…

Listener flags the input pipeline needs when it subscribes to a platform event.

A pointer contact. Field-for-field a subset of the DOM's `PointerEvent`, carrying the identity, position, geometry, tilt, pre…

A positioned host event with no pointer identity of its own, such as a context-menu request.

Undo function returned by every `PlatformAdapter` subscription. Calling it twice is a no-op.

Events the input pipeline sources from the drawing surface itself. The payload types are the browser's event shapes, narrowed…

Geometry of the drawing surface, in one snapshot. `left`/`top`/`width`/ `height` describe where the surface is displayed and…

The transport between a text-editing widget and whatever the host uses to receive real keyboard and IME input. The contract k…

What a host should tell its input method about the field. Every member is a hint: an input method may ignore any of them.

A scroll gesture. `deltaMode` selects the unit the deltas are expressed in.

Events the input pipeline sources from the host window rather than the surface.

Implemented by audio assets (Sound, AudioStream, AudioGenerator) to support system-driven playback via AudioSystem.play. Asse…

Common playback configuration for Sound and AudioStream.

Per-play overrides passed to AudioSystem.play.

Console generation a PlayStation mapping targets. The three generations share one button layout but not one set of button nam…

Unified mouse / touch / pen pointer. Wraps a single browser `PointerEvent.pointerId` and writes its state (position, buttons,…

Channel indices for the buttons of the primary pointer (slot 0), named by role rather than by mouse geometry so they read cor…

Branded numeric type identifying a canonical pointer-state input channel. Values are absolute offsets into the engine's share…

Debug layer that shows a screen-space panel (top-right corner) listing all RenderNodes under the current pointer position, so…

High-level lifecycle state of a Pointer. Distinct from PointerStateFlag, which is a bitfield of the per-frame events a pointe…

A point light: equal in every direction, falling off quadratically to nothing at radius. ```ts player.addChild(new PointLight…

Construction options for PointLight. Every field is also mutable afterwards.

Structural type for any object with a 2D `x`/`y` position.

A single point at `(x, y)`.

A 2D vector expressed in polar coordinates: `radius` (magnitude) and `phi` (angle in radians, measured from the positive X-ax…

Mutable convex polygon defined by a world-space offset `(x, y)` and an array of local-space vertex Vectors. Implements Collid…

Structural type for any object that describes a polygon via a world-space offset `(x, y)` and an array of local-space PointLi…

A closed polygon; `points` are relative to the object origin.

Shadows from an outline of your own, in world space or local to a node. ```ts lighting.occludeFrom(new PolygonOccluder(trunk,…

Tuning for PolygonOccluder.

A convex polygon defined by ≥3 local-space vertices. Input vertices may be given in either winding; they are canonicalised to…

An open polyline; `points` are relative to the object origin.

A reusable, data-driven template captured from a configured scene-graph subtree. Capture once with Prefab.from; stamp out ind…

Tuple type for the variadic tail of `preload()` calls, after the target constructor - mirrors ChangeSceneArgs's conditional-a…

Options passed to SceneDirector.preload. Unlike ChangeSceneOptions, there is no `transition`/`suspendCurrent` - preloading ne…

Pre-sizing options for deferred texture handles - reserves placeholder dimensions to avoid a layout jump when the payload arr…

Constrains a body to **slide along a single axis** relative to another: the perpendicular translation and the relative rotati…

Construction options for a PrismaticJoint.

Horizontal progress / health bar. ProgressBar.value is the fill fraction in `[0, 1]`; setting it redraws only the bar. The tw…

How the bar follows the value: `'scale'` paints the background at the value's width, `'clip'` paints it at full width and sho…

A parent-dependent successor generator that prunes symmetric alternatives without losing optimality - the shape jump-point se…

The default render mode: one textured, rotated, tinted quad per particle, drawn as a single instanced triangle-list. build fi…

Generic recursive spatial index used by the engine's `InteractionSystem` to accelerate per-frame hit-testing of scene nodes.…

An item stored in a Quadtree. Carries an axis-aligned bounding box and an arbitrary `payload`.

A category/mask/group filter applied to a query. Omitting it matches everything.

Radial gradient in UV space around `center` with normalized radius.

Lighting as radiance that propagates, filled by a chain of cascades traced over this frame's geometry. ```ts const lighting =…

Construction options for RadianceLighting.

Seedable pseudo-random number generator using the xoshiro128** algorithm. xoshiro128** (Blackman & Vigna, 2018) keeps a compa…

Uniform random number in `[min, max]`. Each `sample()` returns a fresh roll; the bounds are inclusive on both ends (modulo th…

A voice with rate / pitch controls.

Continuous, rate-based spawner. Emits a RateSpawnConfig.rate sample per second; sub-frame fractions accumulate so low rates (…

Spawn configuration for RateSpawn: the emission rate plus the shared per-property fields.

A single ray-cast intersection.

Read-only view of a Rectangle: every accessor and non-mutating query a rectangle offers, with none of its writers. Returned b…

Public readonly view of a tile chunk. Provides read-only inspection access for iteration, queries, and the future renderer. T…

Options for RenderingContext.readPixels.

One entry of the bounded Application.recentErrors ring buffer - a JSON-friendly snapshot of an engine error (feeds future deb…

Mutable axis-aligned rectangle defined by a top-left origin `(x, y)` and dimensions `(width, height)`. Implements Collidable…

Structural type for any object that describes an axis-aligned rectangle via a top-left origin and dimensions.

An axis-aligned rectangle object spanning `[x, y, width, height]`.

Every string key registered in a `SceneRegistryShape` - the type of a valid `change()`/`restore()` key-based navigation targe…

Identifies the active GPU backend used by the engine. Passed to renderers and shaders so they can select backend-specific cod…

Explicit instanced draw submission: **one** Geometry + MeshMaterial drawn **once** with **N** per-instance `(transform, tint)…

Binds one or more drawable constructors to a renderer factory. Pure descriptor - no active renderer, no GPU resources, no sid…

Structured GPU/render failure. Thrown by synchronous failure paths (WebGL2 shader compile/link, from `flush()`) and dispatche…

Machine-readable classification of a GPU/render failure. Carried by RenderError.code so tooling can branch on the failure cla…

Construction options for a RenderError.

Owns rendering orchestration: builds, optimizes and plays the internal RenderPlan for a RenderNode subtree, manages render-ta…

GPU primitive topology used when issuing draw calls. Values are WebGL2 GLenum constants (e.g. `gl.TRIANGLES`).

SceneNode that can produce visual output. Adds the rendering pipeline features on top of the structural transform/bounds carr…

Renders a scene subtree (a RenderNode) as one pass - into the active target, or off-screen when `options.target` is set. The…

Options for RenderNodePass.

One high-level phase of a frame. Subclass and implement execute, or use a stock subclass (RenderNodePass, CallbackRenderPass,…

Snapshot of one drawable's filter chain at the moment the inspector collected it. Held by reference inside RenderPassInspecto…

Debug layer that lists every RenderNode with an active filter chain each frame. Renders a compact text panel with per-drawabl…

Options shared by every RenderPass.

An ordered list of RenderPass steps, played once per frame against a RenderingContext. A `RenderPipeline` is **itself a `Rend…

One row of a RenderPipeline listing produced by RenderPassInspectorLayer.describePipeline. Identity is the pass object; `labe…

Per-frame rendering counters collected by the backend each tick. Expose live performance data for debugging and profiling too…