# @netforge/engine/runtime API reference

> Every export of @netforge/engine/runtime, generated from its TypeScript source: 199 functions, classes, constants and types with their signatures and doc comments.

Net Forge, the open-source multiplayer browser game engine built for AI coding agents, is published on npm under `@netforge` with source at https://github.com/netnetdev/net-forge.

Source: https://forge.netnet.capital/docs/reference/engine-runtime  
Last updated: 2026-10-23. Checked against @netforge/engine 0.2.0.

The three.js runtime templates draw with: the WebGPU renderer with a WebGL2 fallback, `createRenderStack`, the game feel kit, `CameraRig`, `InputController`, `AssetLoader`, instanced and animated crowds, and the arena client.

```ts
import { createRenderStack, FeelKit } from "@netforge/engine/runtime";
```

Generated from `packages/engine/src/runtime/index.ts` by `apps/forge-docs/scripts/api.mjs`. Signatures are what the TypeScript compiler reports for the current source; long types are cut and say so.

| Kind | Count |
|---|---|
| Functions | 40 |
| Classes | 36 |
| Constants | 13 |
| Types | 109 |
| Other | 1 |

## Functions

### applyCrowdMotion

Vertex animation for crowds without skeletons: bob, waddle, forward
lean and step cadence from each instance's speed, a squash-and-stretch on
hit, a hit flash, idle breathing. Applied to an existing node material
(positionNode, emissiveNode); geometry stands on y = 0 and faces -z.

```ts check=skip
function applyCrowdMotion(material: MotionMaterial, attrs: CrowdAttributes, time: Node<"float">, opts?: CrowdMotionOptions): MotionMaterial;
```

Source: [packages/engine/src/runtime/render/crowd-motion.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/crowd-motion.ts)

### bakeVertexAnimation

Bake one or more clips of a skinned mesh into a vertex animation texture
(CPU, at load). Frames are laid out clip after clip; a crowd then plays
any clip on thousands of instances in one draw (`VatCrowd`).

```ts check=skip
function bakeVertexAnimation(mesh: SkinnedMesh, clips: AnimationClip | readonly AnimationClip[], opts?: BakeOptions): VertexAnimation;
```

Source: [packages/engine/src/runtime/render/vat.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/vat.ts)

### billboardWorld

World position of a sprite vertex: `center` is the feet in world space,
`x`/`y` the vertex in metres on the plane (x across, y up from the feet),
`flip` -1 to mirror. The plane turns to the camera (its up is the camera's
up, so a sprite under a high camera shows its full height).

```ts check=skip
function billboardWorld(center: Node<"vec3">, x: Node<"float">, y: Node<"float">, flip: Node<"float">): Node<"vec3">;
```

Source: [packages/engine/src/runtime/render/sprite.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/sprite.ts)

### boundsShift

How far to move a view so `seen` stays inside `bounds`, per axis: zero
when it already fits, the overshoot when it pokes out of one side, and
centring when it is wider than the bounds.

```ts check=skip
function boundsShift(seen: GroundBounds, bounds: GroundBounds): { x: number; z: number; };
```

Source: [packages/engine/src/runtime/camera.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/camera.ts)

### browserHints

Read the hints from the running browser (safe in node: returns {}).

```ts check=skip
function browserHints(backend?: "webgpu" | "webgl2"): DeviceHints;
```

Source: [packages/engine/src/runtime/render/quality.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/quality.ts)

### buildSegmentRig

A three-bone procedural character (hip, spine, head) skinned to a
cylinder or any upright geometry, with a full animation set built in
code: rest, idle, walk, run, hit, attack, die. Templates with procedural
art get real skinned animation (and VAT crowds via bakeVertexAnimation)
without any asset files.

```ts check=skip
function buildSegmentRig(material: Material, opts?: SegmentRigOptions): SegmentRig;
```

Source: [packages/engine/src/runtime/render/rig.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/rig.ts)

### collectManifest

Collect and cross-check what the game module declared. Called by the
build and the runtime after importing the module, not by game code.

```ts check=skip
function collectManifest(): GameManifest;
```

Source: [packages/engine/src/api/registry.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/api/registry.ts)

### countUp

Count a number up in an element's text (scores, balances).

```ts check=skip
function countUp(el: FeelElement, from: number, to: number, ms?: number, format?: (n: number) => string, tweens?: Tweens): void;
```

Source: [packages/engine/src/runtime/feel/tween.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/tween.ts)

### createPixelStyle

The pixel style with its options.

```ts check=skip
function createPixelStyle(o?: PixelStyleOptions): StyleKit;
```

Source: [packages/engine/src/runtime/styles/pixel/index.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/pixel/index.ts)

### createRenderer

three.js WebGPURenderer. It targets WebGPU where `navigator.gpu` yields an
adapter and falls back to its WebGL2 backend otherwise, so one code path
(node materials, instancing) covers every browser (spec).

```ts check=skip
function createRenderer(canvas: HTMLCanvasElement, opts?: RendererOptions): Promise<RendererHandle>;
```

Source: [packages/engine/src/runtime/renderer.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/renderer.ts)

### createRenderStack

Everything a template needs for a good-looking frame, in one call:
lighting with a following shadow, fog and sky, bloom and grade, GPU
particles, decals and shockwave rings, quality tiers and dynamic
resolution. Replace `renderer.render(scene, camera)` with `stack.frame(...)`.

```ts check=skip
function createRenderStack(handle: RendererHandle, scene: Scene, camera: Camera, opts?: RenderStackOptions): RenderStack;
```

Source: [packages/engine/src/runtime/render/stack.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/stack.ts)

### createStyledView

The style's view of a scene, or null when the style has no session (lowpoly, unknown, or a kit with world builders only).

```ts check=skip
function createStyledView(handle: RendererHandle, scene: Scene, camera: Camera, style: string | StyleKit | null | undefined, opts?: StyledViewOptions): StyledView | null;
```

Source: [packages/engine/src/runtime/styles/view.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/view.ts)

### damp

Frame-rate independent exponential smoothing factor for a rate in 1/s.

```ts check=skip
function damp(rate: number, dt: number): number;
```

Source: [packages/engine/src/runtime/interpolate.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/interpolate.ts)

### detectTier

Pick a tier from device hints. Phones and tablets start at medium (low on
weak or WebGL-only ones); desktops start at high unless the CPU is small.
Dynamic resolution then holds the frame rate within the tier.

```ts check=skip
function detectTier(h: DeviceHints): QualityTier;
```

Source: [packages/engine/src/runtime/render/quality.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/quality.ts)

### distanceGain

Gain for a source `distance` m away (inverse falloff, 0 past maxDistance).

```ts check=skip
function distanceGain(distance: number, refDistance?: number, maxDistance?: number, rolloff?: number): number;
```

Source: [packages/engine/src/runtime/feel/audio.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/audio.ts)

### fieldBounds

Square bounds around the origin: a field of half size `half` plus `margin` of outside ground.

```ts check=skip
function fieldBounds(half: number, margin?: number): GroundBounds;
```

Source: [packages/engine/src/runtime/camera.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/camera.ts)

### flashColor

Write a flashed instance colour into `out` at `offset` (rgb floats):
base colour mixed toward `tint` and boosted by the flash.

```ts check=skip
function flashColor(out: Float32Array | number[], offset: number, flash: number, base?: readonly [number, number, number], tint?: readonly [number, number, number], boost?: number): void;
```

Source: [packages/engine/src/runtime/feel/flash.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/flash.ts)

### flashMultiplier

Colour multiplier for a flash: 1 at rest, 1 + boost at full flash (instance colours above 1 read as glowing white).

```ts check=skip
function flashMultiplier(flash: number, boost?: number): number;
```

Source: [packages/engine/src/runtime/feel/flash.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/flash.ts)

### groundFootprint

The ground a camera sees: the box around where its four corner rays meet
the plane y = `groundY`. A ray at or above the horizon counts as reaching
`reach` m out along the ground. The camera's matrices must be current.

```ts check=skip
function groundFootprint(camera: Camera, groundY?: number, reach?: number): GroundBounds;
```

Source: [packages/engine/src/runtime/camera.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/camera.ts)

### hashSigned

Seeded integer hash to -1..1 (deterministic, no Math.random).

```ts check=skip
function hashSigned(i: number, seed: number): number;
```

Source: [packages/engine/src/runtime/feel/noise.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/noise.ts)

### isSprite

Whether a geometry is a sprite plane (markSprite).

```ts check=skip
function isSprite(geometry: { userData: Record<string, unknown>; }): boolean;
```

Source: [packages/engine/src/runtime/render/sprite.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/sprite.ts)

### lerp

Linear interpolation.

```ts check=skip
function lerp(a: number, b: number, t: number): number;
```

Source: [packages/engine/src/runtime/interpolate.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/interpolate.ts)

### lerpAngle

Interpolate angles along the shortest arc (radians).

```ts check=skip
function lerpAngle(a: number, b: number, t: number): number;
```

Source: [packages/engine/src/runtime/interpolate.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/interpolate.ts)

### locomotionState

The locomotion state for a speed, with hysteresis around the current state. Pure.

```ts check=skip
function locomotionState(speed: number, current: LocomotionState, t?: LocomotionThresholds): LocomotionState;
```

Source: [packages/engine/src/runtime/render/animation.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/animation.ts)

### markSprite

Flag a sprite plane so AnimatedCrowd draws it as billboards (geometry.userData).

```ts check=skip
function markSprite(geometry: { userData: Record<string, unknown>; }): void;
```

Source: [packages/engine/src/runtime/render/sprite.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/sprite.ts)

### markSpriteMaterial

A sprite material's extra output: the pixel style keeps sprites in their
own palette colours and steps only the 3D world into light bands. Safe
everywhere: a target without a "sprite" texture just takes the colour.

```ts check=skip
function markSpriteMaterial(material: { mrtNode: unknown; }): void;
```

Source: [packages/engine/src/runtime/render/sprite.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/sprite.ts)

### pickStyle

The art style a template draws in: a known `?style=` on the URL wins over the game's declared style.

```ts check=skip
function pickStyle(declared: string, requested: string | null | undefined): string;
```

Source: [packages/engine/src/runtime/styles/index.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/index.ts)

### pixelBlock

