• App.default_test_size : { width : I32, height : I32 }
• App.default : Config
• App.init : Config, InitCallback(model, errors) -> Init(model, errors)
• App.init_for_args : ConfigForArgs, InitCallback(model, errors) -> Init(model, errors)
• App.Dropped : { path : Str, position : { x : F32, y : F32 } }
• App.Input := { devices : Snapshot, window : Snapshot, time : Cycle, messages : List(msg), capture : Status, dropped : List(Dropped), dropped_overflow : Bool }
• App.Input.fields : Input(msg) -> { devices : Snapshot, window : Snapshot, time : Cycle, messages : List(msg), capture : Status, dropped : List(Dropped), dropped_overflow : Bool }
• App.Input.from_fields : { devices : Snapshot, window : Snapshot, time : Cycle, messages : List(msg), capture : Status, dropped : List(Dropped), dropped_overflow : Bool } -> Input(msg)
• App.Input.for_tests : {} -> Input(msg)
• App.Input.with_devices : Input(msg), Snapshot -> Input(msg)
• App.Input.with_window : Input(msg), Snapshot -> Input(msg)
• App.Input.with_time : Input(msg), Cycle -> Input(msg)
• App.Input.with_messages : Input(msg), List(msg) -> Input(msg)
• App.Input.with_message : Input(msg), msg -> Input(msg)
• App.Input.with_capture : Input(msg), Status -> Input(msg)
• App.Input.with_dropped : Input(msg), List(Dropped) -> Input(msg)
• App.Input.with_dropped_overflow : Input(msg), Bool -> Input(msg)
• App.FramePacing : AppFramePacing
• App.ExitKey : ExitKey
• App.CloseRequest : [Exit, Deliver]
• App.Config
• App.Config.with_title : Config, Str -> Config
• App.Config.with_size : Config, { width : I32, height : I32 } -> Config
• App.Config.with_min_size : Config, { width : I32, height : I32 } -> Config
• App.Config.with_frame_pacing : Config, FramePacing -> Config
• App.Config.with_exit_key : Config, ExitKey -> Config
• App.Config.with_close_request : Config, CloseRequest -> Config
• App.Config.with_cursor_mode : Config, CursorMode -> Config
• App.Config.with_resizable : Config, Bool -> Config
• App.Config.with_fullscreen : Config, Bool -> Config
• App.Config.with_visible : Config, Bool -> Config
• App.Config.with_output_dir : Config, Str -> Config
• App.Config.with_recording : Config, Recording -> Config
• App.Config.without_recording : Config -> Config
• App.Config.with_default_font : Config, { path : Str, size : I32 } -> Config
• App.Config.with_app_id : Config, Str -> Config
• App.Config.with_permission : Config, Permission -> Config
• App.Config.with_permissions : Config, List(Permission) -> Config
• App.Config.title : Config -> Str
• App.Config.size : Config -> { width : I32, height : I32 }
• App.Config.min_size : Config -> { width : I32, height : I32 }
• App.Config.frame_pacing : Config -> FramePacing
• App.Config.cursor_mode : Config -> CursorMode
• App.Config.resizable : Config -> Bool
• App.Config.fullscreen : Config -> Bool
• App.Config.exit_key : Config -> ExitKey
• App.Config.close_request : Config -> CloseRequest
• App.Config.visible : Config -> Bool
• App.Config.output_dir : Config -> Str
• App.Config.recording : Config -> [NoRecording, Record(Recording)]
• App.Config.default_font : Config -> { path : Str, size : I32 }
• App.Config.app_id : Config -> Str
• App.Config.permissions : Config -> List(Permission)
• App.Io
• App.Io.for_host : Authority -> Io
• App.Io.stub : Io
• App.Io.files : Io -> Access
• App.Io.http : Io -> Client
• App.Io.commands : Io -> Runner
• App.Io.stdout : Io -> Writer
• App.Io.stderr : Io -> Writer
• App.Io.udp : Io -> Network
• App.Io.sqlite : Io -> Service
• App.Io.clipboard : Io -> Clipboard
• App.Io.capture : Io -> Writer
• App.Io.env : Io -> Environment
• App.Io.exit! : Io, I32 => {}
• App.Io.args! : Io => List(Str)
• App.Io.entropy! : Io => U64
• App.Io.random_i32! : Io, I32, I32 => I32
• App.Io.suggest_window_size! : Io, { width : I32, height : I32 } => Try({}, [InvalidSize, NotSupported])
• App.Io.suggest_window_min_size! : Io, { width : I32, height : I32 } => {}
• App.Io.set_target_fps! : Io, I32 => {}
• App.Io.set_exit_key! : Io, ExitKey => {}
• App.Io.set_cursor_mode! : Io, CursorMode => {}
• App.Io.set_cursor! : Io, Cursor => {}
• App.Io.default_font! : Io => Try(Font, [PermissionDenied, AssetPathInvalid, AssetNotFound, AssetReadFailed, FontLoadFailed, ResourceLimit])
• App.Environment
• App.Environment.read! : Environment, Str => Try(Str, [NotFound, PermissionDenied])
• App.InitCallback : Io => Try(model, [Exit(I64), ..errors])
• App.ConfigForArgs : List(Str) -> Config
• App.Init : { config : ConfigForArgs, run! : InitCallback(model, errors) }
• Assets.open! : ReadDir, ManifestPolicy => Try(Store, [PermissionDenied, PathInvalid, RootNotFound, RootNotDirectory, RootUnreadable, InvalidExpectedContentHash, ManifestMissing, ManifestUnreadable, ManifestMalformed, AssetSetMismatch, SchemaMismatch, ContentVersionMismatch, ContentHashMismatch, ResourceLimit])
• Assets.rgba_byte_size : List(Rgba) -> U64
• Assets.load_texture! : Store, Str => Try(Texture, [PathInvalid, NotFound, ReadFailed, TextureLoadFailed, ResourceLimit])
• Assets.texture_from_bytes! : TextureBytes => Try(Texture, [TextureLoadFailed, ResourceLimit])
• Assets.generate_color_texture! : GenerateColorTexture => Try(Texture, [TextureGenerationFailed, ResourceLimit])
• Assets.generate_checked_texture! : GenerateCheckedTexture => Try(Texture, [TextureGenerationFailed, ResourceLimit])
• Assets.update_texture! : Texture, List(Rgba) => Try({}, [PixelCountMismatch])
• Assets.update_texture_region! : Texture, Region => Try({}, [PixelCountMismatch, RegionOutOfBounds])
• Assets.set_texture_filter! : Texture, TextureFilter => {}
• Assets.set_texture_wrap! : Texture, TextureWrap => {}
• Assets.Texture : Texture
• Assets.Store
• Assets.Store.stub : Store
• Assets.ManifestPolicy := [IgnoreManifest, RequireManifest(ManifestExpectation)]
• Assets.ContentExpectation := [AnyContent, Sha256(Str)]
• Assets.ManifestExpectation : { asset_set : Str, schema : U32, content_version : U32, content : ContentExpectation }
• Assets.OpenError : [PermissionDenied, PathInvalid, RootNotFound, RootNotDirectory, RootUnreadable, InvalidExpectedContentHash, ManifestMissing, ManifestUnreadable, ManifestMalformed, AssetSetMismatch, SchemaMismatch, ContentVersionMismatch, ContentHashMismatch, ResourceLimit]
• Assets.ImageFormat := [Png, Jpeg, Bmp, Gif, Qoi]
• Assets.TextureBytes : { format : ImageFormat, bytes : List(U8) }
• Assets.Region : { x : I32, y : I32, width : I32, height : I32, pixels : List(Rgba) }
• Assets.TextureFilter := [Point, Bilinear, Trilinear, Anisotropic4x, Anisotropic8x, Anisotropic16x]
• Assets.TextureFilter.is_eq : _
• Assets.TextureWrap := [Repeat, Clamp, MirrorRepeat, MirrorClamp]
• Assets.TextureWrap.is_eq : _
• Assets.GenerateColorTexture : { width : I32, height : I32, color : Rgba }
• Assets.GenerateCheckedTexture : { width : I32, height : I32, checks_x : I32, checks_y : I32, color_a : Rgba, color_b : Rgba }
• Audio.max_generated_ms : I32
• Audio.gen_sound! : GenSound => Try(Sound, [SoundGenerationFailed, ResourceLimit])
• Audio.gen_tone! : { freq : F32, ms : I32 } => Try(Sound, [SoundGenerationFailed, ResourceLimit])
• Audio.set_master_volume! : F32 => {}
• Audio.load_sound! : Store, Str => Try(Sound, [PathInvalid, NotFound, ReadFailed, SoundLoadFailed, ResourceLimit])
• Audio.load_music! : Store, Str => Try(Music, [PathInvalid, NotFound, ReadFailed, MusicLoadFailed, ResourceLimit])
• Audio.Sound
• Audio.Sound.play! : Sound => {}
• Audio.Sound.stop! : Sound => {}
• Audio.Sound.pause! : Sound => {}
• Audio.Sound.resume! : Sound => {}
• Audio.Sound.is_playing! : Sound => Bool
• Audio.Sound.playback : Sound -> Playback
• Audio.Sound.stub : Sound
• Audio.Playback := { sound : Sound, volume : F32, pitch : F32, pan : F32 }
• Audio.Playback.with_volume : Playback, F32 -> Playback
• Audio.Playback.with_pitch : Playback, F32 -> Playback
• Audio.Playback.with_pan : Playback, F32 -> Playback
• Audio.Playback.play! : Playback => {}
• Audio.Music
• Audio.Music.play! : Music => {}
• Audio.Music.stop! : Music => {}
• Audio.Music.pause! : Music => {}
• Audio.Music.resume! : Music => {}
• Audio.Music.set_volume! : Music, F32 => {}
• Audio.Music.set_pitch! : Music, F32 => {}
• Audio.Music.set_pan! : Music, F32 => {}
• Audio.Music.set_looping! : Music, Bool => {}
• Audio.Music.is_playing! : Music => Bool
• Audio.Music.seek! : Music, F32 => {}
• Audio.Music.length! : Music => F32
• Audio.Music.time_played! : Music => F32
• Audio.Music.stub : Music
• Audio.Waveform := [Sine, Square, Triangle, Saw, Noise]
• Audio.GenSound : { waveform : Waveform, freq_start : F32, freq_end : F32, ms : I32, attack_ms : I32, decay_ms : I32, sustain : F32, release_ms : I32, volume : F32 }
• Camera.fallback_zoom : F32
• Camera.default : Camera2D
• Camera.new : Settings -> Camera2D
• Camera.centered : Vec2, Vec2 -> Camera2D
• Camera.follow : Vec2, { screen : Vec2, zoom : F32 } -> Camera2D
• Camera.Settings : { target : Vec2, offset : Vec2, rotation : F32, zoom : F32 }
• Camera.Camera2D
• Camera.Camera2D.target : Camera2D -> Vec2
• Camera.Camera2D.offset : Camera2D -> Vec2
• Camera.Camera2D.rotation : Camera2D -> F32
• Camera.Camera2D.zoom : Camera2D -> F32
• Camera.Camera2D.with_target : Camera2D, Vec2 -> Camera2D
• Camera.Camera2D.with_offset : Camera2D, Vec2 -> Camera2D
• Camera.Camera2D.with_rotation : Camera2D, F32 -> Camera2D
• Camera.Camera2D.with_zoom : Camera2D, F32 -> Camera2D
• Camera.Camera2D.clamp_zoom : Camera2D, { min : F32, max : F32 } -> Camera2D
• Camera.Camera2D.world_to_screen : Camera2D, Vec2 -> Vec2
• Camera.Camera2D.screen_to_world : Camera2D, Vec2 -> Vec2
• Camera.Camera2D.viewport : Camera2D, Vec2 -> Rect
• Capture.default : Recording
• Capture.pixel_at! : Source, { x : I32, y : I32 } => Try(Rgba, PixelReadError)
• Capture.read_region! : Source, Region => Try(List(U8), PixelReadError)
• Capture.max_readback_bytes : U64
• Capture.Format : CaptureFormat
• Capture.Scale : CaptureScale
• Capture.Timing : CaptureTiming
• Capture.Cursor : CaptureCursor
• Capture.Quality : CaptureQuality
• Capture.Recording
• Capture.Recording.is_eq : _
• Capture.Recording.with_path : Recording, Str -> Recording
• Capture.Recording.with_format : Recording, Format -> Recording
• Capture.Recording.with_fps : Recording, I32 -> Recording
• Capture.Recording.with_max_frames : Recording, U64 -> Recording
• Capture.Recording.with_scale : Recording, Scale -> Recording
• Capture.Recording.with_every_nth : Recording, U32 -> Recording
• Capture.Recording.with_timing : Recording, Timing -> Recording
• Capture.Recording.with_cursor : Recording, Cursor -> Recording
• Capture.Recording.with_quality : Recording, Quality -> Recording
• Capture.Recording.path : Recording -> Str
• Capture.Recording.format : Recording -> Format
• Capture.Recording.fps : Recording -> I32
• Capture.Recording.max_frames : Recording -> U64
• Capture.Recording.scale : Recording -> Scale
• Capture.Recording.every_nth : Recording -> U32
• Capture.Recording.timing : Recording -> Timing
• Capture.Recording.cursor : Recording -> Cursor
• Capture.Recording.quality : Recording -> Quality
• Capture.Status : [Idle, Active({ frames : U64, dropped : U64 }), Finished({ frames : U64, bytes : U64 }), Failed({ frames : U64, reason : FailureReason })]
• Capture.FailureReason : [PathInvalid, PathEscapesOutputDir, AlreadyRecording, BudgetExceeded, UnsupportedFormat, OutOfMemory, WriteFailed, EncodeFailed, Unknown]
• Capture.ScreenshotError : [PermissionDenied, PathInvalid, PathEscapesOutputDir, AlreadyPending, WriteFailed, Busy, Unavailable]
• Capture.TextureExportError : [PermissionDenied, PathInvalid, PathEscapesOutputDir, TargetUnavailable, BudgetExceeded, Busy, OutOfMemory, ReadbackFailed, WriteFailed, Unavailable]
• Capture.Source : [Screen, Target(RenderTexture)]
• Capture.Region : { x : I32, y : I32, width : I32, height : I32 }
• Capture.PixelReadError : [RegionOutOfBounds, TargetUnavailable, Busy, ReadbackFailed, Unavailable]
• Capture.Writer
• Capture.Writer.for_host : Authority -> Writer
• Capture.Writer.screenshot! : Writer, Str => Try({}, ScreenshotError)
• Capture.Writer.screenshot_texture! : Writer, RenderTexture, Str => Try({}, TextureExportError)
• Capture.Writer.start! : Writer, Recording => Try({}, [PermissionDenied])
• Capture.Writer.stop! : Writer => Try({}, [PermissionDenied])
• Cmd.default_timeout_ms : U64
• Cmd.default_output_limit_bytes : U64
• Cmd.new : Str -> Cmd
• Cmd.with_arg : Cmd, Str -> Cmd
• Cmd.with_args : Cmd, List(Str) -> Cmd
• Cmd.with_env : Cmd, Str, Str -> Cmd
• Cmd.with_envs : Cmd, List({ name : Str, value : Str }) -> Cmd
• Cmd.with_clear_envs : Cmd, Bool -> Cmd
• Cmd.with_working_dir : Cmd, Str -> Cmd
• Cmd.with_timeout_ms : Cmd, U64 -> Cmd
• Cmd.with_stdout_limit : Cmd, U64 -> Cmd
• Cmd.with_stderr_limit : Cmd, U64 -> Cmd
• Cmd.Output : { exit_code : I64, stdout : List(U8), stderr : List(U8) }
• Cmd.Utf8Output : { exit_code : I64, stdout : Str, stderr : Str }
• Cmd.CmdErr : [CommandNotFound, AccessRefused, PermissionDenied, SpawnFailed, Busy, Unavailable, Timeout(Output), StdoutLimitExceeded, StderrLimitExceeded]
• Cmd.Runner
• Cmd.Runner.for_host : Authority -> Runner
• Cmd.Runner.run! : Runner, Cmd => Try(Output, CmdErr)
• Cmd.Runner.run_utf8! : Runner, Cmd => Try(Utf8Output, CmdErr)
• Color.rgba : U8, U8, U8, U8 -> Rgba
• Color.rgb : U8, U8, U8 -> Rgba
• Color.with_alpha : Rgba, U8 -> Rgba
• Color.from_hex_rgb : U32 -> Rgba
• Color.from_hex_rgba : U32 -> Rgba
• Color.transparent : Rgba
• Color.black : Rgba
• Color.blue : Rgba
• Color.dark_gray : Rgba
• Color.gray : Rgba
• Color.green : Rgba
• Color.light_gray : Rgba
• Color.orange : Rgba
• Color.pink : Rgba
• Color.purple : Rgba
• Color.ray_white : Rgba
• Color.red : Rgba
• Color.white : Rgba
• Color.yellow : Rgba
• Color.Rgba := { r : U8, g : U8, b : U8, a : U8 }
• Color.Rgba.is_eq : _
• Devices.none : Snapshot
• Devices.empty : Snapshot
• Devices.Snapshot := { keys : List(U8), text_input : List(U32), text_input_overflow : Bool, events : List(Event), events_overflow : Bool, gamepads : Snapshot, mouse : Snapshot }
• Devices.Snapshot.key_down : Snapshot, Key -> Bool
• Devices.Snapshot.key_up : Snapshot, Key -> Bool
• Devices.Snapshot.key_pressed : Snapshot, Key -> Bool
• Devices.Snapshot.key_released : Snapshot, Key -> Bool
• Devices.Snapshot.gamepad : Snapshot, Id -> [Connected(View), Disconnected]
• Devices.Snapshot.with_key_down : Snapshot, Key -> Snapshot
• Devices.Snapshot.with_key_pressed : Snapshot, Key -> Snapshot
• Devices.Snapshot.with_key_released : Snapshot, Key -> Snapshot
• Devices.Snapshot.with_mouse_position : Snapshot, { x : F32, y : F32 } -> Snapshot
• Devices.Snapshot.with_mouse_delta : Snapshot, { x : F32, y : F32 } -> Snapshot
• Devices.Snapshot.with_mouse_wheel : Snapshot, { x : F32, y : F32 } -> Snapshot
• Devices.Snapshot.with_mouse_button_down : Snapshot, Button -> Snapshot
• Devices.Snapshot.with_mouse_button_pressed : Snapshot, Button -> Snapshot
• Devices.Snapshot.with_mouse_button_released : Snapshot, Button -> Snapshot
• Devices.Snapshot.with_text_input : Snapshot, List(U32) -> Snapshot
• Devices.Snapshot.with_text_input_overflow : Snapshot, Bool -> Snapshot
• Devices.Snapshot.with_events : Snapshot, List(Event) -> Snapshot
• Devices.Snapshot.with_events_overflow : Snapshot, Bool -> Snapshot
• Devices.Event : [KeyPressed(Key), KeyReleased(Key), ButtonPressed(Button, { x : F32, y : F32 }), ButtonReleased(Button, { x : F32, y : F32 }), Wheel({ x : F32, y : F32 }), Text(U32)]
• Draw.from_rgba : { r : U8, g : U8, b : U8, a : U8 } -> Rgba
• Draw.alpha_blend : BlendMode
• Draw.additive_blend : BlendMode
• Draw.multiplied_blend : BlendMode
• Draw.add_colors_blend : BlendMode
• Draw.subtract_colors_blend : BlendMode
• Draw.premultiplied_alpha_blend : BlendMode
• Draw.filled : Rgba -> ShapeStyle
• Draw.stroke : Rgba, F32 -> Stroke
• Draw.outlined : Rgba, F32 -> ShapeStyle
• Draw.filled_and_outlined : Rgba, Rgba, F32 -> ShapeStyle
• Draw.default_font! : () => Font
• Draw.default_spacing : F32
• Draw.center_in_rect : Rectangle, TextSize -> Vector2
• Draw.clear! : Frame, Rgba => {}
• Draw.rectangle_gradient_v! : Frame, RectangleGradientV => {}
• Draw.rectangle_gradient_h! : Frame, RectangleGradientH => {}
• Draw.circle_gradient! : Frame, CircleGradient => {}
• Draw.fps! : Frame, Fps => {}
• Draw.rectangle! : Frame, Rectangle => {}
• Draw.rounded_rectangle! : Frame, RoundedRectangle => {}
• Draw.circle! : Frame, Circle => {}
• Draw.line! : Frame, Line => {}
• Draw.triangle! : Frame, Triangle => {}
• Draw.convex_polygon! : Frame, ConvexPolygon => {}
• Draw.load_store_font! : Store, LoadFont => Try(Font, [PathInvalid, NotFound, ReadFailed, FontLoadFailed, ResourceLimit])
• Draw.font_from_bytes! : FontBytes => Try(Font, [FontLoadFailed, ResourceLimit])
• Draw.texture_draw : Texture -> TextureDraw
• Draw.texture_at : Texture, Vec2 -> TextureDraw
• Draw.texture! : Frame, TextureDraw => {}
• Draw.texture_instances! : Frame, Texture, List(TextureInstance) => {}
• Draw.projective_texture! : Frame, ProjectiveTexture => {}
• Draw.with_render_texture! : Frame, RenderTexture, (Frame => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])) => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])
• Draw.with_shader! : Frame, Shader, (Frame => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])) => Try(result, [ScopeLimit, ScopeUnavailable, ..errors])
• Draw.with_blend_mode! : Frame, BlendMode, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])
• Draw.with_camera! : Frame, Camera2D, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])
• Draw.with_scissor! : Frame, Rect, (Frame => Try(result, [ScopeLimit, ..errors])) => Try(result, [ScopeLimit, ..errors])
• Draw.text! : Frame, Text => {}
• Draw.debug_text! : Frame, DebugText => {}
• Draw.text_at! : Frame, SimpleText => {}
• Draw.Frame
• Draw.Frame.size! : Frame => FrameSize
• Draw.FrameSize : { width : F32, height : F32 }
• Draw.Texture : Texture
• Draw.Vector2 : Vec2
• Draw.Rect : Rect
• Draw.Camera2D : Camera2D
• Draw.Fill : [NoFill, Fill(Rgba)]
• Draw.Stroke : [NoStroke, Stroke({ color : Rgba, thickness : F32 })]
• Draw.ShapeStyle : { fill : Fill, stroke : Stroke }
• Draw.Rectangle : { x : F32, y : F32, width : F32, height : F32, style : ShapeStyle }
• Draw.RoundedRectangle : { x : F32, y : F32, width : F32, height : F32, radius : F32, segments : I32, style : ShapeStyle }
• Draw.RectangleGradientV : { x : F32, y : F32, width : F32, height : F32, color_top : Rgba, color_bottom : Rgba }
• Draw.RectangleGradientH : { x : F32, y : F32, width : F32, height : F32, color_left : Rgba, color_right : Rgba }
• Draw.Circle : { center : Vector2, radius : F32, style : ShapeStyle }
• Draw.CircleGradient : { center : Vector2, radius : F32, color_inner : Rgba, color_outer : Rgba }
• Draw.Line : { start : Vector2, end : Vector2, stroke : Stroke }
• Draw.Triangle : { a : Vector2, b : Vector2, c : Vector2, style : ShapeStyle }
• Draw.ConvexPolygon : { points : List(Vector2), style : ShapeStyle }
• Draw.Fps : { pos : Vector2, size : F32, color : Rgba }
• Draw.GlyphMetrics : { codepoint : U32, advance_x : F32, offset_x : F32, offset_y : F32, width : F32, height : F32 }
• Draw.TextSize : { width : F32, height : F32 }
• Draw.Text : { pos : Vector2, text : Str, size : F32, spacing : F32, color : Rgba, font : Font }
• Draw.DebugText : { pos : Vector2, text : Str, size : F32, color : Rgba }
• Draw.SimpleText : { pos : Vector2, text : Str, size : F32, color : Rgba }
• Draw.LoadFont : { path : Str, size : I32 }
• Draw.TextureDraw : TextureDrawConfig
• Draw.TextureInstance : TextureInstanceConfig
• Draw.ProjectiveQuadCorners : { top_left : Vec2, bottom_left : Vec2, bottom_right : Vec2, top_right : Vec2 }
• Draw.ProjectiveQuad
• Draw.ProjectiveQuad.from_corners : ProjectiveQuadCorners -> Try(ProjectiveQuad, [NonFiniteQuad, DegenerateQuad, NonConvexQuad, ProjectiveHorizon])
• Draw.ProjectiveQuad.project : ProjectiveQuad, Vec2 -> Vec2
• Draw.ProjectiveTexture : { texture : Texture, source : Rect, quad : ProjectiveQuad, tint : Rgba }
• Draw.RenderTexture
• Draw.RenderTexture.load! : RenderTextureSize => Try(RenderTexture, [RenderTextureLoadFailed, ResourceLimit])
• Draw.RenderTexture.texture : RenderTexture -> Texture
• Draw.RenderTexture.source : RenderTexture -> Rect
• Draw.RenderTexture.stub : RenderTexture
• Draw.RenderTextureSize : { width : I32, height : I32 }
• Draw.Shader
• Draw.Shader.from_source! : LoadShaderSource => Try(Shader, [ShaderLoadFailed, ResourceLimit])
• Draw.Shader.from_store! : Store, LoadShader => Try(Shader, [PathInvalid, NotFound, ReadFailed, ShaderLoadFailed, ResourceLimit])
• Draw.Shader.uniform_f32! : Shader, Str => Try(F32Uniform, [UniformNotFound])
• Draw.Shader.uniform_i32! : Shader, Str => Try(I32Uniform, [UniformNotFound])
• Draw.Shader.uniform_vec2! : Shader, Str => Try(Vec2Uniform, [UniformNotFound])
• Draw.Shader.uniform_vec3! : Shader, Str => Try(Vec3Uniform, [UniformNotFound])
• Draw.Shader.uniform_vec4! : Shader, Str => Try(Vec4Uniform, [UniformNotFound])
• Draw.Shader.uniform_color! : Shader, Str => Try(ColorUniform, [UniformNotFound])
• Draw.Shader.uniform_texture! : Shader, Str => Try(TextureUniform, [UniformNotFound])
• Draw.Shader.stub : Shader
• Draw.LoadShader : { vertex_path : Str, fragment_path : Str }
• Draw.LoadShaderSource : { vertex_source : Str, fragment_source : Str }
• Draw.FontFormat := [Ttf, Otf]
• Draw.FontBytes : { format : FontFormat, bytes : List(U8), size : I32 }
• Draw.F32Uniform
• Draw.F32Uniform.set! : F32Uniform, F32 => {}
• Draw.I32Uniform
• Draw.I32Uniform.set! : I32Uniform, I32 => {}
• Draw.Vec2Uniform
• Draw.Vec2Uniform.set! : Vec2Uniform, Vector2 => {}
• Draw.Vec3Uniform
• Draw.Vec3Uniform.set! : Vec3Uniform, Vec3 => {}
• Draw.Vec4Uniform
• Draw.Vec4Uniform.set! : Vec4Uniform, Vec4 => {}
• Draw.ColorUniform
• Draw.ColorUniform.set! : ColorUniform, Rgba => {}
• Draw.TextureUniform
• Draw.TextureUniform.set! : TextureUniform, Texture => {}
• Draw.TextureUniform.set_texture! : TextureUniform, Texture => {}
• Draw.Vec3 : { x : F32, y : F32, z : F32 }
• Draw.Vec4 : { x : F32, y : F32, z : F32, w : F32 }
• Draw.BlendMode : [Alpha, Additive, Multiplied, AddColors, SubtractColors, AlphaPremultiply]
• Draw.ScopeError : [ScopeLimit, ScopeUnavailable]
• Files.Entry : { name : Str, kind : EntryKind }
• Files.EntryKind : [File, Dir, Other]
• Files.ReadTextError : [PermissionDenied, PathInvalid, NotFound, ReadFailed, Busy, Unavailable, TooLarge, NotUtf8]
• Files.ReadBytesError : [PermissionDenied, PathInvalid, NotFound, ReadFailed, Busy, Unavailable, TooLarge]
• Files.ListError : [PermissionDenied, PathInvalid, NotFound, NotADirectory, ReadFailed, Busy, Unavailable, TooLarge]
• Files.Metadata : { kind : EntryKind, size_bytes : U64, modified : Timestamp }
• Files.MetadataError : [NotFound, AccessRefused, PathInvalid, PermissionDenied, ReadFailed, Unavailable]
• Files.WriteError : [NotFound, AccessRefused, PathInvalid, PermissionDenied, NoSpace, WriteFailed, Unavailable]
• Files.OpenError : [PermissionDenied, PathInvalid, NotFound, NotADirectory, AccessRefused, OpenFailed, Unavailable]
• Files.PathInvalid : [PathInvalid]
• Files.ReadDir
• Files.ReadDir.stub : ReadDir
• Files.ReadDir.subdir : ReadDir, Str -> Try(ReadDir, [PathInvalid])
• Files.ReadDir.read_text! : ReadDir, Str => Try(Str, ReadTextError)
• Files.ReadDir.read_bytes! : ReadDir, Str => Try(List(U8), ReadBytesError)
• Files.ReadDir.list! : ReadDir, Str => Try(List(Entry), ListError)
• Files.ReadDir.metadata! : ReadDir, Str => Try(Metadata, MetadataError)
• Files.ReadDir.for_host : ReadDir -> { authority : Authority, root : Str, path : Str }
• Files.Dir
• Files.Dir.stub : Dir
• Files.Dir.read_only : Dir -> ReadDir
• Files.Dir.subdir : Dir, Str -> Try(Dir, [PathInvalid])
• Files.Dir.read_text! : Dir, Str => Try(Str, ReadTextError)
• Files.Dir.read_bytes! : Dir, Str => Try(List(U8), ReadBytesError)
• Files.Dir.list! : Dir, Str => Try(List(Entry), ListError)
• Files.Dir.metadata! : Dir, Str => Try(Metadata, MetadataError)
• Files.Dir.write_text! : Dir, Str, Str => Try({}, WriteError)
• Files.Dir.write_bytes! : Dir, Str, List(U8) => Try({}, WriteError)
• Files.Dir.for_host : Dir -> { authority : Authority, root : Str, path : Str }
• Files.Designated
• Files.Designated.stub : Designated
• Files.Designated.path : Designated -> Str
• Files.Designated.read_text! : Designated => Try(Str, ReadTextError)
• Files.Designated.read_bytes! : Designated => Try(List(U8), ReadBytesError)
• Files.Designated.metadata! : Designated => Try(Metadata, MetadataError)
• Files.Designated.dir : Designated -> ReadDir
• Files.Access
• Files.Access.for_host : Authority -> Access
• Files.Access.app_data! : Access => Try(Dir, [PermissionDenied, PathInvalid, NotFound, NotADirectory, AccessRefused, OpenFailed, Unavailable])
• Files.Access.app_config! : Access => Try(Dir, [PermissionDenied, PathInvalid, NotFound, NotADirectory, AccessRefused, OpenFailed, Unavailable])
• Files.Access.app_cache! : Access => Try(Dir, [PermissionDenied, PathInvalid, NotFound, NotADirectory, AccessRefused, OpenFailed, Unavailable])
• Files.Access.beside_executable! : Access => Try(ReadDir, [PermissionDenied, PathInvalid, NotFound, NotADirectory, AccessRefused, OpenFailed, Unavailable])
• Files.Access.working_directory! : Access => Try(Dir, [PermissionDenied, PathInvalid, NotFound, NotADirectory, AccessRefused, OpenFailed, Unavailable])
• Files.Access.working_directory_read! : Access => Try(ReadDir, [PermissionDenied, PathInvalid, NotFound, NotADirectory, AccessRefused, OpenFailed, Unavailable])
• Files.Access.open_dir! : Access, Str => Try(Dir, [PermissionDenied, PathInvalid, NotFound, NotADirectory, AccessRefused, OpenFailed, Unavailable])
• Files.Access.accept_drop! : Access, Str => Try(Designated, [PermissionDenied])
• Files.Access.from_arg! : Access, Str => Try(Designated, [PermissionDenied])
• Files.Access.open_dir_read! : Access, Str => Try(ReadDir, [PermissionDenied, PathInvalid, NotFound, NotADirectory, AccessRefused, OpenFailed, Unavailable])
• Font.stub : Font
• Font.measure : Font, Measure -> Size
• Font.FontHandle : Font
• Font.GlyphMetrics : { codepoint : U32, advance_x : F32, offset_x : F32, offset_y : F32, width : F32, height : F32 }
• Font.FontMetrics : { base_size : F32, line_spacing : F32, fallback_index : U64, glyphs : List(GlyphMetrics) }
• Font.Measure : { text : Str, size : F32, spacing : F32 }
• Font.Size : { width : F32, height : F32 }
• Gamepad.from_index : U64 -> Try(Id, [InvalidGamepadIndex])
• Gamepad.lookup : Snapshot, Id -> [Connected(View), Disconnected]
• Gamepad.button_down : { ..state, buttons : List(U8) }, Id, Button -> Bool
• Gamepad.button_up : { ..state, buttons : List(U8) }, Id, Button -> Bool
• Gamepad.button_pressed : { ..state, buttons : List(U8) }, Id, Button -> Bool
• Gamepad.button_released : { ..state, buttons : List(U8) }, Id, Button -> Bool
• Gamepad.axis : { ..state, axes : List(F32) }, Id, Axis -> F32
• Gamepad.left_stick : { ..state, axes : List(F32) }, Id -> { x : F32, y : F32 }
• Gamepad.right_stick : { ..state, axes : List(F32) }, Id -> { x : F32, y : F32 }
• Gamepad.Snapshot := { connected : List(U8), buttons : List(U8), axes : List(F32) }
• Gamepad.Id := [One, Two, Three, Four]
• Gamepad.Id.is_eq : _
• Gamepad.Button := [Unknown, DpadUp, DpadRight, DpadDown, DpadLeft, FaceUp, FaceRight, FaceDown, FaceLeft, LeftBumper, LeftTrigger, RightBumper, RightTrigger, Select, Guide, Start, LeftStick, RightStick]
• Gamepad.Axis := [LeftX, LeftY, RightX, RightY, LeftTriggerAxis, RightTriggerAxis]
• Gamepad.View
• Gamepad.View.id : View -> Id
• Gamepad.View.button_down : View, Button -> Bool
• Gamepad.View.button_up : View, Button -> Bool
• Gamepad.View.button_pressed : View, Button -> Bool
• Gamepad.View.button_released : View, Button -> Bool
• Gamepad.View.axis : View, Axis -> F32
• Gamepad.View.left_stick : View -> { x : F32, y : F32 }
• Gamepad.View.right_stick : View -> { x : F32, y : F32 }
• Http.default_config : Config
• Http.with_json_body : Request, _ -> Try(Request, [JsonErr(_)])
• Http.decode_json_response : Response -> Try(_, [BadBody(Str), JsonErr(_)])
• Http.TransportErr : [Timeout, NetworkError, MalformedResponse, Other(List(U8))]
• Http.Config : { timeout_ms : U64, max_response_bytes : U64 }
• Http.Client
• Http.Client.for_host : Authority -> Client
• Http.Client.send! : Client, Request => Try(Response, [PermissionDenied, InvalidUrl(ParseErr), HttpErr(TransportErr)])
• Http.Client.send_with! : Client, Config, Request => Try(Response, [PermissionDenied, InvalidUrl(ParseErr), HttpErr(TransportErr)])
• Http.Client.send_json! : Client, Request, _ => Try(Response, [PermissionDenied, JsonErr(_), InvalidUrl(ParseErr), HttpErr(TransportErr)])
• Http.Client.get_utf8! : Client, Url => Try(Str, [PermissionDenied, BadBody(Str), InvalidUrl(ParseErr), HttpErr(TransportErr)])
• Http.Client.get! : Client, Url => Try(_, [PermissionDenied, BadBody(Str), InvalidUrl(ParseErr), HttpErr(TransportErr), JsonErr(_)])
• Keys.from_code : U64 -> Try(Key, [InvalidKeyCode])
• Keys.key_code : Key -> U64
• Keys.key_down : { ..state, keys : List(U8) }, Key -> Bool
• Keys.key_up : { ..state, keys : List(U8) }, Key -> Bool
• Keys.key_pressed : { ..state, keys : List(U8) }, Key -> Bool
• Keys.key_released : { ..state, keys : List(U8) }, Key -> Bool
• Keys.set_exit_key! : ExitKey => {}
• Keys.holding : List(Key) -> Source
• Keys.set_source! : Source => {}
• Keys.typing : Str -> List(U32)
• Keys.set_text! : List(U32) => {}
• Keys.Key := [KeyAndroidBack, KeyAndroidMenu, KeyVolumeUp, KeyVolumeDown, KeyApostrophe, KeyComma, KeyMinus, KeyPeriod, KeySlash, Key0, Key1, Key2, Key3, Key4, Key5, Key6, Key7, Key8, Key9, KeySemicolon, KeyEqual, KeyA, KeyB, KeyC, KeyD, KeyE, KeyF, KeyG, KeyH, KeyI, KeyJ, KeyK, KeyL, KeyM, KeyN, KeyO, KeyP, KeyQ, KeyR, KeyS, KeyT, KeyU, KeyV, KeyW, KeyX, KeyY, KeyZ, KeyLeftBracket, KeyBackslash, KeyRightBracket, KeyGrave, KeySpace, KeyEscape, KeyEnter, KeyTab, KeyBackspace, KeyInsert, KeyDelete, KeyRight, KeyLeft, KeyDown, KeyUp, KeyPageUp, KeyPageDown, KeyHome, KeyEnd, KeyCapsLock, KeyScrollLock, KeyNumLock, KeyPrintScreen, KeyPause, KeyF1, KeyF2, KeyF3, KeyF4, KeyF5, KeyF6, KeyF7, KeyF8, KeyF9, KeyF10, KeyF11, KeyF12, KeyLeftShift, KeyLeftControl, KeyLeftAlt, KeyLeftSuper, KeyRightShift, KeyRightControl, KeyRightAlt, KeyRightSuper, KeyKbMenu, KeyKp0, KeyKp1, KeyKp2, KeyKp3, KeyKp4, KeyKp5, KeyKp6, KeyKp7, KeyKp8, KeyKp9, KeyKpDecimal, KeyKpDivide, KeyKpMultiply, KeyKpSubtract, KeyKpAdd, KeyKpEnter, KeyKpEqual, Raw(U64)]
• Keys.Key.is_eq : _
• Keys.ExitKey := [NoExitKey, ExitKey(Key)]
• Keys.ExitKey.is_eq : ExitKey, ExitKey -> Bool
• Keys.Source : [Hardware, Virtual(List(Key))]
• Math.vec2 : F32, F32 -> Vec2
• Math.zero : Vec2
• Math.rect : F32, F32, F32, F32 -> Rect
• Math.circle : Vec2, F32 -> Circle
• Math.clamp : F32, F32, F32 -> F32
• Math.clamp01 : F32 -> F32
• Math.lerp : F32, F32, F32 -> F32
• Math.sqrt : F32 -> F32
• Math.add : Vec2, Vec2 -> Vec2
• Math.sub : Vec2, Vec2 -> Vec2
• Math.scale : Vec2, F32 -> Vec2
• Math.dot : Vec2, Vec2 -> F32
• Math.length_squared : Vec2 -> F32
• Math.length : Vec2 -> F32
• Math.distance_squared : Vec2, Vec2 -> F32
• Math.distance : Vec2, Vec2 -> F32
• Math.normalize : Vec2 -> Vec2
• Math.lerp_vec2 : Vec2, Vec2, F32 -> Vec2
• Math.left : Rect -> F32
• Math.right : Rect -> F32
• Math.top : Rect -> F32
• Math.bottom : Rect -> F32
• Math.center : Rect -> Vec2
• Math.closest_point : Rect, Vec2 -> Vec2
• Math.contains : Rect, Vec2 -> Bool
• Math.circle_contains : Circle, Vec2 -> Bool
• Math.overlaps : Rect, Rect -> Bool
• Math.circle_overlaps : Circle, Circle -> Bool
• Math.circle_rect : Circle, Rect -> Bool
• Math.contains_point : Circle, Vec2 -> Bool
• Math.overlaps_circle : Circle, Circle -> Bool
• Math.overlaps_rect : Circle, Rect -> Bool
• Math.Vec2 := { x : F32, y : F32 }
• Math.Vec2.is_eq : Vec2, Vec2 -> Bool
• Math.Rect := { x : F32, y : F32, width : F32, height : F32 }
• Math.Rect.is_eq : Rect, Rect -> Bool
• Math.Circle := { center : Vec2, radius : F32 }
• Math.Circle.is_eq : Circle, Circle -> Bool
• Mouse.position : { ..state, x : F32, y : F32 } -> { x : F32, y : F32 }
• Mouse.delta : { ..state, delta_x : F32, delta_y : F32 } -> { x : F32, y : F32 }
• Mouse.wheel_delta : { ..state, wheel_x : F32, wheel_y : F32 } -> { x : F32, y : F32 }
• Mouse.virtual_at : { x : F32, y : F32 } -> Source
• Mouse.virtual_click_at : { x : F32, y : F32 } -> Source
• Mouse.button_down : { ..state, buttons : List(U8) }, Button -> Bool
• Mouse.button_up : { ..state, buttons : List(U8) }, Button -> Bool
• Mouse.button_pressed : { ..state, buttons : List(U8) }, Button -> Bool
• Mouse.button_released : { ..state, buttons : List(U8) }, Button -> Bool
• Mouse.set_source! : Source => {}
• Mouse.set_cursor! : Cursor => {}
• Mouse.set_cursor_mode! : CursorMode => {}
• Mouse.Snapshot := { buttons : List(U8), left : Bool, middle : Bool, right : Bool, wheel : F32, wheel_x : F32, wheel_y : F32, delta_x : F32, delta_y : F32, x : F32, y : F32 }
• Mouse.Snapshot.button_down : Snapshot, Button -> Bool
• Mouse.Snapshot.button_up : Snapshot, Button -> Bool
• Mouse.Snapshot.button_pressed : Snapshot, Button -> Bool
• Mouse.Snapshot.button_released : Snapshot, Button -> Bool
• Mouse.Snapshot.position : Snapshot -> { x : F32, y : F32 }
• Mouse.Snapshot.delta : Snapshot -> { x : F32, y : F32 }
• Mouse.Snapshot.wheel_delta : Snapshot -> { x : F32, y : F32 }
• Mouse.Cursor := [Default, Arrow, IBeam, Crosshair, PointingHand, ResizeEastWest, ResizeNorthSouth, ResizeNorthwestSoutheast, ResizeNortheastSouthwest, ResizeAll, NotAllowed]
• Mouse.Cursor.is_eq : _
• Mouse.Button := [Left, Right, Middle, Side, Extra, Forward, Back]
• Mouse.Button.is_eq : _
• Mouse.Source := [Hardware, Virtual({ x : F32, y : F32, left : Bool, middle : Bool, right : Bool, wheel : F32 })]
• Mouse.CursorMode : [Visible, Hidden, Locked]
• Permission.is_eq : _
• Physics.point : F32, F32, F32 -> Point
• Physics.point_xy : F32, F32 -> Point
• Physics.origin : Point
• Physics.vector : F32, F32, F32 -> Vector
• Physics.vector_xy : F32, F32 -> Vector
• Physics.zero : Vector
• Physics.coords : Point -> Coords
• Physics.components : Vector -> Coords
• Physics.xy : Point -> Vec2
• Physics.vector_xy_components : Vector -> Vec2
• Physics.point_coeffs : Point -> PointCoeffs
• Physics.vector_coeffs : Vector -> VectorCoeffs
• Physics.plane_coeffs : Plane -> PlaneCoeffs
• Physics.line_coeffs : Line -> LineCoeffs
• Physics.motor_coeffs : Motor -> MotorCoeffs
• Physics.add : Point, Vector -> Point
• Physics.sub : Point, Point -> Vector
• Physics.add_vec : Vector, Vector -> Vector
• Physics.sub_vec : Vector, Vector -> Vector
• Physics.scale : Vector, F32 -> Vector
• Physics.dot : Vector, Vector -> F32
• Physics.cross : Vector, Vector -> Vector
• Physics.length_squared : Vector -> F32
• Physics.length : Vector -> F32
• Physics.normalize : Vector -> Vector
• Physics.reflect : Vector, Vector -> Vector
• Physics.distance : Point, Point -> F32
• Physics.plane : Vector, F32 -> Plane
• Physics.plane_from_point_normal : Point, Vector -> Plane
• Physics.signed_distance : Plane, Point -> F32
• Physics.project_point_plane : Plane, Point -> Point
• Physics.line_from_points : Point, Point -> Line
• Physics.motor_identity : Motor
• Physics.translation : Vector -> Motor
• Physics.translation_vector : Motor -> Vector
• Physics.apply_motor_point : Motor, Point -> Point
• Physics.body : Point, Vector -> Body
• Physics.apply_acceleration : Body, Vector, F32 -> Body
• Physics.integrate_body : Body, F32 -> Body
• Physics.clamp_y : Vector, F32, F32 -> Vector
• Physics.Point := { e032 : F32, e013 : F32, e021 : F32, e123 : F32 }
• Physics.Vector := { e032 : F32, e013 : F32, e021 : F32 }
• Physics.Plane := { e0 : F32, e1 : F32, e2 : F32, e3 : F32 }
• Physics.Line := { e01 : F32, e02 : F32, e03 : F32, e23 : F32, e31 : F32, e12 : F32 }
• Physics.Motor := { s : F32, e23 : F32, e31 : F32, e12 : F32, e01 : F32, e02 : F32, e03 : F32, e0123 : F32 }
• Physics.Body := { position : Point, velocity : Vector }
• Physics.Coords : { x : F32, y : F32, z : F32 }
• Physics.PointCoeffs : { e032 : F32, e013 : F32, e021 : F32, e123 : F32 }
• Physics.VectorCoeffs : { e032 : F32, e013 : F32, e021 : F32 }
• Physics.PlaneCoeffs : { e0 : F32, e1 : F32, e2 : F32, e3 : F32 }
• Physics.LineCoeffs : { e01 : F32, e02 : F32, e03 : F32, e23 : F32, e31 : F32, e12 : F32 }
• Physics.MotorCoeffs : { s : F32, e23 : F32, e31 : F32, e12 : F32, e01 : F32, e02 : F32, e03 : F32, e0123 : F32 }
• Random.seed : U32 -> State
• Random.seed_variant : U32, U32 -> State
• Random.step : State, Generator(value) -> Generation(value)
• Random.next : Generation(_), Generator(value) -> Generation(value)
• Random.static : value -> Generator(value)
• Random.map : Generator(a), (a -> b) -> Generator(b)
• Random.map2 : Generator(a), Generator(b), (a, b -> c) -> Generator(c)
• Random.chain : Generator(a), (a -> Generator(b)) -> Generator(b)
• Random.list : Generator(a), U64 -> Generator(List(a))
• Random.shuffle : List(a) -> Generator(List(a))
• Random.bool : Generator(Bool)
• Random.u8 : Generator(U8)
• Random.i8 : Generator(I8)
• Random.u16 : Generator(U16)
• Random.i16 : Generator(I16)
• Random.u32 : Generator(U32)
• Random.i32 : Generator(I32)
• Random.u64 : Generator(U64)
• Random.i64 : Generator(I64)
• Random.bounded_u8 : U8, U8 -> Generator(U8)
• Random.bounded_i8 : I8, I8 -> Generator(I8)
• Random.bounded_u16 : U16, U16 -> Generator(U16)
• Random.bounded_i16 : I16, I16 -> Generator(I16)
• Random.bounded_u32 : U32, U32 -> Generator(U32)
• Random.bounded_i32 : I32, I32 -> Generator(I32)
• Random.bounded_u64 : U64, U64 -> Generator(U64)
• Random.bounded_i64 : I64, I64 -> Generator(I64)
• Random.f32 : F32, F32 -> Generator(F32)
• Random.f64 : F64, F64 -> Generator(F64)
• Random.choice : a, List(a) -> Generator(a)
• Random.choice_try : List(a) -> Try(Generator(a), [ListWasEmpty])
• Random.choice_weighted : (a, F64), List((a, F64)) -> Generator(a)
• Random.choice_weighted_try : List((a, F64)) -> Try(Generator(a), [ListWasEmpty])
• Random.State : State
• Random.Generator : Generator(value)
• Random.Generation : Generation(value)
• Sprite.source : Sprite, Rect -> Sprite
• Sprite.pos : Sprite, Vec2 -> Sprite
• Sprite.origin : Sprite, Vec2 -> Sprite
• Sprite.centered : Sprite -> Sprite
• Sprite.rotation : Sprite, F32 -> Sprite
• Sprite.scale_xy : Sprite, Vec2 -> Sprite
• Sprite.scale : Sprite, F32 -> Sprite
• Sprite.tint : Sprite, Rgba -> Sprite
• Sprite.to_texture_draw : Sprite -> TextureDraw
• Sprite.draw! : Sprite, Frame => {}
• Sprite.from_texture : Texture -> Sprite
• Sprite.sheet_frame : { frame_size : Vec2, row : U64, col : U64 } -> Rect
• Sprite.animation : { frame_count : U64, fps : F32 } -> Animation
• Sprite.step : Animation, F32 -> Animation
• Sprite.animation_source : Animation, { frame_size : Vec2, row : U64 } -> Rect
• Sprite.Animation : { frame : U64, frame_count : U64, fps : F32, elapsed : F32 }
• Sqlite.default_config : Config
• Sqlite.errcode_to_str : ErrCode -> Str
• Sqlite.Value : [Null, Integer(I64), Real(F64), String(Str), Bytes(List(U8))]
• Sqlite.ValueKind : [Null, Integer, Real, String, Bytes]
• Sqlite.Binding : { name : Str, value : Value }
• Sqlite.ErrCode : [Error, Internal, Perm, Abort, Busy, Locked, NoMem, ReadOnly, Interrupt, IOErr, Corrupt, NotFound, Full, CanNotOpen, Protocol, Empty, Schema, TooBig, Constraint, Mismatch, Misuse, NoLFS, AuthDenied, Format, OutOfRange, NotADatabase, Notice, Warning, Row, Done, Unknown(I64)]
• Sqlite.OpenErr : [PermissionDenied, PathInvalid, SqliteErr(ErrCode, Str), TooManyConnections]
• Sqlite.PrepareErr : [SqliteErr(ErrCode, Str), TooManyStatements, MultipleStatements]
• Sqlite.QueryErr : [SqliteErr(ErrCode, Str), ResultTooLarge, MultipleStatements]
• Sqlite.ExecuteErr : [SqliteErr(ErrCode, Str), ResultTooLarge, MultipleStatements, RowsReturnedUseQueryInstead]
• Sqlite.ExactlyOneErr : [SqliteErr(ErrCode, Str), ResultTooLarge, MultipleStatements, NoRowsReturned, TooManyRowsReturned]
• Sqlite.DecodeErr : [NoSuchField(Str), UnexpectedType(ValueKind), IntOutOfBounds]
• Sqlite.Mode : [ReadWriteCreate, ReadWrite, ReadOnly]
• Sqlite.Config : { mode : Mode, busy_timeout_ms : U64, max_result_bytes : U64 }
• Sqlite.Outcome : { changes : I64, last_insert_rowid : I64 }
• Sqlite.Db
• Sqlite.Db.close! : Db => Try({}, [SqliteErr(ErrCode, Str)])
• Sqlite.Db.prepare! : Db, Str => Try(Stmt, PrepareErr)
• Sqlite.Db.execute! : Db, Str, List(Binding) => Try(Outcome, ExecuteErr)
• Sqlite.Db.query! : Db, Str, List(Binding) => Try(List(Row), QueryErr)
• Sqlite.Db.query_exactly_one! : Db, Str, List(Binding) => Try(Row, ExactlyOneErr)
• Sqlite.Db.exec_script! : Db, Str => Try({}, [SqliteErr(ErrCode, Str)])
• Sqlite.Db.stub : Db
• Sqlite.Row := { names : List(Str), values : List(Value) }
• Sqlite.Row.is_eq : _
• Sqlite.Row.names : Row -> List(Str)
• Sqlite.Row.values : Row -> List(Value)
• Sqlite.Row.value : Row, Str -> Try(Value, [NoSuchField(Str)])
• Sqlite.Row.str : Row, Str -> Try(Str, DecodeErr)
• Sqlite.Row.bytes : Row, Str -> Try(List(U8), DecodeErr)
• Sqlite.Row.f64 : Row, Str -> Try(F64, DecodeErr)
• Sqlite.Row.i64 : Row, Str -> Try(I64, DecodeErr)
• Sqlite.Row.i32 : Row, Str -> Try(I32, DecodeErr)
• Sqlite.Row.i16 : Row, Str -> Try(I16, DecodeErr)
• Sqlite.Row.i8 : Row, Str -> Try(I8, DecodeErr)
• Sqlite.Row.u64 : Row, Str -> Try(U64, DecodeErr)
• Sqlite.Row.u32 : Row, Str -> Try(U32, DecodeErr)
• Sqlite.Row.u16 : Row, Str -> Try(U16, DecodeErr)
• Sqlite.Row.u8 : Row, Str -> Try(U8, DecodeErr)
• Sqlite.Row.nullable_str : Row, Str -> Try([NotNull(Str), Null], DecodeErr)
• Sqlite.Row.nullable_bytes : Row, Str -> Try([NotNull(List(U8)), Null], DecodeErr)
• Sqlite.Row.nullable_f64 : Row, Str -> Try([NotNull(F64), Null], DecodeErr)
• Sqlite.Row.nullable_i64 : Row, Str -> Try([NotNull(I64), Null], DecodeErr)
• Sqlite.Row.for_tests : List(Str), List(Value) -> Row
• Sqlite.Stmt
• Sqlite.Stmt.execute! : Stmt, List(Binding) => Try(Outcome, ExecuteErr)
• Sqlite.Stmt.query! : Stmt, List(Binding) => Try(List(Row), QueryErr)
• Sqlite.Stmt.query_exactly_one! : Stmt, List(Binding) => Try(Row, ExactlyOneErr)
• Sqlite.Stmt.stub : Stmt
• Sqlite.Service
• Sqlite.Service.for_host : Authority -> Service
• Sqlite.Service.open! : Service, Dir, Str => Try(Db, OpenErr)
• Sqlite.Service.open_with! : Service, Dir, Str, Config => Try(Db, OpenErr)
• Sqlite.Service.open_read! : Service, ReadDir, Str => Try(Db, OpenErr)
• Sqlite.Service.open_memory! : Service => Try(Db, OpenErr)
• Stderr.WriteError : [PermissionDenied, BufferFull, TooLarge, Unavailable]
• Stderr.Writer
• Stderr.Writer.for_host : Authority -> Writer
• Stderr.Writer.line! : Writer, Str => Try({}, WriteError)
• Stderr.Writer.write! : Writer, Str => Try({}, WriteError)
• Stderr.Writer.write_bytes! : Writer, List(U8) => Try({}, WriteError)
• Stdout.WriteError : [PermissionDenied, BufferFull, TooLarge, Unavailable]
• Stdout.Writer
• Stdout.Writer.for_host : Authority -> Writer
• Stdout.Writer.line! : Writer, Str => Try({}, WriteError)
• Stdout.Writer.write! : Writer, Str => Try({}, WriteError)
• Stdout.Writer.write_bytes! : Writer, List(U8) => Try({}, WriteError)
• Task.spawn! : Input(msg), (() => msg) => {}
• Task.spawn_with! : Input(msg), (() => a), (a -> msg) => {}
• Task.sleep! : U64 => {}
• Text.font_stub : Font
• Text.default_spacing : F32
• Text.from : Str, Font -> Builder
• Text.align_offset : Size, Align -> Vec2
• Text.origin_for : Vec2, Size, Align -> Vec2
• Text.draw_prepared! : Frame, PreparedPlacement => {}
• Text.Font : Font
• Text.HAlign : [Left, Center, Right]
• Text.VAlign : [Top, Middle, Bottom]
• Text.Align : (VAlign, HAlign)
• Text.Size : { width : F32, height : F32 }
• Text.Placement := { pos : Vec2, color : Rgba, align : Align ?? (Top, Left) }
• Text.Builder
• Text.Builder.size : Builder, F32 -> Builder
• Text.Builder.spacing : Builder, F32 -> Builder
• Text.Builder.font : Builder, Font -> Builder
• Text.Builder.draw! : Builder, Frame, Placement => {}
• Text.Builder.prepare! : Builder => Try(Prepared, [ResourceLimit])
• Text.Prepared
• Text.Prepared.bounds : Prepared -> Size
• Text.Prepared.draw! : Prepared, Frame, Placement => {}
• Text.Prepared.stub : Prepared
• Text.PreparedPlacement := { text : Prepared, pos : Vec2, color : Rgba, align : Align ?? (Top, Left) }
• Texture.stub : Texture
• Texture.TextureHandle : Texture
• Tilemap.empty_raw_map : TilemapRawMap
• Tilemap.empty : Tilemap
• Tilemap.from_raw : TilemapRawMap -> TilemapBuilder
• Tilemap.raw_map : Tilemap -> TilemapRawMap
• Tilemap.layer_role_for : Tilemap, TilemapRawLayer -> TilemapLayerRole
• Tilemap.object_role_for : Tilemap, TilemapRawObject -> TilemapObjectRole
• Tilemap.objects : Tilemap -> List(TilemapRawObject)
• Tilemap.objects_named : Tilemap, Str -> List(TilemapRawObject)
• Tilemap.objects_typed : Tilemap, Str -> List(TilemapRawObject)
• Tilemap.objects_with_role : Tilemap, TilemapObjectRole -> List(TilemapRawObject)
• Tilemap.first_object : Tilemap, TilemapObjectRole -> Try(TilemapRawObject, [NotFound])
• Tilemap.object_center : TilemapRawObject -> Vec2
• Tilemap.object_rect : TilemapRawObject -> Rect
• Tilemap.object_circle : TilemapRawObject -> Circle
• Tilemap.object_world_center : Tilemap, TilemapRawObject -> Vec2
• Tilemap.object_world_rect : Tilemap, TilemapRawObject -> Rect
• Tilemap.object_world_circle : Tilemap, TilemapRawObject -> Circle
• Tilemap.property_named : TilemapRawMap, U64, U64, Str -> Try(TilemapRawProperty, [NotFound])
• Tilemap.object_property : TilemapRawMap, TilemapRawObject, Str -> Try(TilemapRawProperty, [NotFound])
• Tilemap.layer_property : TilemapRawMap, TilemapRawLayer, Str -> Try(TilemapRawProperty, [NotFound])
• Tilemap.property_str : TilemapRawMap, TilemapRawObject, Str, Str -> Str
• Tilemap.property_f32 : TilemapRawMap, TilemapRawObject, Str, F32 -> F32
• Tilemap.property_i64 : TilemapRawMap, TilemapRawObject, Str, I64 -> I64
• Tilemap.property_bool : TilemapRawMap, TilemapRawObject, Str, Bool -> Bool
• Tilemap.cell_at_world : Tilemap, Vec2 -> Try(TilemapCell, [OutOfBounds])
• Tilemap.cell_range_for_world_rect : Tilemap, Rect -> Try(TilemapCellRange, [OutOfBounds])
• Tilemap.world_rect_for_cell : Tilemap, TilemapCell -> Rect
• Tilemap.gid_at : Tilemap, Str, TilemapCell -> Try(U64, [NotFound, OutOfBounds])
• Tilemap.solid_cell : Tilemap, TilemapCell -> Bool
• Tilemap.solid_at_world : Tilemap, Vec2 -> Bool
• Tilemap.circle_touches_solid : Tilemap, Circle -> Bool
• Tilemap.draw_layer! : Tilemap, Frame, Str => {}
• Tilemap.draw_layer_in! : Tilemap, Frame, Str, Rect => {}
• Tilemap.draw_layers! : Tilemap, Frame, TilemapDrawRole => {}
• Tilemap.draw_layers_in! : Tilemap, Frame, TilemapDrawRole, Rect => {}
• Tilemap.draw_all! : Tilemap, Frame => {}
• Tilemap.draw_all_in! : Tilemap, Frame, Rect => {}
• Tilemap.viewport_for_camera : Camera2D, Vec2 -> Rect
• Tilemap.draw_all_for_camera! : Tilemap, Frame, Camera2D, Vec2 => {}
• Tilemap.flip_for_gid : U64 -> TilemapFlip
• Tilemap.clean_gid : U64 -> U64
• Tilemap.load_tmx! : Store, Str => Try(TilemapRawMap, [PathInvalid, NotFound, ReadFailed, ParseFailed, Unsupported])
• Tilemap.RawMap : TilemapRawMap
• Tilemap.RawLayer : TilemapRawLayer
• Tilemap.RawObject : TilemapRawObject
• Tilemap.RawProperty : TilemapRawProperty
• Tilemap.RawTileset : TilemapRawTileset
• Tilemap.RawPoint : TilemapRawPoint
• Tilemap.Cell : TilemapCell
• Tilemap.CellRange : TilemapCellRange
• Tilemap.Flip : TilemapFlip
• Tilemap.ResolvedTileset : TilemapResolvedTileset
• Tilemap.LayerRole : TilemapLayerRole
• Tilemap.DrawRole : TilemapDrawRole
• Tilemap.ObjectRole : TilemapObjectRole
• Tilemap.Builder : TilemapBuilder
• Time.first_cycle : Cycle
• Time.to_seconds : U64 -> F32
• Time.delta_seconds : U64, U64 -> F32
• Time.now! : () => Timestamp
• Time.Cycle : { cycle_count : U64, simulation_nanos : U64, monotonic_nanos : U64, elapsed_seconds : F32 }
• Time.Timestamp
• Time.Timestamp.is_eq : _
• Time.Timestamp.epoch : Timestamp
• Time.Timestamp.from_parts : { seconds : I64, nanosecond : U32 } -> Try(Timestamp, [InvalidNanosecond])
• Time.Timestamp.from_nanos_since_epoch : I128 -> Try(Timestamp, [OutOfRange])
• Time.Timestamp.seconds_since_epoch : Timestamp -> I64
• Time.Timestamp.subsecond_nanoseconds : Timestamp -> U32
• Time.Timestamp.nanos_since_epoch : Timestamp -> I128
• Time.Timestamp.difference_nanos : Timestamp, Timestamp -> I128
• Time.Timestamp.to_iso_8601 : Timestamp -> Str
• Time.Timestamp.to_iso_8601_nanos : Timestamp -> Str
• Time.Timestamp.to_file_stamp : Timestamp -> Str
• Trace.mark! : Str => {}
• Trace.begin! : Str => Zone
• Trace.end! : Zone => {}
• Trace.sample_i64! : Str, I64, Unit => {}
• Trace.sample_f64! : Str, F64, Unit => {}
• Trace.Zone
• Trace.Unit : [Bytes, Count, Nanoseconds, Microseconds, Milliseconds, Ratio]
• Udp.default_receive : ReceiveConfig
• Udp.max_datagram_bytes : U64
• Udp.Address : { ip : Str, port : U16 }
• Udp.Datagram : { from : Address, bytes : List(U8) }
• Udp.ReceiveConfig : { timeout_ms : U64, max_datagrams : U32 }
• Udp.BindError : [InvalidAddress, AddressInUse, AddressUnavailable, AccessRefused, PermissionDenied, ResourceLimit, Unavailable]
• Udp.SendError : [InvalidAddress, TooLarge, WouldBlock, Unreachable, AccessRefused, PermissionDenied, SendFailed, Unavailable]
• Udp.ReceiveError : [Timeout, AlreadyReceiving, ReceiveFailed, Unavailable]
• Udp.Socket := { handle : Socket, local : Address }
• Udp.Socket.local_address : Socket -> Address
• Udp.Socket.send! : Socket, Address, List(U8) => Try({}, SendError)
• Udp.Socket.receive! : Socket, ReceiveConfig => Try(List(Datagram), ReceiveError)
• Udp.Socket.stub : Socket
• Udp.Network
• Udp.Network.for_host : Authority -> Network
• Udp.Network.bind! : Network, Address => Try(Socket, BindError)
• Url.parse : Str -> Try(Url, ParseErr)
• Url.from_quote : Str -> Try(Url, [BadQuotedBytes(Str)])
• Url.parser_for : encoding -> (state -> Try({ value : Url, rest : state }, err)) where [encoding.parse_str : encoding, state -> Try({ value : Str, rest : state }, err), encoding.invalid_value : encoding, state -> err]
• Url.encoder_for : encoding -> (Url, state -> Try(state, err)) where [encoding.encode_str : Str, state -> Try(state, err)]
• Url.to_str : Url -> Str
• Url.to_inspect : Url -> Str
• Url.is_eq : Url, Url -> Bool
• Url.to_hash : Url, Hasher -> Hasher
• Url.scheme : Url -> [Http, Https]
• Url.host : Url -> Str
• Url.port : Url -> [None, Some(U16)]
• Url.path : Url -> Str
• Url.query : Url -> [None, Some(Str)]
• Url.fragment : Url -> [None, Some(Str)]
• Url.without_fragment : Url -> Url
• Url.resolve : Url, Str -> Try(Url, ParseErr)
• Url.append_path_segments : Url, List(Str) -> Url
• Url.append_query_param : Url, Str, Str -> Url
• Url.query_pairs : Url -> List((Str, Str))
• Url.with_query : Url, [None, Some(Str)] -> Try(Url, ParseErr)
• Url.with_fragment : Url, [None, Some(Str)] -> Try(Url, ParseErr)
• Url.ParseErr : [CredentialsNotAllowed, EmptyHost, InternationalHostUnsupported, InvalidCharacter(U8), InvalidHost(Str), InvalidIpv4(Str), InvalidIpv6(Str), InvalidPercentEncoding(U64), InvalidPort(Str), MissingAuthority, MissingScheme, PortOutOfRange(U64), UnsupportedScheme(Str)]
• Window.suggest_size! : { width : I32, height : I32 } => {}
• Window.suggest_min_size! : { width : I32, height : I32 } => {}
• Window.set_target_fps! : I32 => {}
• Window.scale! : () => { x : F32, y : F32 }
• Window.monitors! : () => List(Monitor)
• Window.suggest_position! : { x : I32, y : I32 } => {}
• Window.suggest_monitor! : I32 => {}
• Window.Snapshot : { size : { width : I32, height : I32 }, focused : Bool, minimized : Bool, close_requested : Bool }
• Window.ClipboardReadError : [PermissionDenied, Unavailable, TooLarge, Busy]
• Window.Monitor : { index : I32, name : Str, size : { width : I32, height : I32 }, position : { x : I32, y : I32 }, refresh_hz : I32 }
• Window.Clipboard
• Window.Clipboard.for_host : Authority -> Clipboard
• Window.Clipboard.read_text! : Clipboard => Try(Str, ClipboardReadError)
• Window.Clipboard.set_text! : Clipboard, Str => Try({}, [PermissionDenied])

