hayao.js — Public API digest

Auto-generated by npm run api. Everything importable from @hayao. Grep here for the real surface — never guess an API from memory.

967 exports.

classs (74)

Achievements
AmbientField
AnimationPlayer
AudioBus
BitmapText
Blend1D
Blend2D
Bone2D
BroadcastChannelTransport
Camera2D
CameraController
Canvas2DRenderer
CinematicPlayer
ClipPlayer
Clock
Coroutines
DebugPane
DepthSort
DuotoneHero
EventBus
FloatingText
Fsm
GamepadSource
HeadlessRenderer
IkTarget
InputBuffer
InputDeviceTracker
InputRecorder
InputState
IsoPrism
KeyboardSource
LightLayer
LocalStorageAdapter
LockstepSession
LoopbackHub
LoopbackTransport
LootTable
MemoryStorage
MenuGamepad
Node
NodePool
NullStorage
ParallaxLayer
Particles
PhaseClock
PixelBuffer
PlayerInput
PointerSource
PointLight
RingBuffer
Rng
RollbackSession
RoomHost
SaveManager
ScreenTransition
SessionRecorder
Shaker
Shell
Signal
Skeleton
SkeletonDebug
SnapshotRing
SpatialHash
Sprite
SvgRenderer
Text
TextureSprite
TileLayer
Timer
TouchControls
UndoStack
VerletChain
WebGL2Renderer
World

functions (409)