The integer block size (screen pixels per low-res pixel) that puts
`texelsPerMetre` low-res rows on each metre of a view `viewMetres` tall.

```ts check=skip
function pixelBlock(bufferHeight: number, viewMetres: number, texelsPerMetre: number, minRows?: number): number;
```

Source: [packages/engine/src/runtime/styles/pixel/index.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/pixel/index.ts)

### pop

Punch an element's scale up to `scale` and spring it back (level-up, coin gain).

```ts check=skip
function pop(el: FeelElement, scale?: number, ms?: number, tweens?: Tweens): void;
```

Source: [packages/engine/src/runtime/feel/tween.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/tween.ts)

### qualitySettings

```ts check=skip
function qualitySettings(tier: QualityTier): QualitySettings;
```

Source: [packages/engine/src/runtime/render/quality.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/quality.ts)

### resetRegistry

Forget all declarations (the build and tests load several game modules in one process).

```ts check=skip
function resetRegistry(): void;
```

Source: [packages/engine/src/api/registry.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/api/registry.ts)

### resolveLook

A preset by name; unknown names fall back to "studio" (never throws at runtime).

```ts check=skip
function resolveLook(name: string | undefined): Look;
```

Source: [packages/engine/src/runtime/render/presets.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/presets.ts)

### seededRandom

A small seeded PRNG (mulberry32), 0..1, for cosmetic variation that should not use Math.random.

```ts check=skip
function seededRandom(seed: number): () => number;
```

Source: [packages/engine/src/runtime/feel/noise.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/noise.ts)

### shakeEl

Shake an element sideways by up to `px`, decaying over `ms` (denied action, damage taken).

```ts check=skip
function shakeEl(el: FeelElement, px?: number, ms?: number, tweens?: Tweens): void;
```

Source: [packages/engine/src/runtime/feel/tween.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/tween.ts)

### snapToTexel

Snap a world point to the shadow map's texel grid in light space, so a
shadow camera that follows the player moves in whole texels and the
shadow edges never shimmer. `dir` is the light's travel-from direction
(unit), `texel` the world size of one shadow texel.

```ts check=skip
function snapToTexel(p: readonly [number, number, number], dir: readonly [number, number, number], texel: number): Vec3Tuple;
```

Source: [packages/engine/src/runtime/render/lighting.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/lighting.ts)

### spriteBillboardNode

positionNode for a single sprite mesh (a player, a boss): the plane
faces the camera whatever the mesh's rotation, and mirrors when the
mesh's forward (-z) points to screen left.

```ts check=skip
function spriteBillboardNode(): Node<"vec3">;
```

Source: [packages/engine/src/runtime/render/sprite.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/sprite.ts)

### stepSpring

Advance one spring axis toward `target` by `dt` seconds with the exact
solution of the damped oscillator, so it is stable at any stiffness and
frame rate. `omega` is the natural frequency in rad/s, `zeta` the damping
ratio. Returns [value, velocity].

```ts check=skip
function stepSpring(value: number, velocity: number, target: number, omega: number, zeta: number, dt: number): [number, number];
```

Source: [packages/engine/src/runtime/feel/spring.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/spring.ts)

### styleKit

The kit for a style, or null (low-poly, or a style with no kit yet).

```ts check=skip
function styleKit(style: string | null | undefined): StyleKit | null;
```

Source: [packages/engine/src/runtime/styles/index.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/index.ts)

### toNodeMaterial

Copy a classic MeshStandardMaterial into a node material (so positionNode can be set).

```ts check=skip
function toNodeMaterial(m: MeshStandardMaterial): MeshStandardNodeMaterial;
```

Source: [packages/engine/src/runtime/render/crowd-motion.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/crowd-motion.ts)

### valueNoise1

Smooth 1D value noise in -1..1, continuous in `t`, fixed for a seed.

```ts check=skip
function valueNoise1(t: number, seed: number): number;
```

Source: [packages/engine/src/runtime/feel/noise.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/noise.ts)

## Classes

### AnimatedCharacter

A skinned character (glTF or procedural) with an AnimationMixer:
`setSpeed(mps)` drives idle/walk/run with crossfades and playback rate
matched to ground speed; `oneShot("attack")` plays once and blends back
to locomotion; `play(name)` for anything else. Call `update(dt)` per frame.

```ts check=skip
class AnimatedCharacter {
  constructor(root: Object3D, clips: readonly AnimationClip[], opts?: AnimatedCharacterOptions);
  readonly mixer: AnimationMixer<AnimationMixerEventMap>;
  has(name: string): boolean;
  get state(): LocomotionState;
  get playing(): string | null;
  play(name: string, opts?: PlayOptions): boolean;
  oneShot(name: string, opts?: Omit<PlayOptions, "loop">): boolean;
  setSpeed(mps: number): void;
  update(dt: number): void;
  dispose(): void;
}
```

Source: [packages/engine/src/runtime/render/animation.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/animation.ts)

### AnimatedCrowd

An instanced crowd with procedural animation: one draw, per-instance
position, yaw, scale, phase, speed, hit squash and flash. Write instances
between `begin()` and `end(time)` each frame; only the written range uploads.

```ts check=skip
class AnimatedCrowd {
  constructor(geometry: BufferGeometry, material: MeshStandardMaterial | MeshStandardNodeMaterial, capacity: number, opts?: CrowdMotionOptions);
  readonly mesh: Mesh<BufferGeometry<NormalBufferAttributes, BufferGeometryEventMap>, Material<MaterialEventMap> | Material<MaterialEventMap>[], Object3DEventMap>;
  readonly time: UniformNode<"float", number>;
  readonly attrs: CrowdAttributes;
  count: number;
  begin(): void;
  push(x: number, y: number, z: number, yaw: number, phase: number, speed: number, hit?: number, flash?: number, scale?: number): void;
  end(timeSeconds: number): void;
  addTo(parent: Object3D): this;
  dispose(): void;
}
```

Source: [packages/engine/src/runtime/render/crowd-motion.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/crowd-motion.ts)

### ArenaClient

The week-2 single-player arena: engine-sim on a fixed tick, rendered by
three.js with interpolation, one instanced draw for every enemy, a
follow camera, keyboard/mouse/touch input. Placeholder primitives only.

```ts check=skip
class ArenaClient {
  constructor(host: HTMLElement, handle: RendererHandle, world: SimWorld, opts: ArenaOptions);
  static create(host: HTMLElement, opts?: ArenaOptions): Promise<ArenaClient>;
  start(): void;
  stats(): ArenaStats | null;
  dispose(): void;
}
```

Source: [packages/engine/src/runtime/arena.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/arena.ts)

### AssetLoader

glTF loading with the runtime's compression stack: meshopt geometry
(EXT_meshopt_compression) and KTX2/Basis textures (KHR_texture_basisu).
Loads are cached by id, so a prefab used 2,000 times is fetched once.

```ts check=skip
class AssetLoader {
  constructor(renderer: WebGPURenderer, opts: AssetLoaderOptions);
  load(id: string): Promise<GLTF>;
  dispose(): void;
}
```

Source: [packages/engine/src/runtime/assets.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/assets.ts)

### Atmosphere

Fog matched to a sky gradient, so the far ground melts into the
background instead of meeting a hard color. Linear or exp2 distance fog,
plus an optional low height fog (ground mist). Values live in uniforms:
changing them never recompiles a shader.

```ts check=skip
class Atmosphere {
  constructor(scene: Scene, opts?: AtmosphereOptions);
  readonly fogColor: UniformNode<"color", Color>;
  readonly skyTop: UniformNode<"color", Color>;
  readonly near: UniformNode<"float", number>;
  readonly far: UniformNode<"float", number>;
  readonly density: UniformNode<"float", number>;
  readonly heightDensity: UniformNode<"float", number>;
  readonly heightTop: UniformNode<"float", number>;
  setPreset(preset: LookPreset, overrides?: Partial<AtmospherePreset>): void;
  dispose(): void;
}
```

Source: [packages/engine/src/runtime/render/atmosphere.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/atmosphere.ts)

### CameraRig

Third-person orbit-follow camera with the camera parts of the feel kit:
critically damped follow, smoothed and clamped lead, a dead zone, trauma
shake and FOV punches. `yaw` matches the sim's convention (0 looks down
-z), so the input layer can send the camera's yaw as the character's
facing. Shake is applied as a per-frame `offset` and `roll` on top of the
computed pose, so it never accumulates drift.

```ts check=skip
class CameraRig {
  constructor(aspect: number, opts?: CameraRigOptions);
  readonly camera: PerspectiveCamera;
  yaw: number;
  pitch: number;
  readonly trauma: Trauma;
  readonly offset: Vector3;
  roll: number;
  readonly clampShift: { x: number; z: number; };
  setDistance(metres: number): void;
  setBounds(bounds: GroundBounds | null): void;
  get target(): Readonly<Vector3>;
  look(dYaw: number, dPitch: number): void;
  addTrauma(amount: number): void;
  shake(amplitude: number, seconds: number): void;
  punch(degrees: number): void;
  get fovKick(): number;
  update(target: Vector3, dt: number, realDt?: number): void;
  resize(aspect: number): void;
}
```

Source: [packages/engine/src/runtime/camera.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/camera.ts)

### CueGate

The DOM-free decision core: may a cue start now? Per-cue gap and voice
cap, and a global voice cap.

```ts check=skip
class CueGate {
  constructor(maxVoices?: number);
  allow(name: string, nowMs: number, durationMs: number, minGapMs: number, cueVoices: number): boolean;
  get voices(): number;
}
```

Source: [packages/engine/src/runtime/feel/audio.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/audio.ts)

### DamageNumbers

The DOM pool. Construct only in a browser (it creates nodes under `host`).

```ts check=skip
class DamageNumbers {
  constructor(host: HTMLElement, opts?: DamageNumbersOptions | number);
  readonly stack: NumberStack;
  get shown(): number;
  show(x: number, y: number, amount: number, big?: boolean): void;
  add(n: NumberInput, nowMs?: number): void;
  update(dt: number): void;
}
```

Source: [packages/engine/src/runtime/feel/numbers.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/numbers.ts)

### DynamicResolution

Pixel-ratio controller: trades pixels for frame time. Push every frame's
interval; `update(now)` returns the new ratio when it changes, else null.
After a change the window restarts so the next decision sees the new cost.