Text

Align and draw immediate text, or prepare it once to draw repeatedly without per-frame allocation.

title = Text.from("Hello", font).size(38).prepare!()?

Text.from("Score", font).size(24).draw!(frame, { pos, color: Color.white, align: (Top, Right) })

model.title.draw!(frame, { pos: { x: 400, y: 60 }, color: Color.white, align: (Top, Center) })

Prepared.bounds returns the measured size. Placement.align selects which point of those bounds its pos identifies.

Preparation is legal in init!, update!, and tasks, and refused in render!. Drawing requires Draw.Frame and is legal only in render!. Retain repeatedly drawn Prepared values in the model.

font_stub : Font

Resource-free synthetic monospace font for pure layout tests.

default_spacing : F32

The letter spacing a Builder starts with, and what raylib's own text drawing uses.

from : Str, Font -> Builder

Start describing a string drawn in a font. Adjust the result with size, spacing and font, then draw or prepare it.

align_offset : Size, Align -> Vec2

How far the anchor named by an Align sits from the text's top-left corner, for a text of this size. origin_for is what a draw uses; this is the piece it is built from.

origin_for : Vec2, Size, Align -> Vec2

The top-left corner a text of this size must be drawn at for its align anchor to land on pos. Pure, so an app can compute the same box a draw will occupy without drawing anything.