abilitiesOf: (world: WorldGraphDef, taken: readonly string[]) => Set
ablationIssues: <S, M>(exp: AblationExperiment<S, M>, opts?: AblationOptions) => string[]
achievementIssues: (defs: AchievementDef[], timeline: Record<string, unknown>[]) => string[]
addBody: (rw: RigidWorld, def: RigidBodyDef) => number
addDistanceJoint: (rw: RigidWorld, def: DistanceJointDef) => number
addPrismaticJoint: (rw: RigidWorld, def: PrismaticJointDef) => number
addRevoluteJoint: (rw: RigidWorld, def: RevoluteJointDef) => number
addTransition: (parent: Node, config?: TransitionConfig) => ScreenTransition
addWeldJoint: (rw: RigidWorld, def: WeldJointDef) => number
agencyIssues: <State, Move>(puzzle: Puzzle<State, Move>, opts?: AgencyOptions) => string[]
agencyStats: <State, Move>(puzzle: Puzzle<State, Move>, opts?: AgencyOptions) => AgencyStats
albumTrack: (id: string) => AlbumTrack | undefined
all: (…waits: Wait[]) => Wait
analyzePlaytest: (def: GameDefinition<Record<string, unknown>>, session: PlaytestSession, opts?: AnalyzeOptions) => PlaytestReport
angleDelta: (a: number, b: number) => number
applyChannel: (node: Node, channel: ClipChannel, value: number) => void
applyImpulse: (rw: RigidWorld, id: number, ix: number, iy: number, px?: number | undefined, py?: number | undefined) => void
applyReverb: (buf: StereoBuffer, opts?: ReverbOptions) => void
applyReverbSend: (dry: StereoBuffer, send: StereoBuffer, opts?: ReverbOptions) => void
applyTransform: (m: Transform, p: Vec2) => Vec2
asciiEntities: (rowsAscii: string[], tileSize?: number, chars?: Record<string, TileId>) => { char: string; tx: number; ty: number; x: number; y: number; }[]
assertAgency: <State, Move>(puzzle: Puzzle<State, Move>, opts?: AgencyOptions) => AgencyStats
assertAudio: (buf: StereoBuffer, exp: AudioExpectation) => AudioAssertion
assertDeterministic: (makeWorld: WorldFactory, log: InputLog) => DeterminismReport
assertLoadBearing: <S, M>(exp: AblationExperiment<S, M>, opts?: AblationOptions) => AblationReport
assertRamp: (difficulty: readonly number[], opts?: RampOptions) => void
assertSnapshotStable: (makeWorld: WorldFactory, log: InputLog, warmup: number) => { ok: boolean; hashA: string; hashB: string; }
assertSolvable: <State, Move>(puzzle: Puzzle<State, Move>, options?: SolveOptions) => SolveResult
astar: (start: N, isGoal: (n: N) => boolean, neighbours: WeightedNeighbours, key: NodeKey, opts?: { heuristic?: ((n: N) => number) | undefined; maxNodes?: …
astarGrid: (start: Cell, goal: Cell, passable: Passable, opts: { cols: number; rows: number; diagonal?: boolean | undefined; cost?: ((x: number, y: number) => number) |…
atomManifest: (atom: AtomDefinition) => AtomManifestEntry
atomToGame: (atom: AtomDefinition) => GameDefinition<Record<string, unknown>>
attachAchievementToasts: (ach: Achievements, icon?: string) => () => void
autotile4: (grid: BoolGrid) => (WangTile | null)[][]
autotileToCommands: (grid: BoolGrid, options?: AutotileDrawOptions) => (RectCommand | PolyCommand)[]
availableUpgrades: (defs: readonly UpgradeDef[], owned: readonly string[]) => UpgradeDef[]
bandBalance: (sig: Samples, sampleRate?: number) => BandBalance
barPhase: (elapsedSec: number, secPerBar: number) => number
bfs: (start: N, neighbours: Neighbours, key: NodeKey, opts?: { goal?: ((n: N) => boolean) | undefined; maxNodes?: number | undefined; }) => BfsResult
blazon: (c: Crest) => string
bleedViewBox: (containerW: number, containerH: number, safeW: number, safeH: number, maxScale?: number) => ViewBox
blendIssues: (samples: BlendSample[], dims?: 1 | 2) => string[]
blobPath: (rng: Rng, radius: number, wobble?: number, lobes?: number) => string
bodyAABB: (b: RigidBody) => Rect
bodyContains: (b: RigidBody, x: number, y: number) => boolean
bootChimeScore: (a4?: number) => Tone[]
bootDom: (def: GameDefinition<Record<string, unknown>>, mount?: HTMLElement | undefined) => DomHarness
buildHeroRig: (scheme?: DuotoneScheme, name?: string) => Node
buildSkeleton: (root: Node) => Skeleton
cadenceResolves: (romans: string[]) => boolean
cameraIssues: (samples: readonly Vec2[], opts?: CameraOptions) => string[]
canonicalHandle: (handle: string) => string
canvasGradient: (ctx: { createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient; createRadialGradient(x0: number, y0: number, r0: number, x1: nu…
cardLayout: (card: Node) => CardLayout | undefined
cellFloat: (x: number, y: number, seed?: number) => number
cellHash: (x: number, y: number, seed?: number) => number
cellInt: (x: number, y: number, n: number, seed?: number) => number
changeFrames: (timeline: ProbeFrame[], key: string) => number[]
checkDeterministic: (makeWorld: WorldFactory, log: InputLog) => DeterminismReport
chordChanges: (symbols: string[], octave?: number) => number[][]
chordNotes: (symbol: string, octave?: number) => number[]
clientToDesign: (rect: { left: number; top: number; width: number; height: number; }, width: number, height: number, clientX: number, clientY: number) => Vec2
clipEvents: (def: ClipDef, prev: number, next: number) => string[]
clipFinished: (def: ClipDef, elapsed: number) => boolean
clipIssues: (def: ClipDef, knownTargets?: readonly string[] | undefined) => string[]
clipTime: (def: ClipDef, elapsed: number) => number
collide: (a: RigidBody, b: RigidBody) => Manifold | null
commandsToSVGInner: (commands: DrawCommand[], idPrefix?: string, viewW?: number, viewH?: number) => string
composeCampaign: <State, Move>(spec: CampaignSpec<State, Move>) => Campaign<State, Move>
composeTransform: (m: Transform, n: Transform) => Transform
connectedComponents: (cols: number, rows: number, passable: Passable, diagonal?: boolean) => Components
connectWebSocket: (url: string) => Promise
contourToCommands: (grid: BoolGrid, options?: AutotileDrawOptions) => PolyCommand[]
contrastRatio: (a: string, b: string) => number
createPlanBot: <Step extends { kind: string; }, Probe>(plan: Step[], execs: Record<string, StepExec<Step, Probe>>) => PlanBot
createPlatformerState: (x: number, y: number) => PlatformerState
createRigidWorld: (opts?: RigidWorldOpts) => RigidWorld
createStereo: (durationSec: number, sampleRate?: number) => StereoBuffer
createWorld: <TState extends Record<string, unknown> = Record<string, unknown>>(def: GameDefinition, opts?: number | CreateWorldOptions | undefined) => World<…>
crestFactorDb: (sig: Samples) => number
crestSvg: (handle: string, opts?: CrestSvgOptions) => string
cueForState: (state: “title” | “explore” | “tension” | “reward”) => SoundtrackCue | undefined
cullSegments: (light: Vec2, radius: number, segs: readonly ContourSegment[]) => ContourSegment[]
dashJumpDistance: (cfg?: PlatformerConfig) => number
datan: (x: number) => number
datan2: (y: number, x: number) => number
dbfs: (amp: number) => number
dcos: (x: number) => number
debugCircle: (cx: number, cy: number, radius: number, opts?: DebugDrawOptions) => void
debugDrawCount: () => number
debugDrawEnabled: () => boolean
debugLine: (x0: number, y0: number, x1: number, y1: number, opts?: DebugDrawOptions) => void
debugPoint: (x: number, y: number, opts?: DebugDrawOptions) => void
debugRect: (x: number, y: number, w: number, h: number, opts?: DebugDrawOptions) => void
debugText: (text: string, x: number, y: number, opts?: DebugDrawOptions & { size?: number | undefined; }) => void
decode2bit: (source: string | bigint, width: number, height: number) => PixelBuffer
decodeBits: (source: string | bigint, width: number, height: number) => PixelBuffer
decodeMessage: (data: string) => NetMessage | null
decodeRLE: (runs: readonly number[], width: number, height: number) => PixelBuffer
defaultStorage: (prefix?: string | undefined) => StorageAdapter
defineAtom: (def: AtomDefinition) => AtomDefinition
defineGame: <TState extends Record<string, unknown> = Record<string, unknown>>(def: GameDefinition) => Required<Pick<GameDefinition, “seed” | “width” | ”…
defineLevel: (spec: LevelSpec) => LevelData
deserializeNode: (data: SerializedNode) => Node
dexp: (x: number) => number
dexp2: (x: number) => number
dhypot: (x: number, y: number) => number
diamondPoints: (w: number, h: number) => number[]
diatonicChord: (tonic: number, mode: “major” | “minor” | “harmonicMinor” | “melodicMinor” | “dorian” | “phrygian” | “lydian” | “mixolydian” | “locrian” | “majorPentatonic” …
diffLevels: (a: LevelData, b: LevelData) => LevelChange[]
distanceGain: (model: DistanceModel, distance: number, refDistance?: number, maxDistance?: number, rolloff?: number) => number
distanceWrap: (a: number, b: number, size: number) => number
dlog: (x: number) => number
downloadDataURL: (url: string, filename: string) => void
dpow: (base: number, exp: number) => number
drainDebugCommands: (view?: Transform) => DrawCommand[]
drive: (world: World<Record<string, unknown>>, script: InputScript, until?: ((probe: Record<string, unknown>) => boolean) | undefined) => DriveResult
dropShadow: (color: string, blur: number, dx?: number, dy?: number) => Shadow
dsin: (x: number) => number
duckGain: (active: boolean, amountDb?: number) => number
duotone: (base: string, opts?: DuotoneOptions) => DuotoneScheme
encodeMessage: (msg: NetMessage) => string
encodeRLE: (buf: PixelBuffer) => number[]
encodeWav: (buf: StereoBuffer) => Uint8Array
estimateTempo: (sig: Samples, sampleRate?: number) => number
evalCurve: (curve: Breakpoint[], x: number) => number
featureDistance: (reference: AudioFeatures, candidate: AudioFeatures, weights?: Partial) => MatchResult
features: (sig: Samples, sampleRate?: number) => AudioFeatures
feedbackIssues: (contract: FeedbackContract, requiredEvents: readonly string[], opts?: FeedbackOptions) => string[]
fft: (re: Float32Array, im: Float32Array) => void
findSoftlocks: (world: WorldGraphDef, mode?: CompletionMode) => SoftlockReport
firstFrame: (timeline: ProbeFrame[], pred: (p: ProbeFrame) => boolean) => number
fitFontSize: (m: FontMetric, text: string, maxWidth: number, maxSize: number) => number
fitViewport: (rect: { width: number; height: number; }, width: number, height: number) => Viewport
floodFill: (start: Cell, passable: Passable, opts: { cols: number; rows: number; diagonal?: boolean | undefined; }) => Cell[]
fluxEnvelope: (sig: Samples, frameSize?: number, hop?: number) => Float32Array
forgivenessIssues: (spec: ForgivenessSpec, opts?: ForgivenessOptions) => string[]
formatTime: (seconds: number) => string
fractalNoise: (x: number, y: number, seed?: number, opts?: FractalOptions) => number
frameActions: (log: InputLog, i: number) => string[]
frameAxes: (log: InputLog, i: number) => AxisFrame | undefined
gameInputMap: (def: GameDefinition<Record<string, unknown>>) => Readonly<Record<string, readonly string[]>>
generateCave: (rng: Rng, opts: CaveOptions) => Grid
generateDungeon: (rng: Rng, opts: DungeonOptions) => Dungeon
generateLevels: <State, Move>(factory: (rng: Rng) => Puzzle<State, Move>, opts: GenerateOptions<State, Move>) => GeneratedLevel<State, Move>[]
generateLevelsReport: <State, Move>(factory: (rng: Rng) => Puzzle<State, Move>, opts: GenerateOptions<State, Move>) => GenerateReport<State, Move>
genre: (id: string) => GenreTrack | undefined
getBody: (rw: RigidWorld, id: number) => RigidBody | undefined
getJoint: (rw: RigidWorld, id: number) => Joint | undefined
glow: (color: string, blur: number) => Shadow
graceWindowIssues: (label: string, windowFrames: number, accepts: (delayFrames: number) => boolean) => string[]
gradient: (stops: readonly string[], n: number) => string[]
gradientDef: (g: Gradient, id: string) => string
greedyPolicy: <S, M>(heuristic: (state: S) => number, opts?: GreedyPolicyOptions) => Policy<S, M>
gridAt: (g: Grid, x: number, y: number) => number
gridFromRows: (rows: readonly string[], solid?: string) => boolean[][]
gridSet: (g: Grid, x: number, y: number, v: number) => void
gridToTilemap: (g: Grid, tileSize?: number) => TilemapData
groundAt: (map: TilemapData, x: number, y: number, w: number, h: number, solids?: SolidRect[], dropThrough?: boolean) => { grounded: boolean; solid: number; }
hapticsEnabled: () => boolean
hashNoise: (…values: number[]) => number
hashString: (str: string) => number
hashValue: (value: unknown) => string
hayaboxDeck: (moodByCourtier?: Record<string, string>) => DeckSpec
hayaboxLoopBeats: () => number
hayaboxTutti: (moodByCourtier?: Record<string, string>) => Song
heroStateFromMotion: (m: HeroMotion, opts?: { runThreshold?: number | undefined; }) => “idle” | “run” | “jump” | “fall” | “wallSlide” | “death” | “spawn”
hexToHsl: (hex: string) => HSL
hideScreen: () => void
hold: (actions: string[], frames: number) => Segment
hostRoom: (opts: RoomHostOptions) => RoomHost
hsl: (h: number, s: number, l: number) => string
hsv: (h: number, s: number, v: number) => string
initDirector: (waves: readonly WaveDef[]) => DirectorState
inputDensity: (frames: string[][]) => number
installCapture: (target: CaptureTarget) => HayaoCapture
invalidCommandReason: (c: DrawCommand) => string | null
invertTransform: (m: Transform) => Transform
inVisionCone: (map: TilemapData, ex: number, ey: number, faceX: number, faceY: number, fov: number, range: number, tx: number, ty: number) => boolean
isCaptureMode: () => boolean
isGround: (col: number, row: number, opts: TerrainOptions) => boolean
isMonotonic: (values: number[], dir: “up” | “down”, slack?: number) => boolean
iso: (cfg: IsoConfig) => IsoProjection
joinRoom: (opts: RoomClientOptions) => Promise
jumpAirtime: (cfg?: PlatformerConfig) => number
jumpDistance: (cfg?: PlatformerConfig) => number
jumpHeight: (cfg?: PlatformerConfig) => number
keyMentions: (code: string) => string[]
keysToActions: (map: Readonly<Record<string, readonly string[]>>, keysDown: Set) => string[]
layerGains: (layers: MusicLayer[], intensity: number) => Record<string, number>
layoutIssues: (commands: DrawCommand[], opts?: LayoutOptions) => string[]
layoutText: (font: BitmapFont, input: string | readonly RichChar[], options?: TextLayoutOptions) => TextLayout
lerpAngle: (a: number, b: number, t: number) => number
levelFromSeed: <State, Move>(factory: (rng: Rng) => Puzzle<State, Move>, seed: number) => Puzzle<State, Move>
levelIssues: (data: LevelData) => string[]
levelReachable: (data: LevelData, opts?: { passable?: Passable | undefined; diagonal?: boolean | undefined; }) => ReachReport
levelToTilemap: (data: LevelData) => TilemapData
lightingIssues: (commands: DrawCommand[], avatarFill: string, avatarWorld: Vec2, opts?: LightingOptions) => string[]
linearGradient: (stops: readonly StopInput[], angleDeg?: number) => LinearGradient
lineOfSight: (map: TilemapData, ax: number, ay: number, bx: number, by: number) => boolean
lintDeck: (deck: DeckSpec) => string[]
lintSong: (song: Song, opts?: LintOptions) => MusicLintResult
longestLull: (eventFrames: number[], totalFrames: number) => number
lookAheadIssues: (cameraSamples: readonly Vec2[], targetSamples: readonly Vec2[], minLead?: number) => string[]
loop: (id: string) => DrumLoop | undefined
magnitudeSpectrum: (frame: Samples) => Float32Array
makeCard: (spec: CardSpec) => Node
makeGrid: (cols: number, rows: number, fill?: number) => Grid
makeReach: (start?: number, settle?: number) => (target: number, dt: number) => number
makeTransform: (pos: Vec2, rotation: number, scale: Vec2) => Transform
marchingSquaresCases: (grid: BoolGrid) => number[][]
marchingSquaresContours: (grid: BoolGrid, options?: ContourOptions) => ContourSegment[]
mask4: (grid: BoolGrid, x: number, y: number) => number
mask8: (grid: BoolGrid, x: number, y: number) => number
matchReport: (reference: AudioFeatures, candidate: AudioFeatures) => string
measureLine: (font: BitmapFont, chars: readonly RichChar[]) => number
measureText: (font: BitmapFont, text: string) => number
measureVectorText: (m: FontMetric, text: string, size: number) => number
mergePlayerFrames: (players: readonly string[], inputs: ReadonlyMap<string, readonly string[]>) => string[]
midiToFreq: (midi: number, a4?: number) => number
midiToName: (midi: number) => string
missingControlHints: (world: World<Record<string, unknown>>, inputMap: Readonly<Record<string, readonly string[]>>) => string[]
mix: (a: string, b: string, t: number) => string
mixLinear: (a: string, b: string, t: number) => string
mixMono: (bus: StereoBuffer, sig: Samples, startSample: number, gain?: number, pan?: number) => void
mixPose: (a: Pose, b: Pose, t: number, out?: Pose) => Pose
moveRect: (map: TilemapData, rect: Rect, dx: number, dy: number, opts?: MoveOpts) => MoveResult
mutateColor: (rng: Rng, hex: string, amounts?: DriftAmounts) => string
netMessage: <T extends Omit<NetMessage, “v”>>(msg: T) => T & { v: number; }
nextBarBoundary: (elapsedSec: number, secPerBar: number, epsilon?: number) => number
nextStep: () => Wait
nineSlice: (rect: Rect, style: NineSliceStyle, z?: number, transform?: Transform) => DrawCommand[]
normalize: (buf: StereoBuffer, target?: number) => void
noteToMidi: (name: string) => number
occludersFromTilemap: (map: TilemapData) => ContourSegment[]
onsetDensity: (sig: Samples, sampleRate?: number) => number
openVoicing: (chord: number[]) => number[]
optimalPolicy: <S, M>(opts?: SolveOptions) => Policy<S, M>
oscillate: (time: number, frequency?: number, wave?: WaveKind) => number
packVarints: (nums: readonly number[]) => string
panFromOffset: (dx: number, spread?: number) => number
panGains: (pan: number) => { l: number; r: number; }
parseLightRun: (run: DrawCommand[]) => ParsedLightRun | null
parseRich: (markup: string, colorMap?: Record<string, string>) => RichChar[]
parseSnapshot: (text: string | null) => WorldSnapshot | null
passableFromTilemap: (map: TilemapData) => Passable
peak: (buf: StereoBuffer) => number
peakAmp: (sig: Samples) => number
pickEntry: (rng: Rng, entries: readonly WeightedEntry[]) => T
pickForm: <TState extends Record<string, unknown> = Record<string, unknown>>(def: GameDefinition, containerAspect: number) => ResolvedForm
pitchToFreq: (pitch: string | number, a4?: number) => number
pixelsToCommands: (buf: PixelBuffer, palette: readonly Swatch[], options?: PixelDrawOptions) => RectCommand[]
platformerReachable: (data: LevelData, opts: PlatformerReachOptions) => ReachReport
playerIds: (count: number) => string[]
pointQuery: (rw: RigidWorld, x: number, y: number, mask?: number) => RigidBody | undefined
pollDirector: (waves: readonly WaveDef[], state: DirectorState, time: number, rng?: Rng | undefined) => SpawnEvent[]
polygonBox: (w: number, h: number) => RigidShape
progression: (tonic: number, mode: “major” | “minor” | “harmonicMinor” | “melodicMinor” | “dorian” | “phrygian” | “lydian” | “mixolydian” | “locrian” | “majorPentatonic” …
progressionPuzzle: (world: WorldGraphDef, mode?: CompletionMode) => Puzzle<ProgressState, ProgressMove>
proveCompletable: (world: WorldGraphDef) => SolveResult
proveFullCompletion: (world: WorldGraphDef) => SolveResult
pump: (world: World<Record<string, unknown>>, frames: number, actions?: string[]) => void
quantizeAngle: (radians: number, buckets: number) => number
race: (…waits: Wait[]) => Wait
radialGradient: (stops: readonly StopInput[], opts?: { cx?: number | undefined; cy?: number | undefined; r?: number | undefined; }) => RadialGradient
rampIssues: (difficulty: readonly number[], opts?: RampOptions) => string[]
rampStats: (difficulty: readonly number[]) => RampStats
randomPolicy: <S, M>(seed: number, opts?: RandomPolicyOptions) => Policy<S, M>
rayCastRigid: (rw: RigidWorld, x0: number, y0: number, x1: number, y1: number, mask?: number) => RigidRayHit | null
raycastTiles: (map: TilemapData, x0: number, y0: number, x1: number, y1: number) => RayHit
reachableRegions: (world: WorldGraphDef, abilities: Iterable) => string[]
readCrest: (handle: string) => Crest
reconstructPath: (cameFrom: Map<string, N>, key: NodeKey, start: N, goal: N) => N[]
recordTimeline: (world: World<Record<string, unknown>>, frames: string[][]) => ProbeFrame[]
rectBlocked: (map: TilemapData, x: number, y: number, w: number, h: number, solids?: SolidRect[]) => boolean
rectContains: (r: Rect, p: Vec2) => boolean
rectsOverlap: (a: Rect, b: Rect) => boolean
registerNode: (type: string, factory: NodeFactory) => void
regularPolygon: (sides: number, radius: number, rotation?: number) => number[]
regularPolyPoints: (sides: number, r: number, rotation?: number) => number[]
relLuminance: (hex: string) => number
removeBody: (rw: RigidWorld, id: number) => void
removeJoint: (rw: RigidWorld, id: number) => void
renderAudioCard: (buf: StereoBuffer, meta: AudioCardMeta) => string
renderAudioFilmstrip: (buf: StereoBuffer, opts?: AudioFilmstripOptions) => string
renderFilmstrip: (world: World<Record<string, unknown>>, frames: string[][], opts: FilmstripOptions) => string
renderSong: (song: Song, opts?: RenderSongOptions) => StereoBuffer
renderSongAsync: (song: Song, opts?: RenderSongAsyncOptions) => Promise
renderSound: (spec: SoundSpec, opts?: { rng?: Rng | undefined; sampleRate?: number | undefined; }) => Samples
renderToSVGString: (commands: DrawCommand[], width: number, height: number, background?: string) => string
replay: (makeWorld: WorldFactory, log: InputLog) => { finalHash: string; hashes: string[]; }
replaySession: (def: GameDefinition<Record<string, unknown>>, session: PlaytestSession, opts?: number | ReplayOptions | undefined) => World<…>
resetNodeIds: (start?: number) => void
resetZzfxWarnings: () => void
resolveTracks: (def: ClipDef, skeleton: Skeleton) => BoundTrack[]
resolveTuning: (spec: TuningSpec | undefined, overrides?: TuningValues | undefined) => TuningValues
resourceGlyph: (draw: string | GlyphDraw, hue: string, size?: number, set?: GlyphSet) => Node
reverbSendSteps: (dry: StereoBuffer, send: StereoBuffer, opts?: ReverbOptions, window?: number) => Generator<void, void, void>
reverbSteps: (buf: StereoBuffer, opts?: ReverbOptions, window?: number) => Generator<void, void, void>
rigidStep: (rw: RigidWorld, dt: number) => ContactEvent[]
rleDecode: (input: string) => string
rleEncode: (input: string) => string
rms: (sig: Samples) => number
roomCenter: (r: Room) => { x: number; y: number; }
rootless: (chord: number[], targetMidi?: number | undefined) => number[]
rumble: (opts?: RumbleOptions) => void
runAblation: <S, M>(exp: AblationExperiment<S, M>, opts?: AblationOptions) => AblationReport
runBrowser: (def: GameDefinition<Record<string, unknown>>, mount: HTMLElement, opts?: RunOptions) => GameHandle
runBrowserNet: (def: GameDefinition<Record<string, unknown>>, mount: HTMLElement, opts: NetRunOptions) => NetGameHandle
runFeelGates: (spec: FeelSpec, ctx?: FeelContext) => FeelReport
runHeadless: <TState extends Record<string, unknown> = Record<string, unknown>>(def: GameDefinition, inputLog?: InputLog | undefined) => HeadlessResult
runProject: (project: ProjectDefinition, mount: HTMLElement, opts?: WorkshopOptions) => WorkshopHandle
runWorkshop: (baseDef: GameDefinition<Record<string, unknown>>, mount: HTMLElement, opts?: WorkshopOptions) => WorkshopHandle
safeAreaIssues: (commands: DrawCommand[], opts: SafeAreaOptions) => string[]
safeViewport: (rect: { width: number; height: number; }, view: ViewBox, safeW: number, safeH: number) => Viewport
salienceIssues: (commands: DrawCommand[], avatarFill: string, background: string, opts?: SalienceOptions) => string[]
sampleClip: (def: ClipDef, elapsed: number) => SampledChannel[]
sampleGradient: (stops: readonly string[], t: number) => string
samplePose: (def: ClipDef, phase: number) => Pose
sampleTrack: (keys: Keyframe[], t: number) => number
saveCanvas: (el: HTMLElement | SVGElement | undefined, filename?: string) => boolean
scaleMidis: (tonic: number, mode?: “major” | “minor” | “harmonicMinor” | “melodicMinor” | “dorian” | “phrygian” | “lydian” | “mixolydian” | “locrian” | “majorPentatonic”…
scalePitchClasses: (tonic: number, mode?: “major” | “minor” | “harmonicMinor” | “melodicMinor” | “dorian” | “phrygian” | “lydian” | “mixolydian” | “locrian” | “majorPentatonic”…
scatter: (x: number, y: number, probability: number, seed?: number) => boolean
scatterCells: (x0: number, y0: number, cols: number, rows: number, probability: number, seed?: number) => { x: number; y: number; }[]
scoreTrack: (buf: StereoBuffer, profile: GenreProfile) => QualityScore
screenNav: () => ScreenNav | null
scriptedPlaythrough: (world: World<Record<string, unknown>>, script: Segment[]) => PlaythroughResult
scriptToFrames: (script: InputScript) => string[][]
scrubTo: (world: World<Record<string, unknown>>, def: GameDefinition<Record<string, unknown>>, ring: SnapshotRing, inputFrames: readonly string[][], axesLog: readonly…
secondsPerBar: (bpm: number, beatsPerBar?: number) => number
serializeSnapshot: (snap: WorldSnapshot) => string
series: (timeline: ProbeFrame[], key: string) => unknown[]
setDebugDraw: (on: boolean) => void
setHapticsEnabled: (on: boolean) => void
setOverlayHost: (el: HTMLElement) => void
setScreenObserver: (cb: ((kind: “show” | “hide”, title?: string | undefined) => void) | null) => void
setToastHost: (el: HTMLElement) => void
shadeHex: (hex: string, f: number) => string
shadowDef: (s: Shadow, id: string) => string
shadowQuads: (light: Vec2, radius: number, segs: readonly ContourSegment[]) => number[][]
shapeBBox: (c: DrawCommand) => BBox | null
shapeBox: (cmd: DrawCommand) => { x: number; y: number; w: number; h: number; } | null
shareURL: (opts?: ShareOptions) => Promise<“shared” | “copied” | “unavailable”>
showScreen: (spec: ScreenSpec) => ScreenHandle
signalHash: (sig: Samples) => number
sleep: (seconds: number) => Wait
smoothClosedPath: (points: Vec2[], tension?: number) => string
smoothOpenPath: (points: Vec2[], tension?: number) => string
snapAxis: (value: number, buckets: number, min?: number, max?: number) => number
softClip: (x: number) => number
softClipInPlace: (buf: StereoBuffer) => void
solidNeighbours: (g: Grid, x: number, y: number) => number
solve: <State, Move>(puzzle: Puzzle<State, Move>, options?: SolveOptions) => SolveResult
solveFabrik: (root: Vec2, lengths: number[], target: Vec2, opts?: { maxIter?: number | undefined; tolerance?: number | undefined; initial?: Vec2[] | undefined; }) => Fabr…
solveJoint: (j: Joint, A: RigidBody, B: RigidBody, dt: number, scratch: JointScratch) => void
solveTwoBoneIK: (root: Vec2, l0: number, l1: number, target: Vec2, bendDir?: 1 | -1) => TwoBoneResult
songBeats: (song: Song) => number
songDuration: (song: Song) => number
songRenderCost: (song: Song, opts?: { sampleRate?: number | undefined; }) => SongRenderCost
sortCommands: (cmds: DrawCommand[]) => DrawCommand[]
soundtrackCue: (id: string) => SoundtrackCue | undefined
spatialMix: (dx: number, dy: number, hearing?: number, rolloff?: number) => SpatialMix
specFromZzfx: (p: readonly (number | undefined)[]) => SoundSpec
spectralCentroid: (sig: Samples, sampleRate?: number) => number
splitByLightLayer: (sorted: DrawCommand[]) => LightRunSplit
springStep: (s: SpringState, target: number, omega: number, dt: number) => SpringState
star: (points: number, outer: number, inner: number, rotation?: number) => number[]
steer2D: (px: number, py: number, tx: number, ty: number, out: string[], dead?: number) => void
stepPattern: (grid: string, pitch: Pitch, opts?: StepGridOptions) => Note[]
stepPlatformer: (s: PlatformerState, input: PadInput, dt: number, map: TilemapData, cfg?: PlatformerConfig, platforms?: Platform[]) => PlatformerEvents
stereoDuration: (buf: StereoBuffer) => number
stereoFrames: (buf: StereoBuffer) => number
stereoWidth: (buf: StereoBuffer) => number
stopHaptics: () => void
subSeed: (seed: number, i: number) => number
telegraphIssues: (timeline: readonly TelegraphFrame[], minFrames: number, label?: string) => string[]
terrainHeight: (col: number, opts: TerrainOptions) => number
terrainSlice: (startCol: number, count: number, opts: TerrainOptions) => number[]
textBox: (cmd: TextCommand) => TextBox
textToCommands: (font: BitmapFont, layout: TextLayout, options?: TextDrawOptions) => RectCommand[]
tileAt: (map: TilemapData, tx: number, ty: number) => number
tileAtPoint: (map: TilemapData, x: number, y: number) => number
tilemapFromAscii: (rowsAscii: string[], tileSize?: number, chars?: Record<string, TileId>) => TilemapData
toast: (title: string, opts?: ToastOptions) => () => void
toggleFullscreen: () => void
transpose: (notes: number[], semitones: number) => number[]
typewriterCount: (total: number, elapsedSec: number, charsPerSec: number) => number
unpackVarints: (input: string) => number[]
validateWorld: (world: WorldGraphDef) => string[]
valueNoise: (x: number, y: number, seed?: number) => number
vibrate: (pattern: number | number[]) => void
viewBoxToDesign: (rect: { left: number; top: number; width: number; height: number; }, view: ViewBox, clientX: number, clientY: number) => Vec2
vnorm: (a: Vec2) => Vec2
voiceLead: (chords: number[][]) => number[][]
wait: (frames: number) => Segment
waitFor: (cond: () => boolean) => Wait
wakeBody: (b: RigidBody) => void
wangTile: (mask: number) => WangTile
warnCommandOnce: (kind: string, reason: string, detail?: unknown) => void
weatherEnvelope: (t: number, keys: readonly WeatherKey[]) => number
weightedIndex: (rng: Rng, weights: readonly number[]) => number
weightedPick: (rng: Rng, items: readonly T[], weights: readonly number[]) => T
wipeStep: (transition: ScreenTransition, opts?: WipeOptions & { name?: string | undefined; }) => CinematicStep
withAlpha: (hex: string, alpha: number) => string
worldPoints: (b: RigidBody) => number[]
wrap: (v: number, lo: number, hi: number) => number
wrapVectorText: (m: FontMetric, text: string, maxWidth: number, size: number) => string[]
zcr: (sig: Samples, sampleRate?: number) => number

interfaces (324)

AblationExperiment
AblationOptions
AblationReport
AcceptedProof
AchievementDef
AchievementEntry
ActBounds
ActSpec
AgencyOptions
AgencyStats
AlbumTrack
AmbientStyle
AnalyzeOptions
Annotation
AnnotationContext
ArcCommand
AtomCue
AtomDefinition
AtomManifestEntry
AudioAssertion
AudioCardMeta
AudioExpectation
AudioFeatures
AudioFilmstripOptions
AutotileDrawOptions
BandBalance
BBox
Behavior
BfsResult
BitmapFont
BitmapTextConfig
BlendSample
Bone2DConfig
BotCtx
BoundTrack
Breakpoint
CameraBounds
CameraConfig
CameraControllerConfig
CameraOptions
Campaign
CampaignLevel
CampaignSpec
CaptureTarget
CardLayout
CardSpec
CardTemplate
CardTheme
CaveOptions
Cell
Chip
CinematicStep
CircleCommand
ClipDef
ClipEvent
ClipPlayerConfig
ClockConfig
Components
ContactEvent
ContactPoint
ContourOptions
ContourSegment
CoreEvents
CoroutineHandle
CreateWorldOptions
Crest
CrestSvgOptions
DeathCluster
DebugDrawOptions
DebugHost
DebugPaneOptions
DeckSpec
DepthSortConfig
DesyncInfo
DeterminismReport
DeviceTrackerOptions
DifficultyBand
DirectorState
DistanceJoint
DistanceJointDef
DomHarness
DriftAmounts
DriveResult
DrumLoop
Dungeon
DungeonOptions
DuotoneOptions
DuotoneScheme
EffectRow
EllipseCommand
FabrikResult
FeatureDelta
FeedbackOptions
FeedbackResponse
FeelContext
FeelReport
FeelSpec
FilmstripOptions
FloatStyle
FontMetric
ForgivenessOptions
ForgivenessSpec
FormFactor
FractalOptions
FutileVerb
GameDefinition
GameHandle
GamepadSourceOptions
GeneratedLevel
GenerateOptions
GenerateReport
GenreProfile
GenreTrack
GradientStop
GreedyPolicyOptions
Grid
HayaboxCourtier
HayaboxMood
HayaoCapture
HeadlessResult
HeroConfig
HeroMotion
HesitationSpan
HotContext
HSL
IkTargetConfig
ImageCommand
InputLog
InputSource
IsoConfig
IsoPrismConfig
IsoProjection
JointScratch
Keyframe
KnobEvent
LayoutOptions
LevelChange
LevelData
LevelEntity
LevelSpec
LightingOptions
LightLayerConfig
LightRunSplit
LinearGradient
LintOptions
LockstepOptions
LoopbackOptions
LoopDeckHandle
LoopStem
Manifold
MatchResult
MenuAction
MenuGamepadOptions
MoveOpts
MoveResult
MusicLayer
MusicLintResult
NetGame
NetGameHandle
NetRunOptions
NetSessionConfig
NineSliceStyle
NodeConfig
Note
PadInput
Paint
Palette
ParallaxLayerConfig
ParsedLight
ParsedLightRun
ParticleStyle
PathCommand
PhaseDef
PixelDrawOptions
PlacedGlyph
PlanBot
Platform
PlatformerConfig
PlatformerEvents
PlatformerReachOptions
PlatformerState
PlaytestReport
PlaytestSession
PlaythroughResult
PointerReadout
PointerSourceOptions
PointerTarget
PointLightConfig
PolyCommand
PostProcessPass
PreparedSong
PreparedStem
PrismaticJoint
PrismaticJointDef
ProgressState
ProjectDefinition
ProjectManifest
Puzzle
QualityScore
QuitContext
RadialGradient
RampOptions
RampStats
RandomPolicyOptions
RayHit
ReachReport
RecorderInit
Rect
RectCommand
Renderer
RendererConfig
RenderSongAsyncOptions
RenderSongOptions
ReplayOptions
ResolvedForm
ReverbOptions
RevoluteJoint
RevoluteJointDef
RichChar
RigidBody
RigidBodyDef
RigidRayHit
RigidWorld
RigidWorldOpts
RngState
RollbackOptions
Room
RoomCallbacks
RoomClientOptions
RoomHostOptions
RumbleOptions
RunOptions
SafeAreaOptions
SalienceOptions
SampledChannel
SampleHandle
ScreenEvent
ScreenHandle
ScreenNav
ScreenSpec
ScriptSegment
Segment
SerializedNode
Settings
Shadow
ShareOptions
ShellOptions
SkeletonDebugConfig
SliderSpec
SlotBox
SoftlockReport
SolidRect
SolveOptions
SolveResult
Song
SongHandle
SongRenderCost
SoundSpec
SoundtrackCue
SpatialMix
SpawnEvent
SplashConfig
SpringState
SpriteConfig
StateHandlers
StepGridOptions
StereoBuffer
StorageAdapter
TelegraphFrame
TerrainOptions
TextBox
TextCommand
TextConfig
TextDrawOptions
TextLayout
TextLayoutOptions
TextureSpriteConfig
TileCell
TileLayerConfig
TilemapData
TimelineEntry
TimerConfig
ToastOptions
ToggleSpec
Tone
TouchButton
TouchControlsLayout
TouchStick
Track
TrackDef
Transform
Transition
TransitionConfig
Transport
TuningKnob
TuningSpec
TwoBoneResult
UpgradeDef
Variant
VariantRef
Vec2
VerletChainConfig
ViewBox
Viewport
Volumes
WallClockMark
WangTile
WaveDef
WeatherKey
WebGLRendererConfig
WeightedEdge
WeightedEntry
WeldJoint
WeldJointDef
WipeOptions
WorkshopHandle
WorkshopOptions
WorldConfig
WorldContext
WorldEdge
WorldGraphDef
WorldPickup
WorldRegion
WorldSnapshot

types (70)

AtomKind
AxisFrame
BodyKind
BoolGrid
ClipChannel
ClipLoop
CompletionMode
CrestArrangement
CrestBordure
CrestCharge
CrestDivision
CrestHue
CrestOrdinary
CrestShape
CrestTreatment
DistanceModel
DrawCommand
Ease
Easing
Edge
EndReason
FeedbackChannel
FeedbackContract
GamepadMap
GlyphDraw
GlyphSet
Gradient
HeroState
InputDeviceKind
InputMap
InputScript
Instrument
Joint
Listener
Neighbours
NetMessage
NodeFactory
NodeKey
Occluder
Passable
PauseMode
Pitch
PlayerId
Policy
Pose
ProbeFrame
ProgressMove
RegaliaSchemeName
RigidShape
Samples
ScaleName
Shape
Slot
SlotAnchor
StepExec
Swatch
TextAlign
TileId
TileProducer
Trigger
TuningValue
TuningValues
UniformValue
Wait
WangFrame
Wave
WaveKind
WeightedNeighbours
WipeKind
WorldFactory

consts (88)

ALBUM: { title: string; subtitle: string; concept: string; tracks: AlbumTrack[]; }
AMBIENT_PRESETS: { readonly snow: (colors?: string[]) => AmbientStyle; readonly rain: (colors?: string[]) => AmbientStyle; readonly ash: (colors?: string[]) => AmbientStyle; }
atomId: (title: string) => string
audio: AudioBus
BACKGROUND_PROFILE: GenreProfile
BLEED_MAX: 1.6
BLOOM_PIPELINE: PostProcessPass[]
CARD_DAY: CardTheme
CARD_NIGHT: CardTheme
CARD_TEMPLATE: CardTemplate
clamp: (v: number, lo: number, hi: number) => number
CLIP_CHANNELS: readonly ClipChannel[]
DEFAULT_GAMEPAD_MAP: GamepadMap
DEFAULT_GLYPHS: GlyphSet
DEFAULT_INPUT_MAP: Readonly<Record<string, readonly string[]>>
DEFAULT_PALETTE: Palette
DEFAULT_PLATFORMER: PlatformerConfig
DEFAULT_SESSION_CONFIG: NetSessionConfig
DEFAULT_TILE_CHARS: Record<string, TileId>
deg2rad: (d: number) => number
dlog10: (x: number) => number
dlog2: (x: number) => number
EASINGS: Record<string, Easing>
FLOAT_PRESETS: { readonly damage: (color?: string) => FloatStyle; readonly crit: (color?: string) => FloatStyle; readonly heal: (color?: string) => FloatStyle; readonly lab…
FONT_5: BitmapFont
GENRE_PROFILES: Record<string, GenreProfile>
GENRES: GenreTrack[]
GLYPH_NATIVE: 22
HAYABOX: { title: string; subtitle: string; concept: string; bpm: number; beatsPerBar: number; bars: number; courtiers: HayaboxCourtier[]; }
HAYABOX_BARS: 8
HAYABOX_BEATS_PER_BAR: 4
HAYABOX_BPM: 96
HAYABOX_SCALE: readonly string[]
HERO_CLIPS: { readonly idle: ClipDef; readonly run: ClipDef; readonly jump: ClipDef; readonly fall: ClipDef; readonly wallSlide: ClipDef; readonly death: ClipDef; readon…
HERO_FOOT_OFFSET: number
HERO_STATES: (“idle” | “run” | “jump” | “fall” | “wallSlide” | “death” | “spawn”)[]
IDENTITY: Transform
INSTRUMENTS: Record<string, Instrument>
invLerp: (a: number, b: number, v: number) => number
isLightCommand: (c: DrawCommand) => boolean
knob: { num(key: string, opts: { default: number; min?: number | undefined; max?: number | undefined; step?: number | undefined; label?: string | undefined; group?…
LAYER_DEBUG: 2
LAYER_HUD: 1
LAYER_LIGHT: 0.5
LAYER_WORLD: 0
lerp: (a: number, b: number, t: number) => number
lerpDamp: (current: number, target: number, lambda: number, dt: number) => number
LOOPS: DrumLoop[]
mapHeight: (map: TilemapData) => number
mapWidth: (map: TilemapData) => number
MOUSE_ACTIONS: readonly [“mouse.left”, “mouse.right”, “mouse.middle”]
NEIGHBORS_4: readonly Cell[]
NEIGHBORS_8: readonly Cell[]
NET_PROTOCOL_VERSION: 1
PAD_NEUTRAL: PadInput
PALETTES: Record<string, Palette>
PANEL_PRESETS: { readonly parchment: () => NineSliceStyle; readonly slate: () => NineSliceStyle; }
PARTICLE_PRESETS: { readonly dust: (colors?: string[]) => ParticleStyle; readonly burst: (colors?: string[]) => ParticleStyle; readonly hit: (colors?: string[]) => ParticleSty…
playerAction: (player: string, action: string) => string
playerInput: (world: World<Record<string, unknown>>, player: string) => PlayerInput
poseKey: (target: string, channel: string) => string
rad2deg: (r: number) => number
REGALIA: { readonly paper: “#ffffff”; readonly mist: “#f4f6fb”; readonly cloud: “#eef1f6”; readonly line: “#e7e8ee”; readonly muted: “#8b90a6”; readonly soft: “#5a607…
REGALIA_DAY: Palette
REGALIA_NIGHT: Palette
REGALIA_SCHEME_NAMES: (“gold” | “meadow” | “dusk” | “rose” | “bark”)[]
REGALIA_SCHEMES: { readonly gold: DuotoneScheme; readonly meadow: DuotoneScheme; readonly dusk: DuotoneScheme; readonly rose: DuotoneScheme; readonly bark: DuotoneScheme; }
remap: (v: number, a0: number, a1: number, b0: number, b1: number) => number
SAMPLE_RATE: 44100
SAVE_FORMAT_VERSION: 1
SCALES: { readonly major: readonly [0, 2, 4, 5, 7, 9, 11]; readonly minor: readonly [0, 2, 3, 5, 7, 8, 10]; readonly harmonicMinor: readonly [0, 2, 3, 5, 7, 8, 11]; …
screenRect: (w: number, h: number) => Rect
settings: SettingsStore
smoothstep: (edge0: number, edge1: number, v: number) => number
SOUNDTRACK: { title: string; subtitle: string; concept: string; designNote: string; cues: SoundtrackCue[]; }
spring: (value?: number) => SpringState
TAU: number
TILE: { readonly EMPTY: 0; readonly SOLID: 1; readonly ONEWAY: 2; readonly HAZARD: 3; }
tileCenter: (tx: number, ty: number, tileSize: number) => { x: number; y: number; }
vadd: (a: Vec2, b: Vec2) => Vec2
vdist: (a: Vec2, b: Vec2) => number
vdot: (a: Vec2, b: Vec2) => number
vec2: (x?: number, y?: number) => Vec2
VERSION: “0.5.3”
vlen: (a: Vec2) => number
vscale: (a: Vec2, s: number) => Vec2
vsub: (a: Vec2, b: Vec2) => Vec2
WEBGL_EFFECTS: { readonly passthrough: “#version 300 es\nprecision mediump float;\nin vec2 v_uv;\nuniform sampler2D u_scene;\nuniform sampler2D u_prev;\nout vec4 fragColor;…

exports (2)

Node2D
OVERPASS_600

This page rendersthe repo's markdowndirectly — edit it there, it changes here.