```ts check=skip
class DynamicResolution {
  constructor(initial: number, opts?: DynamicResolutionOptions);
  ratio: number;
  readonly o: Required<DynamicResolutionOptions>;
  push(frameMs: number): void;
  p95(): number;
  setRange(min: number, max: number): number | null;
  update(now: number): number | null;
}
```

Source: [packages/engine/src/runtime/render/quality.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/quality.ts)

### FeelAudio

```ts check=skip
class FeelAudio {
  constructor(opts?: FeelAudioOptions);
  muted: boolean;
  played: number;
  readonly gate: CueGate;
  unlock(): void;
  whenUnlocked(fn: (ctx: AudioContext) => void): void;
  get context(): AudioContext | null;
  unlockOnGesture(target?: EventTarget): void;
  get ready(): boolean;
  get master(): number;
  define(name: string, recipe: SynthRecipe, opts?: CueOptions): void;
  addBuffer(name: string, source: AudioBuffer | string, opts?: CueOptions & { readonly gain?: number; }): Promise<void>;
  has(name: string): boolean;
  play(name: string, opts?: PlayOptions): boolean;
  impact(damage: number, opts?: PlayOptions): boolean;
}
```

Source: [packages/engine/src/runtime/feel/audio.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/audio.ts)

### FeelClock

```ts check=skip
class FeelClock {
  constructor(opts?: FeelClockOptions);
  stops: number;
  slows: number;
  hitStop(ms: number, realNow?: number): void;
  slowMo(scale: number, ms: number, easeMs?: number, realNow?: number): void;
  tick(realNow?: number): ClockTick;
  get stopped(): boolean;
  get lagMs(): number;
}
```

Source: [packages/engine/src/runtime/feel/clock.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/clock.ts)

### FeelKit

```ts check=skip
class FeelKit {
  constructor(opts?: FeelKitOptions);
  readonly preset: FeelPreset;
  readonly clock: FeelClock;
  readonly flash: HitFlash;
  readonly knock: KnockbackOffsets;
  readonly trauma: Trauma;
  readonly tweens: Tweens;
  readonly numbers: DamageNumbers | null;
  readonly audio: FeelAudio | null;
  readonly rumble: Rumble | null;
  readonly footsteps: Footsteps | null;
  particles: ParticleSink | null;
  hurtPulse: number;
  readonly counts: { hits: number; kills: number; bigKills: number; hurts: number; levelUps: number; lands: number; dashes: number; };
  camera: TraumaTarget;
  project: Projector | undefined;
  tick(realNow?: number): ClockTick;
  hit(e: HitEvent): void;
  kill(e: KillEvent): void;
  hurt(amount: number, maxHealth?: number): void;
  levelUp(): void;
  land(intensity?: number): void;
  dash(): void;
  footstep(speed: number, grounded?: boolean, surface?: Surface): void;
  update(dt: number, realDt?: number): void;
}
```

Source: [packages/engine/src/runtime/feel/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/kit.ts)

### Footsteps

Footstep cadence from speed: steps per second = speed / stride, with an
alternating left/right pitch. Calls `play(pitch, gain)` on each step.

```ts check=skip
class Footsteps {
  constructor(play: (pitch: number, gain: number) => void, opts?: FootstepOptions);
  surface: "grass" | "stone" | "dirt" | "wood" | "metal";
  steps: number;
  update(dt: number, speed: number, grounded?: boolean): number;
}
```

Source: [packages/engine/src/runtime/feel/audio.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/audio.ts)

### FrameStats

Rolling frame-time statistics (ms) over the last `size` frames.

```ts check=skip
class FrameStats {
  constructor(size?: number);
  push(ms: number): void;
  get count(): number;
  mean(): number;
  percentile(q: number): number;
}
```

Source: [packages/engine/src/runtime/stats.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/stats.ts)

### GpuParticles

Pooled GPU particles: one draw for every additive particle on screen
(and one for alpha-blended smoke and dust). The CPU writes only the
spawn slots of a burst; the vertex stage computes motion (velocity, drag,
gravity, a floor clamp), billboarding, velocity stretch, size and fade.

```ts check=skip
class GpuParticles {
  constructor(parent: Object3D, opts?: GpuParticlesOptions);
  readonly time: UniformNode<"float", number>;
  bursts: number;
  get meshes(): Mesh<BufferGeometry<NormalBufferAttributes, BufferGeometryEventMap>, Material<MaterialEventMap> | Material<MaterialEventMap>[], Object3DEventMap>[];
  burst(preset: string, x: number, y: number, z: number, opts?: ParticleBurstOptions): void;
  emit(preset: string, x: number, y: number, z: number, rate: number, dt: number, opts?: ParticleBurstOptions): void;
  update(timeSeconds: number): void;
  dispose(): void;
}
```

Source: [packages/engine/src/runtime/render/particles.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/particles.ts)

### GroundDecals

Ground decals (scorch marks, splats, rings) in one draw: flat quads on
the floor, shapes drawn procedurally in the fragment stage (no textures),
faded over their life. A ring buffer: the oldest decal is reused.

```ts check=skip
class GroundDecals {
  constructor(parent: Object3D, capacity?: number, random?: () => number, look?: DecalLook);
  readonly time: UniformNode<"float", number>;
  readonly ring: ParticleRing;
  readonly mesh: Mesh<BufferGeometry<NormalBufferAttributes, BufferGeometryEventMap>, Material<MaterialEventMap> | Material<MaterialEventMap>[], Object3DEventMap>;
  floorY: number;
  add(kind: DecalKind, x: number, z: number, opts?: DecalOptions): void;
  update(timeSeconds: number): void;
  dispose(): void;
}
```

Source: [packages/engine/src/runtime/render/decals.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/decals.ts)

### GroundRings

Expanding shockwave rings on the floor (nova blasts, landings, dash
starts): one additive draw, pooled. Generalized from EMBERWATCH's rings.

```ts check=skip
class GroundRings {
  constructor(parent: Object3D, capacity?: number, look?: RingLook);
  readonly time: UniformNode<"float", number>;
  readonly ring: ParticleRing;
  readonly mesh: Mesh<BufferGeometry<NormalBufferAttributes, BufferGeometryEventMap>, Material<MaterialEventMap> | Material<MaterialEventMap>[], Object3DEventMap>;
  fired: number;
  fire(x: number, z: number, radius: number, opts?: RingOptions): void;
  update(timeSeconds: number): void;
  dispose(): void;
}
```

Source: [packages/engine/src/runtime/render/decals.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/decals.ts)

### HeroHighlight

```ts check=skip
class HeroHighlight {
  constructor(root: Object3D, opts?: HeroHighlightOptions);
  readonly parts: Mesh<BufferGeometry<NormalBufferAttributes, BufferGeometryEventMap>, Material<MaterialEventMap> | Material<MaterialEventMap>[], Object3DEventMap>[];
  dispose(): void;
}
```

Source: [packages/engine/src/runtime/render/highlight.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/highlight.ts)

### HitFlash

Hit flash: per-entity timers that read as 0..1 intensity, for instanced
crowds that tint an instance toward white (or any colour) on a hit.

```ts check=skip
class HitFlash {
  constructor(seconds?: number);
  count: number;
  trigger(id: number, strength?: number): void;
  value(id: number): number;
  update(dt: number): void;
  get size(): number;
  clear(): void;
}
```

Source: [packages/engine/src/runtime/feel/flash.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/flash.ts)

### InputController

Keyboard + mouse (pointer lock) and touch (nipplejs virtual stick on the
left half, drag-to-look and action buttons on the right). `sample()`
produces one sequence-numbered InputCommand per fixed tick.

```ts check=skip
class InputController {
  constructor(element: HTMLElement, look: LookTarget, opts?: InputOptions);
  readonly touch: boolean;
  sample(tick: number): InputCommand;
  dispose(): void;
}
```

Source: [packages/engine/src/runtime/input.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/input.ts)

### InstancedCrowd

One InstancedMesh per entity kind: 2,000 enemies are one draw call
(spec). Each frame writes interpolated matrices straight into the
instance buffer (rotation about y only; no per-instance Object3D).

```ts check=skip
class InstancedCrowd {
  constructor(geometry: BufferGeometry, material: Material, capacity: number, kind: number, scale?: number);
  readonly mesh: InstancedMesh<BufferGeometry<NormalBufferAttributes, BufferGeometryEventMap>, Material<MaterialEventMap> | Material<MaterialEventMap>[], Object3DEventMap>;
  update(view: RenderView, alpha: number): number;
  dispose(): void;
}
```

Source: [packages/engine/src/runtime/crowd.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/crowd.ts)

### KnockbackOffsets

```ts check=skip
class KnockbackOffsets {
  constructor(opts?: KnockbackOptions);
  kicks: number;
  kick(id: number, dirX: number, dirZ: number, strength?: number): void;
  get(id: number): Readonly<KnockbackSample>;
  update(dt: number): void;
  get size(): number;
  clear(): void;
}
```

Source: [packages/engine/src/runtime/feel/knockback.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/knockback.ts)

### LightingRig

Hemisphere + one directional light whose single shadow map follows a
focus point (the player), snapped to texels. Sized for a top-down or
third-person view: one tuned map beats cascades at this camera distance.

```ts check=skip
class LightingRig {
  constructor(renderer: WebGPURenderer, scene: Scene, opts?: LightingOptions);
  readonly root: Object3D<Object3DEventMap>;
  readonly hemi: HemisphereLight;
  readonly sun: DirectionalLight;
  readonly ambient: AmbientLight;
  get texel(): number;
  get shadowsOn(): boolean;
  setShadowMapSize(size: number): void;
  setShadowExtent(extent: number): void;
  follow(x: number, y: number, z: number): void;
  setPreset(preset: LookPreset, overrides?: Partial<LightingPreset>): void;
  dispose(): void;
}
```

Source: [packages/engine/src/runtime/render/lighting.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/lighting.ts)

### NumberStack

```ts check=skip
class NumberStack {
  constructor(capacity?: number, opts?: NumberStackOptions);
  readonly slots: NumberSlot[];
  shown: number;
  merged: number;
  add(nowMs: number, n: NumberInput): { index: number; merged: boolean; };
  update(dt: number): void;
  draw(s: NumberSlot): NumberDraw;
  get active(): number;
}
```