draw_prepared! : Frame, PreparedPlacement => {}

Draw prepared text, as Prepared.draw! does.

Legal in render! only.

Prefer the method. This form takes the frame first, like every other free drawing function, and takes the text as a field of its config record rather than as its own argument.

Font : Font

A host-owned font and immutable metric snapshot. This is the shared type owned by the platform's Font module.

HAlign : [Left, Center, Right]

Which horizontal edge or centre of the text pos names.

VAlign : [Top, Middle, Bottom]

Which vertical edge or centre of the text pos names.

Align : (VAlign, HAlign)

Where pos sits within the text, as (vertical, horizontal).

Size : { width : F32, height : F32 }

A measured width and height, in the same logical units as every drawing call. This is Draw.TextSize and Font.Size under a third name; they are one type.

Placement

:= {
    pos : Vec2,
    color : Rgba,
    align : Align ?? (Top, Left),
}

Everything a draw needs beyond the text itself: where to put it, what colour to paint it, and which point of it pos names.

Builder

Text.Builder :: # (opaque)

A string and its drawing style. Start one with Text.from, adjust it with the methods below, then draw it immediately or finish it with prepare! for repeated drawing.

A builder is a plain description, so building and measuring one costs nothing and it can be assembled anywhere. draw! and prepare! are the operations that call the host.