Source: [packages/engine/src/runtime/feel/numbers.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/numbers.ts)

### ParticleRing

A ring of `capacity` particle slots. Allocation never iterates live
particles: the oldest slot is simply overwritten. Records which slot
ranges changed since the last flush so only those bytes are uploaded.

```ts check=skip
class ParticleRing {
  constructor(capacity: number);
  head: number;
  written: number;
  alloc(n: number): number[];
  flush(): [number, number][];
}
```

Source: [packages/engine/src/runtime/render/particles.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/particles.ts)

### PostFX

The post stack: scene pass (HDR) -> bloom -> optional depth outline ->
color grade (exposure, contrast, saturation, split tone, vignette, hurt
pulse) -> tone mapping and sRGB (once, via renderOutput) -> FXAA.

Tone mapping is the renderer's (`renderer.toneMapping`), so the same
curve applies whether post is on (here, in renderOutput) or off
(renderer.render to the canvas). Every knob is a uniform.

```ts check=skip
class PostFX {
  constructor(renderer: WebGPURenderer, scene: Scene, camera: Camera, opts?: PostFXOptions);
  readonly pipeline: RenderPipeline;
  readonly exposure: UniformNode<"float", number>;
  readonly contrast: UniformNode<"float", number>;
  readonly saturation: UniformNode<"float", number>;
  readonly shadowTint: UniformNode<"vec3", Vector3>;
  readonly highlightTint: UniformNode<"vec3", Vector3>;
  readonly vignette: UniformNode<"float", number>;
  readonly hurt: UniformNode<"float", number>;
  readonly outlineColor: UniformNode<"color", Color>;
  readonly outlineThickness: UniformNode<"float", number>;
  readonly outlineThreshold: UniformNode<"float", number>;
  readonly outlineStrength: UniformNode<"float", number>;
  enabled: boolean;
  get bloom(): BloomNode | null;
  setPreset(preset: LookPreset, overrides?: Partial<GradePreset>): void;
  configure(o: { bloom?: boolean; outline?: boolean; fxaa?: boolean; bloomScale?: number; enabled?: boolean; }): void;
  setQuality(tier: QualityTier, outlineWanted?: boolean): void;
  get stages(): { enabled: boolean; bloom: boolean; outline: boolean; fxaa: boolean; };
  setStyle(style: StylePost | null): void;
  setSize(width: number, height: number): void;
  render(): void;
  dispose(): void;
}
```

Source: [packages/engine/src/runtime/render/post.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/post.ts)

### QualityManager

Holds the tier and the dynamic resolution for one renderer. Listeners
(lighting, post, particles) re-read `settings` on `onChange`.

```ts check=skip
class QualityManager {
  constructor(target: QualityTarget, tier: QualityTier, opts?: { devicePixelRatio?: number; dynamic?: boolean; budgetMs?: number; });
  settings: QualitySettings;
  readonly dynamic: DynamicResolution;
  enabled: boolean;
  get tier(): QualityTier;
  get pixelRatio(): number;
  onChange(fn: (s: QualitySettings) => void): void;
  setTier(tier: QualityTier): void;
  frame(now: number): boolean;
}
```

Source: [packages/engine/src/runtime/render/quality.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/quality.ts)

### RenderClock

```ts check=skip
class RenderClock {
  constructor(opts?: FeelClockOptions);
  stops: number;
  slows: number;
  hitStop(ms: number, realNow?: number): void;
  slowMo(scale: number, ms: number, easeMs?: number, realNow?: number): void;
  tick(realNow?: number): ClockTick;
  get stopped(): boolean;
  get lagMs(): number;
}
```

Source: [packages/engine/src/runtime/feel/clock.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/clock.ts)

### Rumble

```ts check=skip
class Rumble {
  constructor(opts?: RumbleOptions);
  enabled: boolean;
  pulses: number;
  pulse(strong: number, weak?: number, ms?: number): boolean;
}
```

Source: [packages/engine/src/runtime/feel/rumble.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/rumble.ts)

### SoundPlayer

```ts check=skip
class SoundPlayer {
  constructor(audio: FeelAudio, opts?: SoundPlayerOptions);
  readonly loaded: { cues: number; failed: number; music: boolean; };
  load(bank: SoundBank): void;
  unlockOnGesture(target?: EventTarget): void;
  get muted(): boolean;
  toggle(): boolean;
  get musicEnabled(): boolean;
  get musicPlaying(): boolean;
  get current(): SoundBank | null;
  dispose(): void;
}
```

Source: [packages/engine/src/runtime/feel/sound.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/sound.ts)

### Spring

```ts check=skip
class Spring {
  constructor(value?: number, opts?: SpringOptions);
  value: number;
  velocity: number;
  target: number;
  frequency: number;
  damping: number;
  kick(velocity: number): void;
  snap(value: number): void;
  step(dt: number): number;
  settled(eps?: number): boolean;
}
```

Source: [packages/engine/src/runtime/feel/spring.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/spring.ts)

### Spring3

Three springs sharing settings (a position or offset).

```ts check=skip
class Spring3 {
  constructor(x?: number, y?: number, z?: number, opts?: SpringOptions);
  readonly x: Spring;
  readonly y: Spring;
  readonly z: Spring;
  setTarget(x: number, y: number, z: number): void;
  snap(x: number, y: number, z: number): void;
  step(dt: number): void;
}
```

Source: [packages/engine/src/runtime/feel/spring.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/spring.ts)

### SystemScheduler

Runs the declared systems' schedules against a host, one fixed tick at a
time. Timers are tick-based (seconds are rounded to whole ticks at
declaration), so the schedule is identical on the server and in client
prediction. Timers fire in declaration order within a tick.

```ts check=skip
class SystemScheduler {
  constructor(manifest: GameManifest, host: SystemHost);
  start(): void;
  dispatch(event: string, players: readonly number[]): void;
  tick(): void;
}
```

Source: [packages/engine/src/api/scheduler.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/api/scheduler.ts)

### Trauma

Trauma screen shake: hits add trauma 0..1, it decays linearly, and the
shake is trauma squared, so small hits barely move the camera and big
ones kick hard. Offsets come from smooth seeded noise, so the shake is
fluid rather than jittery and never uses Math.random.

```ts check=skip
class Trauma {
  constructor(opts?: TraumaOptions);
  value: number;
  x: number;
  y: number;
  roll: number;
  adds: number;
  get options(): Readonly<Required<TraumaOptions>>;
  add(amount: number): void;
  addTrauma(amount: number): void;
  sustain(seconds: number): void;
  get shake(): number;
  update(dt: number): void;
  reset(): void;
  traumaFor(amplitude: number): number;
}
```

Source: [packages/engine/src/runtime/feel/trauma.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/trauma.ts)

### Tweens

```ts check=skip
class Tweens {
  constructor();
  to<T extends object>(target: T, props: TweenProps<T>, opts: TweenOptions): number;
  cancel(handleOrTarget: number | object): void;
  get active(): number;
  tick(dt: number): void;
}
```

Source: [packages/engine/src/runtime/feel/tween.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/tween.ts)

### VatCrowd

Thousands of animated characters in one draw: every instance samples the
VAT at its own clip, phase and rate, then is rotated, scaled and placed
from per-instance attributes. CPU work per instance is one 12-float write.

```ts check=skip
class VatCrowd {
  constructor(vat: VertexAnimation, material: Material & { positionNode: Node | null; normalNode: Node | null; emissiveNode?: Node | null; flatShading?: boolean; }, capacity: number, opts?: VatCrowdOptions);
  readonly mesh: Mesh<BufferGeometry<NormalBufferAttributes, BufferGeometryEventMap>, Material<MaterialEventMap> | Material<MaterialEventMap>[], Object3DEventMap>;
  readonly time: UniformNode<"float", number>;
  count: number;
  clipNamed(name: string): VatClip | undefined;
  begin(): void;
  push(x: number, y: number, z: number, yaw: number, opts?: { clip?: string; phase?: number; rate?: number; scale?: number; flash?: number; }): void;
  end(timeSeconds: number): void;
  addTo(parent: Object3D): this;
  dispose(): void;
}
```

Source: [packages/engine/src/runtime/render/vat.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/vat.ts)

## Constants

### DEFAULT_CUES

The built-in cues every template can use by name.

```ts check=skip
const DEFAULT_CUES: Readonly<Record<string, SynthRecipe & CueOptions>>;
```

Source: [packages/engine/src/runtime/feel/audio.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/audio.ts)

### DEFAULT_LOCOMOTION

```ts check=skip
const DEFAULT_LOCOMOTION: LocomotionThresholds;
```

Source: [packages/engine/src/runtime/render/animation.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/animation.ts)

### Ease

```ts check=skip
const Ease: { readonly linear: (t: number) => number; readonly quadIn: (t: number) => number; readonly quadOut: (t: number) => number; readonly quadInOut: (t: number) => number; readonly cubicOut: (t: number) => number; readonly cubicInOut: (t: number) => number; readonly sineInOut: (t: number) => number; readonly expoOut: (t: number) => number; readonly backOut: (t: number) => number; readonly elasticOut: (t: number) => number; readonly bounceOut: (t: number) => number; };
```

Source: [packages/engine/src/runtime/feel/tween.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/tween.ts)

### FEEL_PRESETS

```ts check=skip
const FEEL_PRESETS: Readonly<Record<FeelPresetName, FeelPreset>>;
```

Source: [packages/engine/src/runtime/feel/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/kit.ts)

### LOOK_PRESETS

```ts check=skip
const LOOK_PRESETS: readonly LookPreset[];
```

Source: [packages/engine/src/runtime/render/presets.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/presets.ts)

### PARTICLE_PRESETS

```ts check=skip
const PARTICLE_PRESETS: Readonly<Record<ParticlePresetName, ParticlePreset>>;
```

Source: [packages/engine/src/runtime/render/particles.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/particles.ts)

### PIXEL_PALETTE

The pixel style's palette (DawnBringer 16). The asset library's
manifest/pixel.json carries the same list; its test keeps them equal.

```ts check=skip
const PIXEL_PALETTE: readonly string[];
```

Source: [packages/engine/src/runtime/styles/pixel/index.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/pixel/index.ts)

### QUALITY_TIERS

```ts check=skip
const QUALITY_TIERS: readonly QualityTier[];
```

Source: [packages/engine/src/runtime/render/quality.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/quality.ts)

### SPRITE_TEXEL

Metres one source pixel covers at `spriteScale` 1.

```ts check=skip
const SPRITE_TEXEL: number;
```

Source: [packages/engine/src/runtime/render/sprite.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/sprite.ts)

### spriteScale

The pixel style's resize for every billboard sprite (1 elsewhere).

```ts check=skip
const spriteScale: UniformNode<"float", number>;
```

Source: [packages/engine/src/runtime/render/sprite.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/sprite.ts)

### STYLE_KITS

One entry per art style. Keep it a plain map.

```ts check=skip
const STYLE_KITS: Readonly<Record<string, StyleKit>>;
```

Source: [packages/engine/src/runtime/styles/index.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/index.ts)

### SURFACES

Surfaces change a footstep's pitch and weight.

```ts check=skip
const SURFACES: { readonly grass: { readonly pitch: 0.85; readonly gain: 0.8; }; readonly dirt: { readonly pitch: 0.9; readonly gain: 0.9; }; readonly stone: { readonly pitch: 1.25; readonly gain: 1; }; readonly wood: { readonly pitch: 1.05; readonly gain: 1; }; readonly metal: { readonly pitch: 1.6; readonly gain: 1.1; }; };
```

Source: [packages/engine/src/runtime/feel/audio.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/audio.ts)

### uiTweens

The shared UI tween manager. It drives itself on requestAnimationFrame in a browser; call `uiTweens.tick(dt)` elsewhere.

```ts check=skip
const uiTweens: Tweens;
```

Source: [packages/engine/src/runtime/feel/tween.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/tween.ts)

## Types

### AnimatedCharacterOptions

```ts check=skip
interface AnimatedCharacterOptions {
  readonly clips?: Partial<Record<LocomotionState, string>>;
  readonly thresholds?: Partial<LocomotionThresholds>;
  readonly walkSpeed?: number;
  readonly runSpeed?: number;
  readonly fade?: number;
}
```

Source: [packages/engine/src/runtime/render/animation.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/animation.ts)

### AnimationPlayOptions

```ts check=skip
interface PlayOptions {
  readonly fade?: number;
  readonly loop?: "repeat" | "once";
  readonly timeScale?: number;
}
```

Source: [packages/engine/src/runtime/render/animation.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/animation.ts)

### ArenaOptions

```ts check=skip
interface ArenaOptions {
  readonly sim?: SimConfig;
  readonly forceWebGL?: boolean;
  readonly onStats?: (s: ArenaStats) => void;
  readonly frameBudgetMs?: number;
  readonly autopilot?: boolean;
}
```

Source: [packages/engine/src/runtime/arena.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/arena.ts)

### ArenaStats

```ts check=skip
interface ArenaStats {
  readonly backend: Backend;
  readonly fps: number;
  readonly frameMs: { readonly mean: number; readonly p50: number; readonly p95: number; readonly p99: number };
  readonly cpuMs: { readonly mean: number; readonly p95: number };
  readonly simMsPerTick: number;
  readonly drawCalls: number;
  readonly triangles: number;
  readonly entities: number;
  readonly enemies: number;
  readonly frames: number;
  readonly pixelRatio: number;
  readonly tick: number;
  readonly health: number;
  readonly kills: number;
}
```

Source: [packages/engine/src/runtime/arena.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/arena.ts)

### AssetLoaderOptions

```ts check=skip
interface AssetLoaderOptions {
  readonly resolve: (id: string) => string;
  readonly transcoderPath: string;
}
```

Source: [packages/engine/src/runtime/assets.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/assets.ts)

### AtmosphereOptions

```ts check=skip
interface AtmosphereOptions {
  readonly preset?: LookPreset;
  readonly overrides?: Partial<AtmospherePreset>;
  readonly sky?: boolean;
}
```

Source: [packages/engine/src/runtime/render/atmosphere.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/atmosphere.ts)

### AtmospherePreset

```ts check=skip
interface AtmospherePreset {
  readonly fog: number;
  readonly skyTop: number;
  readonly mode: "linear" | "exp2";
  readonly near: number;
  readonly far: number;
  readonly density: number;
  readonly heightFog: number;
  readonly heightFogTop: number;
}
```

Source: [packages/engine/src/runtime/render/presets.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/presets.ts)

### Backend

```ts check=skip
type Backend = "webgpu" | "webgl2";
```

Source: [packages/engine/src/runtime/renderer.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/renderer.ts)

### BakeOptions

```ts check=skip
interface BakeOptions {
  readonly fps?: number;
  readonly frames?: number;
  readonly normals?: boolean;
  readonly maxWidth?: number;
}
```

Source: [packages/engine/src/runtime/render/vat.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/vat.ts)

### CameraRigOptions

```ts check=skip
interface CameraRigOptions {
  readonly distance?: number;
  readonly height?: number;
  readonly minPitch?: number;
  readonly maxPitch?: number;
  readonly follow?: number;
  readonly lead?: number;
  readonly leadMax?: number;
  readonly leadSmoothing?: number;
  readonly deadZone?: number;
  readonly fov?: number;
  readonly shake?: TraumaOptions;
  readonly punchFrequency?: number;
  readonly punchDamping?: number;
  readonly bounds?: GroundBounds | null;
  readonly groundY?: number;
}
```

Source: [packages/engine/src/runtime/camera.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/camera.ts)

### ClockTick

```ts check=skip
interface ClockTick {
  readonly now: number;
  readonly dt: number;
  readonly realDt: number;
  readonly timeScale: number;
}
```

Source: [packages/engine/src/runtime/feel/clock.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/clock.ts)

### CrowdAttributes

The per-instance attributes a crowd-motion material reads.

```ts check=skip
interface CrowdAttributes {
  readonly xform: InstancedBufferAttribute;
  readonly anim: InstancedBufferAttribute;
  readonly extra: InstancedBufferAttribute;
}
```

Source: [packages/engine/src/runtime/render/crowd-motion.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/crowd-motion.ts)

### CrowdMotionOptions

```ts check=skip
interface CrowdMotionOptions {
  readonly bob?: number;
  readonly waddle?: number;
  readonly lean?: number;
  readonly squash?: number;
  readonly cadence?: readonly [number, number];
  readonly fullSpeed?: number;
  readonly breathe?: number;
  readonly flash?: number;
  readonly billboard?: boolean;
}
```

Source: [packages/engine/src/runtime/render/crowd-motion.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/crowd-motion.ts)

### CueOptions

```ts check=skip
interface CueOptions {
  readonly minGapMs?: number;
  readonly pitchVar?: number;
  readonly gainVar?: number;
  readonly voices?: number;
}
```

Source: [packages/engine/src/runtime/feel/audio.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/audio.ts)

### DamageNumbersOptions

```ts check=skip
interface DamageNumbersOptions extends NumberStackOptions {
  readonly capacity?: number;
  readonly className?: string;
  readonly colors?: Readonly<Record<string, string>>;
  readonly format?: (amount: number) => string;
}
```

Source: [packages/engine/src/runtime/feel/numbers.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/numbers.ts)

### DecalKind

```ts check=skip
type DecalKind = "scorch" | "splat" | "ring";
```

Source: [packages/engine/src/runtime/render/decals.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/decals.ts)

### DecalLook

```ts check=skip
type DecalLook = (n: DecalLookInput) => LookOutput;
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

### DecalLookInput

What a ground decal's look can read (GroundDecals).

```ts check=skip
interface DecalLookInput {
  readonly uv: Node<"vec2">;
  readonly r: Node<"float">;
  readonly angle: Node<"float">;
  readonly kind: Node<"float">;
  readonly t: Node<"float">;
  readonly color: Node<"vec3">;
  readonly shape: Node<"float">;
  readonly opacity: Node<"float">;
}
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

### DecalOptions

```ts check=skip
interface DecalOptions {
  size?: number;
  color?: number;
  life?: number;
  opacity?: number;
  rotation?: number;
  glow?: number;
}
```

Source: [packages/engine/src/runtime/render/decals.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/decals.ts)

### DeviceHints

What the browser tells us about the device. Every field optional: missing reads as "unknown".

```ts check=skip
interface DeviceHints {
  readonly userAgent?: string;
  readonly coarsePointer?: boolean;
  readonly hardwareConcurrency?: number;
  readonly deviceMemory?: number;
  readonly devicePixelRatio?: number;
  readonly backend?: "webgpu" | "webgl2";
  readonly screenWidth?: number;
}
```

Source: [packages/engine/src/runtime/render/quality.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/quality.ts)

### DynamicResolutionOptions

```ts check=skip
interface DynamicResolutionOptions {
  readonly budgetMs?: number;
  readonly overFactor?: number;
  readonly underFactor?: number;
  readonly step?: number;
  readonly min?: number;
  readonly max?: number;
  readonly hysteresisMs?: number;
  readonly minSamples?: number;
  readonly window?: number;
}
```

Source: [packages/engine/src/runtime/render/quality.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/quality.ts)

### EaseFn

Juicy UI tweens: a tiny tween manager with an easing table, and DOM
helpers (pop, shake, count up) built on it. The helpers use the CSS
`scale` and `translate` properties, so they never fight a transform the
page already sets.

```ts check=skip
type EaseFn = (t: number) => number;
```

Source: [packages/engine/src/runtime/feel/tween.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/tween.ts)

### EaseName

```ts check=skip
type EaseName = keyof typeof Ease;
```

Source: [packages/engine/src/runtime/feel/tween.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/tween.ts)

### FeelAudioOptions

```ts check=skip
interface FeelAudioOptions {
  readonly master?: number;
  readonly voices?: number;
  readonly refDistance?: number;
  readonly maxDistance?: number;
  readonly context?: () => AudioContext;
  readonly now?: () => number;
  readonly seed?: number;
}
```

Source: [packages/engine/src/runtime/feel/audio.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/audio.ts)

### FeelClockOptions

The render clock: hit-stop and slow motion for the DRAWN world only.
The netcode never pauses; the clock returns a render time `now` that
runs behind real time while frozen or slowed, then catches up smoothly so
the world never jumps. `now` never runs ahead of real time.