size : Builder, F32 -> Builder

Draw this text at a different pixel size. The default is 20.

Sizes far above the font's own base_size scale its glyph atlas up rather than re-rasterizing, so load the font at the size wanted when the difference shows.

spacing : Builder, F32 -> Builder

Change the space added between glyphs. The default is Text.default_spacing.

font : Builder, Font -> Builder

Draw this text in a different font.

draw! : Builder, Frame, Placement => {}

Measure this description from the font's immutable metric snapshot, resolve placement.align, and draw it immediately.

Legal in render! only. This is an alignment convenience for text that does not need a retained Prepared resource; Draw.text! is the lower-level operation for callers that already resolved the origin.

prepare! : Builder => Try(Prepared, [ResourceLimit])

Cache immutable UTF-8 text, font and style, and measurement in the host.

Legal in init!, update!, and tasks; refused in render!.

Prepared

Text.Prepared :: # (opaque)

Host-owned immutable text. Its ARC handle retains any loaded font and its cached native NUL-terminated bytes are reused by every draw.

bounds : Prepared -> Size

The size the host measured while preparing this text.

Pure, and free: the measurement was taken once, at preparation. Use it to size a panel around the text or to hit-test it, in update! as readily as in render!.

draw! : Prepared, Frame, Placement => {}

Draw this prepared text at a placement.

Legal in render! only.

The frame is the second argument here because the prepared text is the value the method is called on; Text.draw_prepared! is the same call with the frame first.

stub : Prepared

Resource-free prepared text for pure tests.

Prepared text holds more than a handle: the host measured it once while preparing it, and the value keeps that size. A stub has no measurement to keep, so its measured bounds are zeroed -- bounds() returns { width: 0, height: 0 } and every alignment therefore resolves to the placement point itself. Copy this value with the bounds a test needs, the way the platform's Texture.stub is copied with dimensions.

The handle never resolves to a host resource, so drawing it is skipped the way a released one is. Do not use it to test drawing, measurement, or resource lifetime.

PreparedPlacement

:= { text : Prepared, pos : Vec2, color : Rgba, align : Align ?? (Top, Left) }

Prepared text and its placement, with top-left alignment by default.