```ts check=skip
interface FeelClockOptions {
  readonly catchUpMs?: number;
  readonly maxLagMs?: number;
  readonly maxFrameMs?: number;
}
```

Source: [packages/engine/src/runtime/feel/clock.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/clock.ts)

### FeelElement

A minimal element: anything with a style and text (real elements, or fakes in tests).

```ts check=skip
interface FeelElement {
  readonly style: { scale: string; translate: string };
  textContent: string | null;
}
```

Source: [packages/engine/src/runtime/feel/tween.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/tween.ts)

### FeelKitOptions

```ts check=skip
interface FeelKitOptions {
  readonly preset?: FeelPresetName | (Partial<FeelPreset> & { readonly base?: FeelPresetName });
  readonly camera?: TraumaTarget;
  readonly particles?: ParticleSink | null;
  readonly project?: Projector;
  readonly screenWidth?: () => number;
  readonly numbers?: DamageNumbers | HTMLElement | null;
  readonly audio?: FeelAudio | null;
  readonly rumble?: Rumble | null;
  readonly clock?: FeelClock;
}
```

Source: [packages/engine/src/runtime/feel/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/kit.ts)

### FeelPreset

Tunables for every one-liner. Pick a named preset or override fields.

```ts check=skip
interface FeelPreset {
  readonly hitTrauma: number;
  readonly hitTraumaPerFrame: number;
  readonly killTrauma: number;
  readonly bigKillTrauma: number;
  readonly hurtTrauma: number;
  readonly bigKillStopMs: number;
  readonly hurtStopMs: number;
  readonly levelUpStopMs: number;
  readonly knockback: number;
  readonly bigKnockback: number;
  readonly flashSeconds: number;
  readonly bigKillPunch: number;
  readonly hurtPunch: number;
  readonly levelUpPunch: number;
  readonly dashPunch: number;
  readonly landTrauma: number;
  readonly hurtRumble: readonly [number, number, number];
  readonly bigKillRumble: readonly [number, number, number];
  readonly landRumble: readonly [number, number, number];
  readonly killParticles: number;
  readonly bigKillParticles: number;
  readonly numbersPerFrame: number;
}
```

Source: [packages/engine/src/runtime/feel/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/kit.ts)

### FeelPresetName

```ts check=skip
type FeelPresetName = "subtle" | "default" | "heavy";
```

Source: [packages/engine/src/runtime/feel/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/kit.ts)

### FieldSpec

The play field: a square of half size `half` m with a wall `wallHeight` tall, and `outside` m of dressed ground past it.

```ts check=skip
interface FieldSpec {
  readonly half: number;
  readonly wallHeight: number;
  readonly outside: number;
  readonly theme: WorldTheme;
  readonly wall?: boolean;
  readonly pillars?: readonly PillarSpec[];
}
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

### FootstepOptions

```ts check=skip
interface FootstepOptions {
  readonly stride?: number;
  readonly maxRate?: number;
  readonly minSpeed?: number;
}
```

Source: [packages/engine/src/runtime/feel/audio.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/audio.ts)

### GamepadLike

```ts check=skip
interface GamepadLike {
  readonly connected?: boolean;
  readonly vibrationActuator?: RumbleActuator | null;
}
```

Source: [packages/engine/src/runtime/feel/rumble.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/rumble.ts)

### GpuBurstOptions

The feel kit's burst options plus the renderer's extras (all optional).

```ts check=skip
interface ParticleBurstOptions extends FeelBurstOptions {
  readonly dirY?: number;
  readonly speed?: number;
  readonly spread?: number;
  readonly size?: number;
}
```

Source: [packages/engine/src/runtime/render/particles.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/particles.ts)

### GpuParticlesOptions

```ts check=skip
interface GpuParticlesOptions {
  readonly capacity?: number;
  readonly random?: () => number;
  readonly look?: ParticleShade;
}
```

Source: [packages/engine/src/runtime/render/particles.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/particles.ts)

### GradePreset

```ts check=skip
interface GradePreset {
  readonly exposure: number;
  readonly contrast: number;
  readonly saturation: number;
  readonly shadowTint: readonly [number, number, number];
  readonly highlightTint: readonly [number, number, number];
  readonly vignette: number;
  readonly bloomStrength: number;
  readonly bloomRadius: number;
  readonly bloomThreshold: number;
  readonly toneMapping: "aces" | "agx" | "neutral";
}
```

Source: [packages/engine/src/runtime/render/presets.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/presets.ts)

### GroundBounds

A rectangle on the ground plane.

```ts check=skip
interface GroundBounds {
  readonly minX: number;
  readonly maxX: number;
  readonly minZ: number;
  readonly maxZ: number;
}
```

Source: [packages/engine/src/runtime/camera.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/camera.ts)

### HeroHighlightOptions

```ts check=skip
interface HeroHighlightOptions {
  readonly rim?: ColorRepresentation | null;
  readonly rimStrength?: number;
  readonly rimPower?: number;
  readonly outline?: ColorRepresentation | null;
  readonly outlineWidth?: number;
}
```

Source: [packages/engine/src/runtime/render/highlight.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/highlight.ts)

### HitEvent

```ts check=skip
interface HitEvent {
  readonly x: number;
  readonly y: number;
  readonly z: number;
  readonly amount: number;
  readonly id?: number;
  readonly big?: boolean;
  readonly dirX?: number;
  readonly dirZ?: number;
  readonly kind?: string;
}
```

Source: [packages/engine/src/runtime/feel/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/kit.ts)

### InputOptions

```ts check=skip
interface InputOptions {
  readonly mouseSensitivity?: number;
  readonly touchSensitivity?: number;
  readonly touch?: boolean;
}
```

Source: [packages/engine/src/runtime/input.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/input.ts)

### KillEvent

```ts check=skip
interface KillEvent {
  readonly x: number;
  readonly y: number;
  readonly z: number;
  readonly big?: boolean;
  readonly id?: number;
  readonly color?: number;
  readonly particles?: string;
  readonly dirX?: number;
  readonly dirZ?: number;
}
```

Source: [packages/engine/src/runtime/feel/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/kit.ts)

### KnockbackOptions

Client-side visual knockback and squash per entity. The authoritative
sim moves the entity; this adds a springy offset and a squash-stretch on
top of the interpolated position, so a hit reads instantly even ~100 ms
in the past. Read `get(id)` each frame and add it when drawing.

```ts check=skip
interface KnockbackOptions {
  readonly frequency?: number;
  readonly damping?: number;
  readonly maxOffset?: number;
  readonly squash?: number;
}
```

Source: [packages/engine/src/runtime/feel/knockback.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/knockback.ts)

### KnockbackSample

```ts check=skip
interface KnockbackSample {
  x: number;
  z: number;
  sx: number;
  sy: number;
  sz: number;
}
```

Source: [packages/engine/src/runtime/feel/knockback.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/knockback.ts)

### LightingOptions

```ts check=skip
interface LightingOptions {
  readonly preset?: LookPreset;
  readonly overrides?: Partial<LightingPreset>;
  readonly shadowMapSize?: number;
  readonly shadowExtent?: number;
}
```

Source: [packages/engine/src/runtime/render/lighting.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/lighting.ts)

### LightingPreset

```ts check=skip
interface LightingPreset {
  readonly sky: number;
  readonly ground: number;
  readonly hemi: number;
  readonly sun: number;
  readonly sunIntensity: number;
  readonly sunDir: readonly [number, number, number];
  readonly ambient: number;
  readonly ambientColor: number;
  readonly shadowStrength: number;
}
```

Source: [packages/engine/src/runtime/render/presets.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/presets.ts)

### LocomotionState

```ts check=skip
type LocomotionState = "idle" | "walk" | "run";
```

Source: [packages/engine/src/runtime/render/animation.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/animation.ts)

### LocomotionThresholds

```ts check=skip
interface LocomotionThresholds {
  readonly walk: number;
  readonly run: number;
  readonly band: number;
}
```

Source: [packages/engine/src/runtime/render/animation.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/animation.ts)

### Look

```ts check=skip
interface Look {
  readonly lighting: LightingPreset;
  readonly atmosphere: AtmospherePreset;
  readonly grade: GradePreset;
}
```

Source: [packages/engine/src/runtime/render/presets.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/presets.ts)

### LookOutput

A decal or ring look's answer: colour and opacity nodes, and the blend to draw with.

```ts check=skip
interface LookOutput {
  readonly color: Node<"vec3">;
  readonly opacity: Node<"float">;
  readonly blending?: "add" | "normal";
}
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

### LookPreset

Look presets: one name picks the lighting, the atmosphere and the color
grade together, so a template (or a generated game) says `preset: "dusk"`
and gets a coherent picture. Plain data, node-testable.

```ts check=skip
type LookPreset = "night" | "dusk" | "day" | "studio";
```

Source: [packages/engine/src/runtime/render/presets.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/presets.ts)

### LookTarget

```ts check=skip
interface LookTarget {
  look(dYaw: number, dPitch: number): void;
  readonly yaw: number;
}
```

Source: [packages/engine/src/runtime/input.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/input.ts)

### MusicElement

The slice of HTMLAudioElement the music uses.

```ts check=skip
interface MusicElement {
  src: string;
  loop: boolean;
  volume: number;
  muted: boolean;
  preload: string;
  readonly paused: boolean;
  play(): Promise<void> | void;
  pause(): void;
}
```

Source: [packages/engine/src/runtime/feel/sound.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/sound.ts)

### NavigatorLike

```ts check=skip
interface NavigatorLike {
  getGamepads?(): readonly (GamepadLike | null)[];
  vibrate?(pattern: number | number[]): boolean;
}
```

Source: [packages/engine/src/runtime/feel/rumble.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/rumble.ts)

### NumberDraw

```ts check=skip
interface NumberDraw {
  readonly x: number;
  readonly y: number;
  readonly scale: number;
  readonly opacity: number;
}
```

Source: [packages/engine/src/runtime/feel/numbers.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/numbers.ts)

### NumberInput

Floating damage numbers. `NumberStack` is the DOM-free core (slots,
merging, motion); `DamageNumbers` draws it with a fixed pool of DOM nodes
moved by transforms only (no layout per frame).

```ts check=skip
interface NumberInput {
  readonly x: number;
  readonly y: number;
  readonly amount: number;
  readonly id?: number;
  readonly big?: boolean;
  readonly kind?: string;
}
```

Source: [packages/engine/src/runtime/feel/numbers.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/numbers.ts)

### NumberSlot

```ts check=skip
interface NumberSlot {
  active: boolean;
  id: number;
  amount: number;
  t: number;
  x: number;
  y: number;
  drift: number;
  big: boolean;
  kind: string;
  at: number;
  gen: number;
}
```

Source: [packages/engine/src/runtime/feel/numbers.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/numbers.ts)

### NumberStackOptions

```ts check=skip
interface NumberStackOptions {
  readonly mergeMs?: number;
  readonly lifeSeconds?: number;
  readonly rise?: number;
}
```

Source: [packages/engine/src/runtime/feel/numbers.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/numbers.ts)

### ParticleBurstOptions

```ts check=skip
interface ParticleBurstOptions {
  readonly count?: number;
  readonly color?: number;
  readonly scale?: number;
  readonly dirX?: number;
  readonly dirZ?: number;
}
```

Source: [packages/engine/src/runtime/feel/types.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/types.ts)

### ParticlePreset

```ts check=skip
interface ParticlePreset {
  readonly blend: "add" | "alpha";
  readonly count: number;
  readonly speed: readonly [number, number];
  readonly spread: number;
  readonly dir: readonly [number, number, number];
  readonly life: readonly [number, number];
  readonly size: readonly [number, number];
  readonly gravity: number;
  readonly drag: number;
  readonly color: number;
  readonly stretch: number;
  readonly jitter: number;
}
```

Source: [packages/engine/src/runtime/render/particles.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/particles.ts)

### ParticlePresetName

```ts check=skip
type ParticlePresetName = "sparks" | "burst" | "embers" | "smoke" | "hitSpark" | "dust" | "magic" | "kill" | "bigKill";
```

Source: [packages/engine/src/runtime/render/particles.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/particles.ts)

### ParticleShade

A particle look: every particle's shape and colour, plus an optional
size curve over its life (a pop, a shrink). The default is soft round
glows; an art style brings its own (the toon style draws stars, streaks
and puffs).

```ts check=skip
interface ParticleShade {
  shade(p: ParticleShadeInput): ParticleShadeOutput;
  size?(t: Node<"float">, seed: Node<"float">, blend: "add" | "alpha"): Node<"float">;
}
```

Source: [packages/engine/src/runtime/render/particles.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/particles.ts)

### ParticleShadeInput

What a particle look (an art style's) reads, per fragment.

```ts check=skip
interface ParticleShadeInput {
  readonly t: Node<"float">;
  readonly uv: Node<"vec2">;
  readonly color: Node<"vec3">;
  readonly seed: Node<"float">;
  readonly blend: "add" | "alpha";
}
```

Source: [packages/engine/src/runtime/render/particles.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/particles.ts)

### ParticleShadeOutput

```ts check=skip
interface ParticleShadeOutput {
  readonly color: Node<"vec3">;
  readonly opacity: Node<"float">;
  readonly blend?: "add" | "alpha";
}
```

Source: [packages/engine/src/runtime/render/particles.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/particles.ts)

### ParticleSink

Something that can play a pooled particle effect (the GPU particle system implements it).

```ts check=skip
interface ParticleSink {
  burst(preset: string, x: number, y: number, z: number, opts?: ParticleBurstOptions): void;
}
```

Source: [packages/engine/src/runtime/feel/types.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/types.ts)

### PillarSpec

One pillar or post (sim metres).

```ts check=skip
interface PillarSpec {
  readonly x: number;
  readonly z: number;
  readonly radius: number;
  readonly height: number;
}
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

### PixelStyleOptions

```ts check=skip
interface PixelStyleOptions {
  readonly texelsPerMetre?: number;
  readonly dither?: number;
  readonly saturation?: number;
  readonly bands?: readonly number[];
  readonly minRows?: number;
}
```

Source: [packages/engine/src/runtime/styles/pixel/index.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/pixel/index.ts)

### PlayOptions

```ts check=skip
interface PlayOptions {
  readonly pitch?: number;
  readonly gain?: number;
  readonly pan?: number;
  readonly screenX?: number;
  readonly width?: number;
  readonly distance?: number;
}
```

Source: [packages/engine/src/runtime/feel/audio.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/audio.ts)

### PostFXOptions

```ts check=skip
interface PostFXOptions {
  readonly preset?: LookPreset;
  readonly overrides?: Partial<GradePreset>;
  readonly bloom?: boolean;
  readonly outline?: boolean;
  readonly fxaa?: boolean;
  readonly enabled?: boolean;
  readonly bloomScale?: number;
  readonly style?: StylePost;
}
```

Source: [packages/engine/src/runtime/render/post.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/post.ts)

### Projector

World position to CSS pixels on the canvas.

```ts check=skip
type Projector = (x: number, y: number, z: number) => { x: number; y: number; onScreen: boolean };
```

Source: [packages/engine/src/runtime/feel/types.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/types.ts)

### QualitySettings

What a tier turns on.

```ts check=skip
interface QualitySettings {
  readonly tier: QualityTier;
  readonly shadowMapSize: number;
  readonly post: boolean;
  readonly bloomScale: number;
  readonly outline: boolean;
  readonly maxPixelRatio: number;
  readonly minPixelRatio: number;
  readonly particles: number;
}
```

Source: [packages/engine/src/runtime/render/quality.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/quality.ts)

### QualityTier

Quality tiers and dynamic resolution ("auto-detected
low, medium or high (shadows, post-processing, resolution scale) with
dynamic resolution to hold the frame rate"). The decision logic is pure
so it is tested in node; `QualityManager` applies it to a renderer.

```ts check=skip
type QualityTier = "low" | "medium" | "high";
```

Source: [packages/engine/src/runtime/render/quality.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/quality.ts)

### RendererHandle

```ts check=skip
interface RendererHandle {
  readonly renderer: WebGPURenderer;
  readonly backend: Backend;
}
```

Source: [packages/engine/src/runtime/renderer.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/renderer.ts)

### RendererOptions

```ts check=skip
interface RendererOptions {
  readonly forceWebGL?: boolean;
  readonly antialias?: boolean;
  readonly maxPixelRatio?: number;
}
```

Source: [packages/engine/src/runtime/renderer.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/renderer.ts)

### RenderStack

```ts check=skip
interface RenderStack {
  readonly lighting: LightingRig;
  readonly atmosphere: Atmosphere;
  readonly post: PostFX;
  readonly particles: GpuParticles;
  readonly decals: GroundDecals;
  readonly rings: GroundRings;
  readonly quality: QualityManager;
  readonly style: string | null;
  readonly kit: StyleKit | null;
  readonly session: StyleSession | null;
  readonly time: number;
  frame(dt: number, focus: { x: number; y: number; z: number }, realNowMs?: number): boolean;
  resize(width: number, height: number): void;
  setPreset(preset: LookPreset): void;
  setQuality(tier: QualityTier): void;
  dispose(): void;
}
```

Source: [packages/engine/src/runtime/render/stack.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/stack.ts)

### RenderStackOptions

```ts check=skip
interface RenderStackOptions {
  readonly preset?: LookPreset;
  readonly style?: string;
  readonly quality?: QualityTier | "auto";
  readonly bloom?: boolean;
  readonly outline?: boolean;
  readonly dynamicResolution?: boolean;
  readonly shadowExtent?: number;
  readonly lighting?: Partial<LightingPreset>;
  readonly atmosphere?: Partial<AtmospherePreset>;
  readonly grade?: Partial<GradePreset>;
  readonly particles?: number;
  readonly makeParticles?: (scene: Scene, capacity: number) => GpuParticles;
  readonly decals?: number;
  readonly resolve?: (id: string) => string | null;
}
```

Source: [packages/engine/src/runtime/render/stack.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/stack.ts)

### RingLook

```ts check=skip
type RingLook = (n: RingLookInput) => LookOutput;
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

### RingLookInput

What a shockwave ring's look can read (GroundRings).

```ts check=skip
interface RingLookInput {
  readonly uv: Node<"vec2">;
  readonly r: Node<"float">;
  readonly t: Node<"float">;
  readonly alive: Node<"float">;
  readonly color: Node<"vec3">;
}
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

### RingOptions

```ts check=skip
interface RingOptions {
  color?: number;
  duration?: number;
  glow?: number;
}
```

Source: [packages/engine/src/runtime/render/decals.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/decals.ts)

### RumbleActuator

Controller rumble (Gamepad API dual-rumble) with a phone vibration
fallback, rate-limited so a swarm of hits is one buzz, not fifty.

```ts check=skip
interface RumbleActuator {
  playEffect?(type: string, params: { duration: number; strongMagnitude: number; weakMagnitude: number; startDelay?: number }): Promise<unknown>;
}
```

Source: [packages/engine/src/runtime/feel/rumble.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/rumble.ts)

### RumbleOptions

```ts check=skip
interface RumbleOptions {
  readonly minGapMs?: number;
  readonly vibrateFallback?: boolean;
  readonly navigator?: NavigatorLike;
  readonly now?: () => number;
}
```

Source: [packages/engine/src/runtime/feel/rumble.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/rumble.ts)

### SegmentRig

```ts check=skip
interface SegmentRig {
  readonly mesh: SkinnedMesh;
  readonly bones: readonly [Bone, Bone, Bone];
  readonly clips: readonly AnimationClip[];
}
```

Source: [packages/engine/src/runtime/render/rig.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/rig.ts)

### SegmentRigOptions

```ts check=skip
interface SegmentRigOptions {
  readonly height?: number;
  readonly radius?: number;
  readonly topRadius?: number;
  readonly radialSegments?: number;
  readonly heightSegments?: number;
  readonly geometry?: BufferGeometry;
}
```

Source: [packages/engine/src/runtime/render/rig.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/rig.ts)

### SoundBank

Cue name -> sample, and an optional music loop (the asset library's `soundBank()` builds one).

```ts check=skip
interface SoundBank {
  readonly cues: Readonly<Record<string, SoundBankEntry>>;
  readonly music?: SoundBankEntry | null;
}
```

Source: [packages/engine/src/runtime/feel/sound.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/sound.ts)

### SoundBankEntry

```ts check=skip
interface SoundBankEntry {
  readonly url: string;
  readonly gain?: number;
}
```

Source: [packages/engine/src/runtime/feel/sound.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/sound.ts)

### SoundPlayerOptions

```ts check=skip
interface SoundPlayerOptions {
  readonly musicVolume?: number;
  readonly sfxVolume?: number;
  readonly music?: boolean;
  readonly key?: string | null;
  readonly fadeIn?: number;
  readonly createMusic?: () => MusicElement | null;
  readonly fetchBytes?: (url: string) => Promise<ArrayBuffer>;
  readonly pauseWhenHidden?: boolean;
}
```

Source: [packages/engine/src/runtime/feel/sound.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/sound.ts)

### SpringOptions

Damped springs for game feel: camera follow, FOV punch, knockback
offsets, UI pops. `frequency` is the natural frequency in Hz and
`damping` the damping ratio (1 = critically damped, no overshoot; below 1
it wobbles). Integrated with fixed sub-steps, so any frame rate is stable.

```ts check=skip
interface SpringOptions {
  readonly frequency?: number;
  readonly damping?: number;
}
```

Source: [packages/engine/src/runtime/feel/spring.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/spring.ts)

### StyleContext

What a style's session is attached to (one renderer, one scene).

```ts check=skip
interface StyleContext {
  readonly handle: RendererHandle;
  readonly renderer: WebGPURenderer;
  readonly scene: Scene;
  readonly camera: Camera;
  readonly tier: QualityTier;
  readonly preset: LookPreset;
  readonly post?: PostFX;
  readonly atmosphere?: Atmosphere;
  readonly resolve?: (id: string) => string | null;
}
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

### StyledPillar

A pillar as drawn: its body (own material, so the template can fade it), the pieces on top, and where its flame burns (null: none).

```ts check=skip
interface StyledPillar {
  readonly body: Object3D;
  readonly fade: readonly Material[];
  readonly top: readonly Object3D[];
  readonly flame: readonly [number, number, number] | null;
}
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

### StyledView

```ts check=skip
interface StyledView {
  readonly session: StyleSession;
  readonly post: PostFX;
  render(nowMs?: number): void;
  setSize(width: number, height: number): void;
  dispose(): void;
}
```

Source: [packages/engine/src/runtime/styles/view.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/view.ts)

### StyledViewOptions

```ts check=skip
interface StyledViewOptions {
  readonly preset?: LookPreset;
  readonly bloom?: boolean;
  readonly tier?: QualityTier;
}
```

Source: [packages/engine/src/runtime/styles/view.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/view.ts)

### StyleKit

```ts check=skip
interface StyleKit {
  readonly id: string;
  stack?(preset: LookPreset): StyleStack;
  look?(preset: LookPreset): Look;
  readonly needsPost?: boolean;
  readonly bloom?: boolean;
  readonly outline?: boolean;
  attach?(ctx: StyleContext): StyleSession;
  field?(spec: FieldSpec): Object3D[];
  groundHeight?(spec: FieldSpec, x: number, z: number): number;
  pillar?(spec: PillarSpec, theme: WorldTheme, index: number): StyledPillar;
  shape?(name: StyleShapeName): StyleShape | null;
}
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

### StylePost

Post-graph hooks, in graph order: called whenever the post stack rebuilds its node graph.

```ts check=skip
interface StylePost {
  scenePass?(pass: PassNode): void;
  scene?(input: StylePostInput): Node<"vec4">;
  color?(rgb: Node<"vec3">, pass: PassNode): Node<"vec3">;
  display?(color: Node<"vec4">, input: StylePostInput): Node<"vec4">;
}
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

### StylePostInput

What the post stages can read: the scene pass, sampleable at any uv.

```ts check=skip
interface StylePostInput {
  readonly color: Node<"vec4"> & { sample(uv: Node<"vec2">): Node<"vec4"> };
  readonly depth: Node<"vec4"> & { sample(uv: Node<"vec2">): Node<"vec4"> };
  readonly texel: UniformNode<"vec2", Vector2>;
  readonly near: UniformNode<"float", number>;
  readonly far: UniformNode<"float", number>;
}
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

### StyleSession

One style attached to one renderer and scene (StyleKit.attach).

```ts check=skip
interface StyleSession {
  render?(draw: () => void): void;
  readonly post?: StylePost;
  readonly particles?: ParticleShade;
  readonly decals?: DecalLook;
  readonly rings?: RingLook;
  frame?(seconds: number): void;
  setPreset?(preset: LookPreset): void;
  surface?(kind: SurfaceKind, opts?: SurfaceOptions): Texture | null;
  setSize?(width: number, height: number): void;
  setQuality?(tier: QualityTier): void;
  dispose(): void;
}
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

### StyleShape

A shape a template draws instanced (bolts, blades, chunks, props).

```ts check=skip
interface StyleShape {
  readonly geometry: BufferGeometry;
  readonly material: Material;
}
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

### StyleShapeName

Template machinery shapes a style may redraw.

```ts check=skip
type StyleShapeName = "bolt" | "lance" | "blade" | "pellet" | "shard" | "chunk" | "rock" | "stump" | "barrel" | "crate" | "lantern" | "flame";
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

### StyleStack

Overrides for the render stack under one look preset, plus the style's opinion on sun shadows.

```ts check=skip
interface StyleStack extends Partial<Pick<RenderStackOptions, "lighting" | "atmosphere" | "grade" | "makeParticles">> {
  readonly shadows?: boolean;
}
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

### Surface

```ts check=skip
type Surface = keyof typeof SURFACES;
```

Source: [packages/engine/src/runtime/feel/audio.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/audio.ts)

### SurfaceKind

Surfaces templates build themselves and may ask the style for: ground
(a natural field), floor (paving), wall, stone, and glow (a pool of
light on the ground, white with alpha, which the template tints).

```ts check=skip
type SurfaceKind = "ground" | "floor" | "wall" | "stone" | "glow";
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

### SurfaceOptions

```ts check=skip
interface SurfaceOptions {
  readonly tile?: number;
  readonly mood?: string;
}
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

### SynthRecipe

```ts check=skip
interface SynthRecipe {
  readonly wave: OscillatorType | "noise";
  readonly f0: number;
  readonly f1: number;
  readonly ms: number;
  readonly gain: number;
}
```

Source: [packages/engine/src/runtime/feel/audio.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/audio.ts)

### SystemHost

What the scheduler needs from the simulation it drives.

```ts check=skip
interface SystemHost {
  readonly tickRate: number;
  tick(): number;
  players(): readonly PlayerView[];
  spawn(prefab: string, at: readonly [number, number, number], opts?: { readonly elite?: boolean }): void;
  random(): number;
  emit(event: string, players?: readonly number[]): void;
  alive?(prefab?: string): number;
  respawnDead?(): void;
  end?(outcome: "won" | "lost"): void;
  ringPoint?(cx: number, cz: number, radius: number, prefab: string): readonly [number, number] | null;
  spawnEdge?(prefab: string, opts: SpawnEdgeOptions): number;
  spawnPickup?(prefab: string, at: readonly [number, number, number]): void;
  announce?(text: string, tone: "info" | "danger" | "reward"): void;
  upcoming?(label: string, seconds: number): void;
  bossAlive?(): boolean;
  pauseDirector?(seconds: number): void;
  surge?(multiplier: number, seconds: number): void;
  xpBoost?(multiplier: number, seconds: number): void;
  scatter?(prefab: string, count: number): number;
  clear?(prefab: string): number;
  onScreen?(x: number, z: number): boolean;
}
```

Source: [packages/engine/src/api/scheduler.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/api/scheduler.ts)

### TraumaOptions

```ts check=skip
interface TraumaOptions {
  readonly decay?: number;
  readonly exponent?: number;
  readonly maxOffset?: number;
  readonly maxRoll?: number;
  readonly frequency?: number;
  readonly seed?: number;
}
```

Source: [packages/engine/src/runtime/feel/trauma.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/trauma.ts)

### TraumaTarget

Anything that takes trauma and an optional FOV punch: a CameraRig, or a bare Trauma.

```ts check=skip
interface TraumaTarget {
  addTrauma(amount: number): void;
  punch?(fovKickDegrees: number): void;
}
```

Source: [packages/engine/src/runtime/feel/types.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/types.ts)

### TweenOptions

```ts check=skip
interface TweenOptions {
  readonly duration: number;
  readonly ease?: EaseName | EaseFn;
  readonly delay?: number;
  readonly yoyo?: boolean;
  readonly repeat?: number;
  readonly onUpdate?: () => void;
  readonly onDone?: () => void;
}
```

Source: [packages/engine/src/runtime/feel/tween.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/tween.ts)

### TweenProps

```ts check=skip
type TweenProps<T> = Partial<Record<NumericKeys<T>, number>>;
```

Source: [packages/engine/src/runtime/feel/tween.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/feel/tween.ts)

### VatClip

```ts check=skip
interface VatClip {
  readonly name: string;
  readonly start: number;
  readonly frames: number;
}
```

Source: [packages/engine/src/runtime/render/vat.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/vat.ts)

### VatCrowdOptions

```ts check=skip
interface VatCrowdOptions {
  readonly bakedNormals?: boolean;
}
```

Source: [packages/engine/src/runtime/render/vat.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/vat.ts)

### VertexAnimation

A vertex animation texture: every vertex's skinned position (and normal) per frame.

```ts check=skip
interface VertexAnimation {
  readonly positions: DataTexture;
  readonly normals: DataTexture | null;
  readonly vertexCount: number;
  readonly width: number;
  readonly rowsPerFrame: number;
  readonly totalFrames: number;
  readonly fps: number;
  readonly clips: readonly VatClip[];
  readonly geometry: BufferGeometry;
}
```

Source: [packages/engine/src/runtime/render/vat.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/render/vat.ts)

### WorldTheme

Words a template passes so one kit can dress different places: "meadow" (EMBERWATCH's night field), "yard" (VOLTYARD's lot).

```ts check=skip
type WorldTheme = string;
```

Source: [packages/engine/src/runtime/styles/kit.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/kit.ts)

## Other

### voxel

```ts check=skip
voxel
```

Source: [packages/engine/src/runtime/styles/voxel/index.ts](https://github.com/netnetdev/net-forge/blob/main/packages/engine/src/runtime/styles/voxel/index.ts)