ludic/symbols.json

{
  "items": {
    "kw-program": {
      "id": "kw-program",
      "name": "program",
      "sig": "program Name { … }",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "The top-level unit — one program compiles to one native game.",
      "page": "kw-program.html"
    },
    "kw-property": {
      "id": "kw-property",
      "name": "property",
      "sig": "property Name { field: T = default, … }",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "A named record of typed fields — a per-model component, or a plain heap record.",
      "page": "kw-property.html"
    },
    "kw-model": {
      "id": "kw-model",
      "name": "model",
      "sig": "model Name { PropA, PropB, … }",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "A named kind of thing — a fixed bundle of properties you spawn by one name.",
      "page": "kw-model.html"
    },
    "kw-handler": {
      "id": "kw-handler",
      "name": "handler",
      "sig": "handler Name phase P { … }",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "A named block the engine runs each frame during phase P.",
      "page": "kw-handler.html"
    },
    "kw-phase": {
      "id": "kw-phase",
      "name": "phase",
      "sig": "phase Start | Input | Update | FixedUpdate | Render",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "Names which stage of the frame a handler runs in.",
      "page": "kw-phase.html"
    },
    "kw-const": {
      "id": "kw-const",
      "name": "const",
      "sig": "const NAME: T = value",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "A compile-time constant, folded into the code with no storage.",
      "page": "kw-const.html"
    },
    "kw-var": {
      "id": "kw-var",
      "name": "var",
      "sig": "var name: T = value",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "A mutable binding — at program scope, your game's persistent named state.",
      "page": "kw-var.html"
    },
    "kw-let": {
      "id": "kw-let",
      "name": "let",
      "sig": "let name = value",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "An immutable binding — the default choice for a value that never changes.",
      "page": "kw-let.html"
    },
    "kw-function": {
      "id": "kw-function",
      "name": "function",
      "sig": "function name(a: T, b: T) -> R { … }",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "A function — reusable logic called positionally or with named arguments.",
      "page": "kw-function.html"
    },
    "kw-fn": {
      "id": "kw-fn",
      "name": "fn",
      "sig": "fn name",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "A top-level function named as a value - the entry point handed to Job.parallel_for.",
      "page": "kw-fn.html"
    },
    "kw-prefab": {
      "id": "kw-prefab",
      "name": "prefab",
      "sig": "prefab Name: Model { Comp { field: value }, … }",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "A model with preset component fields — spawn it, override what varies.",
      "page": "kw-prefab.html"
    },
    "kw-return": {
      "id": "kw-return",
      "name": "return",
      "sig": "return value",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "Hand a value back from a function and stop running it.",
      "page": "kw-return.html"
    },
    "kw-entry": {
      "id": "kw-entry",
      "name": "entry",
      "sig": "entry { … }",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "The program's main block — runs once, top to bottom.",
      "page": "kw-entry.html"
    },
    "kw-import": {
      "id": "kw-import",
      "name": "import",
      "sig": "import \"file.ludic\"",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "Splice another Ludic file's declarations into this program.",
      "page": "kw-import.html"
    },
    "kw-public": {
      "id": "kw-public",
      "name": "public",
      "sig": "scene Name start public { … }",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "Expose a declaration's lifecycle on the public event bus.",
      "page": "kw-public.html"
    },
    "kw-extern": {
      "id": "kw-extern",
      "name": "extern",
      "sig": "extern function name(a: T) -> R = \"symbol\"",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "Bind a name to an external native symbol — the seam for platform and library calls.",
      "page": "kw-extern.html"
    },
    "kw-new": {
      "id": "kw-new",
      "name": "new",
      "sig": "new Record { … }   new []T",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "Allocate a property record or an empty slice on the heap.",
      "page": "kw-new.html"
    },
    "kw-namespace": {
      "id": "kw-namespace",
      "name": "namespace",
      "sig": "namespace Name { export function foo(…) … internal function bar(…) … }",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "Group functions into a Name.* namespace and control its public surface.",
      "page": "kw-namespace.html"
    },
    "kw-enum": {
      "id": "kw-enum",
      "name": "enum",
      "sig": "enum Name { A, B, C }",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "A named set of integer constants — names for a magic-number space.",
      "page": "kw-enum.html"
    },
    "kw-ui": {
      "id": "kw-ui",
      "name": "ui",
      "sig": "ui { panel { … } }",
      "kind": "keyword",
      "category": "structure",
      "section": "Program structure",
      "tip": "Declare a retained widget tree as data; the engine lays it out and draws it.",
      "page": "kw-ui.html"
    },
    "kw-spawn": {
      "id": "kw-spawn",
      "name": "spawn",
      "sig": "spawn Label { Prop { field: v }; … }",
      "kind": "keyword",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Create a model instance carrying the listed properties, seeding their fields.",
      "page": "kw-spawn.html"
    },
    "kw-despawn": {
      "id": "kw-despawn",
      "name": "despawn",
      "sig": "despawn entity",
      "kind": "keyword",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Remove a model instance from the world, firing any @OnDespawn hooks.",
      "page": "kw-despawn.html"
    },
    "kw-query": {
      "id": "kw-query",
      "name": "query",
      "sig": "query [PropA, PropB, {Tag}]",
      "kind": "keyword",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Match every model instance carrying all the listed properties.",
      "page": "kw-query.html"
    },
    "kw-self": {
      "id": "kw-self",
      "name": "self",
      "sig": "self()",
      "kind": "keyword",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "The model instance currently bound by the enclosing query loop.",
      "page": "kw-self.html"
    },
    "kw-enable": {
      "id": "kw-enable",
      "name": "enable",
      "sig": "enable Prop on entity",
      "kind": "keyword",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Re-activate a disabled property, model, or handler — its data is intact.",
      "page": "kw-enable.html"
    },
    "kw-disable": {
      "id": "kw-disable",
      "name": "disable",
      "sig": "disable Prop on entity",
      "kind": "keyword",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Deactivate a property, model, or handler without destroying its data.",
      "page": "kw-disable.html"
    },
    "kw-attach": {
      "id": "kw-attach",
      "name": "attach",
      "sig": "attach Prop on entity { overrides }",
      "kind": "keyword",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Structurally add a property to a live model instance, seeding its fields.",
      "page": "kw-attach.html"
    },
    "kw-detach": {
      "id": "kw-detach",
      "name": "detach",
      "sig": "detach Prop on entity",
      "kind": "keyword",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Structurally remove a property from a live model instance.",
      "page": "kw-detach.html"
    },
    "fn-world_attach_dyn": {
      "id": "fn-world_attach_dyn",
      "name": "world_attach_dyn",
      "sig": "world_attach_dyn(target, property)",
      "kind": "builtin",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Attach a property to an instance by numeric id at runtime (dynamic ECS).",
      "page": "fn-world_attach_dyn.html"
    },
    "fn-world_count": {
      "id": "fn-world_count",
      "name": "world_count",
      "sig": "world_count() -> int",
      "kind": "builtin",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "The total number of live model instances in the world.",
      "page": "fn-world_count.html"
    },
    "fn-world_detach_dyn": {
      "id": "fn-world_detach_dyn",
      "name": "world_detach_dyn",
      "sig": "world_detach_dyn(target, property)",
      "kind": "builtin",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Detach a property from an instance by numeric id at runtime (dynamic ECS).",
      "page": "fn-world_detach_dyn.html"
    },
    "fn-world_field_id": {
      "id": "fn-world_field_id",
      "name": "world_field_id",
      "sig": "world_field_id(property, name) -> int",
      "kind": "builtin",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Resolve a field name within a property to its numeric index.",
      "page": "fn-world_field_id.html"
    },
    "fn-world_get": {
      "id": "fn-world_get",
      "name": "world_get",
      "sig": "world_get(target, property, field) -> int",
      "kind": "builtin",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Read one field of a model instance by numeric id (reflection ABI).",
      "page": "fn-world_get.html"
    },
    "fn-world_has": {
      "id": "fn-world_has",
      "name": "world_has",
      "sig": "world_has(target, property) -> bool",
      "kind": "builtin",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Test whether a model instance currently carries a property.",
      "page": "fn-world_has.html"
    },
    "fn-world_kind": {
      "id": "fn-world_kind",
      "name": "world_kind",
      "sig": "world_kind(target) -> int",
      "kind": "builtin",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "The model id of an instance — which kind of thing it is.",
      "page": "fn-world_kind.html"
    },
    "fn-world_load": {
      "id": "fn-world_load",
      "name": "world_load",
      "sig": "world_load(buf, len)",
      "kind": "builtin",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Restore the whole world from a serialized byte buffer.",
      "page": "fn-world_load.html"
    },
    "fn-world_model_id": {
      "id": "fn-world_model_id",
      "name": "world_model_id",
      "sig": "world_model_id(name) -> int",
      "kind": "builtin",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Resolve a model's name to its stable numeric id.",
      "page": "fn-world_model_id.html"
    },
    "fn-world_prop_id": {
      "id": "fn-world_prop_id",
      "name": "world_prop_id",
      "sig": "world_prop_id(name) -> int",
      "kind": "builtin",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Resolve a property's name to its stable numeric id.",
      "page": "fn-world_prop_id.html"
    },
    "fn-world_query_next": {
      "id": "fn-world_query_next",
      "name": "world_query_next",
      "sig": "world_query_next(property, cursor) -> entity",
      "kind": "builtin",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Step to the next instance carrying a property, walking the world by id.",
      "page": "fn-world_query_next.html"
    },
    "fn-world_register_prop": {
      "id": "fn-world_register_prop",
      "name": "world_register_prop",
      "sig": "world_register_prop(name, fields) -> int",
      "kind": "builtin",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Register a brand-new property at runtime and get its id (dynamic ECS).",
      "page": "fn-world_register_prop.html"
    },
    "fn-world_save": {
      "id": "fn-world_save",
      "name": "world_save",
      "sig": "world_save(buf) -> int",
      "kind": "builtin",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Serialize the whole world into a buffer; returns the number of bytes written.",
      "page": "fn-world_save.html"
    },
    "fn-world_set": {
      "id": "fn-world_set",
      "name": "world_set",
      "sig": "world_set(target, property, field, value)",
      "kind": "builtin",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Write one field of a model instance by numeric id (reflection ABI).",
      "page": "fn-world_set.html"
    },
    "fn-world_size": {
      "id": "fn-world_size",
      "name": "world_size",
      "sig": "world_size() -> int",
      "kind": "builtin",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "The number of live model instances in the world.",
      "page": "fn-world_size.html"
    },
    "fn-world_spawn": {
      "id": "fn-world_spawn",
      "name": "world_spawn",
      "sig": "world_spawn(model) -> entity",
      "kind": "builtin",
      "category": "ecs",
      "section": "Entities & the ECS",
      "tip": "Spawn an instance of a model chosen by numeric id at runtime.",
      "page": "fn-world_spawn.html"
    },
    "kw-if": {
      "id": "kw-if",
      "name": "if / else",
      "sig": "if cond { … } else { … }",
      "kind": "keyword",
      "category": "control",
      "section": "Control flow",
      "tip": "A branch — run one block when a condition holds, another when it doesn't.",
      "page": "kw-if.html"
    },
    "kw-while": {
      "id": "kw-while",
      "name": "while",
      "sig": "while cond { … }",
      "kind": "keyword",
      "category": "control",
      "section": "Control flow",
      "tip": "Loop as long as a condition holds, re-checking it before each pass.",
      "page": "kw-while.html"
    },
    "kw-for": {
      "id": "kw-for",
      "name": "for … in",
      "sig": "for name in a .. b { … }",
      "kind": "keyword",
      "category": "control",
      "section": "Control flow",
      "tip": "Range loop — iterate the half-open range from a up to but not including b.",
      "page": "kw-for.html"
    },
    "kw-in": {
      "id": "kw-in",
      "name": "in",
      "sig": "for x in range | query",
      "kind": "keyword",
      "category": "control",
      "section": "Control flow",
      "tip": "The part of a for loop that names what to iterate — a range or a query.",
      "page": "kw-in.html"
    },
    "kw-match": {
      "id": "kw-match",
      "name": "match",
      "sig": "match value { 0, 1 => … _ => … }",
      "kind": "keyword",
      "category": "control",
      "section": "Control flow",
      "tip": "Multi-way branch on one value, matching one or more literals per arm.",
      "page": "kw-match.html"
    },
    "kw-machine": {
      "id": "kw-machine",
      "name": "machine",
      "sig": "machine store { state Name { … } }",
      "kind": "keyword",
      "category": "control",
      "section": "Control flow",
      "tip": "An explicit state machine over an int var — dispatches on the store's value.",
      "page": "kw-machine.html"
    },
    "kw-state": {
      "id": "kw-state",
      "name": "state",
      "sig": "state Name { … }",
      "kind": "keyword",
      "category": "control",
      "section": "Control flow",
      "tip": "One state of a machine — its body runs while the machine sits in it.",
      "page": "kw-state.html"
    },
    "kw-become": {
      "id": "kw-become",
      "name": "become",
      "sig": "become Name",
      "kind": "keyword",
      "category": "control",
      "section": "Control flow",
      "tip": "Transition to another state of the enclosing machine, or to another scene.",
      "page": "kw-become.html"
    },
    "kw-break": {
      "id": "kw-break",
      "name": "break",
      "sig": "break",
      "kind": "keyword",
      "category": "control",
      "section": "Control flow",
      "tip": "Leave the enclosing loop immediately.",
      "page": "kw-break.html"
    },
    "kw-continue": {
      "id": "kw-continue",
      "name": "continue",
      "sig": "continue",
      "kind": "keyword",
      "category": "control",
      "section": "Control flow",
      "tip": "Skip to the next iteration of the loop.",
      "page": "kw-continue.html"
    },
    "kw-where": {
      "id": "kw-where",
      "name": "where",
      "sig": "for (Binds) in query [Comps] where cond { … }",
      "kind": "keyword",
      "category": "control",
      "section": "Control flow",
      "tip": "Filter a query loop to entities that satisfy a condition.",
      "page": "kw-where.html"
    },
    "kw-try": {
      "id": "kw-try",
      "name": "try",
      "sig": "try EXPR else { … }",
      "kind": "keyword",
      "category": "control",
      "section": "Control flow",
      "tip": "Recover a fallible result as a value, with a fallback — no exceptions, no unwinding.",
      "page": "kw-try.html"
    },
    "kw-scene": {
      "id": "kw-scene",
      "name": "scene",
      "sig": "scene Name [start] { on enter{} on exit{} layer … }",
      "kind": "keyword",
      "category": "scenes",
      "section": "Scenes & layers",
      "tip": "A mutually-exclusive game state — a title screen, the overworld, a battle.",
      "page": "kw-scene.html"
    },
    "kw-layer": {
      "id": "kw-layer",
      "name": "layer",
      "sig": "layer Name { handlers }",
      "kind": "keyword",
      "category": "scenes",
      "section": "Scenes & layers",
      "tip": "A named group of handlers inside a scene; layers render in declaration order.",
      "page": "kw-layer.html"
    },
    "kw-on": {
      "id": "kw-on",
      "name": "on enter / on exit",
      "sig": "on enter { … }   on exit { … }",
      "kind": "keyword",
      "category": "scenes",
      "section": "Scenes & layers",
      "tip": "Scene lifecycle hooks that fire as a scene becomes active or is left.",
      "page": "kw-on.html"
    },
    "kw-enter": {
      "id": "kw-enter",
      "name": "enter",
      "sig": "on enter { … }",
      "kind": "keyword",
      "category": "scenes",
      "section": "Scenes & layers",
      "tip": "The scene-entry hook — runs once as a scene becomes active.",
      "page": "kw-enter.html"
    },
    "kw-exit": {
      "id": "kw-exit",
      "name": "exit",
      "sig": "on exit { … }",
      "kind": "keyword",
      "category": "scenes",
      "section": "Scenes & layers",
      "tip": "The scene-exit hook — runs once as a scene is left.",
      "page": "kw-exit.html"
    },
    "kw-start": {
      "id": "kw-start",
      "name": "start",
      "sig": "scene Name start { … }",
      "kind": "keyword",
      "category": "scenes",
      "section": "Scenes & layers",
      "tip": "Marks the one scene the game begins in.",
      "page": "kw-start.html"
    },
    "kw-event": {
      "id": "kw-event",
      "name": "event",
      "sig": "event Name { field: T = default }",
      "kind": "keyword",
      "category": "events",
      "section": "Events",
      "tip": "Declare a public event carrying a flat payload that listeners react to.",
      "page": "kw-event.html"
    },
    "kw-emit": {
      "id": "kw-emit",
      "name": "emit",
      "sig": "emit Name(field: value)",
      "kind": "keyword",
      "category": "events",
      "section": "Events",
      "tip": "Fire an event, running every listener; as an expression it yields the veto flag.",
      "page": "kw-emit.html"
    },
    "kw-cancel": {
      "id": "kw-cancel",
      "name": "cancel",
      "sig": "cancel",
      "kind": "keyword",
      "category": "events",
      "section": "Events",
      "tip": "Inside a listener, veto the cancellable event being emitted.",
      "page": "kw-cancel.html"
    },
    "kw-cancellable": {
      "id": "kw-cancellable",
      "name": "cancellable",
      "sig": "event cancellable Name { … }",
      "kind": "keyword",
      "category": "events",
      "section": "Events",
      "tip": "Marks an event whose listeners may veto it with cancel.",
      "page": "kw-cancellable.html"
    },
    "screen-clear": {
      "id": "screen-clear",
      "name": "Screen.clear",
      "sig": "Screen.clear(color)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Fill the whole framebuffer with one color to start a fresh frame.",
      "page": "screen-clear.html"
    },
    "screen-fill_rectangle": {
      "id": "screen-fill_rectangle",
      "name": "Screen.fill_rectangle",
      "sig": "Screen.fill_rectangle(x, y, width, height, color)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Draw a solid, filled rectangle at a pixel position.",
      "page": "screen-fill_rectangle.html"
    },
    "screen-draw_rectangle": {
      "id": "screen-draw_rectangle",
      "name": "Screen.draw_rectangle",
      "sig": "Screen.draw_rectangle(x, y, width, height, color)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Draw a one-pixel-thick rectangle outline (not filled).",
      "page": "screen-draw_rectangle.html"
    },
    "screen-put_pixel": {
      "id": "screen-put_pixel",
      "name": "Screen.put_pixel",
      "sig": "Screen.put_pixel(x, y, color)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Set a single pixel at a pixel coordinate to one color.",
      "page": "screen-put_pixel.html"
    },
    "screen-draw_text": {
      "id": "screen-draw_text",
      "name": "Screen.draw_text",
      "sig": "Screen.draw_text(x, y, text, color, scale)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Draw a string with the built-in font at an integer scale.",
      "page": "screen-draw_text.html"
    },
    "screen-draw_number": {
      "id": "screen-draw_number",
      "name": "Screen.draw_number",
      "sig": "Screen.draw_number(x, y, value, color, scale)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Draw an integer directly, with no string allocation or conversion.",
      "page": "screen-draw_number.html"
    },
    "screen-show": {
      "id": "screen-show",
      "name": "Screen.show",
      "sig": "Screen.show()",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Present the finished frame — copy everything drawn this frame to the window.",
      "page": "screen-show.html"
    },
    "screen-width": {
      "id": "screen-width",
      "name": "Screen.width",
      "sig": "Screen.width() -> int",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "The framebuffer width in pixels.",
      "page": "screen-width.html"
    },
    "screen-height": {
      "id": "screen-height",
      "name": "Screen.height",
      "sig": "Screen.height() -> int",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "The framebuffer height in pixels.",
      "page": "screen-height.html"
    },
    "screen-status": {
      "id": "screen-status",
      "name": "Screen.status",
      "sig": "Screen.status(text)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Set the persistent one-line status/HUD string shown by the runtime.",
      "page": "screen-status.html"
    },
    "screen-line": {
      "id": "screen-line",
      "name": "Screen.line",
      "sig": "Screen.line(x1, y1, x2, y2, color)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Draw a straight line between two points.",
      "page": "screen-line.html"
    },
    "screen-circle": {
      "id": "screen-circle",
      "name": "Screen.circle",
      "sig": "Screen.circle(x, y, radius, color)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Draw a circle outline.",
      "page": "screen-circle.html"
    },
    "screen-fill_circle": {
      "id": "screen-fill_circle",
      "name": "Screen.fill_circle",
      "sig": "Screen.fill_circle(x, y, radius, color)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Draw a filled disc.",
      "page": "screen-fill_circle.html"
    },
    "screen-triangle": {
      "id": "screen-triangle",
      "name": "Screen.triangle",
      "sig": "Screen.triangle(x1, y1, x2, y2, x3, y3, color)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Draw a triangle outline.",
      "page": "screen-triangle.html"
    },
    "screen-fill_triangle": {
      "id": "screen-fill_triangle",
      "name": "Screen.fill_triangle",
      "sig": "Screen.fill_triangle(x1, y1, x2, y2, x3, y3, color)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Draw a filled triangle.",
      "page": "screen-fill_triangle.html"
    },
    "screen-sprite": {
      "id": "screen-sprite",
      "name": "Screen.sprite",
      "sig": "Screen.sprite(id, x, y)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Blit a sprite at its natural size.",
      "page": "screen-sprite.html"
    },
    "screen-sprite_scaled": {
      "id": "screen-sprite_scaled",
      "name": "Screen.sprite_scaled",
      "sig": "Screen.sprite_scaled(id, x, y, scale)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Blit a sprite at an integer scale.",
      "page": "screen-sprite_scaled.html"
    },
    "screen-oval": {
      "id": "screen-oval",
      "name": "Screen.oval",
      "sig": "Screen.oval(x, y, rx, ry, color)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Draw an axis-aligned ellipse outline.",
      "page": "screen-oval.html"
    },
    "screen-camera": {
      "id": "screen-camera",
      "name": "Screen.camera",
      "sig": "Screen.camera(x, y)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Set the world-space camera offset for the draw path.",
      "page": "screen-camera.html"
    },
    "screen-clip": {
      "id": "screen-clip",
      "name": "Screen.clip",
      "sig": "Screen.clip(x, y, width, height)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Restrict drawing to a screen-space rectangle.",
      "page": "screen-clip.html"
    },
    "screen-clip_reset": {
      "id": "screen-clip_reset",
      "name": "Screen.clip_reset",
      "sig": "Screen.clip_reset()",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Lift the clip rectangle (draw to the whole screen again).",
      "page": "screen-clip_reset.html"
    },
    "screen-blend_mode": {
      "id": "screen-blend_mode",
      "name": "Screen.blend_mode",
      "sig": "Screen.blend_mode(mode)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Choose replace or additive pixel blending.",
      "page": "screen-blend_mode.html"
    },
    "screen-measure_text": {
      "id": "screen-measure_text",
      "name": "Screen.measure_text",
      "sig": "Screen.measure_text(text) -> int",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "The pixel advance width of text in the built-in font.",
      "page": "screen-measure_text.html"
    },
    "screen-pixel": {
      "id": "screen-pixel",
      "name": "Screen.pixel",
      "sig": "Screen.pixel(x, y) -> int",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "Read a framebuffer pixel (0x00RRGGBB), or 0 if off-screen.",
      "page": "screen-pixel.html"
    },
    "screen-bar": {
      "id": "screen-bar",
      "name": "Screen.bar",
      "sig": "Screen.bar(x:, y:, width:, height:, value:, max:, color:, back:)",
      "kind": "namespace-method",
      "category": "screen",
      "section": "Screen — drawing",
      "tip": "A filled meter: value of max over a track.",
      "page": "screen-bar.html"
    },
    "clock-now": {
      "id": "clock-now",
      "name": "Clock.now",
      "sig": "Clock.now() -> int",
      "kind": "namespace-method",
      "category": "clock",
      "section": "Clock",
      "tip": "The current simulated instant.",
      "page": "clock-now.html"
    },
    "clock-set": {
      "id": "clock-set",
      "name": "Clock.set",
      "sig": "Clock.set(t)",
      "kind": "namespace-method",
      "category": "clock",
      "section": "Clock",
      "tip": "Set the clock to an instant.",
      "page": "clock-set.html"
    },
    "clock-advance": {
      "id": "clock-advance",
      "name": "Clock.advance",
      "sig": "Clock.advance(span)",
      "kind": "namespace-method",
      "category": "clock",
      "section": "Clock",
      "tip": "Move the clock forward by a Duration.",
      "page": "clock-advance.html"
    },
    "clock-reset": {
      "id": "clock-reset",
      "name": "Clock.reset",
      "sig": "Clock.reset()",
      "kind": "namespace-method",
      "category": "clock",
      "section": "Clock",
      "tip": "Reset the clock to the epoch (0).",
      "page": "clock-reset.html"
    },
    "collision-rects": {
      "id": "collision-rects",
      "name": "Collision.rects",
      "sig": "Collision.rects(ax, ay, aw, ah, bx, by, bw, bh) -> bool",
      "kind": "namespace-method",
      "category": "collision",
      "section": "Collision",
      "tip": "Do two rectangles overlap?",
      "page": "collision-rects.html"
    },
    "collision-point_rect": {
      "id": "collision-point_rect",
      "name": "Collision.point_rect",
      "sig": "Collision.point_rect(px, py, rx, ry, rw, rh) -> bool",
      "kind": "namespace-method",
      "category": "collision",
      "section": "Collision",
      "tip": "Is a point inside a rectangle?",
      "page": "collision-point_rect.html"
    },
    "collision-circles": {
      "id": "collision-circles",
      "name": "Collision.circles",
      "sig": "Collision.circles(ax, ay, ar, bx, by, br) -> bool",
      "kind": "namespace-method",
      "category": "collision",
      "section": "Collision",
      "tip": "Do two circles overlap?",
      "page": "collision-circles.html"
    },
    "collision-rect_circle": {
      "id": "collision-rect_circle",
      "name": "Collision.rect_circle",
      "sig": "Collision.rect_circle(rx, ry, rw, rh, cx, cy, cr) -> bool",
      "kind": "namespace-method",
      "category": "collision",
      "section": "Collision",
      "tip": "Does a rectangle overlap a circle?",
      "page": "collision-rect_circle.html"
    },
    "color-rgb": {
      "id": "color-rgb",
      "name": "Color.rgb",
      "sig": "Color.rgb(r, g, b) -> int",
      "kind": "namespace-method",
      "category": "color",
      "section": "Color functions",
      "tip": "Build a color from red, green, blue.",
      "page": "color-rgb.html"
    },
    "color-rgba": {
      "id": "color-rgba",
      "name": "Color.rgba",
      "sig": "Color.rgba(r, g, b, a) -> int",
      "kind": "namespace-method",
      "category": "color",
      "section": "Color functions",
      "tip": "Build a color with an alpha byte.",
      "page": "color-rgba.html"
    },
    "color-lerp": {
      "id": "color-lerp",
      "name": "Color.lerp",
      "sig": "Color.lerp(c0, c1, t) -> int",
      "kind": "namespace-method",
      "category": "color",
      "section": "Color functions",
      "tip": "Blend between two colors.",
      "page": "color-lerp.html"
    },
    "color-darken": {
      "id": "color-darken",
      "name": "Color.darken",
      "sig": "Color.darken(c, amount) -> int",
      "kind": "namespace-method",
      "category": "color",
      "section": "Color functions",
      "tip": "Scale a color toward black.",
      "page": "color-darken.html"
    },
    "color-lighten": {
      "id": "color-lighten",
      "name": "Color.lighten",
      "sig": "Color.lighten(c, amount) -> int",
      "kind": "namespace-method",
      "category": "color",
      "section": "Color functions",
      "tip": "Scale a color toward white.",
      "page": "color-lighten.html"
    },
    "color-with_alpha": {
      "id": "color-with_alpha",
      "name": "Color.with_alpha",
      "sig": "Color.with_alpha(c, a) -> int",
      "kind": "namespace-method",
      "category": "color",
      "section": "Color functions",
      "tip": "Replace a color's alpha byte.",
      "page": "color-with_alpha.html"
    },
    "crypto-sha256": {
      "id": "crypto-sha256",
      "name": "Crypto.sha256",
      "sig": "Crypto.sha256(s) -> string",
      "kind": "namespace-method",
      "category": "crypto",
      "section": "Crypto",
      "tip": "SHA-256 of a string, as 64 hex characters.",
      "page": "crypto-sha256.html"
    },
    "crypto-hmac_sha256": {
      "id": "crypto-hmac_sha256",
      "name": "Crypto.hmac_sha256",
      "sig": "Crypto.hmac_sha256(key, msg) -> string",
      "kind": "namespace-method",
      "category": "crypto",
      "section": "Crypto",
      "tip": "Sign a message with a shared secret key.",
      "page": "crypto-hmac_sha256.html"
    },
    "crypto-verify_hmac": {
      "id": "crypto-verify_hmac",
      "name": "Crypto.verify_hmac",
      "sig": "Crypto.verify_hmac(key, msg, mac) -> bool",
      "kind": "namespace-method",
      "category": "crypto",
      "section": "Crypto",
      "tip": "Constant-time check that a MAC matches.",
      "page": "crypto-verify_hmac.html"
    },
    "crypto-hex": {
      "id": "crypto-hex",
      "name": "Crypto.hex",
      "sig": "Crypto.hex(s) -> string",
      "kind": "namespace-method",
      "category": "crypto",
      "section": "Crypto",
      "tip": "Lowercase hex of a string's bytes.",
      "page": "crypto-hex.html"
    },
    "crypto-ct_equal": {
      "id": "crypto-ct_equal",
      "name": "Crypto.ct_equal",
      "sig": "Crypto.ct_equal(a, b) -> bool",
      "kind": "namespace-method",
      "category": "crypto",
      "section": "Crypto",
      "tip": "Constant-time string equality for secrets.",
      "page": "crypto-ct_equal.html"
    },
    "crypto-random_bytes": {
      "id": "crypto-random_bytes",
      "name": "Crypto.random_bytes",
      "sig": "Crypto.random_bytes(n) -> string",
      "kind": "namespace-method",
      "category": "crypto",
      "section": "Crypto",
      "tip": "n bytes from the OS CSPRNG, as a 2n-character hex string.",
      "page": "crypto-random_bytes.html"
    },
    "crypto-random_hex": {
      "id": "crypto-random_hex",
      "name": "Crypto.random_hex",
      "sig": "Crypto.random_hex(n) -> string",
      "kind": "namespace-method",
      "category": "crypto",
      "section": "Crypto",
      "tip": "Alias for random_bytes — n secure bytes as a 2n-char hex string.",
      "page": "crypto-random_hex.html"
    },
    "crypto-random_u32": {
      "id": "crypto-random_u32",
      "name": "Crypto.random_u32",
      "sig": "Crypto.random_u32() -> int",
      "kind": "namespace-method",
      "category": "crypto",
      "section": "Crypto",
      "tip": "One CSPRNG-drawn 32-bit integer.",
      "page": "crypto-random_u32.html"
    },
    "crypto-base64": {
      "id": "crypto-base64",
      "name": "Crypto.base64",
      "sig": "Crypto.base64(s) -> string",
      "kind": "namespace-method",
      "category": "crypto",
      "section": "Crypto",
      "tip": "Standard base64 (RFC 4648) of a string's bytes.",
      "page": "crypto-base64.html"
    },
    "date-new": {
      "id": "date-new",
      "name": "Date.new",
      "sig": "Date.new(year, month, day) -> int",
      "kind": "namespace-method",
      "category": "date",
      "section": "Date",
      "tip": "A calendar day as days-since-1970.",
      "page": "date-new.html"
    },
    "date-year": {
      "id": "date-year",
      "name": "Date.year",
      "sig": "Date.year(date) -> int",
      "kind": "namespace-method",
      "category": "date",
      "section": "Date",
      "tip": "The calendar year of a date.",
      "page": "date-year.html"
    },
    "date-month": {
      "id": "date-month",
      "name": "Date.month",
      "sig": "Date.month(date) -> int",
      "kind": "namespace-method",
      "category": "date",
      "section": "Date",
      "tip": "The month (1-12) of a date.",
      "page": "date-month.html"
    },
    "date-day": {
      "id": "date-day",
      "name": "Date.day",
      "sig": "Date.day(date) -> int",
      "kind": "namespace-method",
      "category": "date",
      "section": "Date",
      "tip": "The day of the month (1-31) of a date.",
      "page": "date-day.html"
    },
    "date-weekday": {
      "id": "date-weekday",
      "name": "Date.weekday",
      "sig": "Date.weekday(date) -> int",
      "kind": "namespace-method",
      "category": "date",
      "section": "Date",
      "tip": "Day of the week, 0=Sunday..6=Saturday.",
      "page": "date-weekday.html"
    },
    "date-is_leap": {
      "id": "date-is_leap",
      "name": "Date.is_leap",
      "sig": "Date.is_leap(year) -> bool",
      "kind": "namespace-method",
      "category": "date",
      "section": "Date",
      "tip": "True if the year is a leap year.",
      "page": "date-is_leap.html"
    },
    "date-days_in_month": {
      "id": "date-days_in_month",
      "name": "Date.days_in_month",
      "sig": "Date.days_in_month(year, month) -> int",
      "kind": "namespace-method",
      "category": "date",
      "section": "Date",
      "tip": "Number of days in a given month.",
      "page": "date-days_in_month.html"
    },
    "date-to_epoch": {
      "id": "date-to_epoch",
      "name": "Date.to_epoch",
      "sig": "Date.to_epoch(date) -> int",
      "kind": "namespace-method",
      "category": "date",
      "section": "Date",
      "tip": "Midnight UTC of the day, as a DateTime.",
      "page": "date-to_epoch.html"
    },
    "date-add_days": {
      "id": "date-add_days",
      "name": "Date.add_days",
      "sig": "Date.add_days(date, n) -> int",
      "kind": "namespace-method",
      "category": "date",
      "section": "Date",
      "tip": "The date n days later (n may be negative).",
      "page": "date-add_days.html"
    },
    "date-diff_days": {
      "id": "date-diff_days",
      "name": "Date.diff_days",
      "sig": "Date.diff_days(a, b) -> int",
      "kind": "namespace-method",
      "category": "date",
      "section": "Date",
      "tip": "Whole days from b to a (a - b).",
      "page": "date-diff_days.html"
    },
    "datetime-from": {
      "id": "datetime-from",
      "name": "DateTime.from",
      "sig": "DateTime.from(year, month, day, hour, minute, second) -> int",
      "kind": "namespace-method",
      "category": "datetime",
      "section": "DateTime",
      "tip": "Build an instant from its calendar parts.",
      "page": "datetime-from.html"
    },
    "datetime-date": {
      "id": "datetime-date",
      "name": "DateTime.date",
      "sig": "DateTime.date(dt) -> int",
      "kind": "namespace-method",
      "category": "datetime",
      "section": "DateTime",
      "tip": "The calendar day the instant falls on.",
      "page": "datetime-date.html"
    },
    "datetime-add": {
      "id": "datetime-add",
      "name": "DateTime.add",
      "sig": "DateTime.add(dt, span) -> int",
      "kind": "namespace-method",
      "category": "datetime",
      "section": "DateTime",
      "tip": "The instant `span` seconds later.",
      "page": "datetime-add.html"
    },
    "datetime-year": {
      "id": "datetime-year",
      "name": "DateTime.year",
      "sig": "DateTime.year(dt) -> int",
      "kind": "namespace-method",
      "category": "datetime",
      "section": "DateTime",
      "tip": "The calendar year of an instant.",
      "page": "datetime-year.html"
    },
    "datetime-month": {
      "id": "datetime-month",
      "name": "DateTime.month",
      "sig": "DateTime.month(dt) -> int",
      "kind": "namespace-method",
      "category": "datetime",
      "section": "DateTime",
      "tip": "The month (1-12) of an instant.",
      "page": "datetime-month.html"
    },
    "datetime-day": {
      "id": "datetime-day",
      "name": "DateTime.day",
      "sig": "DateTime.day(dt) -> int",
      "kind": "namespace-method",
      "category": "datetime",
      "section": "DateTime",
      "tip": "The day of the month (1-31) of an instant.",
      "page": "datetime-day.html"
    },
    "datetime-weekday": {
      "id": "datetime-weekday",
      "name": "DateTime.weekday",
      "sig": "DateTime.weekday(dt) -> int",
      "kind": "namespace-method",
      "category": "datetime",
      "section": "DateTime",
      "tip": "Day of the week, 0=Sunday..6=Saturday.",
      "page": "datetime-weekday.html"
    },
    "datetime-hour": {
      "id": "datetime-hour",
      "name": "DateTime.hour",
      "sig": "DateTime.hour(dt) -> int",
      "kind": "namespace-method",
      "category": "datetime",
      "section": "DateTime",
      "tip": "The hour of day (0-23) of an instant.",
      "page": "datetime-hour.html"
    },
    "datetime-minute": {
      "id": "datetime-minute",
      "name": "DateTime.minute",
      "sig": "DateTime.minute(dt) -> int",
      "kind": "namespace-method",
      "category": "datetime",
      "section": "DateTime",
      "tip": "The minute of the hour (0-59) of an instant.",
      "page": "datetime-minute.html"
    },
    "datetime-second": {
      "id": "datetime-second",
      "name": "DateTime.second",
      "sig": "DateTime.second(dt) -> int",
      "kind": "namespace-method",
      "category": "datetime",
      "section": "DateTime",
      "tip": "The second of the minute (0-59) of an instant.",
      "page": "datetime-second.html"
    },
    "datetime-format": {
      "id": "datetime-format",
      "name": "DateTime.format",
      "sig": "DateTime.format(dt, pattern) -> string",
      "kind": "namespace-method",
      "category": "datetime",
      "section": "DateTime",
      "tip": "Render an instant as text using a token pattern.",
      "page": "datetime-format.html"
    },
    "datetime-parse": {
      "id": "datetime-parse",
      "name": "DateTime.parse",
      "sig": "DateTime.parse(text, pattern) -> int",
      "kind": "namespace-method",
      "category": "datetime",
      "section": "DateTime",
      "tip": "Parse text into an instant; -1 on failure.",
      "page": "datetime-parse.html"
    },
    "duration-seconds": {
      "id": "duration-seconds",
      "name": "Duration.seconds",
      "sig": "Duration.seconds(n) -> int",
      "kind": "namespace-method",
      "category": "duration",
      "section": "Duration",
      "tip": "A span of n whole seconds.",
      "page": "duration-seconds.html"
    },
    "duration-minutes": {
      "id": "duration-minutes",
      "name": "Duration.minutes",
      "sig": "Duration.minutes(n) -> int",
      "kind": "namespace-method",
      "category": "duration",
      "section": "Duration",
      "tip": "A span of n minutes, in seconds.",
      "page": "duration-minutes.html"
    },
    "duration-hours": {
      "id": "duration-hours",
      "name": "Duration.hours",
      "sig": "Duration.hours(n) -> int",
      "kind": "namespace-method",
      "category": "duration",
      "section": "Duration",
      "tip": "A span of n hours, in seconds.",
      "page": "duration-hours.html"
    },
    "duration-days": {
      "id": "duration-days",
      "name": "Duration.days",
      "sig": "Duration.days(n) -> int",
      "kind": "namespace-method",
      "category": "duration",
      "section": "Duration",
      "tip": "A span of n days, in seconds.",
      "page": "duration-days.html"
    },
    "duration-as_seconds": {
      "id": "duration-as_seconds",
      "name": "Duration.as_seconds",
      "sig": "Duration.as_seconds(span) -> int",
      "kind": "namespace-method",
      "category": "duration",
      "section": "Duration",
      "tip": "The span in whole seconds.",
      "page": "duration-as_seconds.html"
    },
    "duration-as_minutes": {
      "id": "duration-as_minutes",
      "name": "Duration.as_minutes",
      "sig": "Duration.as_minutes(span) -> int",
      "kind": "namespace-method",
      "category": "duration",
      "section": "Duration",
      "tip": "The span in whole minutes.",
      "page": "duration-as_minutes.html"
    },
    "duration-as_hours": {
      "id": "duration-as_hours",
      "name": "Duration.as_hours",
      "sig": "Duration.as_hours(span) -> int",
      "kind": "namespace-method",
      "category": "duration",
      "section": "Duration",
      "tip": "The span in whole hours.",
      "page": "duration-as_hours.html"
    },
    "duration-as_days": {
      "id": "duration-as_days",
      "name": "Duration.as_days",
      "sig": "Duration.as_days(span) -> int",
      "kind": "namespace-method",
      "category": "duration",
      "section": "Duration",
      "tip": "The span in whole days.",
      "page": "duration-as_days.html"
    },
    "ease-in": {
      "id": "ease-in",
      "name": "Ease.in",
      "sig": "Ease.in(t) -> fixed",
      "kind": "namespace-method",
      "category": "ease",
      "section": "Ease",
      "tip": "Accelerate from rest (quadratic ease-in).",
      "page": "ease-in.html"
    },
    "ease-out": {
      "id": "ease-out",
      "name": "Ease.out",
      "sig": "Ease.out(t) -> fixed",
      "kind": "namespace-method",
      "category": "ease",
      "section": "Ease",
      "tip": "Decelerate to rest (quadratic ease-out).",
      "page": "ease-out.html"
    },
    "ease-in_out": {
      "id": "ease-in_out",
      "name": "Ease.in_out",
      "sig": "Ease.in_out(t) -> fixed",
      "kind": "namespace-method",
      "category": "ease",
      "section": "Ease",
      "tip": "Ease in and then out (smoothstep).",
      "page": "ease-in_out.html"
    },
    "ease-back": {
      "id": "ease-back",
      "name": "Ease.back",
      "sig": "Ease.back(t) -> fixed",
      "kind": "namespace-method",
      "category": "ease",
      "section": "Ease",
      "tip": "Ease in with a small backward anticipation.",
      "page": "ease-back.html"
    },
    "ease-bounce": {
      "id": "ease-bounce",
      "name": "Ease.bounce",
      "sig": "Ease.bounce(t) -> fixed",
      "kind": "namespace-method",
      "category": "ease",
      "section": "Ease",
      "tip": "Ease out with a settling bounce.",
      "page": "ease-bounce.html"
    },
    "ease-elastic": {
      "id": "ease-elastic",
      "name": "Ease.elastic",
      "sig": "Ease.elastic(t) -> fixed",
      "kind": "namespace-method",
      "category": "ease",
      "section": "Ease",
      "tip": "Ease out with a springy wobble.",
      "page": "ease-elastic.html"
    },
    "fs-exists": {
      "id": "fs-exists",
      "name": "Fs.exists",
      "sig": "Fs.exists(p) -> bool",
      "kind": "namespace-method",
      "category": "fs",
      "section": "Fs",
      "tip": "Does a path exist?",
      "page": "fs-exists.html"
    },
    "fs-is_dir": {
      "id": "fs-is_dir",
      "name": "Fs.is_dir",
      "sig": "Fs.is_dir(p) -> bool",
      "kind": "namespace-method",
      "category": "fs",
      "section": "Fs",
      "tip": "Is a path a directory?",
      "page": "fs-is_dir.html"
    },
    "fs-read_text": {
      "id": "fs-read_text",
      "name": "Fs.read_text",
      "sig": "Fs.read_text(p) -> string",
      "kind": "namespace-method",
      "category": "fs",
      "section": "Fs",
      "tip": "Read a whole file as a string.",
      "page": "fs-read_text.html"
    },
    "fs-write_text": {
      "id": "fs-write_text",
      "name": "Fs.write_text",
      "sig": "Fs.write_text(p, s) -> bool",
      "kind": "namespace-method",
      "category": "fs",
      "section": "Fs",
      "tip": "Write a string to a file (atomically).",
      "page": "fs-write_text.html"
    },
    "fs-append_text": {
      "id": "fs-append_text",
      "name": "Fs.append_text",
      "sig": "Fs.append_text(p, s) -> bool",
      "kind": "namespace-method",
      "category": "fs",
      "section": "Fs",
      "tip": "Append a string to a file.",
      "page": "fs-append_text.html"
    },
    "fs-remove": {
      "id": "fs-remove",
      "name": "Fs.remove",
      "sig": "Fs.remove(p) -> bool",
      "kind": "namespace-method",
      "category": "fs",
      "section": "Fs",
      "tip": "Delete a file.",
      "page": "fs-remove.html"
    },
    "fs-size": {
      "id": "fs-size",
      "name": "Fs.size",
      "sig": "Fs.size(p) -> int",
      "kind": "namespace-method",
      "category": "fs",
      "section": "Fs",
      "tip": "File size in bytes.",
      "page": "fs-size.html"
    },
    "fs-mkdir": {
      "id": "fs-mkdir",
      "name": "Fs.mkdir",
      "sig": "Fs.mkdir(p) -> bool",
      "kind": "namespace-method",
      "category": "fs",
      "section": "Fs",
      "tip": "Create a directory and its parents.",
      "page": "fs-mkdir.html"
    },
    "fs-copy": {
      "id": "fs-copy",
      "name": "Fs.copy",
      "sig": "Fs.copy(src, dst) -> bool",
      "kind": "namespace-method",
      "category": "fs",
      "section": "Fs",
      "tip": "Copy a file byte-for-byte.",
      "page": "fs-copy.html"
    },
    "fs-list": {
      "id": "fs-list",
      "name": "Fs.list",
      "sig": "Fs.list(dir) -> []string",
      "kind": "namespace-method",
      "category": "fs",
      "section": "Fs",
      "tip": "Directory entries, sorted.",
      "page": "fs-list.html"
    },
    "hash-of": {
      "id": "hash-of",
      "name": "Hash.of",
      "sig": "Hash.of(s) -> int",
      "kind": "namespace-method",
      "category": "hash",
      "section": "Hash",
      "tip": "The fast default string hash.",
      "page": "hash-of.html"
    },
    "hash-fnv1a": {
      "id": "hash-fnv1a",
      "name": "Hash.fnv1a",
      "sig": "Hash.fnv1a(s) -> int",
      "kind": "namespace-method",
      "category": "hash",
      "section": "Hash",
      "tip": "FNV-1a 32-bit, named explicitly.",
      "page": "hash-fnv1a.html"
    },
    "hash-crc32": {
      "id": "hash-crc32",
      "name": "Hash.crc32",
      "sig": "Hash.crc32(s) -> int",
      "kind": "namespace-method",
      "category": "hash",
      "section": "Hash",
      "tip": "CRC-32 checksum for corruption detection.",
      "page": "hash-crc32.html"
    },
    "hash-mix": {
      "id": "hash-mix",
      "name": "Hash.mix",
      "sig": "Hash.mix(x) -> int",
      "kind": "namespace-method",
      "category": "hash",
      "section": "Hash",
      "tip": "Avalanche one integer into a well-scrambled value.",
      "page": "hash-mix.html"
    },
    "hash-combine": {
      "id": "hash-combine",
      "name": "Hash.combine",
      "sig": "Hash.combine(...) -> int",
      "kind": "namespace-method",
      "category": "hash",
      "section": "Hash",
      "tip": "Fold several ints into one deterministic seed.",
      "page": "hash-combine.html"
    },
    "hash-of64": {
      "id": "hash-of64",
      "name": "Hash.of64",
      "sig": "Hash.of64(s) -> long",
      "kind": "namespace-method",
      "category": "hash",
      "section": "Hash",
      "tip": "The fast default 64-bit string hash.",
      "page": "hash-of64.html"
    },
    "hash-fnv1a_64": {
      "id": "hash-fnv1a_64",
      "name": "Hash.fnv1a_64",
      "sig": "Hash.fnv1a_64(s) -> long",
      "kind": "namespace-method",
      "category": "hash",
      "section": "Hash",
      "tip": "FNV-1a 64-bit, named explicitly.",
      "page": "hash-fnv1a_64.html"
    },
    "hash-mix64": {
      "id": "hash-mix64",
      "name": "Hash.mix64",
      "sig": "Hash.mix64(x) -> long",
      "kind": "namespace-method",
      "category": "hash",
      "section": "Hash",
      "tip": "Avalanche one 64-bit integer into a well-scrambled value.",
      "page": "hash-mix64.html"
    },
    "input-key": {
      "id": "input-key",
      "name": "Input.key",
      "sig": "Input.key() -> int",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "The key pressed this frame as a character code (0 when nothing is pressed).",
      "page": "input-key.html"
    },
    "input-bind": {
      "id": "input-bind",
      "name": "Input.bind",
      "sig": "Input.bind(action: str, key: int) -> void",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Bind a physical key to a named action, so gameplay reads the action, not the key.",
      "page": "input-bind.html"
    },
    "input-rebind": {
      "id": "input-rebind",
      "name": "Input.rebind",
      "sig": "Input.rebind(action: str, from: int, to: int) -> void",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Remap an action from one key to another at runtime (rebinding menus).",
      "page": "input-rebind.html"
    },
    "input-poll": {
      "id": "input-poll",
      "name": "Input.poll",
      "sig": "Input.poll() -> int",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Advance one frame of input; the single per-frame read behind actions and replay.",
      "page": "input-poll.html"
    },
    "input-down": {
      "id": "input-down",
      "name": "Input.down",
      "sig": "Input.down(action: str) -> bool",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Is a named action held on the frame last polled?",
      "page": "input-down.html"
    },
    "input-pressed": {
      "id": "input-pressed",
      "name": "Input.pressed",
      "sig": "Input.pressed(action: str) -> bool",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Did a named action go down this frame (a one-shot edge)?",
      "page": "input-pressed.html"
    },
    "input-record": {
      "id": "input-record",
      "name": "Input.record",
      "sig": "Input.record() -> void",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Start recording polled input each frame (for deterministic replay).",
      "page": "input-record.html"
    },
    "input-replay": {
      "id": "input-replay",
      "name": "Input.replay",
      "sig": "Input.replay() -> void",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Replay recorded input; poll then reads the tape, not the device.",
      "page": "input-replay.html"
    },
    "input-key_down": {
      "id": "input-key_down",
      "name": "Input.key_down",
      "sig": "Input.key_down(key) -> bool",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Is a physical key held this frame?",
      "page": "input-key_down.html"
    },
    "input-key_pressed": {
      "id": "input-key_pressed",
      "name": "Input.key_pressed",
      "sig": "Input.key_pressed(key) -> bool",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Did a key go down this frame (edge)?",
      "page": "input-key_pressed.html"
    },
    "input-key_released": {
      "id": "input-key_released",
      "name": "Input.key_released",
      "sig": "Input.key_released(key) -> bool",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Did a key go up this frame (edge)?",
      "page": "input-key_released.html"
    },
    "input-key_label": {
      "id": "input-key_label",
      "name": "Input.key_label",
      "sig": "Input.key_label(key) -> string",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "The name to show a player for a key - in their own keyboard layout.",
      "page": "input-key_label.html"
    },
    "input-press": {
      "id": "input-press",
      "name": "Input.press",
      "sig": "Input.press(key)",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Inject a held key (AI, tutorial, testing, network).",
      "page": "input-press.html"
    },
    "input-release": {
      "id": "input-release",
      "name": "Input.release",
      "sig": "Input.release(key)",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Release an injected key.",
      "page": "input-release.html"
    },
    "input-axis": {
      "id": "input-axis",
      "name": "Input.axis",
      "sig": "Input.axis(neg, pos) -> fixed",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "A -1..+1 axis from two keys.",
      "page": "input-axis.html"
    },
    "input-axis_i": {
      "id": "input-axis_i",
      "name": "Input.axis_i",
      "sig": "Input.axis_i(neg, pos) -> int",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "A -1/0/1 directional intent as a plain int, no bool->int glue.",
      "page": "input-axis_i.html"
    },
    "input-vector": {
      "id": "input-vector",
      "name": "Input.vector",
      "sig": "Input.vector(left, right, up, down) -> Vector",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "A normalized 2D vector from four keys.",
      "page": "input-vector.html"
    },
    "input-strength": {
      "id": "input-strength",
      "name": "Input.strength",
      "sig": "Input.strength(action) -> fixed",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "0..1 strength of a named action.",
      "page": "input-strength.html"
    },
    "input-mouse_x": {
      "id": "input-mouse_x",
      "name": "Input.mouse_x",
      "sig": "Input.mouse_x() -> int",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "The mouse x position this frame.",
      "page": "input-mouse_x.html"
    },
    "input-mouse_y": {
      "id": "input-mouse_y",
      "name": "Input.mouse_y",
      "sig": "Input.mouse_y() -> int",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "The mouse y position this frame.",
      "page": "input-mouse_y.html"
    },
    "input-mouse_dx": {
      "id": "input-mouse_dx",
      "name": "Input.mouse_dx",
      "sig": "Input.mouse_dx() -> int",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Mouse x movement since the last poll.",
      "page": "input-mouse_dx.html"
    },
    "input-mouse_dy": {
      "id": "input-mouse_dy",
      "name": "Input.mouse_dy",
      "sig": "Input.mouse_dy() -> int",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Mouse y movement since the last poll.",
      "page": "input-mouse_dy.html"
    },
    "input-mouse_down": {
      "id": "input-mouse_down",
      "name": "Input.mouse_down",
      "sig": "Input.mouse_down(button) -> bool",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Is a mouse button held?",
      "page": "input-mouse_down.html"
    },
    "input-wheel": {
      "id": "input-wheel",
      "name": "Input.wheel",
      "sig": "Input.wheel() -> int",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Scroll-wheel delta this frame.",
      "page": "input-wheel.html"
    },
    "input-set_mouse": {
      "id": "input-set_mouse",
      "name": "Input.set_mouse",
      "sig": "Input.set_mouse(x, y, buttons, wheel)",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Inject the mouse state (headless / AI / testing).",
      "page": "input-set_mouse.html"
    },
    "input-pad_connected": {
      "id": "input-pad_connected",
      "name": "Input.pad_connected",
      "sig": "Input.pad_connected(pad) -> bool",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Is a gamepad connected?",
      "page": "input-pad_connected.html"
    },
    "input-pad_button": {
      "id": "input-pad_button",
      "name": "Input.pad_button",
      "sig": "Input.pad_button(pad, button) -> bool",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Is a gamepad button held?",
      "page": "input-pad_button.html"
    },
    "input-pad_axis": {
      "id": "input-pad_axis",
      "name": "Input.pad_axis",
      "sig": "Input.pad_axis(pad, axis) -> fixed",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "A gamepad analog axis, -1..+1.",
      "page": "input-pad_axis.html"
    },
    "input-set_pad": {
      "id": "input-set_pad",
      "name": "Input.set_pad",
      "sig": "Input.set_pad(pad, connected, buttons, lx, ly, rx, ry)",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Inject a gamepad's whole state.",
      "page": "input-set_pad.html"
    },
    "input-touch_count": {
      "id": "input-touch_count",
      "name": "Input.touch_count",
      "sig": "Input.touch_count() -> int",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "How many touch points are active?",
      "page": "input-touch_count.html"
    },
    "input-touch_x": {
      "id": "input-touch_x",
      "name": "Input.touch_x",
      "sig": "Input.touch_x(index) -> int",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "The x of a touch point.",
      "page": "input-touch_x.html"
    },
    "input-touch_y": {
      "id": "input-touch_y",
      "name": "Input.touch_y",
      "sig": "Input.touch_y(index) -> int",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "The y of a touch point.",
      "page": "input-touch_y.html"
    },
    "input-set_touch": {
      "id": "input-set_touch",
      "name": "Input.set_touch",
      "sig": "Input.set_touch(index, x, y, active)",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Inject a touch point.",
      "page": "input-set_touch.html"
    },
    "input-action": {
      "id": "input-action",
      "name": "Input.action",
      "sig": "Input.action(action: str, key: int) -> void",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Register a default key binding for an action (kept if already bound).",
      "page": "input-action.html"
    },
    "input-bind_pad": {
      "id": "input-bind_pad",
      "name": "Input.bind_pad",
      "sig": "Input.bind_pad(action: str, button: int) -> void",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Also fire a named action from a gamepad button (device-agnostic).",
      "page": "input-bind_pad.html"
    },
    "input-active": {
      "id": "input-active",
      "name": "Input.active",
      "sig": "Input.active(action: str) -> bool",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Is a named action active right now (any bound key held, or pad button down)?",
      "page": "input-active.html"
    },
    "input-just_pressed": {
      "id": "input-just_pressed",
      "name": "Input.just_pressed",
      "sig": "Input.just_pressed(action: str) -> bool",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Did a named action go active this frame (the deterministic on-press)?",
      "page": "input-just_pressed.html"
    },
    "input-just_released": {
      "id": "input-just_released",
      "name": "Input.just_released",
      "sig": "Input.just_released(action: str) -> bool",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Did a named action go inactive this frame (the on-release edge)?",
      "page": "input-just_released.html"
    },
    "input-cursor_mode": {
      "id": "input-cursor_mode",
      "name": "Input.cursor_mode",
      "sig": "Input.cursor_mode(mode)",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "Hide / lock / confine the OS mouse cursor to the window (windowed).",
      "page": "input-cursor_mode.html"
    },
    "input-move_i": {
      "id": "input-move_i",
      "name": "Input.move_i",
      "sig": "Input.move_i() -> IVec2",
      "kind": "namespace-method",
      "category": "input",
      "section": "Input",
      "tip": "The standard top-down movement intent, -1/0/1 per axis.",
      "page": "input-move_i.html"
    },
    "list-len": {
      "id": "list-len",
      "name": "List.len",
      "sig": "List.len(s) -> int",
      "kind": "namespace-method",
      "category": "list",
      "section": "List",
      "tip": "The number of elements in a slice.",
      "page": "list-len.html"
    },
    "list-push": {
      "id": "list-push",
      "name": "List.push",
      "sig": "List.push(s, v) -> void",
      "kind": "namespace-method",
      "category": "list",
      "section": "List",
      "tip": "Append an element to the end of a slice.",
      "page": "list-push.html"
    },
    "list-clear": {
      "id": "list-clear",
      "name": "List.clear",
      "sig": "List.clear(s) -> void",
      "kind": "namespace-method",
      "category": "list",
      "section": "List",
      "tip": "Remove all elements, keeping capacity.",
      "page": "list-clear.html"
    },
    "list-first": {
      "id": "list-first",
      "name": "List.first",
      "sig": "List.first(s) -> T",
      "kind": "namespace-method",
      "category": "list",
      "section": "List",
      "tip": "The first element of a slice.",
      "page": "list-first.html"
    },
    "list-last": {
      "id": "list-last",
      "name": "List.last",
      "sig": "List.last(s) -> T",
      "kind": "namespace-method",
      "category": "list",
      "section": "List",
      "tip": "The last element of a slice.",
      "page": "list-last.html"
    },
    "list-pop": {
      "id": "list-pop",
      "name": "List.pop",
      "sig": "List.pop(s) -> T",
      "kind": "namespace-method",
      "category": "list",
      "section": "List",
      "tip": "Remove and return the last element.",
      "page": "list-pop.html"
    },
    "list-swap": {
      "id": "list-swap",
      "name": "List.swap",
      "sig": "List.swap(s, i, j) -> void",
      "kind": "namespace-method",
      "category": "list",
      "section": "List",
      "tip": "Exchange the elements at two indices.",
      "page": "list-swap.html"
    },
    "list-contains": {
      "id": "list-contains",
      "name": "List.contains",
      "sig": "List.contains(s, v) -> bool",
      "kind": "namespace-method",
      "category": "list",
      "section": "List",
      "tip": "Whether a value appears in a slice.",
      "page": "list-contains.html"
    },
    "list-index_of": {
      "id": "list-index_of",
      "name": "List.index_of",
      "sig": "List.index_of(s, v) -> int",
      "kind": "namespace-method",
      "category": "list",
      "section": "List",
      "tip": "The index of a value in a slice, or -1 if absent.",
      "page": "list-index_of.html"
    },
    "list-reverse": {
      "id": "list-reverse",
      "name": "List.reverse",
      "sig": "List.reverse(s) -> void",
      "kind": "namespace-method",
      "category": "list",
      "section": "List",
      "tip": "Reverse the order of a slice in place.",
      "page": "list-reverse.html"
    },
    "list-insert": {
      "id": "list-insert",
      "name": "List.insert",
      "sig": "List.insert(s, i, v) -> void",
      "kind": "namespace-method",
      "category": "list",
      "section": "List",
      "tip": "Insert an element at an index, shifting the rest up.",
      "page": "list-insert.html"
    },
    "list-remove_at": {
      "id": "list-remove_at",
      "name": "List.remove_at",
      "sig": "List.remove_at(s, i) -> void",
      "kind": "namespace-method",
      "category": "list",
      "section": "List",
      "tip": "Remove the element at an index, shifting the rest down.",
      "page": "list-remove_at.html"
    },
    "list-remove": {
      "id": "list-remove",
      "name": "List.remove",
      "sig": "List.remove(s, v) -> void",
      "kind": "namespace-method",
      "category": "list",
      "section": "List",
      "tip": "Remove the first element equal to a value.",
      "page": "list-remove.html"
    },
    "list-sort": {
      "id": "list-sort",
      "name": "List.sort",
      "sig": "List.sort(s) -> void",
      "kind": "namespace-method",
      "category": "list",
      "section": "List",
      "tip": "Sort a slice in ascending order, in place.",
      "page": "list-sort.html"
    },
    "list-sort_by": {
      "id": "list-sort_by",
      "name": "List.sort_by",
      "sig": "List.sort_by(s, key) -> void",
      "kind": "namespace-method",
      "category": "list",
      "section": "List",
      "tip": "Sort a slice ascending by a key each element maps to.",
      "page": "list-sort_by.html"
    },
    "list-sort_desc_by": {
      "id": "list-sort_desc_by",
      "name": "List.sort_desc_by",
      "sig": "List.sort_desc_by(s, key) -> void",
      "kind": "namespace-method",
      "category": "list",
      "section": "List",
      "tip": "Sort a slice descending by a key each element maps to.",
      "page": "list-sort_desc_by.html"
    },
    "list-sort_with": {
      "id": "list-sort_with",
      "name": "List.sort_with",
      "sig": "List.sort_with(s, cmp) -> void",
      "kind": "namespace-method",
      "category": "list",
      "section": "List",
      "tip": "Sort a slice with a full two-argument comparator.",
      "page": "list-sort_with.html"
    },
    "list-sample": {
      "id": "list-sample",
      "name": "List.sample",
      "sig": "List.sample(pool, count) -> []int",
      "kind": "namespace-method",
      "category": "list",
      "section": "List",
      "tip": "Random picks from an int slice, distinct while it can.",
      "page": "list-sample.html"
    },
    "log-trace": {
      "id": "log-trace",
      "name": "Log.trace",
      "sig": "Log.trace(msg, [key, value]...) -> void",
      "kind": "namespace-method",
      "category": "log",
      "section": "Log",
      "tip": "Log at the trace level (0) — the most verbose.",
      "page": "log-trace.html"
    },
    "log-debug": {
      "id": "log-debug",
      "name": "Log.debug",
      "sig": "Log.debug(msg, [key, value]...) -> void",
      "kind": "namespace-method",
      "category": "log",
      "section": "Log",
      "tip": "Log at the debug level (1) — development detail.",
      "page": "log-debug.html"
    },
    "log-info": {
      "id": "log-info",
      "name": "Log.info",
      "sig": "Log.info(msg, [key, value]...) -> void",
      "kind": "namespace-method",
      "category": "log",
      "section": "Log",
      "tip": "Log at the info level (2) — normal operation.",
      "page": "log-info.html"
    },
    "log-warn": {
      "id": "log-warn",
      "name": "Log.warn",
      "sig": "Log.warn(msg, [key, value]...) -> void",
      "kind": "namespace-method",
      "category": "log",
      "section": "Log",
      "tip": "Log at the warn level (3) — something looks wrong.",
      "page": "log-warn.html"
    },
    "log-error": {
      "id": "log-error",
      "name": "Log.error",
      "sig": "Log.error(msg, [key, value]...) -> void",
      "kind": "namespace-method",
      "category": "log",
      "section": "Log",
      "tip": "Log at the error level (4) — a failure.",
      "page": "log-error.html"
    },
    "log-set_level": {
      "id": "log-set_level",
      "name": "Log.set_level",
      "sig": "Log.set_level(n) -> void",
      "kind": "namespace-method",
      "category": "log",
      "section": "Log",
      "tip": "Show only messages at level n or above (0 = all).",
      "page": "log-set_level.html"
    },
    "log-level": {
      "id": "log-level",
      "name": "Log.level",
      "sig": "Log.level() -> int",
      "kind": "namespace-method",
      "category": "log",
      "section": "Log",
      "tip": "The current logging threshold.",
      "page": "log-level.html"
    },
    "math-min": {
      "id": "math-min",
      "name": "Math.min",
      "sig": "Math.min(a, b) -> int",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "The smaller of two values.",
      "page": "math-min.html"
    },
    "math-max": {
      "id": "math-max",
      "name": "Math.max",
      "sig": "Math.max(a, b) -> int",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "The larger of two values.",
      "page": "math-max.html"
    },
    "math-abs": {
      "id": "math-abs",
      "name": "Math.abs",
      "sig": "Math.abs(x) -> int",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "The magnitude of a value, dropping its sign.",
      "page": "math-abs.html"
    },
    "math-clamp": {
      "id": "math-clamp",
      "name": "Math.clamp",
      "sig": "Math.clamp(v, lo, hi) -> int",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Constrain a value to the range [lo, hi].",
      "page": "math-clamp.html"
    },
    "math-sign": {
      "id": "math-sign",
      "name": "Math.sign",
      "sig": "Math.sign(x) -> int",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "The sign of a value as -1, 0, or 1.",
      "page": "math-sign.html"
    },
    "math-floor": {
      "id": "math-floor",
      "name": "Math.floor",
      "sig": "Math.floor(x) -> int",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Round a fixed value down to the nearest whole int.",
      "page": "math-floor.html"
    },
    "math-ceil": {
      "id": "math-ceil",
      "name": "Math.ceil",
      "sig": "Math.ceil(x) -> int",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Round a fixed value up to the nearest whole int.",
      "page": "math-ceil.html"
    },
    "math-round": {
      "id": "math-round",
      "name": "Math.round",
      "sig": "Math.round(x) -> int",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Round a fixed value to the nearest whole int.",
      "page": "math-round.html"
    },
    "math-lerp": {
      "id": "math-lerp",
      "name": "Math.lerp",
      "sig": "Math.lerp(a, b, t) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Blend between two values by a 0..1 amount.",
      "page": "math-lerp.html"
    },
    "math-inverse_lerp": {
      "id": "math-inverse_lerp",
      "name": "Math.inverse_lerp",
      "sig": "Math.inverse_lerp(a, b, v) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Find where a value sits between two endpoints as a 0..1 fraction.",
      "page": "math-inverse_lerp.html"
    },
    "math-remap": {
      "id": "math-remap",
      "name": "Math.remap",
      "sig": "Math.remap(v, in0, in1, out0, out1) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Rescale a value from one range into another.",
      "page": "math-remap.html"
    },
    "math-sqrt": {
      "id": "math-sqrt",
      "name": "Math.sqrt",
      "sig": "Math.sqrt(x) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "The square root of a fixed value.",
      "page": "math-sqrt.html"
    },
    "math-sin": {
      "id": "math-sin",
      "name": "Math.sin",
      "sig": "Math.sin(radians) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Sine of an angle in radians.",
      "page": "math-sin.html"
    },
    "math-cos": {
      "id": "math-cos",
      "name": "Math.cos",
      "sig": "Math.cos(radians) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Cosine of an angle in radians.",
      "page": "math-cos.html"
    },
    "math-tan": {
      "id": "math-tan",
      "name": "Math.tan",
      "sig": "Math.tan(radians) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Tangent of an angle in radians.",
      "page": "math-tan.html"
    },
    "math-hypot": {
      "id": "math-hypot",
      "name": "Math.hypot",
      "sig": "Math.hypot(x, y) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Length of the vector (x, y).",
      "page": "math-hypot.html"
    },
    "math-dist": {
      "id": "math-dist",
      "name": "Math.dist",
      "sig": "Math.dist(x0, y0, x1, y1) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Distance between two points.",
      "page": "math-dist.html"
    },
    "math-dist2": {
      "id": "math-dist2",
      "name": "Math.dist2",
      "sig": "Math.dist2(x0, y0, x1, y1) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Squared distance between two points.",
      "page": "math-dist2.html"
    },
    "math-deg_to_rad": {
      "id": "math-deg_to_rad",
      "name": "Math.deg_to_rad",
      "sig": "Math.deg_to_rad(degrees) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Convert degrees to radians.",
      "page": "math-deg_to_rad.html"
    },
    "math-rad_to_deg": {
      "id": "math-rad_to_deg",
      "name": "Math.rad_to_deg",
      "sig": "Math.rad_to_deg(radians) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Convert radians to degrees.",
      "page": "math-rad_to_deg.html"
    },
    "math-posmod": {
      "id": "math-posmod",
      "name": "Math.posmod",
      "sig": "Math.posmod(a, m) -> int",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Modulo that is always non-negative.",
      "page": "math-posmod.html"
    },
    "math-wrap": {
      "id": "math-wrap",
      "name": "Math.wrap",
      "sig": "Math.wrap(v, lo, hi) -> int",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Wrap a value into the range [lo, hi).",
      "page": "math-wrap.html"
    },
    "math-ping_pong": {
      "id": "math-ping_pong",
      "name": "Math.ping_pong",
      "sig": "Math.ping_pong(t, len) -> int",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Bounce a counter back and forth in [0, len].",
      "page": "math-ping_pong.html"
    },
    "math-snapped": {
      "id": "math-snapped",
      "name": "Math.snapped",
      "sig": "Math.snapped(v, step) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Round a value to the nearest multiple of step.",
      "page": "math-snapped.html"
    },
    "math-move_toward": {
      "id": "math-move_toward",
      "name": "Math.move_toward",
      "sig": "Math.move_toward(from, to, delta) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "Step from one value toward another by at most delta.",
      "page": "math-move_toward.html"
    },
    "math-smoothstep": {
      "id": "math-smoothstep",
      "name": "Math.smoothstep",
      "sig": "Math.smoothstep(e0, e1, x) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "A smooth 0..1 ramp between two edges.",
      "page": "math-smoothstep.html"
    },
    "math-atan2": {
      "id": "math-atan2",
      "name": "Math.atan2",
      "sig": "Math.atan2(y, x) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "The angle of the vector (x, y), in radians.",
      "page": "math-atan2.html"
    },
    "math-asin": {
      "id": "math-asin",
      "name": "Math.asin",
      "sig": "Math.asin(x) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "The arcsine of a value, in radians.",
      "page": "math-asin.html"
    },
    "math-acos": {
      "id": "math-acos",
      "name": "Math.acos",
      "sig": "Math.acos(x) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "The arccosine of a value, in radians.",
      "page": "math-acos.html"
    },
    "math-exp": {
      "id": "math-exp",
      "name": "Math.exp",
      "sig": "Math.exp(x) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "e raised to the power x.",
      "page": "math-exp.html"
    },
    "math-log": {
      "id": "math-log",
      "name": "Math.log",
      "sig": "Math.log(x) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "The natural logarithm of x.",
      "page": "math-log.html"
    },
    "math-pow": {
      "id": "math-pow",
      "name": "Math.pow",
      "sig": "Math.pow(base, exp) -> fixed",
      "kind": "namespace-method",
      "category": "math",
      "section": "Math",
      "tip": "base raised to a fixed exponent.",
      "page": "math-pow.html"
    },
    "memory-bytes": {
      "id": "memory-bytes",
      "name": "Memory.bytes",
      "sig": "Memory.bytes(n) -> pointer",
      "kind": "namespace-method",
      "category": "memory",
      "section": "Memory",
      "tip": "Allocate n bytes.",
      "page": "memory-bytes.html"
    },
    "memory-words": {
      "id": "memory-words",
      "name": "Memory.words",
      "sig": "Memory.words(n) -> words",
      "kind": "namespace-method",
      "category": "memory",
      "section": "Memory",
      "tip": "Allocate n 32-bit words.",
      "page": "memory-words.html"
    },
    "memory-copy": {
      "id": "memory-copy",
      "name": "Memory.copy",
      "sig": "Memory.copy(dst, src, n) -> void",
      "kind": "namespace-method",
      "category": "memory",
      "section": "Memory",
      "tip": "Copy n bytes between buffers.",
      "page": "memory-copy.html"
    },
    "memory-fill": {
      "id": "memory-fill",
      "name": "Memory.fill",
      "sig": "Memory.fill(buf, value, n) -> void",
      "kind": "namespace-method",
      "category": "memory",
      "section": "Memory",
      "tip": "Set n bytes to a value.",
      "page": "memory-fill.html"
    },
    "memory-peek": {
      "id": "memory-peek",
      "name": "Memory.peek",
      "sig": "Memory.peek(buf, i) -> int",
      "kind": "namespace-method",
      "category": "memory",
      "section": "Memory",
      "tip": "Read one byte.",
      "page": "memory-peek.html"
    },
    "memory-poke": {
      "id": "memory-poke",
      "name": "Memory.poke",
      "sig": "Memory.poke(buf, i, value) -> void",
      "kind": "namespace-method",
      "category": "memory",
      "section": "Memory",
      "tip": "Write one byte.",
      "page": "memory-poke.html"
    },
    "mime-of": {
      "id": "mime-of",
      "name": "Mime.of",
      "sig": "Mime.of(path) -> string",
      "kind": "namespace-method",
      "category": "mime",
      "section": "Mime",
      "tip": "MIME type from a file extension.",
      "page": "mime-of.html"
    },
    "mime-sniff": {
      "id": "mime-sniff",
      "name": "Mime.sniff",
      "sig": "Mime.sniff(path) -> string",
      "kind": "namespace-method",
      "category": "mime",
      "section": "Mime",
      "tip": "MIME type refined by magic bytes.",
      "page": "mime-sniff.html"
    },
    "network-send": {
      "id": "network-send",
      "name": "Network.send",
      "sig": "Network.send(peer, buf, len) -> void",
      "kind": "namespace-method",
      "category": "network",
      "section": "Network",
      "tip": "Put a datagram on the wire.",
      "page": "network-send.html"
    },
    "network-poll": {
      "id": "network-poll",
      "name": "Network.poll",
      "sig": "Network.poll(buf, cap) -> int",
      "kind": "namespace-method",
      "category": "network",
      "section": "Network",
      "tip": "Read an inbound datagram.",
      "page": "network-poll.html"
    },
    "network-serialize": {
      "id": "network-serialize",
      "name": "Network.serialize",
      "sig": "Network.serialize(entity, buf) -> int",
      "kind": "namespace-method",
      "category": "network",
      "section": "Network",
      "tip": "Serialize an entity's synced state.",
      "page": "network-serialize.html"
    },
    "network-apply": {
      "id": "network-apply",
      "name": "Network.apply",
      "sig": "Network.apply(entity, buf) -> int",
      "kind": "namespace-method",
      "category": "network",
      "section": "Network",
      "tip": "Apply serialized state to an entity.",
      "page": "network-apply.html"
    },
    "network-owner": {
      "id": "network-owner",
      "name": "Network.owner",
      "sig": "Network.owner(entity) -> int",
      "kind": "namespace-method",
      "category": "network",
      "section": "Network",
      "tip": "The peer that owns an entity.",
      "page": "network-owner.html"
    },
    "network-set_owner": {
      "id": "network-set_owner",
      "name": "Network.set_owner",
      "sig": "Network.set_owner(entity, peer) -> void",
      "kind": "namespace-method",
      "category": "network",
      "section": "Network",
      "tip": "Assign ownership of an entity.",
      "page": "network-set_owner.html"
    },
    "network-is_server": {
      "id": "network-is_server",
      "name": "Network.is_server",
      "sig": "Network.is_server() -> bool",
      "kind": "namespace-method",
      "category": "network",
      "section": "Network",
      "tip": "Is this peer the server?",
      "page": "network-is_server.html"
    },
    "network-is_owner": {
      "id": "network-is_owner",
      "name": "Network.is_owner",
      "sig": "Network.is_owner(entity) -> bool",
      "kind": "namespace-method",
      "category": "network",
      "section": "Network",
      "tip": "Does this peer own the entity?",
      "page": "network-is_owner.html"
    },
    "network-local_id": {
      "id": "network-local_id",
      "name": "Network.local_id",
      "sig": "Network.local_id() -> int",
      "kind": "namespace-method",
      "category": "network",
      "section": "Network",
      "tip": "This peer's own id.",
      "page": "network-local_id.html"
    },
    "noise-value2": {
      "id": "noise-value2",
      "name": "Noise.value2",
      "sig": "Noise.value2(x, y, seed) -> fixed",
      "kind": "namespace-method",
      "category": "noise",
      "section": "Noise",
      "tip": "2D value (lattice) noise, deterministic, in [-1, 1].",
      "page": "noise-value2.html"
    },
    "noise-perlin2": {
      "id": "noise-perlin2",
      "name": "Noise.perlin2",
      "sig": "Noise.perlin2(x, y, seed) -> fixed",
      "kind": "namespace-method",
      "category": "noise",
      "section": "Noise",
      "tip": "2D Perlin gradient noise, deterministic, in [-1, 1].",
      "page": "noise-perlin2.html"
    },
    "noise-simplex2": {
      "id": "noise-simplex2",
      "name": "Noise.simplex2",
      "sig": "Noise.simplex2(x, y, seed) -> fixed",
      "kind": "namespace-method",
      "category": "noise",
      "section": "Noise",
      "tip": "2D simplex noise, the organic default, in [-1, 1].",
      "page": "noise-simplex2.html"
    },
    "noise-fbm2": {
      "id": "noise-fbm2",
      "name": "Noise.fbm2",
      "sig": "Noise.fbm2(x, y, seed, octaves) -> fixed",
      "kind": "namespace-method",
      "category": "noise",
      "section": "Noise",
      "tip": "Fractal Brownian motion — octaves of simplex, in [-1, 1].",
      "page": "noise-fbm2.html"
    },
    "noise-cellular2": {
      "id": "noise-cellular2",
      "name": "Noise.cellular2",
      "sig": "Noise.cellular2(x, y, seed) -> fixed",
      "kind": "namespace-method",
      "category": "noise",
      "section": "Noise",
      "tip": "Worley (cellular) F1 distance to the nearest cell point.",
      "page": "noise-cellular2.html"
    },
    "noise-cellular2_id": {
      "id": "noise-cellular2_id",
      "name": "Noise.cellular2_id",
      "sig": "Noise.cellular2_id(x, y, seed) -> int",
      "kind": "namespace-method",
      "category": "noise",
      "section": "Noise",
      "tip": "The id of the nearest Worley cell — stable per cell.",
      "page": "noise-cellular2_id.html"
    },
    "noise-unit": {
      "id": "noise-unit",
      "name": "Noise.unit",
      "sig": "Noise.unit(n) -> fixed",
      "kind": "namespace-method",
      "category": "noise",
      "section": "Noise",
      "tip": "Remap a [-1,1] noise sample to [0,1].",
      "page": "noise-unit.html"
    },
    "os-args": {
      "id": "os-args",
      "name": "Os.args",
      "sig": "Os.args() -> []string",
      "kind": "namespace-method",
      "category": "os",
      "section": "Os",
      "tip": "Every command-line argument, as a list.",
      "page": "os-args.html"
    },
    "os-arg_count": {
      "id": "os-arg_count",
      "name": "Os.arg_count",
      "sig": "Os.arg_count() -> int",
      "kind": "namespace-method",
      "category": "os",
      "section": "Os",
      "tip": "How many command-line arguments there are.",
      "page": "os-arg_count.html"
    },
    "os-arg": {
      "id": "os-arg",
      "name": "Os.arg",
      "sig": "Os.arg(i) -> string",
      "kind": "namespace-method",
      "category": "os",
      "section": "Os",
      "tip": "The i-th command-line argument.",
      "page": "os-arg.html"
    },
    "os-env": {
      "id": "os-env",
      "name": "Os.env",
      "sig": "Os.env(name) -> string",
      "kind": "namespace-method",
      "category": "os",
      "section": "Os",
      "tip": "Read an environment variable (null if unset).",
      "page": "os-env.html"
    },
    "os-env_or": {
      "id": "os-env_or",
      "name": "Os.env_or",
      "sig": "Os.env_or(name, fallback) -> string",
      "kind": "namespace-method",
      "category": "os",
      "section": "Os",
      "tip": "Read an environment variable, or a fallback.",
      "page": "os-env_or.html"
    },
    "os-has_env": {
      "id": "os-has_env",
      "name": "Os.has_env",
      "sig": "Os.has_env(name) -> bool",
      "kind": "namespace-method",
      "category": "os",
      "section": "Os",
      "tip": "Is an environment variable set?",
      "page": "os-has_env.html"
    },
    "os-set_env": {
      "id": "os-set_env",
      "name": "Os.set_env",
      "sig": "Os.set_env(name, value) -> bool",
      "kind": "namespace-method",
      "category": "os",
      "section": "Os",
      "tip": "Set an environment variable.",
      "page": "os-set_env.html"
    },
    "os-unset_env": {
      "id": "os-unset_env",
      "name": "Os.unset_env",
      "sig": "Os.unset_env(name) -> bool",
      "kind": "namespace-method",
      "category": "os",
      "section": "Os",
      "tip": "Remove an environment variable.",
      "page": "os-unset_env.html"
    },
    "os-exit": {
      "id": "os-exit",
      "name": "Os.exit",
      "sig": "Os.exit(code)",
      "kind": "namespace-method",
      "category": "os",
      "section": "Os",
      "tip": "Terminate the process with a status code.",
      "page": "os-exit.html"
    },
    "os-platform": {
      "id": "os-platform",
      "name": "Os.platform",
      "sig": "Os.platform() -> string",
      "kind": "namespace-method",
      "category": "os",
      "section": "Os",
      "tip": "The host platform id.",
      "page": "os-platform.html"
    },
    "os-arch": {
      "id": "os-arch",
      "name": "Os.arch",
      "sig": "Os.arch() -> string",
      "kind": "namespace-method",
      "category": "os",
      "section": "Os",
      "tip": "The host CPU architecture.",
      "page": "os-arch.html"
    },
    "os-stdout_write": {
      "id": "os-stdout_write",
      "name": "Os.stdout_write",
      "sig": "Os.stdout_write(s)",
      "kind": "namespace-method",
      "category": "os",
      "section": "Os",
      "tip": "Write a string to standard output.",
      "page": "os-stdout_write.html"
    },
    "os-stderr_write": {
      "id": "os-stderr_write",
      "name": "Os.stderr_write",
      "sig": "Os.stderr_write(s)",
      "kind": "namespace-method",
      "category": "os",
      "section": "Os",
      "tip": "Write a string to standard error.",
      "page": "os-stderr_write.html"
    },
    "os-save_dir": {
      "id": "os-save_dir",
      "name": "Os.save_dir",
      "sig": "Os.save_dir(app) -> string",
      "kind": "namespace-method",
      "category": "os",
      "section": "Os",
      "tip": "Per-user save directory for an app.",
      "page": "os-save_dir.html"
    },
    "os-config_dir": {
      "id": "os-config_dir",
      "name": "Os.config_dir",
      "sig": "Os.config_dir(app) -> string",
      "kind": "namespace-method",
      "category": "os",
      "section": "Os",
      "tip": "Per-user config directory for an app.",
      "page": "os-config_dir.html"
    },
    "os-cache_dir": {
      "id": "os-cache_dir",
      "name": "Os.cache_dir",
      "sig": "Os.cache_dir(app) -> string",
      "kind": "namespace-method",
      "category": "os",
      "section": "Os",
      "tip": "Per-user cache directory for an app.",
      "page": "os-cache_dir.html"
    },
    "os-temp_dir": {
      "id": "os-temp_dir",
      "name": "Os.temp_dir",
      "sig": "Os.temp_dir() -> string",
      "kind": "namespace-method",
      "category": "os",
      "section": "Os",
      "tip": "The system temporary directory.",
      "page": "os-temp_dir.html"
    },
    "os-pid": {
      "id": "os-pid",
      "name": "Os.pid",
      "sig": "Os.pid() -> int",
      "kind": "namespace-method",
      "category": "os",
      "section": "Os",
      "tip": "This process's id.",
      "page": "os-pid.html"
    },
    "path-join": {
      "id": "path-join",
      "name": "Path.join",
      "sig": "Path.join(a, b) -> string",
      "kind": "namespace-method",
      "category": "path",
      "section": "Path",
      "tip": "Join two path segments with the separator.",
      "page": "path-join.html"
    },
    "path-dir": {
      "id": "path-dir",
      "name": "Path.dir",
      "sig": "Path.dir(p) -> string",
      "kind": "namespace-method",
      "category": "path",
      "section": "Path",
      "tip": "The directory part of a path.",
      "page": "path-dir.html"
    },
    "path-base": {
      "id": "path-base",
      "name": "Path.base",
      "sig": "Path.base(p) -> string",
      "kind": "namespace-method",
      "category": "path",
      "section": "Path",
      "tip": "The final component of a path.",
      "page": "path-base.html"
    },
    "path-ext": {
      "id": "path-ext",
      "name": "Path.ext",
      "sig": "Path.ext(p) -> string",
      "kind": "namespace-method",
      "category": "path",
      "section": "Path",
      "tip": "The file extension, including the dot.",
      "page": "path-ext.html"
    },
    "path-stem": {
      "id": "path-stem",
      "name": "Path.stem",
      "sig": "Path.stem(p) -> string",
      "kind": "namespace-method",
      "category": "path",
      "section": "Path",
      "tip": "The final component without its extension.",
      "page": "path-stem.html"
    },
    "path-normalize": {
      "id": "path-normalize",
      "name": "Path.normalize",
      "sig": "Path.normalize(p) -> string",
      "kind": "namespace-method",
      "category": "path",
      "section": "Path",
      "tip": "Collapse . / .. / duplicate separators.",
      "page": "path-normalize.html"
    },
    "save-write": {
      "id": "save-write",
      "name": "Save.write",
      "sig": "Save.write() -> void",
      "kind": "namespace-method",
      "category": "save",
      "section": "Save",
      "tip": "Save a snapshot of the world.",
      "page": "save-write.html"
    },
    "save-read": {
      "id": "save-read",
      "name": "Save.read",
      "sig": "Save.read() -> bool",
      "kind": "namespace-method",
      "category": "save",
      "section": "Save",
      "tip": "Restore the saved snapshot.",
      "page": "save-read.html"
    },
    "system-run": {
      "id": "system-run",
      "name": "System.run",
      "sig": "System.run(command) -> int",
      "kind": "namespace-method",
      "category": "system",
      "section": "System",
      "tip": "Run a shell command.",
      "page": "system-run.html"
    },
    "system-read_char": {
      "id": "system-read_char",
      "name": "System.read_char",
      "sig": "System.read_char() -> int",
      "kind": "namespace-method",
      "category": "system",
      "section": "System",
      "tip": "Read one byte from standard input.",
      "page": "system-read_char.html"
    },
    "system-file_open": {
      "id": "system-file_open",
      "name": "System.file_open",
      "sig": "System.file_open(path, mode) -> pointer",
      "kind": "namespace-method",
      "category": "system",
      "section": "System",
      "tip": "Open a file.",
      "page": "system-file_open.html"
    },
    "system-file_read": {
      "id": "system-file_read",
      "name": "System.file_read",
      "sig": "System.file_read(file, buf, n) -> int",
      "kind": "namespace-method",
      "category": "system",
      "section": "System",
      "tip": "Read bytes from a file.",
      "page": "system-file_read.html"
    },
    "system-file_write": {
      "id": "system-file_write",
      "name": "System.file_write",
      "sig": "System.file_write(file, buf, n) -> int",
      "kind": "namespace-method",
      "category": "system",
      "section": "System",
      "tip": "Write bytes to a file.",
      "page": "system-file_write.html"
    },
    "system-file_seek": {
      "id": "system-file_seek",
      "name": "System.file_seek",
      "sig": "System.file_seek(file, offset, whence) -> int",
      "kind": "namespace-method",
      "category": "system",
      "section": "System",
      "tip": "Move a file's read/write position.",
      "page": "system-file_seek.html"
    },
    "system-file_tell": {
      "id": "system-file_tell",
      "name": "System.file_tell",
      "sig": "System.file_tell(file) -> int",
      "kind": "namespace-method",
      "category": "system",
      "section": "System",
      "tip": "The current file position.",
      "page": "system-file_tell.html"
    },
    "system-file_close": {
      "id": "system-file_close",
      "name": "System.file_close",
      "sig": "System.file_close(file) -> void",
      "kind": "namespace-method",
      "category": "system",
      "section": "System",
      "tip": "Close a file.",
      "page": "system-file_close.html"
    },
    "text-length": {
      "id": "text-length",
      "name": "Text.length",
      "sig": "Text.length(s) -> int",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "The number of bytes in a string.",
      "page": "text-length.html"
    },
    "text-char_at": {
      "id": "text-char_at",
      "name": "Text.char_at",
      "sig": "Text.char_at(s, i) -> int",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "The byte value at an index, 0..255.",
      "page": "text-char_at.html"
    },
    "text-slice": {
      "id": "text-slice",
      "name": "Text.slice",
      "sig": "Text.slice(s, a, b) -> string",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "A substring covering bytes [a, b).",
      "page": "text-slice.html"
    },
    "text-starts_with": {
      "id": "text-starts_with",
      "name": "Text.starts_with",
      "sig": "Text.starts_with(s, prefix) -> bool",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "Whether a string begins with a given prefix.",
      "page": "text-starts_with.html"
    },
    "text-ends_with": {
      "id": "text-ends_with",
      "name": "Text.ends_with",
      "sig": "Text.ends_with(s, suffix) -> bool",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "Whether a string ends with a given suffix.",
      "page": "text-ends_with.html"
    },
    "text-contains": {
      "id": "text-contains",
      "name": "Text.contains",
      "sig": "Text.contains(s, sub) -> bool",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "Whether a substring appears anywhere in a string.",
      "page": "text-contains.html"
    },
    "text-index_of": {
      "id": "text-index_of",
      "name": "Text.index_of",
      "sig": "Text.index_of(s, sub) -> int",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "The byte index of a substring, or -1 if absent.",
      "page": "text-index_of.html"
    },
    "text-equals": {
      "id": "text-equals",
      "name": "Text.equals",
      "sig": "Text.equals(a, b) -> bool",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "Whether two strings have identical bytes.",
      "page": "text-equals.html"
    },
    "text-concat": {
      "id": "text-concat",
      "name": "Text.concat",
      "sig": "Text.concat(a, b) -> string",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "Join two strings into a new one.",
      "page": "text-concat.html"
    },
    "text-to_int": {
      "id": "text-to_int",
      "name": "Text.to_int",
      "sig": "Text.to_int(s) -> int",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "Parse a leading integer from a string.",
      "page": "text-to_int.html"
    },
    "text-from_int": {
      "id": "text-from_int",
      "name": "Text.from_int",
      "sig": "Text.from_int(n) -> string",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "Render an integer as a string.",
      "page": "text-from_int.html"
    },
    "text-upper": {
      "id": "text-upper",
      "name": "Text.upper",
      "sig": "Text.upper(s) -> string",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "An uppercased copy of a string.",
      "page": "text-upper.html"
    },
    "text-lower": {
      "id": "text-lower",
      "name": "Text.lower",
      "sig": "Text.lower(s) -> string",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "A lowercased copy of a string.",
      "page": "text-lower.html"
    },
    "text-trim": {
      "id": "text-trim",
      "name": "Text.trim",
      "sig": "Text.trim(s) -> string",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "A copy with surrounding whitespace removed.",
      "page": "text-trim.html"
    },
    "text-repeat": {
      "id": "text-repeat",
      "name": "Text.repeat",
      "sig": "Text.repeat(s, n) -> string",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "A string repeated n times.",
      "page": "text-repeat.html"
    },
    "text-pad_left": {
      "id": "text-pad_left",
      "name": "Text.pad_left",
      "sig": "Text.pad_left(s, width) -> string",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "Pad with spaces on the left to a width.",
      "page": "text-pad_left.html"
    },
    "text-pad_right": {
      "id": "text-pad_right",
      "name": "Text.pad_right",
      "sig": "Text.pad_right(s, width) -> string",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "Pad with spaces on the right to a width.",
      "page": "text-pad_right.html"
    },
    "text-split": {
      "id": "text-split",
      "name": "Text.split",
      "sig": "Text.split(s, sep) -> []string",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "Split a string on a separator into a list.",
      "page": "text-split.html"
    },
    "text-join": {
      "id": "text-join",
      "name": "Text.join",
      "sig": "Text.join(parts, sep) -> string",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "Join a list of strings with a separator.",
      "page": "text-join.html"
    },
    "text-replace": {
      "id": "text-replace",
      "name": "Text.replace",
      "sig": "Text.replace(s, from, to) -> string",
      "kind": "namespace-method",
      "category": "text",
      "section": "Text",
      "tip": "Replace every occurrence of a substring.",
      "page": "text-replace.html"
    },
    "time-frame": {
      "id": "time-frame",
      "name": "Time.frame",
      "sig": "Time.frame() -> int",
      "kind": "namespace-method",
      "category": "time",
      "section": "Time",
      "tip": "The number of frames elapsed since start.",
      "page": "time-frame.html"
    },
    "time-delta": {
      "id": "time-delta",
      "name": "Time.delta",
      "sig": "Time.delta() -> fixed",
      "kind": "namespace-method",
      "category": "time",
      "section": "Time",
      "tip": "Seconds per frame (a fixed 1/60).",
      "page": "time-delta.html"
    },
    "time-elapsed": {
      "id": "time-elapsed",
      "name": "Time.elapsed",
      "sig": "Time.elapsed() -> fixed",
      "kind": "namespace-method",
      "category": "time",
      "section": "Time",
      "tip": "Seconds since start (deterministic).",
      "page": "time-elapsed.html"
    },
    "time-now": {
      "id": "time-now",
      "name": "Time.now",
      "sig": "Time.now() -> int",
      "kind": "namespace-method",
      "category": "time",
      "section": "Time",
      "tip": "Wall-clock seconds (non-deterministic).",
      "page": "time-now.html"
    },
    "time-since": {
      "id": "time-since",
      "name": "Time.since",
      "sig": "Time.since(past) -> int",
      "kind": "namespace-method",
      "category": "time",
      "section": "Time",
      "tip": "Seconds elapsed from a past instant to now (non-deterministic).",
      "page": "time-since.html"
    },
    "unicode-len": {
      "id": "unicode-len",
      "name": "Unicode.len",
      "sig": "Unicode.len(s) -> int",
      "kind": "namespace-method",
      "category": "unicode",
      "section": "Unicode",
      "tip": "Number of code points in a string (not bytes).",
      "page": "unicode-len.html"
    },
    "unicode-byte_len": {
      "id": "unicode-byte_len",
      "name": "Unicode.byte_len",
      "sig": "Unicode.byte_len(s) -> int",
      "kind": "namespace-method",
      "category": "unicode",
      "section": "Unicode",
      "tip": "Number of bytes in a string.",
      "page": "unicode-byte_len.html"
    },
    "unicode-is_valid_utf8": {
      "id": "unicode-is_valid_utf8",
      "name": "Unicode.is_valid_utf8",
      "sig": "Unicode.is_valid_utf8(s) -> bool",
      "kind": "namespace-method",
      "category": "unicode",
      "section": "Unicode",
      "tip": "Is a string well-formed UTF-8?",
      "page": "unicode-is_valid_utf8.html"
    },
    "unicode-char_at": {
      "id": "unicode-char_at",
      "name": "Unicode.char_at",
      "sig": "Unicode.char_at(s, i) -> int",
      "kind": "namespace-method",
      "category": "unicode",
      "section": "Unicode",
      "tip": "The i-th code point of a string.",
      "page": "unicode-char_at.html"
    },
    "unicode-chars": {
      "id": "unicode-chars",
      "name": "Unicode.chars",
      "sig": "Unicode.chars(s) -> []int",
      "kind": "namespace-method",
      "category": "unicode",
      "section": "Unicode",
      "tip": "Every code point of a string, in order.",
      "page": "unicode-chars.html"
    },
    "unicode-upper": {
      "id": "unicode-upper",
      "name": "Unicode.upper",
      "sig": "Unicode.upper(s) -> string",
      "kind": "namespace-method",
      "category": "unicode",
      "section": "Unicode",
      "tip": "Uppercase a string.",
      "page": "unicode-upper.html"
    },
    "unicode-lower": {
      "id": "unicode-lower",
      "name": "Unicode.lower",
      "sig": "Unicode.lower(s) -> string",
      "kind": "namespace-method",
      "category": "unicode",
      "section": "Unicode",
      "tip": "Lowercase a string.",
      "page": "unicode-lower.html"
    },
    "unicode-truncate": {
      "id": "unicode-truncate",
      "name": "Unicode.truncate",
      "sig": "Unicode.truncate(s, n) -> string",
      "kind": "namespace-method",
      "category": "unicode",
      "section": "Unicode",
      "tip": "First n code points of a string.",
      "page": "unicode-truncate.html"
    },
    "unicode-grapheme_len": {
      "id": "unicode-grapheme_len",
      "name": "Unicode.grapheme_len",
      "sig": "Unicode.grapheme_len(s) -> int",
      "kind": "namespace-method",
      "category": "unicode",
      "section": "Unicode",
      "tip": "Number of user-perceived characters.",
      "page": "unicode-grapheme_len.html"
    },
    "uuid-new": {
      "id": "uuid-new",
      "name": "Uuid.new",
      "sig": "Uuid.new() -> string",
      "kind": "namespace-method",
      "category": "uuid",
      "section": "Uuid",
      "tip": "A new random (v4) UUID as a canonical 36-char string.",
      "page": "uuid-new.html"
    },
    "uuid-v4": {
      "id": "uuid-v4",
      "name": "Uuid.v4",
      "sig": "Uuid.v4() -> string",
      "kind": "namespace-method",
      "category": "uuid",
      "section": "Uuid",
      "tip": "Explicit alias for Uuid.new — a random (v4) UUID.",
      "page": "uuid-v4.html"
    },
    "uuid-new_v7": {
      "id": "uuid-new_v7",
      "name": "Uuid.new_v7",
      "sig": "Uuid.new_v7() -> string",
      "kind": "namespace-method",
      "category": "uuid",
      "section": "Uuid",
      "tip": "A new time-ordered (v7) UUID; sorts by creation time.",
      "page": "uuid-new_v7.html"
    },
    "uuid-v7": {
      "id": "uuid-v7",
      "name": "Uuid.v7",
      "sig": "Uuid.v7() -> string",
      "kind": "namespace-method",
      "category": "uuid",
      "section": "Uuid",
      "tip": "Explicit alias for Uuid.new_v7 — a time-ordered UUID.",
      "page": "uuid-v7.html"
    },
    "uuid-parse": {
      "id": "uuid-parse",
      "name": "Uuid.parse",
      "sig": "Uuid.parse(s) -> string",
      "kind": "namespace-method",
      "category": "uuid",
      "section": "Uuid",
      "tip": "Normalise an untrusted string to a lowercase UUID, or the nil UUID.",
      "page": "uuid-parse.html"
    },
    "uuid-is_valid": {
      "id": "uuid-is_valid",
      "name": "Uuid.is_valid",
      "sig": "Uuid.is_valid(s) -> bool",
      "kind": "namespace-method",
      "category": "uuid",
      "section": "Uuid",
      "tip": "Is s a well-formed UUID string?",
      "page": "uuid-is_valid.html"
    },
    "uuid-to_text": {
      "id": "uuid-to_text",
      "name": "Uuid.to_text",
      "sig": "Uuid.to_text(id) -> string",
      "kind": "namespace-method",
      "category": "uuid",
      "section": "Uuid",
      "tip": "The canonical text form of a UUID.",
      "page": "uuid-to_text.html"
    },
    "uuid-equals": {
      "id": "uuid-equals",
      "name": "Uuid.equals",
      "sig": "Uuid.equals(a, b) -> bool",
      "kind": "namespace-method",
      "category": "uuid",
      "section": "Uuid",
      "tip": "Case-insensitive UUID equality.",
      "page": "uuid-equals.html"
    },
    "uuid-nil": {
      "id": "uuid-nil",
      "name": "Uuid.nil",
      "sig": "Uuid.nil() -> string",
      "kind": "namespace-method",
      "category": "uuid",
      "section": "Uuid",
      "tip": "The all-zero UUID.",
      "page": "uuid-nil.html"
    },
    "world-get": {
      "id": "world-get",
      "name": "World.get",
      "sig": "World.get(prop_id, field_id, entity) -> int",
      "kind": "namespace-method",
      "category": "world",
      "section": "World",
      "tip": "Read a component field by id.",
      "page": "world-get.html"
    },
    "world-set": {
      "id": "world-set",
      "name": "World.set",
      "sig": "World.set(prop_id, field_id, entity, value) -> void",
      "kind": "namespace-method",
      "category": "world",
      "section": "World",
      "tip": "Write a component field by id.",
      "page": "world-set.html"
    },
    "world-has": {
      "id": "world-has",
      "name": "World.has",
      "sig": "World.has(entity, prop_id) -> int",
      "kind": "namespace-method",
      "category": "world",
      "section": "World",
      "tip": "Does an entity have a component?",
      "page": "world-has.html"
    },
    "world-count": {
      "id": "world-count",
      "name": "World.count",
      "sig": "World.count() -> int",
      "kind": "namespace-method",
      "category": "world",
      "section": "World",
      "tip": "The number of live entities.",
      "page": "world-count.html"
    },
    "world-size": {
      "id": "world-size",
      "name": "World.size",
      "sig": "World.size() -> int",
      "kind": "namespace-method",
      "category": "world",
      "section": "World",
      "tip": "The serialized size of the world.",
      "page": "world-size.html"
    },
    "world-spawn": {
      "id": "world-spawn",
      "name": "World.spawn",
      "sig": "World.spawn(model_id) -> entity",
      "kind": "namespace-method",
      "category": "world",
      "section": "World",
      "tip": "Spawn an entity of a model by id.",
      "page": "world-spawn.html"
    },
    "world-save": {
      "id": "world-save",
      "name": "World.save",
      "sig": "World.save(buf) -> int",
      "kind": "namespace-method",
      "category": "world",
      "section": "World",
      "tip": "Serialize the world into a buffer.",
      "page": "world-save.html"
    },
    "world-load": {
      "id": "world-load",
      "name": "World.load",
      "sig": "World.load(buf, len) -> void",
      "kind": "namespace-method",
      "category": "world",
      "section": "World",
      "tip": "Restore the world from a buffer.",
      "page": "world-load.html"
    },
    "world-prop_id": {
      "id": "world-prop_id",
      "name": "World.prop_id",
      "sig": "World.prop_id(name) -> int",
      "kind": "namespace-method",
      "category": "world",
      "section": "World",
      "tip": "Look up a component's id by name.",
      "page": "world-prop_id.html"
    },
    "world-field_id": {
      "id": "world-field_id",
      "name": "World.field_id",
      "sig": "World.field_id(prop_id, name) -> int",
      "kind": "namespace-method",
      "category": "world",
      "section": "World",
      "tip": "Look up a field's id by name.",
      "page": "world-field_id.html"
    },
    "world-model_id": {
      "id": "world-model_id",
      "name": "World.model_id",
      "sig": "World.model_id(name) -> int",
      "kind": "namespace-method",
      "category": "world",
      "section": "World",
      "tip": "Look up a model's id by name.",
      "page": "world-model_id.html"
    },
    "world-kind": {
      "id": "world-kind",
      "name": "World.kind",
      "sig": "World.kind(entity) -> int",
      "kind": "namespace-method",
      "category": "world",
      "section": "World",
      "tip": "The model id of an entity.",
      "page": "world-kind.html"
    },
    "world-register_prop": {
      "id": "world-register_prop",
      "name": "World.register_prop",
      "sig": "World.register_prop(name, size) -> int",
      "kind": "namespace-method",
      "category": "world",
      "section": "World",
      "tip": "Register a new component at runtime.",
      "page": "world-register_prop.html"
    },
    "world-attach": {
      "id": "world-attach",
      "name": "World.attach",
      "sig": "World.attach(entity, prop_id) -> void",
      "kind": "namespace-method",
      "category": "world",
      "section": "World",
      "tip": "Attach a component to an entity at runtime.",
      "page": "world-attach.html"
    },
    "world-detach": {
      "id": "world-detach",
      "name": "World.detach",
      "sig": "World.detach(entity, prop_id) -> void",
      "kind": "namespace-method",
      "category": "world",
      "section": "World",
      "tip": "Detach a component from an entity at runtime.",
      "page": "world-detach.html"
    },
    "world-query_next": {
      "id": "world-query_next",
      "name": "World.query_next",
      "sig": "World.query_next(query_id, cursor) -> int",
      "kind": "namespace-method",
      "category": "world",
      "section": "World",
      "tip": "Advance a reflective query.",
      "page": "world-query_next.html"
    },
    "world-despawn": {
      "id": "world-despawn",
      "name": "World.despawn",
      "sig": "World.despawn(entity)",
      "kind": "namespace-method",
      "category": "world",
      "section": "World",
      "tip": "Despawn an entity by id — runs its @OnDespawn hooks and frees the slot.",
      "page": "world-despawn.html"
    },
    "audio-load": {
      "id": "audio-load",
      "name": "Audio.load",
      "sig": "Audio.load(path) -> int",
      "kind": "namespace-method",
      "category": "audio",
      "section": "Audio",
      "tip": "Load a sound file into a handle.",
      "page": "audio-load.html"
    },
    "audio-play": {
      "id": "audio-play",
      "name": "Audio.play",
      "sig": "Audio.play(id) -> void",
      "kind": "namespace-method",
      "category": "audio",
      "section": "Audio",
      "tip": "Fire a one-shot sound.",
      "page": "audio-play.html"
    },
    "audio-play_at": {
      "id": "audio-play_at",
      "name": "Audio.play_at",
      "sig": "Audio.play_at(id, gain, pitch, pan) -> void",
      "kind": "namespace-method",
      "category": "audio",
      "section": "Audio",
      "tip": "Fire a one-shot with its own gain, pitch and stereo position.",
      "page": "audio-play_at.html"
    },
    "audio-play_sound": {
      "id": "audio-play_sound",
      "name": "Audio.play_sound",
      "sig": "Audio.play_sound(id) -> void",
      "kind": "namespace-method",
      "category": "audio",
      "section": "Audio",
      "tip": "Fire a one-shot sound (alias of play).",
      "page": "audio-play_sound.html"
    },
    "audio-play_music": {
      "id": "audio-play_music",
      "name": "Audio.play_music",
      "sig": "Audio.play_music(id) -> void",
      "kind": "namespace-method",
      "category": "audio",
      "section": "Audio",
      "tip": "Loop a sound as background music.",
      "page": "audio-play_music.html"
    },
    "audio-stop": {
      "id": "audio-stop",
      "name": "Audio.stop",
      "sig": "Audio.stop(id) -> void",
      "kind": "namespace-method",
      "category": "audio",
      "section": "Audio",
      "tip": "Stop one sound.",
      "page": "audio-stop.html"
    },
    "audio-stop_music": {
      "id": "audio-stop_music",
      "name": "Audio.stop_music",
      "sig": "Audio.stop_music() -> void",
      "kind": "namespace-method",
      "category": "audio",
      "section": "Audio",
      "tip": "Stop the music channel.",
      "page": "audio-stop_music.html"
    },
    "audio-stop_all": {
      "id": "audio-stop_all",
      "name": "Audio.stop_all",
      "sig": "Audio.stop_all() -> void",
      "kind": "namespace-method",
      "category": "audio",
      "section": "Audio",
      "tip": "Stop every sound.",
      "page": "audio-stop_all.html"
    },
    "audio-volume": {
      "id": "audio-volume",
      "name": "Audio.volume",
      "sig": "Audio.volume(v) -> void",
      "kind": "namespace-method",
      "category": "audio",
      "section": "Audio",
      "tip": "Set the master volume.",
      "page": "audio-volume.html"
    },
    "audio-pitch": {
      "id": "audio-pitch",
      "name": "Audio.pitch",
      "sig": "Audio.pitch(v) -> void",
      "kind": "namespace-method",
      "category": "audio",
      "section": "Audio",
      "tip": "Set the playback rate / pitch.",
      "page": "audio-pitch.html"
    },
    "audio-is_playing": {
      "id": "audio-is_playing",
      "name": "Audio.is_playing",
      "sig": "Audio.is_playing(id) -> bool",
      "kind": "namespace-method",
      "category": "audio",
      "section": "Audio",
      "tip": "Is this sound playing?",
      "page": "audio-is_playing.html"
    },
    "audio-define": {
      "id": "audio-define",
      "name": "Audio.define",
      "sig": "Audio.define(name: s, path: p) -> int",
      "kind": "namespace-method",
      "category": "audio",
      "section": "Audio",
      "tip": "Load a sound into the bank under a name.",
      "page": "audio-define.html"
    },
    "audio-named": {
      "id": "audio-named",
      "name": "Audio.named",
      "sig": "Audio.named(name: s) -> int",
      "kind": "namespace-method",
      "category": "audio",
      "section": "Audio",
      "tip": "The handle registered under a name, or 0.",
      "page": "audio-named.html"
    },
    "random-range": {
      "id": "random-range",
      "name": "Random.range",
      "sig": "Random.range(low, high) -> int",
      "kind": "namespace-method",
      "category": "random",
      "section": "Random",
      "tip": "A random integer in the inclusive range [low, high].",
      "page": "random-range.html"
    },
    "random-chance": {
      "id": "random-chance",
      "name": "Random.chance",
      "sig": "Random.chance(percent) -> bool",
      "kind": "namespace-method",
      "category": "random",
      "section": "Random",
      "tip": "Return true with the given percent probability.",
      "page": "random-chance.html"
    },
    "random-seed": {
      "id": "random-seed",
      "name": "Random.seed",
      "sig": "Random.seed(value)",
      "kind": "namespace-method",
      "category": "random",
      "section": "Random",
      "tip": "Seed the random generator so runs are reproducible.",
      "page": "random-seed.html"
    },
    "random-value": {
      "id": "random-value",
      "name": "Random.value",
      "sig": "Random.value() -> fixed",
      "kind": "namespace-method",
      "category": "random",
      "section": "Random",
      "tip": "A random fixed value in [0, 1).",
      "page": "random-value.html"
    },
    "random-int": {
      "id": "random-int",
      "name": "Random.int",
      "sig": "Random.int(max) -> int",
      "kind": "namespace-method",
      "category": "random",
      "section": "Random",
      "tip": "A random integer in [0, max).",
      "page": "random-int.html"
    },
    "random-sign": {
      "id": "random-sign",
      "name": "Random.sign",
      "sig": "Random.sign() -> int",
      "kind": "namespace-method",
      "category": "random",
      "section": "Random",
      "tip": "A random +1 or -1.",
      "page": "random-sign.html"
    },
    "random-weighted": {
      "id": "random-weighted",
      "name": "Random.weighted",
      "sig": "Random.weighted(weights: []int) -> int",
      "kind": "namespace-method",
      "category": "random",
      "section": "Random",
      "tip": "An index drawn in proportion to its weight.",
      "page": "random-weighted.html"
    },
    "vector-make": {
      "id": "vector-make",
      "name": "Vector.make",
      "sig": "Vector.make(x, y) -> Vector",
      "kind": "namespace-method",
      "category": "vector",
      "section": "Vector",
      "tip": "Build a vector from x and y components.",
      "page": "vector-make.html"
    },
    "vector-zero": {
      "id": "vector-zero",
      "name": "Vector.zero",
      "sig": "Vector.zero() -> Vector",
      "kind": "namespace-method",
      "category": "vector",
      "section": "Vector",
      "tip": "The zero vector, (0, 0).",
      "page": "vector-zero.html"
    },
    "vector-x": {
      "id": "vector-x",
      "name": "Vector.x",
      "sig": "Vector.x(v) -> fixed",
      "kind": "namespace-method",
      "category": "vector",
      "section": "Vector",
      "tip": "The x component of a vector.",
      "page": "vector-x.html"
    },
    "vector-y": {
      "id": "vector-y",
      "name": "Vector.y",
      "sig": "Vector.y(v) -> fixed",
      "kind": "namespace-method",
      "category": "vector",
      "section": "Vector",
      "tip": "The y component of a vector.",
      "page": "vector-y.html"
    },
    "vector-add": {
      "id": "vector-add",
      "name": "Vector.add",
      "sig": "Vector.add(a, b) -> Vector",
      "kind": "namespace-method",
      "category": "vector",
      "section": "Vector",
      "tip": "Component-wise sum a + b.",
      "page": "vector-add.html"
    },
    "vector-sub": {
      "id": "vector-sub",
      "name": "Vector.sub",
      "sig": "Vector.sub(a, b) -> Vector",
      "kind": "namespace-method",
      "category": "vector",
      "section": "Vector",
      "tip": "Component-wise difference a - b.",
      "page": "vector-sub.html"
    },
    "vector-scale": {
      "id": "vector-scale",
      "name": "Vector.scale",
      "sig": "Vector.scale(v, s) -> Vector",
      "kind": "namespace-method",
      "category": "vector",
      "section": "Vector",
      "tip": "Scale a vector by a scalar.",
      "page": "vector-scale.html"
    },
    "vector-dot": {
      "id": "vector-dot",
      "name": "Vector.dot",
      "sig": "Vector.dot(a, b) -> fixed",
      "kind": "namespace-method",
      "category": "vector",
      "section": "Vector",
      "tip": "The dot product of two vectors.",
      "page": "vector-dot.html"
    },
    "vector-length": {
      "id": "vector-length",
      "name": "Vector.length",
      "sig": "Vector.length(v) -> fixed",
      "kind": "namespace-method",
      "category": "vector",
      "section": "Vector",
      "tip": "The length (magnitude) of a vector.",
      "page": "vector-length.html"
    },
    "vector-distance": {
      "id": "vector-distance",
      "name": "Vector.distance",
      "sig": "Vector.distance(a, b) -> fixed",
      "kind": "namespace-method",
      "category": "vector",
      "section": "Vector",
      "tip": "The distance between two points.",
      "page": "vector-distance.html"
    },
    "vector-normalize": {
      "id": "vector-normalize",
      "name": "Vector.normalize",
      "sig": "Vector.normalize(v) -> Vector",
      "kind": "namespace-method",
      "category": "vector",
      "section": "Vector",
      "tip": "A unit vector in the same direction.",
      "page": "vector-normalize.html"
    },
    "vector-lerp": {
      "id": "vector-lerp",
      "name": "Vector.lerp",
      "sig": "Vector.lerp(a, b, t) -> Vector",
      "kind": "namespace-method",
      "category": "vector",
      "section": "Vector",
      "tip": "Linear interpolation between two vectors.",
      "page": "vector-lerp.html"
    },
    "vector-rotate": {
      "id": "vector-rotate",
      "name": "Vector.rotate",
      "sig": "Vector.rotate(v, angle) -> Vector",
      "kind": "namespace-method",
      "category": "vector",
      "section": "Vector",
      "tip": "Rotate a vector by an angle in radians.",
      "page": "vector-rotate.html"
    },
    "vector-angle": {
      "id": "vector-angle",
      "name": "Vector.angle",
      "sig": "Vector.angle(v) -> fixed",
      "kind": "namespace-method",
      "category": "vector",
      "section": "Vector",
      "tip": "The angle of a vector in radians.",
      "page": "vector-angle.html"
    },
    "vector-from_angle": {
      "id": "vector-from_angle",
      "name": "Vector.from_angle",
      "sig": "Vector.from_angle(a) -> Vector",
      "kind": "namespace-method",
      "category": "vector",
      "section": "Vector",
      "tip": "A unit vector pointing at an angle.",
      "page": "vector-from_angle.html"
    },
    "http-get": {
      "id": "http-get",
      "name": "Http.get",
      "sig": "Http.get(url) -> int",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "Start an async GET request.",
      "page": "http-get.html"
    },
    "http-post": {
      "id": "http-post",
      "name": "Http.post",
      "sig": "Http.post(url, body) -> int",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "Start an async POST with a body.",
      "page": "http-post.html"
    },
    "http-request": {
      "id": "http-request",
      "name": "Http.request",
      "sig": "Http.request(method, url, body) -> int",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "Start a request with any method.",
      "page": "http-request.html"
    },
    "http-open": {
      "id": "http-open",
      "name": "Http.open",
      "sig": "Http.open(method, url) -> int",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "Open a request to configure before sending.",
      "page": "http-open.html"
    },
    "http-set": {
      "id": "http-set",
      "name": "Http.set",
      "sig": "Http.set(handle, name, value) -> void",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "Set a request header before sending.",
      "page": "http-set.html"
    },
    "http-body": {
      "id": "http-body",
      "name": "Http.body",
      "sig": "Http.body(handle, body) -> void",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "Set a string request body.",
      "page": "http-body.html"
    },
    "http-body_bytes": {
      "id": "http-body_bytes",
      "name": "Http.body_bytes",
      "sig": "Http.body_bytes(handle, bytes, len) -> void",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "Set a raw byte request body.",
      "page": "http-body_bytes.html"
    },
    "http-send": {
      "id": "http-send",
      "name": "Http.send",
      "sig": "Http.send(handle) -> void",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "Dispatch an opened request.",
      "page": "http-send.html"
    },
    "http-poll": {
      "id": "http-poll",
      "name": "Http.poll",
      "sig": "Http.poll(handle) -> int",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "Poll a request; -1 pending, 0 error, else status.",
      "page": "http-poll.html"
    },
    "http-status": {
      "id": "http-status",
      "name": "Http.status",
      "sig": "Http.status(handle) -> int",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "The response HTTP status code.",
      "page": "http-status.html"
    },
    "http-ok": {
      "id": "http-ok",
      "name": "Http.ok",
      "sig": "Http.ok(handle) -> bool",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "Was the response status 2xx?",
      "page": "http-ok.html"
    },
    "http-text": {
      "id": "http-text",
      "name": "Http.text",
      "sig": "Http.text(handle) -> str",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "The response body as text.",
      "page": "http-text.html"
    },
    "http-body_len": {
      "id": "http-body_len",
      "name": "Http.body_len",
      "sig": "Http.body_len(handle) -> int",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "The response body length in bytes.",
      "page": "http-body_len.html"
    },
    "http-header": {
      "id": "http-header",
      "name": "Http.header",
      "sig": "Http.header(handle, name) -> str",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "A response header value (case-insensitive).",
      "page": "http-header.html"
    },
    "http-free": {
      "id": "http-free",
      "name": "Http.free",
      "sig": "Http.free(handle) -> void",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "Release a request's resources.",
      "page": "http-free.html"
    },
    "http-parse": {
      "id": "http-parse",
      "name": "Http.parse",
      "sig": "Http.parse(bytes, len) -> int",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "Parse a raw HTTP response into a handle.",
      "page": "http-parse.html"
    },
    "http-save_to": {
      "id": "http-save_to",
      "name": "Http.save_to",
      "sig": "Http.save_to(handle, path) -> void",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "Stream the response body to a file.",
      "page": "http-save_to.html"
    },
    "http-received": {
      "id": "http-received",
      "name": "Http.received",
      "sig": "Http.received(handle) -> int",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "Body bytes received so far.",
      "page": "http-received.html"
    },
    "http-expected": {
      "id": "http-expected",
      "name": "Http.expected",
      "sig": "Http.expected(handle) -> int",
      "kind": "namespace-method",
      "category": "http",
      "section": "Http",
      "tip": "The body length the server announced, or -1.",
      "page": "http-expected.html"
    },
    "ivec2-make": {
      "id": "ivec2-make",
      "name": "IVec2.make",
      "sig": "IVec2.make(x, y) -> IVec2",
      "kind": "namespace-method",
      "category": "ivec2",
      "section": "IVec2",
      "tip": "Build an integer vector from x and y components.",
      "page": "ivec2-make.html"
    },
    "ivec2-zero": {
      "id": "ivec2-zero",
      "name": "IVec2.zero",
      "sig": "IVec2.zero() -> IVec2",
      "kind": "namespace-method",
      "category": "ivec2",
      "section": "IVec2",
      "tip": "The origin cell, (0, 0).",
      "page": "ivec2-zero.html"
    },
    "ivec2-x": {
      "id": "ivec2-x",
      "name": "IVec2.x",
      "sig": "IVec2.x(v) -> int",
      "kind": "namespace-method",
      "category": "ivec2",
      "section": "IVec2",
      "tip": "The x component of an integer vector.",
      "page": "ivec2-x.html"
    },
    "ivec2-y": {
      "id": "ivec2-y",
      "name": "IVec2.y",
      "sig": "IVec2.y(v) -> int",
      "kind": "namespace-method",
      "category": "ivec2",
      "section": "IVec2",
      "tip": "The y component of an integer vector.",
      "page": "ivec2-y.html"
    },
    "ivec2-add": {
      "id": "ivec2-add",
      "name": "IVec2.add",
      "sig": "IVec2.add(a, b) -> IVec2",
      "kind": "namespace-method",
      "category": "ivec2",
      "section": "IVec2",
      "tip": "Component-wise sum of two integer vectors.",
      "page": "ivec2-add.html"
    },
    "ivec2-sub": {
      "id": "ivec2-sub",
      "name": "IVec2.sub",
      "sig": "IVec2.sub(a, b) -> IVec2",
      "kind": "namespace-method",
      "category": "ivec2",
      "section": "IVec2",
      "tip": "Component-wise difference of two integer vectors.",
      "page": "ivec2-sub.html"
    },
    "ivec2-scale": {
      "id": "ivec2-scale",
      "name": "IVec2.scale",
      "sig": "IVec2.scale(v, s) -> IVec2",
      "kind": "namespace-method",
      "category": "ivec2",
      "section": "IVec2",
      "tip": "Multiply both components by an integer.",
      "page": "ivec2-scale.html"
    },
    "ivec2-dot": {
      "id": "ivec2-dot",
      "name": "IVec2.dot",
      "sig": "IVec2.dot(a, b) -> int",
      "kind": "namespace-method",
      "category": "ivec2",
      "section": "IVec2",
      "tip": "The dot product ax*bx + ay*by.",
      "page": "ivec2-dot.html"
    },
    "ivec2-equal": {
      "id": "ivec2-equal",
      "name": "IVec2.equal",
      "sig": "IVec2.equal(a, b) -> bool",
      "kind": "namespace-method",
      "category": "ivec2",
      "section": "IVec2",
      "tip": "True when both components match.",
      "page": "ivec2-equal.html"
    },
    "ivec2-manhattan": {
      "id": "ivec2-manhattan",
      "name": "IVec2.manhattan",
      "sig": "IVec2.manhattan(a, b) -> int",
      "kind": "namespace-method",
      "category": "ivec2",
      "section": "IVec2",
      "tip": "Grid distance |dx| + |dy|.",
      "page": "ivec2-manhattan.html"
    },
    "ivec2-to_vector": {
      "id": "ivec2-to_vector",
      "name": "IVec2.to_vector",
      "sig": "IVec2.to_vector(v) -> Vector",
      "kind": "namespace-method",
      "category": "ivec2",
      "section": "IVec2",
      "tip": "Widen to a fixed-point Vector.",
      "page": "ivec2-to_vector.html"
    },
    "ivec2-distance2": {
      "id": "ivec2-distance2",
      "name": "IVec2.distance2",
      "sig": "IVec2.distance2(a, b) -> int",
      "kind": "namespace-method",
      "category": "ivec2",
      "section": "IVec2",
      "tip": "The squared distance between two points.",
      "page": "ivec2-distance2.html"
    },
    "ivec2-within": {
      "id": "ivec2-within",
      "name": "IVec2.within",
      "sig": "IVec2.within(a, b, radius) -> bool",
      "kind": "namespace-method",
      "category": "ivec2",
      "section": "IVec2",
      "tip": "Are two points within a radius of each other?",
      "page": "ivec2-within.html"
    },
    "ivec2-heading": {
      "id": "ivec2-heading",
      "name": "IVec2.heading",
      "sig": "IVec2.heading(from, to) -> int",
      "kind": "namespace-method",
      "category": "ivec2",
      "section": "IVec2",
      "tip": "The direction from one point to another, in degrees.",
      "page": "ivec2-heading.html"
    },
    "ivec2-along": {
      "id": "ivec2-along",
      "name": "IVec2.along",
      "sig": "IVec2.along(origin, degrees, distance) -> IVec2",
      "kind": "namespace-method",
      "category": "ivec2",
      "section": "IVec2",
      "tip": "The point a distance along a heading.",
      "page": "ivec2-along.html"
    },
    "ivec2-step": {
      "id": "ivec2-step",
      "name": "IVec2.step",
      "sig": "IVec2.step(degrees) -> IVec2",
      "kind": "namespace-method",
      "category": "ivec2",
      "section": "IVec2",
      "tip": "A -1/0/1 unit step along a heading.",
      "page": "ivec2-step.html"
    },
    "map-size": {
      "id": "map-size",
      "name": "Map.size",
      "sig": "Map.size(width, height)",
      "kind": "namespace-method",
      "category": "map",
      "section": "Map — tilemap",
      "tip": "Set the tilemap dimensions in cells before filling rows.",
      "page": "map-size.html"
    },
    "map-row": {
      "id": "map-row",
      "name": "Map.row",
      "sig": "Map.row(y, cells)",
      "kind": "namespace-method",
      "category": "map",
      "section": "Map — tilemap",
      "tip": "Fill one row of the tilemap from a string of tile characters.",
      "page": "map-row.html"
    },
    "map-tile": {
      "id": "map-tile",
      "name": "Map.tile",
      "sig": "Map.tile(x, y) -> int",
      "kind": "namespace-method",
      "category": "map",
      "section": "Map — tilemap",
      "tip": "Read the tile character at a cell (out-of-bounds reads answer '#').",
      "page": "map-tile.html"
    },
    "map-get": {
      "id": "map-get",
      "name": "Map.get",
      "sig": "Map.get(x: tx, y: ty) -> int",
      "kind": "namespace-method",
      "category": "map",
      "section": "Map — tilemap",
      "tip": "The glyph at a cell ('#' outside the map).",
      "page": "map-get.html"
    },
    "map-set": {
      "id": "map-set",
      "name": "Map.set",
      "sig": "Map.set(x: tx, y: ty, glyph: g)",
      "kind": "namespace-method",
      "category": "map",
      "section": "Map — tilemap",
      "tip": "Write one cell in place.",
      "page": "map-set.html"
    },
    "map-fill": {
      "id": "map-fill",
      "name": "Map.fill",
      "sig": "Map.fill(glyph: g)",
      "kind": "namespace-method",
      "category": "map",
      "section": "Map — tilemap",
      "tip": "Every cell becomes the glyph.",
      "page": "map-fill.html"
    },
    "map-rect": {
      "id": "map-rect",
      "name": "Map.rect",
      "sig": "Map.rect(x: tx, y: ty, width: w, height: h, glyph: g)",
      "kind": "namespace-method",
      "category": "map",
      "section": "Map — tilemap",
      "tip": "Fill a rectangle of cells.",
      "page": "map-rect.html"
    },
    "map-border": {
      "id": "map-border",
      "name": "Map.border",
      "sig": "Map.border(glyph: g)",
      "kind": "namespace-method",
      "category": "map",
      "section": "Map — tilemap",
      "tip": "The outermost ring of cells.",
      "page": "map-border.html"
    },
    "map-random_cell": {
      "id": "map-random_cell",
      "name": "Map.random_cell",
      "sig": "Map.random_cell(glyph: g) -> IVec2",
      "kind": "namespace-method",
      "category": "map",
      "section": "Map — tilemap",
      "tip": "A random cell holding the glyph (seeded RNG).",
      "page": "map-random_cell.html"
    },
    "map-is_solid": {
      "id": "map-is_solid",
      "name": "Map.is_solid",
      "sig": "Map.is_solid(x: tx, y: ty) -> bool",
      "kind": "namespace-method",
      "category": "map",
      "section": "Map — tilemap",
      "tip": "Is a cell solid, per the Solids config?",
      "page": "map-is_solid.html"
    },
    "map-is_solid_at": {
      "id": "map-is_solid_at",
      "name": "Map.is_solid_at",
      "sig": "Map.is_solid_at(x: px, y: py) -> bool",
      "kind": "namespace-method",
      "category": "map",
      "section": "Map — tilemap",
      "tip": "Is the cell under a pixel position solid?",
      "page": "map-is_solid_at.html"
    },
    "map-width": {
      "id": "map-width",
      "name": "Map.width",
      "sig": "Map.width() -> int",
      "kind": "namespace-method",
      "category": "map",
      "section": "Map — tilemap",
      "tip": "The map's width in cells.",
      "page": "map-width.html"
    },
    "map-height": {
      "id": "map-height",
      "name": "Map.height",
      "sig": "Map.height() -> int",
      "kind": "namespace-method",
      "category": "map",
      "section": "Map — tilemap",
      "tip": "The map's height in cells.",
      "page": "map-height.html"
    },
    "map-random_cell_far": {
      "id": "map-random_cell_far",
      "name": "Map.random_cell_far",
      "sig": "Map.random_cell_far(glyph:, from:, min_tiles:) -> IVec2",
      "kind": "namespace-method",
      "category": "map",
      "section": "Map — tilemap",
      "tip": "A random cell with the glyph, at least a distance from a point.",
      "page": "map-random_cell_far.html"
    },
    "map-to_tile": {
      "id": "map-to_tile",
      "name": "Map.to_tile",
      "sig": "Map.to_tile(pixel: IVec2) -> IVec2",
      "kind": "namespace-method",
      "category": "map",
      "section": "Map — tilemap",
      "tip": "The tile under a pixel position.",
      "page": "map-to_tile.html"
    },
    "rect-make": {
      "id": "rect-make",
      "name": "Rect.make",
      "sig": "Rect.make(x, y, w, h) -> Rect",
      "kind": "namespace-method",
      "category": "rect",
      "section": "Rect",
      "tip": "Build a rectangle from a corner and a size.",
      "page": "rect-make.html"
    },
    "rect-x": {
      "id": "rect-x",
      "name": "Rect.x",
      "sig": "Rect.x(r) -> fixed",
      "kind": "namespace-method",
      "category": "rect",
      "section": "Rect",
      "tip": "The left edge (x position).",
      "page": "rect-x.html"
    },
    "rect-y": {
      "id": "rect-y",
      "name": "Rect.y",
      "sig": "Rect.y(r) -> fixed",
      "kind": "namespace-method",
      "category": "rect",
      "section": "Rect",
      "tip": "The top edge (y position).",
      "page": "rect-y.html"
    },
    "rect-w": {
      "id": "rect-w",
      "name": "Rect.w",
      "sig": "Rect.w(r) -> fixed",
      "kind": "namespace-method",
      "category": "rect",
      "section": "Rect",
      "tip": "The width.",
      "page": "rect-w.html"
    },
    "rect-h": {
      "id": "rect-h",
      "name": "Rect.h",
      "sig": "Rect.h(r) -> fixed",
      "kind": "namespace-method",
      "category": "rect",
      "section": "Rect",
      "tip": "The height.",
      "page": "rect-h.html"
    },
    "rect-right": {
      "id": "rect-right",
      "name": "Rect.right",
      "sig": "Rect.right(r) -> fixed",
      "kind": "namespace-method",
      "category": "rect",
      "section": "Rect",
      "tip": "The right edge, x + w.",
      "page": "rect-right.html"
    },
    "rect-bottom": {
      "id": "rect-bottom",
      "name": "Rect.bottom",
      "sig": "Rect.bottom(r) -> fixed",
      "kind": "namespace-method",
      "category": "rect",
      "section": "Rect",
      "tip": "The bottom edge, y + h.",
      "page": "rect-bottom.html"
    },
    "rect-center": {
      "id": "rect-center",
      "name": "Rect.center",
      "sig": "Rect.center(r) -> Vector",
      "kind": "namespace-method",
      "category": "rect",
      "section": "Rect",
      "tip": "The center point as a Vector.",
      "page": "rect-center.html"
    },
    "rect-contains": {
      "id": "rect-contains",
      "name": "Rect.contains",
      "sig": "Rect.contains(r, px, py) -> bool",
      "kind": "namespace-method",
      "category": "rect",
      "section": "Rect",
      "tip": "True when the point is inside.",
      "page": "rect-contains.html"
    },
    "rect-intersects": {
      "id": "rect-intersects",
      "name": "Rect.intersects",
      "sig": "Rect.intersects(a, b) -> bool",
      "kind": "namespace-method",
      "category": "rect",
      "section": "Rect",
      "tip": "True when two rectangles overlap.",
      "page": "rect-intersects.html"
    },
    "udp-open": {
      "id": "udp-open",
      "name": "Udp.open",
      "sig": "Udp.open(port) -> int",
      "kind": "namespace-method",
      "category": "udp",
      "section": "Udp",
      "tip": "Open a socket on a port.",
      "page": "udp-open.html"
    },
    "udp-port": {
      "id": "udp-port",
      "name": "Udp.port",
      "sig": "Udp.port(socket) -> int",
      "kind": "namespace-method",
      "category": "udp",
      "section": "Udp",
      "tip": "The port a socket is bound to.",
      "page": "udp-port.html"
    },
    "udp-send": {
      "id": "udp-send",
      "name": "Udp.send",
      "sig": "Udp.send(socket, ip, port, bytes, len) -> int",
      "kind": "namespace-method",
      "category": "udp",
      "section": "Udp",
      "tip": "Send one datagram.",
      "page": "udp-send.html"
    },
    "udp-recv": {
      "id": "udp-recv",
      "name": "Udp.recv",
      "sig": "Udp.recv(socket, bytes, cap) -> int",
      "kind": "namespace-method",
      "category": "udp",
      "section": "Udp",
      "tip": "Read the next waiting datagram.",
      "page": "udp-recv.html"
    },
    "udp-from_ip": {
      "id": "udp-from_ip",
      "name": "Udp.from_ip",
      "sig": "Udp.from_ip(socket) -> int",
      "kind": "namespace-method",
      "category": "udp",
      "section": "Udp",
      "tip": "The sender of the last datagram read.",
      "page": "udp-from_ip.html"
    },
    "udp-from_port": {
      "id": "udp-from_port",
      "name": "Udp.from_port",
      "sig": "Udp.from_port(socket) -> int",
      "kind": "namespace-method",
      "category": "udp",
      "section": "Udp",
      "tip": "The sender's port.",
      "page": "udp-from_port.html"
    },
    "udp-close": {
      "id": "udp-close",
      "name": "Udp.close",
      "sig": "Udp.close(socket) -> void",
      "kind": "namespace-method",
      "category": "udp",
      "section": "Udp",
      "tip": "Close a socket.",
      "page": "udp-close.html"
    },
    "udp-resolve": {
      "id": "udp-resolve",
      "name": "Udp.resolve",
      "sig": "Udp.resolve(name) -> int",
      "kind": "namespace-method",
      "category": "udp",
      "section": "Udp",
      "tip": "Look a host name up.",
      "page": "udp-resolve.html"
    },
    "udp-local_ip": {
      "id": "udp-local_ip",
      "name": "Udp.local_ip",
      "sig": "Udp.local_ip() -> int",
      "kind": "namespace-method",
      "category": "udp",
      "section": "Udp",
      "tip": "This machine's address.",
      "page": "udp-local_ip.html"
    },
    "udp-ip": {
      "id": "udp-ip",
      "name": "Udp.ip",
      "sig": "Udp.ip(text) -> int",
      "kind": "namespace-method",
      "category": "udp",
      "section": "Udp",
      "tip": "Parse a dotted address.",
      "page": "udp-ip.html"
    },
    "udp-ip_text": {
      "id": "udp-ip_text",
      "name": "Udp.ip_text",
      "sig": "Udp.ip_text(ip) -> string",
      "kind": "namespace-method",
      "category": "udp",
      "section": "Udp",
      "tip": "Format an address.",
      "page": "udp-ip_text.html"
    },
    "bigint-from": {
      "id": "bigint-from",
      "name": "BigInt.from",
      "sig": "BigInt.from(value) -> BigInt",
      "kind": "namespace-method",
      "category": "bigint",
      "section": "BigInt",
      "tip": "Turn a plain int into a BigInt.",
      "page": "bigint-from.html"
    },
    "bigint-parse": {
      "id": "bigint-parse",
      "name": "BigInt.parse",
      "sig": "BigInt.parse(text) -> BigInt",
      "kind": "namespace-method",
      "category": "bigint",
      "section": "BigInt",
      "tip": "Parse decimal text into a BigInt.",
      "page": "bigint-parse.html"
    },
    "bigint-add": {
      "id": "bigint-add",
      "name": "BigInt.add",
      "sig": "BigInt.add(a, b) -> BigInt",
      "kind": "namespace-method",
      "category": "bigint",
      "section": "BigInt",
      "tip": "Exact sum of two big integers.",
      "page": "bigint-add.html"
    },
    "bigint-sub": {
      "id": "bigint-sub",
      "name": "BigInt.sub",
      "sig": "BigInt.sub(a, b) -> BigInt",
      "kind": "namespace-method",
      "category": "bigint",
      "section": "BigInt",
      "tip": "Exact difference of two big integers.",
      "page": "bigint-sub.html"
    },
    "bigint-mul": {
      "id": "bigint-mul",
      "name": "BigInt.mul",
      "sig": "BigInt.mul(a, b) -> BigInt",
      "kind": "namespace-method",
      "category": "bigint",
      "section": "BigInt",
      "tip": "Exact product of two big integers.",
      "page": "bigint-mul.html"
    },
    "bigint-neg": {
      "id": "bigint-neg",
      "name": "BigInt.neg",
      "sig": "BigInt.neg(a) -> BigInt",
      "kind": "namespace-method",
      "category": "bigint",
      "section": "BigInt",
      "tip": "Negate a big integer.",
      "page": "bigint-neg.html"
    },
    "bigint-pow": {
      "id": "bigint-pow",
      "name": "BigInt.pow",
      "sig": "BigInt.pow(a, exp) -> BigInt",
      "kind": "namespace-method",
      "category": "bigint",
      "section": "BigInt",
      "tip": "Raise a big integer to an int power.",
      "page": "bigint-pow.html"
    },
    "bigint-div": {
      "id": "bigint-div",
      "name": "BigInt.div",
      "sig": "BigInt.div(a, d) -> BigInt",
      "kind": "namespace-method",
      "category": "bigint",
      "section": "BigInt",
      "tip": "Divide a big integer by an int (toward zero).",
      "page": "bigint-div.html"
    },
    "bigint-mod": {
      "id": "bigint-mod",
      "name": "BigInt.mod",
      "sig": "BigInt.mod(a, d) -> int",
      "kind": "namespace-method",
      "category": "bigint",
      "section": "BigInt",
      "tip": "Remainder of a big integer divided by an int.",
      "page": "bigint-mod.html"
    },
    "bigint-cmp": {
      "id": "bigint-cmp",
      "name": "BigInt.cmp",
      "sig": "BigInt.cmp(a, b) -> int",
      "kind": "namespace-method",
      "category": "bigint",
      "section": "BigInt",
      "tip": "Compare two big integers: -1, 0, or 1.",
      "page": "bigint-cmp.html"
    },
    "bigint-eq": {
      "id": "bigint-eq",
      "name": "BigInt.eq",
      "sig": "BigInt.eq(a, b) -> bool",
      "kind": "namespace-method",
      "category": "bigint",
      "section": "BigInt",
      "tip": "True when two big integers are equal.",
      "page": "bigint-eq.html"
    },
    "bigint-is_zero": {
      "id": "bigint-is_zero",
      "name": "BigInt.is_zero",
      "sig": "BigInt.is_zero(a) -> bool",
      "kind": "namespace-method",
      "category": "bigint",
      "section": "BigInt",
      "tip": "True when a big integer is zero.",
      "page": "bigint-is_zero.html"
    },
    "bigint-to_int": {
      "id": "bigint-to_int",
      "name": "BigInt.to_int",
      "sig": "BigInt.to_int(a) -> int",
      "kind": "namespace-method",
      "category": "bigint",
      "section": "BigInt",
      "tip": "Narrow a big integer to a plain int (clamped).",
      "page": "bigint-to_int.html"
    },
    "bigint-str": {
      "id": "bigint-str",
      "name": "BigInt.str",
      "sig": "BigInt.str(a) -> string",
      "kind": "namespace-method",
      "category": "bigint",
      "section": "BigInt",
      "tip": "Render a big integer as decimal text.",
      "page": "bigint-str.html"
    },
    "process-spawn": {
      "id": "process-spawn",
      "name": "Process.spawn",
      "sig": "Process.spawn(path, args) -> int",
      "kind": "namespace-method",
      "category": "process",
      "section": "Process",
      "tip": "Start a program; never blocks.",
      "page": "process-spawn.html"
    },
    "process-poll": {
      "id": "process-poll",
      "name": "Process.poll",
      "sig": "Process.poll(handle) -> int",
      "kind": "namespace-method",
      "category": "process",
      "section": "Process",
      "tip": "-1 while running, else the exit code.",
      "page": "process-poll.html"
    },
    "process-kill": {
      "id": "process-kill",
      "name": "Process.kill",
      "sig": "Process.kill(handle) -> void",
      "kind": "namespace-method",
      "category": "process",
      "section": "Process",
      "tip": "End a running child.",
      "page": "process-kill.html"
    },
    "process-free": {
      "id": "process-free",
      "name": "Process.free",
      "sig": "Process.free(handle) -> void",
      "kind": "namespace-method",
      "category": "process",
      "section": "Process",
      "tip": "Let a process handle go.",
      "page": "process-free.html"
    },
    "decimal-from": {
      "id": "decimal-from",
      "name": "Decimal.from",
      "sig": "Decimal.from(value) -> Decimal",
      "kind": "namespace-method",
      "category": "decimal",
      "section": "Decimal",
      "tip": "Turn a whole int into a Decimal.",
      "page": "decimal-from.html"
    },
    "decimal-parse": {
      "id": "decimal-parse",
      "name": "Decimal.parse",
      "sig": "Decimal.parse(text) -> Decimal",
      "kind": "namespace-method",
      "category": "decimal",
      "section": "Decimal",
      "tip": "Parse decimal text like \"19.99\".",
      "page": "decimal-parse.html"
    },
    "decimal-add": {
      "id": "decimal-add",
      "name": "Decimal.add",
      "sig": "Decimal.add(a, b) -> Decimal",
      "kind": "namespace-method",
      "category": "decimal",
      "section": "Decimal",
      "tip": "Exact sum of two decimals.",
      "page": "decimal-add.html"
    },
    "decimal-sub": {
      "id": "decimal-sub",
      "name": "Decimal.sub",
      "sig": "Decimal.sub(a, b) -> Decimal",
      "kind": "namespace-method",
      "category": "decimal",
      "section": "Decimal",
      "tip": "Exact difference of two decimals.",
      "page": "decimal-sub.html"
    },
    "decimal-mul": {
      "id": "decimal-mul",
      "name": "Decimal.mul",
      "sig": "Decimal.mul(a, b) -> Decimal",
      "kind": "namespace-method",
      "category": "decimal",
      "section": "Decimal",
      "tip": "Exact product of two decimals.",
      "page": "decimal-mul.html"
    },
    "decimal-neg": {
      "id": "decimal-neg",
      "name": "Decimal.neg",
      "sig": "Decimal.neg(a) -> Decimal",
      "kind": "namespace-method",
      "category": "decimal",
      "section": "Decimal",
      "tip": "Negate a decimal.",
      "page": "decimal-neg.html"
    },
    "decimal-cmp": {
      "id": "decimal-cmp",
      "name": "Decimal.cmp",
      "sig": "Decimal.cmp(a, b) -> int",
      "kind": "namespace-method",
      "category": "decimal",
      "section": "Decimal",
      "tip": "Compare two decimals: -1, 0, or 1.",
      "page": "decimal-cmp.html"
    },
    "decimal-eq": {
      "id": "decimal-eq",
      "name": "Decimal.eq",
      "sig": "Decimal.eq(a, b) -> bool",
      "kind": "namespace-method",
      "category": "decimal",
      "section": "Decimal",
      "tip": "True when two decimals are equal in value.",
      "page": "decimal-eq.html"
    },
    "decimal-scale": {
      "id": "decimal-scale",
      "name": "Decimal.scale",
      "sig": "Decimal.scale(d) -> int",
      "kind": "namespace-method",
      "category": "decimal",
      "section": "Decimal",
      "tip": "The number of digits after the point.",
      "page": "decimal-scale.html"
    },
    "decimal-rescale": {
      "id": "decimal-rescale",
      "name": "Decimal.rescale",
      "sig": "Decimal.rescale(d, places) -> Decimal",
      "kind": "namespace-method",
      "category": "decimal",
      "section": "Decimal",
      "tip": "Change precision (truncates toward zero).",
      "page": "decimal-rescale.html"
    },
    "decimal-str": {
      "id": "decimal-str",
      "name": "Decimal.str",
      "sig": "Decimal.str(d) -> string",
      "kind": "namespace-method",
      "category": "decimal",
      "section": "Decimal",
      "tip": "Render a decimal as text.",
      "page": "decimal-str.html"
    },
    "type-int": {
      "id": "type-int",
      "name": "int",
      "sig": "int",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "The default 32-bit signed integer — also how colors, keys, and tiles are carried.",
      "page": "type-int.html"
    },
    "type-fixed": {
      "id": "type-fixed",
      "name": "fixed",
      "sig": "fixed",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "Q16.16 fixed-point for deterministic fractional math — no floats.",
      "page": "type-fixed.html"
    },
    "type-long": {
      "id": "type-long",
      "name": "long",
      "sig": "long",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "A 64-bit signed integer for values that overflow a 32-bit int.",
      "page": "type-long.html"
    },
    "type-bool": {
      "id": "type-bool",
      "name": "bool",
      "sig": "bool",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "A truth value — the result of comparisons and of and / or / not.",
      "page": "type-bool.html"
    },
    "type-float": {
      "id": "type-float",
      "name": "float",
      "sig": "float",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "A 32-bit IEEE floating-point number — what the GPU uses.",
      "page": "type-float.html"
    },
    "type-string": {
      "id": "type-string",
      "name": "string",
      "sig": "string",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "An immutable string — compared by content, sliceable, and interpolatable.",
      "page": "type-string.html"
    },
    "type-double": {
      "id": "type-double",
      "name": "double",
      "sig": "double",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "A 64-bit IEEE floating-point number for precise math.",
      "page": "type-double.html"
    },
    "type-entity": {
      "id": "type-entity",
      "name": "entity",
      "sig": "entity",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "The id/handle of a spawned model instance, as returned by self().",
      "page": "type-entity.html"
    },
    "type-pointer": {
      "id": "type-pointer",
      "name": "pointer",
      "sig": "pointer",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "A raw address into memory — a byte buffer from bytes(n), or an FFI handle.",
      "page": "type-pointer.html"
    },
    "type-words": {
      "id": "type-words",
      "name": "words",
      "sig": "words",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "A raw buffer indexed as 32-bit words — each buffer[i] reads or writes an int.",
      "page": "type-words.html"
    },
    "type-byte": {
      "id": "type-byte",
      "name": "byte",
      "sig": "byte",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "A raw buffer indexed one byte at a time — each buffer[i] reads or writes a byte.",
      "page": "type-byte.html"
    },
    "type-slices": {
      "id": "type-slices",
      "name": "[]T (slices)",
      "sig": "[]T",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "A growable slice of T — new []T makes one, push appends, len counts, s[i] indexes.",
      "page": "type-slices.html"
    },
    "type-fixeds": {
      "id": "type-fixeds",
      "name": "fixeds",
      "sig": "fixeds",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "A buffer of fixed-point values — f[i] reads and writes a fixed.",
      "page": "type-fixeds.html"
    },
    "type-countdown": {
      "id": "type-countdown",
      "name": "countdown",
      "sig": "countdown",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "An int component field the engine steps toward 0 once per Update.",
      "page": "type-countdown.html"
    },
    "type-floats": {
      "id": "type-floats",
      "name": "floats",
      "sig": "floats / doubles",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "A buffer of floats (or doubles) — v[i] reads and writes one.",
      "page": "type-floats.html"
    },
    "type-pointers": {
      "id": "type-pointers",
      "name": "pointers",
      "sig": "pointers",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "A buffer of pointers — p[i] reads and writes a pointer.",
      "page": "type-pointers.html"
    },
    "type-vector": {
      "id": "type-vector",
      "name": "Vector",
      "sig": "Vector",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "A 2D vector — two fixed components (x, y), copied by value.",
      "page": "type-vector.html"
    },
    "type-ivec2": {
      "id": "type-ivec2",
      "name": "IVec2",
      "sig": "IVec2",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "An integer 2D vector — two int components (x, y), copied by value.",
      "page": "type-ivec2.html"
    },
    "type-rect": {
      "id": "type-rect",
      "name": "Rect",
      "sig": "Rect",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "A rectangle — position (x, y) and size (w, h), copied by value.",
      "page": "type-rect.html"
    },
    "type-void": {
      "id": "type-void",
      "name": "void",
      "sig": "void",
      "kind": "type",
      "category": "types",
      "section": "Types",
      "tip": "The absence of a value — the return type of a function that returns nothing.",
      "page": "type-void.html"
    },
    "dict-new": {
      "id": "dict-new",
      "name": "Dict.new",
      "sig": "Dict.new() -> Dict",
      "kind": "namespace-method",
      "category": "dict",
      "section": "Dict",
      "tip": "Create an empty string-keyed map.",
      "page": "dict-new.html"
    },
    "dict-set": {
      "id": "dict-set",
      "name": "Dict.set",
      "sig": "Dict.set(d, key, value)",
      "kind": "namespace-method",
      "category": "dict",
      "section": "Dict",
      "tip": "Insert or update a key.",
      "page": "dict-set.html"
    },
    "dict-get": {
      "id": "dict-get",
      "name": "Dict.get",
      "sig": "Dict.get(d, key) -> int",
      "kind": "namespace-method",
      "category": "dict",
      "section": "Dict",
      "tip": "Look up a key (0 if absent).",
      "page": "dict-get.html"
    },
    "dict-get_or": {
      "id": "dict-get_or",
      "name": "Dict.get_or",
      "sig": "Dict.get_or(d, key, fallback) -> int",
      "kind": "namespace-method",
      "category": "dict",
      "section": "Dict",
      "tip": "Look up a key with an explicit default.",
      "page": "dict-get_or.html"
    },
    "dict-has": {
      "id": "dict-has",
      "name": "Dict.has",
      "sig": "Dict.has(d, key) -> bool",
      "kind": "namespace-method",
      "category": "dict",
      "section": "Dict",
      "tip": "Is a key present?",
      "page": "dict-has.html"
    },
    "dict-remove": {
      "id": "dict-remove",
      "name": "Dict.remove",
      "sig": "Dict.remove(d, key)",
      "kind": "namespace-method",
      "category": "dict",
      "section": "Dict",
      "tip": "Delete a key.",
      "page": "dict-remove.html"
    },
    "dict-size": {
      "id": "dict-size",
      "name": "Dict.size",
      "sig": "Dict.size(d) -> int",
      "kind": "namespace-method",
      "category": "dict",
      "section": "Dict",
      "tip": "How many keys are stored.",
      "page": "dict-size.html"
    },
    "dict-clear": {
      "id": "dict-clear",
      "name": "Dict.clear",
      "sig": "Dict.clear(d)",
      "kind": "namespace-method",
      "category": "dict",
      "section": "Dict",
      "tip": "Remove every key.",
      "page": "dict-clear.html"
    },
    "dict-keys": {
      "id": "dict-keys",
      "name": "Dict.keys",
      "sig": "Dict.keys(d) -> []pointer",
      "kind": "namespace-method",
      "category": "dict",
      "section": "Dict",
      "tip": "Every key, as a slice of strings.",
      "page": "dict-keys.html"
    },
    "op-arith": {
      "id": "op-arith",
      "name": "Arithmetic",
      "sig": "+  -  *  /  %",
      "kind": "operator",
      "category": "operators",
      "section": "Operators & tokens",
      "tip": "Add, subtract, multiply, integer-divide, and remainder — on int and fixed.",
      "page": "op-arith.html"
    },
    "op-compare": {
      "id": "op-compare",
      "name": "Comparison",
      "sig": "==  !=  <  <=  >  >=",
      "kind": "operator",
      "category": "operators",
      "section": "Operators & tokens",
      "tip": "Compare two values and yield a bool; on strings == compares contents.",
      "page": "op-compare.html"
    },
    "op-logical": {
      "id": "op-logical",
      "name": "Logical",
      "sig": "and  or  not",
      "kind": "operator",
      "category": "operators",
      "section": "Operators & tokens",
      "tip": "The boolean combinators, spelled as words — never && or || or a bare !.",
      "page": "op-logical.html"
    },
    "op-bitwise": {
      "id": "op-bitwise",
      "name": "Bitwise",
      "sig": "&  |  ^  ~  <<  >>",
      "kind": "operator",
      "category": "operators",
      "section": "Operators & tokens",
      "tip": "Bit-level and, or, xor, not, and shifts — with Go-style precedence.",
      "page": "op-bitwise.html"
    },
    "op-range": {
      "id": "op-range",
      "name": "Range",
      "sig": "a .. b",
      "kind": "operator",
      "category": "operators",
      "section": "Operators & tokens",
      "tip": "A half-open range for numeric for loops — from a up to but not including b.",
      "page": "op-range.html"
    },
    "op-assign": {
      "id": "op-assign",
      "name": "Assignment",
      "sig": "name = value",
      "kind": "operator",
      "category": "operators",
      "section": "Operators & tokens",
      "tip": "Store into a var, a field, or an element — a statement, not an expression.",
      "page": "op-assign.html"
    },
    "op-access": {
      "id": "op-access",
      "name": "Member & index",
      "sig": "x.field   buffer[i]   text[a..b]",
      "kind": "operator",
      "category": "operators",
      "section": "Operators & tokens",
      "tip": "Field access, element index, and string slice — usable as value or target.",
      "page": "op-access.html"
    },
    "op-interp": {
      "id": "op-interp",
      "name": "String interpolation",
      "sig": "`text {expr} more`",
      "kind": "operator",
      "category": "operators",
      "section": "Operators & tokens",
      "tip": "A backtick string with {expr} holes, each stringified and concatenated.",
      "page": "op-interp.html"
    },
    "op-literals": {
      "id": "op-literals",
      "name": "Literals",
      "sig": "42   0x1E90FF   'w'   \"text\"   true   null",
      "kind": "operator",
      "category": "operators",
      "section": "Operators & tokens",
      "tip": "Integer, hex, character, string, boolean, and null-pointer literals.",
      "page": "op-literals.html"
    },
    "op-comment": {
      "id": "op-comment",
      "name": "Comment",
      "sig": "# to end of line",
      "kind": "operator",
      "category": "operators",
      "section": "Operators & tokens",
      "tip": "Everything after # on a line is a comment, ignored by the compiler.",
      "page": "op-comment.html"
    },
    "fn-print": {
      "id": "fn-print",
      "name": "print",
      "sig": "print(x)",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Print an int or string followed by a newline — for headless tests and debugging.",
      "page": "fn-print.html"
    },
    "fn-string": {
      "id": "fn-string",
      "name": "string",
      "sig": "string(x) -> string",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Convert an int, bool, or fixed value to text; a string passes through unchanged.",
      "page": "fn-string.html"
    },
    "fn-quit": {
      "id": "fn-quit",
      "name": "quit",
      "sig": "quit()",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Stop the game loop cleanly after the current frame finishes.",
      "page": "fn-quit.html"
    },
    "fn-save": {
      "id": "fn-save",
      "name": "save",
      "sig": "save()",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Serialize the whole world — every model instance, property, and program var — in one call.",
      "page": "fn-save.html"
    },
    "fn-load": {
      "id": "fn-load",
      "name": "load",
      "sig": "load() -> bool",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Restore the world from a snapshot previously written by save().",
      "page": "fn-load.html"
    },
    "fn-len": {
      "id": "fn-len",
      "name": "len",
      "sig": "len(x) -> int",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "The number of elements in a slice, or the byte length of a string.",
      "page": "fn-len.html"
    },
    "fn-push": {
      "id": "fn-push",
      "name": "push",
      "sig": "push(slice, x)",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Append one element to the end of a growable slice.",
      "page": "fn-push.html"
    },
    "fn-abs": {
      "id": "fn-abs",
      "name": "abs",
      "sig": "abs(a) -> int",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "The absolute value of an integer (its magnitude, never negative).",
      "page": "fn-abs.html"
    },
    "fn-clamp": {
      "id": "fn-clamp",
      "name": "clamp",
      "sig": "clamp(v, lo, hi) -> int",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Constrain a value to the inclusive range [lo, hi].",
      "page": "fn-clamp.html"
    },
    "fn-panic": {
      "id": "fn-panic",
      "name": "panic",
      "sig": "panic(msg: string)",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Abort with a located error message instead of crashing.",
      "page": "fn-panic.html"
    },
    "fn-assert": {
      "id": "fn-assert",
      "name": "assert",
      "sig": "assert(cond: bool, msg: string)",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Abort with a located message when an invariant is false.",
      "page": "fn-assert.html"
    },
    "fn-ok": {
      "id": "fn-ok",
      "name": "ok",
      "sig": "ok(v) -> result",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Wrap a success payload in a result — the happy half of try/else.",
      "page": "fn-ok.html"
    },
    "fn-err": {
      "id": "fn-err",
      "name": "err",
      "sig": "err(msg: string) -> result",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Wrap a failure message in a result — the sad half, recovered by try/else.",
      "page": "fn-err.html"
    },
    "fn-is_ok": {
      "id": "fn-is_ok",
      "name": "is_ok",
      "sig": "is_ok(r: result) -> bool",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "True when a result carries a success payload.",
      "page": "fn-is_ok.html"
    },
    "fn-is_err": {
      "id": "fn-is_err",
      "name": "is_err",
      "sig": "is_err(r: result) -> bool",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "True when a result carries a failure.",
      "page": "fn-is_err.html"
    },
    "fn-some": {
      "id": "fn-some",
      "name": "some",
      "sig": "some(v) -> option",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Wrap a present value in an option.",
      "page": "fn-some.html"
    },
    "fn-none": {
      "id": "fn-none",
      "name": "none",
      "sig": "none() -> option",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "The empty option — a missing value.",
      "page": "fn-none.html"
    },
    "fn-is_some": {
      "id": "fn-is_some",
      "name": "is_some",
      "sig": "is_some(o: option) -> bool",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "True when an option holds a value.",
      "page": "fn-is_some.html"
    },
    "fn-is_none": {
      "id": "fn-is_none",
      "name": "is_none",
      "sig": "is_none(o: option) -> bool",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "True when an option is empty.",
      "page": "fn-is_none.html"
    },
    "fn-unwrap_or": {
      "id": "fn-unwrap_or",
      "name": "unwrap_or",
      "sig": "unwrap_or(o: option, fallback) -> int",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "The option value, or a fallback if empty.",
      "page": "fn-unwrap_or.html"
    },
    "fn-exit": {
      "id": "fn-exit",
      "name": "exit",
      "sig": "exit(code)",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Terminate the process immediately with a status code.",
      "page": "fn-exit.html"
    },
    "fn-run": {
      "id": "fn-run",
      "name": "run",
      "sig": "run(cmd)",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Run a string as a shell command.",
      "page": "fn-run.html"
    },
    "fn-getenv": {
      "id": "fn-getenv",
      "name": "getenv",
      "sig": "getenv(name) -> string",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Read an environment variable, returning empty when it is unset.",
      "page": "fn-getenv.html"
    },
    "fn-read_char": {
      "id": "fn-read_char",
      "name": "read_char",
      "sig": "read_char() -> int",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Read one byte from standard input, or -1 at end of input.",
      "page": "fn-read_char.html"
    },
    "fn-arg": {
      "id": "fn-arg",
      "name": "arg",
      "sig": "arg(i) -> string",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "The i-th command-line argument as a string.",
      "page": "fn-arg.html"
    },
    "fn-arg_count": {
      "id": "fn-arg_count",
      "name": "arg_count",
      "sig": "arg_count() -> int",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "The number of command-line arguments, counting the program name.",
      "page": "fn-arg_count.html"
    },
    "fn-bytes": {
      "id": "fn-bytes",
      "name": "bytes",
      "sig": "bytes(n) -> pointer",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Allocate a raw buffer of n bytes and return a pointer to it.",
      "page": "fn-bytes.html"
    },
    "fn-file_stderr": {
      "id": "fn-file_stderr",
      "name": "file_stderr",
      "sig": "file_stderr() -> pointer",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "The standard-error stream handle for use with file_write.",
      "page": "fn-file_stderr.html"
    },
    "fn-file_stdout": {
      "id": "fn-file_stdout",
      "name": "file_stdout",
      "sig": "file_stdout() -> pointer",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "The standard-output stream handle for use with file_write.",
      "page": "fn-file_stdout.html"
    },
    "fn-file_write": {
      "id": "fn-file_write",
      "name": "file_write",
      "sig": "file_write(handle, buf, len)",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Write a run of raw bytes to a stream handle.",
      "page": "fn-file_write.html"
    },
    "fn-fixed": {
      "id": "fn-fixed",
      "name": "fixed",
      "sig": "fixed(x) -> fixed",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Convert an int (or a float) into a Q16.16 fixed-point value.",
      "page": "fn-fixed.html"
    },
    "fn-floor": {
      "id": "fn-floor",
      "name": "floor",
      "sig": "floor(x) -> int",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Floor a fixed-point value down to the nearest integer.",
      "page": "fn-floor.html"
    },
    "fn-max": {
      "id": "fn-max",
      "name": "max",
      "sig": "max(a, b) -> int",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "The larger of two integers.",
      "page": "fn-max.html"
    },
    "fn-min": {
      "id": "fn-min",
      "name": "min",
      "sig": "min(a, b) -> int",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "The smaller of two integers.",
      "page": "fn-min.html"
    },
    "fn-ui_build": {
      "id": "fn-ui_build",
      "name": "ui_build",
      "sig": "ui_build()",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Build the declared UI tree so it can be opened and rendered.",
      "page": "fn-ui_build.html"
    },
    "fn-words": {
      "id": "fn-words",
      "name": "words",
      "sig": "words(n) -> words",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Allocate a raw buffer of n 32-bit words, indexable with [i].",
      "page": "fn-words.html"
    },
    "fn-float": {
      "id": "fn-float",
      "name": "float",
      "sig": "float(x) -> float / double(x) -> double",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Convert any number to a float (or double).",
      "page": "fn-float.html"
    },
    "fn-int": {
      "id": "fn-int",
      "name": "int",
      "sig": "int(x) -> int / long(x) -> long",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "Convert a number to a whole number, truncating toward zero.",
      "page": "fn-int.html"
    },
    "fn-float_bits": {
      "id": "fn-float_bits",
      "name": "float_bits",
      "sig": "float_bits(x) -> int / float_from_bits(bits) -> float",
      "kind": "builtin",
      "category": "builtins",
      "section": "Builtin functions",
      "tip": "A float's IEEE bit pattern as an int, and back.",
      "page": "fn-float_bits.html"
    },
    "set-new": {
      "id": "set-new",
      "name": "Set.new",
      "sig": "Set.new() -> Set",
      "kind": "namespace-method",
      "category": "set",
      "section": "Set",
      "tip": "Create an empty string set.",
      "page": "set-new.html"
    },
    "set-add": {
      "id": "set-add",
      "name": "Set.add",
      "sig": "Set.add(s, key)",
      "kind": "namespace-method",
      "category": "set",
      "section": "Set",
      "tip": "Add a member (duplicates ignored).",
      "page": "set-add.html"
    },
    "set-has": {
      "id": "set-has",
      "name": "Set.has",
      "sig": "Set.has(s, key) -> bool",
      "kind": "namespace-method",
      "category": "set",
      "section": "Set",
      "tip": "Is a member present?",
      "page": "set-has.html"
    },
    "set-remove": {
      "id": "set-remove",
      "name": "Set.remove",
      "sig": "Set.remove(s, key)",
      "kind": "namespace-method",
      "category": "set",
      "section": "Set",
      "tip": "Remove a member.",
      "page": "set-remove.html"
    },
    "set-size": {
      "id": "set-size",
      "name": "Set.size",
      "sig": "Set.size(s) -> int",
      "kind": "namespace-method",
      "category": "set",
      "section": "Set",
      "tip": "How many members.",
      "page": "set-size.html"
    },
    "set-clear": {
      "id": "set-clear",
      "name": "Set.clear",
      "sig": "Set.clear(s)",
      "kind": "namespace-method",
      "category": "set",
      "section": "Set",
      "tip": "Remove every member.",
      "page": "set-clear.html"
    },
    "set-members": {
      "id": "set-members",
      "name": "Set.members",
      "sig": "Set.members(s) -> []pointer",
      "kind": "namespace-method",
      "category": "set",
      "section": "Set",
      "tip": "Every member, as a slice of strings.",
      "page": "set-members.html"
    },
    "annot-queries": {
      "id": "annot-queries",
      "name": "@Queries",
      "sig": "@Queries(these: [Position, Velocity])",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Declare the properties a handler operates on, binding their fields by name in the body.",
      "page": "annot-queries.html"
    },
    "annot-computed": {
      "id": "annot-computed",
      "name": "@Computed",
      "sig": "@Computed on a property field",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "A derived field expanded inline wherever it is read, never stored.",
      "page": "annot-computed.html"
    },
    "annot-on": {
      "id": "annot-on",
      "name": "@On",
      "sig": "@On(Event) handler Name { … }",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Register a compile-time listener that runs whenever an event is emitted.",
      "page": "annot-on.html"
    },
    "annot-export": {
      "id": "annot-export",
      "name": "@export",
      "sig": "@export function name(…) -> R",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Expose a function as a native symbol so a host can call it.",
      "page": "annot-export.html"
    },
    "annot-sync": {
      "id": "annot-sync",
      "name": "@Sync",
      "sig": "@Sync property … / @Owned",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Mark fields as replicated and models as owned so the compiler generates networking.",
      "page": "annot-sync.html"
    },
    "annot-handles": {
      "id": "annot-handles",
      "name": "@Handles",
      "sig": "@Handles(Event) handler Name { … }",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Declarative hint naming the event or subsystem a handler is responsible for.",
      "page": "annot-handles.html"
    },
    "annot-onattach": {
      "id": "annot-onattach",
      "name": "@OnAttach",
      "sig": "@OnAttach(Property) handler Name { … }",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Run a handler when a property is structurally attached to a live instance.",
      "page": "annot-onattach.html"
    },
    "annot-ondespawn": {
      "id": "annot-ondespawn",
      "name": "@OnDespawn",
      "sig": "@OnDespawn(Model, reason: r) handler Name { … }",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Run a handler when a model instance is torn down, optionally knowing why.",
      "page": "annot-ondespawn.html"
    },
    "annot-ondetach": {
      "id": "annot-ondetach",
      "name": "@OnDetach",
      "sig": "@OnDetach(Property) handler Name { … }",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Run a handler when a property is structurally detached from a live instance.",
      "page": "annot-ondetach.html"
    },
    "annot-ondisable": {
      "id": "annot-ondisable",
      "name": "@OnDisable",
      "sig": "@OnDisable(Property) handler Name { … }",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Run a handler when a property is paused (disabled) on an instance.",
      "page": "annot-ondisable.html"
    },
    "annot-onenable": {
      "id": "annot-onenable",
      "name": "@OnEnable",
      "sig": "@OnEnable(Property) handler Name { … }",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Run a handler when a paused property is re-enabled on an instance.",
      "page": "annot-onenable.html"
    },
    "annot-onquit": {
      "id": "annot-onquit",
      "name": "@OnQuit",
      "sig": "@OnQuit handler Name { … }",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Run a handler once at shutdown, after the last frame.",
      "page": "annot-onquit.html"
    },
    "annot-onspawn": {
      "id": "annot-onspawn",
      "name": "@OnSpawn",
      "sig": "@OnSpawn(Model) handler Name { … }",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Run a handler once each time an instance of a model is spawned.",
      "page": "annot-onspawn.html"
    },
    "annot-onstart": {
      "id": "annot-onstart",
      "name": "@OnStart",
      "sig": "@OnStart handler Name { … }",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Run a handler once at boot instead of assigning it a frame phase.",
      "page": "annot-onstart.html"
    },
    "annot-owned": {
      "id": "annot-owned",
      "name": "@Owned",
      "sig": "@Owned model Name { … }",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Give a model a network owner slot so its instances can be assigned to a peer.",
      "page": "annot-owned.html"
    },
    "annot-predicted": {
      "id": "annot-predicted",
      "name": "@Predicted",
      "sig": "@Predicted handler Name { … }",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Run a control handler on the owning client speculatively and on the server authoritatively.",
      "page": "annot-predicted.html"
    },
    "annot-public": {
      "id": "annot-public",
      "name": "@Public",
      "sig": "@Public @OnSpawn(Model) handler … { … }",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Promote a lifecycle hook to a public event other modules can listen for.",
      "page": "annot-public.html"
    },
    "annot-reads": {
      "id": "annot-reads",
      "name": "@Reads",
      "sig": "@Reads(Property)",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Declare that a handler reads a property — an analysis and scheduling hint.",
      "page": "annot-reads.html"
    },
    "annot-server": {
      "id": "annot-server",
      "name": "@Server",
      "sig": "@Server handler Name { … }",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Run a handler only on the authority; clients receive the result via @Sync.",
      "page": "annot-server.html"
    },
    "annot-toclients": {
      "id": "annot-toclients",
      "name": "@ToClients",
      "sig": "@ToClients event Name { … }",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "A remote event broadcast from the server to clients — a server→clients notification.",
      "page": "annot-toclients.html"
    },
    "annot-toserver": {
      "id": "annot-toserver",
      "name": "@ToServer",
      "sig": "@ToServer event Name { … }",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "A remote event sent from a client to the server — a client→server request.",
      "page": "annot-toserver.html"
    },
    "annot-writes": {
      "id": "annot-writes",
      "name": "@Writes",
      "sig": "@Writes(Property)",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Declare that a handler writes a property — an analysis and scheduling hint.",
      "page": "annot-writes.html"
    },
    "annot-enginesystem": {
      "id": "annot-enginesystem",
      "name": "@EngineSystem",
      "sig": "\"@EngineSystem(Component, Phase) function esys_name() { … }\"",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Register a package's engine-owned system so the frame loop runs it each phase.",
      "page": "annot-enginesystem.html"
    },
    "annot-namespace": {
      "id": "annot-namespace",
      "name": "@Namespace",
      "sig": "\"@Namespace(Name) function name_method(…) -> T { … }\"",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Let a package provide a Name.method(…) namespace that dispatches to name_method.",
      "page": "annot-namespace.html"
    },
    "annot-clearcolor": {
      "id": "annot-clearcolor",
      "name": "\"@ClearColor\"",
      "sig": "\"@ClearColor(0xRRGGBB) handler Draw phase Render { … }\"",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Declare a clear colour so the Render phase auto-clears + auto-presents for you.",
      "page": "annot-clearcolor.html"
    },
    "annot-system": {
      "id": "annot-system",
      "name": "@System",
      "sig": "\"@System(Phase) function name() { … }\"",
      "kind": "annotation",
      "category": "annotations",
      "section": "Annotations",
      "tip": "Register a prebuilt binary module's system with the host at load, per phase.",
      "page": "annot-system.html"
    },
    "huge-from": {
      "id": "huge-from",
      "name": "Huge.from",
      "sig": "Huge.from(value) -> Huge",
      "kind": "namespace-method",
      "category": "huge",
      "section": "Huge",
      "tip": "Turn an int into a Huge.",
      "page": "huge-from.html"
    },
    "huge-add": {
      "id": "huge-add",
      "name": "Huge.add",
      "sig": "Huge.add(a, b) -> Huge",
      "kind": "namespace-method",
      "category": "huge",
      "section": "Huge",
      "tip": "Sum of two big numbers.",
      "page": "huge-add.html"
    },
    "huge-sub": {
      "id": "huge-sub",
      "name": "Huge.sub",
      "sig": "Huge.sub(a, b) -> Huge",
      "kind": "namespace-method",
      "category": "huge",
      "section": "Huge",
      "tip": "Difference of two big numbers.",
      "page": "huge-sub.html"
    },
    "huge-mul": {
      "id": "huge-mul",
      "name": "Huge.mul",
      "sig": "Huge.mul(a, b) -> Huge",
      "kind": "namespace-method",
      "category": "huge",
      "section": "Huge",
      "tip": "Product of two big numbers.",
      "page": "huge-mul.html"
    },
    "huge-neg": {
      "id": "huge-neg",
      "name": "Huge.neg",
      "sig": "Huge.neg(a) -> Huge",
      "kind": "namespace-method",
      "category": "huge",
      "section": "Huge",
      "tip": "Negate a big number.",
      "page": "huge-neg.html"
    },
    "huge-cmp": {
      "id": "huge-cmp",
      "name": "Huge.cmp",
      "sig": "Huge.cmp(a, b) -> int",
      "kind": "namespace-method",
      "category": "huge",
      "section": "Huge",
      "tip": "Compare two big numbers: -1, 0, or 1.",
      "page": "huge-cmp.html"
    },
    "huge-sign": {
      "id": "huge-sign",
      "name": "Huge.sign",
      "sig": "Huge.sign(a) -> int",
      "kind": "namespace-method",
      "category": "huge",
      "section": "Huge",
      "tip": "The sign: -1, 0, or 1.",
      "page": "huge-sign.html"
    },
    "huge-mantissa": {
      "id": "huge-mantissa",
      "name": "Huge.mantissa",
      "sig": "Huge.mantissa(a) -> fixed",
      "kind": "namespace-method",
      "category": "huge",
      "section": "Huge",
      "tip": "The mantissa in [1, 10).",
      "page": "huge-mantissa.html"
    },
    "huge-exp": {
      "id": "huge-exp",
      "name": "Huge.exp",
      "sig": "Huge.exp(a) -> int",
      "kind": "namespace-method",
      "category": "huge",
      "section": "Huge",
      "tip": "The base-10 exponent.",
      "page": "huge-exp.html"
    },
    "huge-str": {
      "id": "huge-str",
      "name": "Huge.str",
      "sig": "Huge.str(a) -> string",
      "kind": "namespace-method",
      "category": "huge",
      "section": "Huge",
      "tip": "Render as scientific text like 1.23e45.",
      "page": "huge-str.html"
    },
    "angle-from_degrees": {
      "id": "angle-from_degrees",
      "name": "Angle.from_degrees",
      "sig": "Angle.from_degrees(d) -> fixed",
      "kind": "namespace-method",
      "category": "angle",
      "section": "Angle",
      "tip": "Degrees to a wrapped radian angle.",
      "page": "angle-from_degrees.html"
    },
    "angle-to_degrees": {
      "id": "angle-to_degrees",
      "name": "Angle.to_degrees",
      "sig": "Angle.to_degrees(a) -> fixed",
      "kind": "namespace-method",
      "category": "angle",
      "section": "Angle",
      "tip": "Radians back to degrees.",
      "page": "angle-to_degrees.html"
    },
    "angle-wrap": {
      "id": "angle-wrap",
      "name": "Angle.wrap",
      "sig": "Angle.wrap(a) -> fixed",
      "kind": "namespace-method",
      "category": "angle",
      "section": "Angle",
      "tip": "Normalize any radian value to [-pi, pi).",
      "page": "angle-wrap.html"
    },
    "angle-sin": {
      "id": "angle-sin",
      "name": "Angle.sin",
      "sig": "Angle.sin(a) -> fixed",
      "kind": "namespace-method",
      "category": "angle",
      "section": "Angle",
      "tip": "Sine of an angle.",
      "page": "angle-sin.html"
    },
    "angle-cos": {
      "id": "angle-cos",
      "name": "Angle.cos",
      "sig": "Angle.cos(a) -> fixed",
      "kind": "namespace-method",
      "category": "angle",
      "section": "Angle",
      "tip": "Cosine of an angle.",
      "page": "angle-cos.html"
    },
    "angle-add": {
      "id": "angle-add",
      "name": "Angle.add",
      "sig": "Angle.add(a, b) -> fixed",
      "kind": "namespace-method",
      "category": "angle",
      "section": "Angle",
      "tip": "Add two angles (wrapped).",
      "page": "angle-add.html"
    },
    "angle-diff": {
      "id": "angle-diff",
      "name": "Angle.diff",
      "sig": "Angle.diff(a, b) -> fixed",
      "kind": "namespace-method",
      "category": "angle",
      "section": "Angle",
      "tip": "Shortest signed rotation from a to b.",
      "page": "angle-diff.html"
    },
    "angle-lerp": {
      "id": "angle-lerp",
      "name": "Angle.lerp",
      "sig": "Angle.lerp(a, b, t) -> fixed",
      "kind": "namespace-method",
      "category": "angle",
      "section": "Angle",
      "tip": "Interpolate along the shortest arc.",
      "page": "angle-lerp.html"
    },
    "angle-diff_degrees": {
      "id": "angle-diff_degrees",
      "name": "Angle.diff_degrees",
      "sig": "Angle.diff_degrees(a: int, b: int) -> int",
      "kind": "namespace-method",
      "category": "angle",
      "section": "Angle",
      "tip": "The signed difference between two headings in whole degrees.",
      "page": "angle-diff_degrees.html"
    },
    "percent-clamp": {
      "id": "percent-clamp",
      "name": "Percent.clamp",
      "sig": "Percent.clamp(v) -> fixed",
      "kind": "namespace-method",
      "category": "percent",
      "section": "Percent",
      "tip": "Clamp any fixed into [0, 1].",
      "page": "percent-clamp.html"
    },
    "percent-of": {
      "id": "percent-of",
      "name": "Percent.of",
      "sig": "Percent.of(num, den) -> fixed",
      "kind": "namespace-method",
      "category": "percent",
      "section": "Percent",
      "tip": "Clamped ratio num / den.",
      "page": "percent-of.html"
    },
    "percent-lerp": {
      "id": "percent-lerp",
      "name": "Percent.lerp",
      "sig": "Percent.lerp(a, b, t) -> fixed",
      "kind": "namespace-method",
      "category": "percent",
      "section": "Percent",
      "tip": "Interpolate a..b by a clamped t.",
      "page": "percent-lerp.html"
    },
    "percent-apply": {
      "id": "percent-apply",
      "name": "Percent.apply",
      "sig": "Percent.apply(value, p) -> fixed",
      "kind": "namespace-method",
      "category": "percent",
      "section": "Percent",
      "tip": "Scale a value by a clamped percent.",
      "page": "percent-apply.html"
    },
    "regex-compile": {
      "id": "regex-compile",
      "name": "Regex.compile",
      "sig": "Regex.compile(pattern) -> Regex",
      "kind": "namespace-method",
      "category": "regex",
      "section": "Regex",
      "tip": "Compile a pattern once for reuse; returns an error value (null) if it is invalid.",
      "page": "regex-compile.html"
    },
    "regex-valid": {
      "id": "regex-valid",
      "name": "Regex.valid",
      "sig": "Regex.valid(pattern) -> bool",
      "kind": "namespace-method",
      "category": "regex",
      "section": "Regex",
      "tip": "True if the pattern is well-formed (compiles without error).",
      "page": "regex-valid.html"
    },
    "regex-matches": {
      "id": "regex-matches",
      "name": "Regex.matches",
      "sig": "Regex.matches(text, pattern) -> bool",
      "kind": "namespace-method",
      "category": "regex",
      "section": "Regex",
      "tip": "True if the pattern matches anywhere in the text (a search).",
      "page": "regex-matches.html"
    },
    "regex-test": {
      "id": "regex-test",
      "name": "Regex.test",
      "sig": "Regex.test(text, re) -> bool",
      "kind": "namespace-method",
      "category": "regex",
      "section": "Regex",
      "tip": "Like matches, but reuses an already-compiled Regex.",
      "page": "regex-test.html"
    },
    "regex-find": {
      "id": "regex-find",
      "name": "Regex.find",
      "sig": "Regex.find(text, pattern) -> Match",
      "kind": "namespace-method",
      "category": "regex",
      "section": "Regex",
      "tip": "The first match of the pattern in the text (a Match, or null if none).",
      "page": "regex-find.html"
    },
    "regex-exec": {
      "id": "regex-exec",
      "name": "Regex.exec",
      "sig": "Regex.exec(text, re) -> Match",
      "kind": "namespace-method",
      "category": "regex",
      "section": "Regex",
      "tip": "Like find, but with an already-compiled Regex.",
      "page": "regex-exec.html"
    },
    "regex-next": {
      "id": "regex-next",
      "name": "Regex.next",
      "sig": "Regex.next(text, re, from) -> Match",
      "kind": "namespace-method",
      "category": "regex",
      "section": "Regex",
      "tip": "The next match at or after byte offset from — the basis of a find-all loop.",
      "page": "regex-next.html"
    },
    "regex-replace": {
      "id": "regex-replace",
      "name": "Regex.replace",
      "sig": "Regex.replace(text, pattern, replacement) -> string",
      "kind": "namespace-method",
      "category": "regex",
      "section": "Regex",
      "tip": "Replace every match; the replacement expands \\0..\\9 group references.",
      "page": "regex-replace.html"
    },
    "regex-group": {
      "id": "regex-group",
      "name": "Regex.group",
      "sig": "Regex.group(match, n) -> string",
      "kind": "namespace-method",
      "category": "regex",
      "section": "Regex",
      "tip": "The text of capture group n (group 0 is the whole match); empty if unset.",
      "page": "regex-group.html"
    },
    "regex-group_count": {
      "id": "regex-group_count",
      "name": "Regex.group_count",
      "sig": "Regex.group_count(match) -> int",
      "kind": "namespace-method",
      "category": "regex",
      "section": "Regex",
      "tip": "How many capture groups the match's pattern has.",
      "page": "regex-group_count.html"
    },
    "regex-start": {
      "id": "regex-start",
      "name": "Regex.start",
      "sig": "Regex.start(match, n) -> int",
      "kind": "namespace-method",
      "category": "regex",
      "section": "Regex",
      "tip": "The start byte offset of group n, or -1 if it did not participate.",
      "page": "regex-start.html"
    },
    "regex-end": {
      "id": "regex-end",
      "name": "Regex.end",
      "sig": "Regex.end(match, n) -> int",
      "kind": "namespace-method",
      "category": "regex",
      "section": "Regex",
      "tip": "The end byte offset of group n, or -1 if it did not participate.",
      "page": "regex-end.html"
    },
    "regex-ok": {
      "id": "regex-ok",
      "name": "Regex.ok",
      "sig": "Regex.ok(match) -> bool",
      "kind": "namespace-method",
      "category": "regex",
      "section": "Regex",
      "tip": "True if the match succeeded (the Match is non-null).",
      "page": "regex-ok.html"
    },
    "grid-line": {
      "id": "grid-line",
      "name": "Grid.line",
      "sig": "Grid.line(x0, y0, x1, y1) -> []Cell",
      "kind": "namespace-method",
      "category": "grid",
      "section": "Grid",
      "tip": "Every cell a straight line from (x0,y0) to (x1,y1) crosses (Bresenham).",
      "page": "grid-line.html"
    },
    "grid-blocked": {
      "id": "grid-blocked",
      "name": "Grid.blocked",
      "sig": "Grid.blocked(x, y, wall) -> bool",
      "kind": "namespace-method",
      "category": "grid",
      "section": "Grid",
      "tip": "True if the cell is out of bounds or holds the wall tile.",
      "page": "grid-blocked.html"
    },
    "grid-line_of_sight": {
      "id": "grid-line_of_sight",
      "name": "Grid.line_of_sight",
      "sig": "Grid.line_of_sight(x0, y0, x1, y1, wall) -> bool",
      "kind": "namespace-method",
      "category": "grid",
      "section": "Grid",
      "tip": "True if the straight line between two cells crosses no wall.",
      "page": "grid-line_of_sight.html"
    },
    "grid-flood": {
      "id": "grid-flood",
      "name": "Grid.flood",
      "sig": "Grid.flood(x, y, wall) -> []Cell",
      "kind": "namespace-method",
      "category": "grid",
      "section": "Grid",
      "tip": "Every passable cell reachable from (x,y), 4-connected, in BFS order.",
      "page": "grid-flood.html"
    },
    "grid-a_star": {
      "id": "grid-a_star",
      "name": "Grid.a_star",
      "sig": "Grid.a_star(x0, y0, x1, y1, wall) -> []Cell",
      "kind": "namespace-method",
      "category": "grid",
      "section": "Grid",
      "tip": "The shortest 4-connected path between two cells (A*), or an empty list.",
      "page": "grid-a_star.html"
    },
    "anim-frame": {
      "id": "anim-frame",
      "name": "Anim.frame",
      "sig": "Anim.frame(timer, fps, count) -> int",
      "kind": "namespace-method",
      "category": "anim",
      "section": "Anim",
      "tip": "The looping frame index for an elapsed timer at a given fps.",
      "page": "anim-frame.html"
    },
    "anim-once": {
      "id": "anim-once",
      "name": "Anim.once",
      "sig": "Anim.once(timer, fps, count) -> int",
      "kind": "namespace-method",
      "category": "anim",
      "section": "Anim",
      "tip": "A non-looping frame index that clamps on the last frame.",
      "page": "anim-once.html"
    },
    "anim-pingpong": {
      "id": "anim-pingpong",
      "name": "Anim.pingpong",
      "sig": "Anim.pingpong(timer, fps, count) -> int",
      "kind": "namespace-method",
      "category": "anim",
      "section": "Anim",
      "tip": "A frame index that bounces 0..count-1..0 and repeats.",
      "page": "anim-pingpong.html"
    },
    "anim-finished": {
      "id": "anim-finished",
      "name": "Anim.finished",
      "sig": "Anim.finished(timer, fps, count) -> bool",
      "kind": "namespace-method",
      "category": "anim",
      "section": "Anim",
      "tip": "True once a one-shot clip has run past its last frame.",
      "page": "anim-finished.html"
    },
    "anim-duration": {
      "id": "anim-duration",
      "name": "Anim.duration",
      "sig": "Anim.duration(fps, count) -> fixed",
      "kind": "namespace-method",
      "category": "anim",
      "section": "Anim",
      "tip": "Seconds for one full cycle of a clip: count / fps.",
      "page": "anim-duration.html"
    },
    "anim-cell_x": {
      "id": "anim-cell_x",
      "name": "Anim.cell_x",
      "sig": "Anim.cell_x(frame, cols, cell_w) -> int",
      "kind": "namespace-method",
      "category": "anim",
      "section": "Anim",
      "tip": "The source x (pixels) of a frame on a grid spritesheet.",
      "page": "anim-cell_x.html"
    },
    "anim-cell_y": {
      "id": "anim-cell_y",
      "name": "Anim.cell_y",
      "sig": "Anim.cell_y(frame, cols, cell_h) -> int",
      "kind": "namespace-method",
      "category": "anim",
      "section": "Anim",
      "tip": "The source y (pixels) of a frame on a grid spritesheet.",
      "page": "anim-cell_y.html"
    },
    "anim-play": {
      "id": "anim-play",
      "name": "Anim.play",
      "sig": "Anim.play(entity, clip) | Anim.play(entity, fps, frames, mode)",
      "kind": "namespace-method",
      "category": "anim",
      "section": "Anim",
      "tip": "Start (or restart) a spritesheet clip on an entity in one call.",
      "page": "anim-play.html"
    },
    "anim-clip": {
      "id": "anim-clip",
      "name": "Anim.clip",
      "sig": "Anim.clip(name, frames, fps, mode)",
      "kind": "namespace-method",
      "category": "anim",
      "section": "Anim",
      "tip": "Register a named spritesheet clip so Anim.play can play it by name.",
      "page": "anim-clip.html"
    },
    "anim-on_frame": {
      "id": "anim-on_frame",
      "name": "Anim.on_frame",
      "sig": "Anim.on_frame(entity, frame)",
      "kind": "namespace-method",
      "category": "anim",
      "section": "Anim",
      "tip": "Arm a frame event — the engine flags the tick a clip lands on this frame.",
      "page": "anim-on_frame.html"
    },
    "anim-fired": {
      "id": "anim-fired",
      "name": "Anim.fired",
      "sig": "Anim.fired(entity) -> bool",
      "kind": "namespace-method",
      "category": "anim",
      "section": "Anim",
      "tip": "Did the entity's clip land on its armed frame event this tick?",
      "page": "anim-fired.html"
    },
    "motion-to": {
      "id": "motion-to",
      "name": "Motion.to",
      "sig": "Motion.to(entity, from, to, dur, ease)",
      "kind": "namespace-method",
      "category": "motion",
      "section": "Motion",
      "tip": "Start a value tween on an entity's Motion component in one call.",
      "page": "motion-to.html"
    },
    "tween-progress": {
      "id": "tween-progress",
      "name": "Tween.progress",
      "sig": "Tween.progress(timer, duration) -> fixed",
      "kind": "namespace-method",
      "category": "tween",
      "section": "Tween",
      "tip": "A one-shot 0..1 amount, clamped, for timer over duration.",
      "page": "tween-progress.html"
    },
    "tween-loop": {
      "id": "tween-loop",
      "name": "Tween.loop",
      "sig": "Tween.loop(timer, duration) -> fixed",
      "kind": "namespace-method",
      "category": "tween",
      "section": "Tween",
      "tip": "A repeating 0..1 sawtooth amount over duration.",
      "page": "tween-loop.html"
    },
    "tween-yoyo": {
      "id": "tween-yoyo",
      "name": "Tween.yoyo",
      "sig": "Tween.yoyo(timer, duration) -> fixed",
      "kind": "namespace-method",
      "category": "tween",
      "section": "Tween",
      "tip": "A repeating 0..1..0 triangle amount over duration.",
      "page": "tween-yoyo.html"
    },
    "tween-done": {
      "id": "tween-done",
      "name": "Tween.done",
      "sig": "Tween.done(timer, duration) -> bool",
      "kind": "namespace-method",
      "category": "tween",
      "section": "Tween",
      "tip": "True once a one-shot tween's timer reaches its duration.",
      "page": "tween-done.html"
    },
    "tween-ease": {
      "id": "tween-ease",
      "name": "Tween.ease",
      "sig": "Tween.ease(t, mode) -> fixed",
      "kind": "namespace-method",
      "category": "tween",
      "section": "Tween",
      "tip": "Shape a 0..1 amount through an easing curve chosen by a literal mode.",
      "page": "tween-ease.html"
    },
    "tween-number": {
      "id": "tween-number",
      "name": "Tween.number",
      "sig": "Tween.number(from, to, t) -> fixed",
      "kind": "namespace-method",
      "category": "tween",
      "section": "Tween",
      "tip": "Linear blend of two fixeds by amount t.",
      "page": "tween-number.html"
    },
    "tween-round": {
      "id": "tween-round",
      "name": "Tween.round",
      "sig": "Tween.round(from, to, t) -> int",
      "kind": "namespace-method",
      "category": "tween",
      "section": "Tween",
      "tip": "Linear blend of two ints by amount t, rounded to the nearest int.",
      "page": "tween-round.html"
    },
    "tween-point": {
      "id": "tween-point",
      "name": "Tween.point",
      "sig": "Tween.point(from, to, t) -> Vector",
      "kind": "namespace-method",
      "category": "tween",
      "section": "Tween",
      "tip": "Component-wise blend of two Vectors by amount t.",
      "page": "tween-point.html"
    },
    "tween-tint": {
      "id": "tween-tint",
      "name": "Tween.tint",
      "sig": "Tween.tint(from, to, t) -> int",
      "kind": "namespace-method",
      "category": "tween",
      "section": "Tween",
      "tip": "Per-channel blend of two colors by amount t.",
      "page": "tween-tint.html"
    },
    "tween-to": {
      "id": "tween-to",
      "name": "Tween.to",
      "sig": "Tween.to(from, to, dur, ease) -> handle",
      "kind": "namespace-method",
      "category": "tween",
      "section": "Tween",
      "tip": "Start a fluent, engine-advanced tween and return a handle.",
      "page": "tween-to.html"
    },
    "tween-chain": {
      "id": "tween-chain",
      "name": "Tween.chain",
      "sig": "Tween.chain(handle, to, dur, ease) -> handle",
      "kind": "namespace-method",
      "category": "tween",
      "section": "Tween",
      "tip": "Append a tween segment that runs after the handle's current queue.",
      "page": "tween-chain.html"
    },
    "tween-delay": {
      "id": "tween-delay",
      "name": "Tween.delay",
      "sig": "Tween.delay(handle, ticks) -> handle",
      "kind": "namespace-method",
      "category": "tween",
      "section": "Tween",
      "tip": "Append a pause to a tween handle's sequence.",
      "page": "tween-delay.html"
    },
    "tween-value": {
      "id": "tween-value",
      "name": "Tween.value",
      "sig": "Tween.value(handle) -> int",
      "kind": "namespace-method",
      "category": "tween",
      "section": "Tween",
      "tip": "The current value of a fluent tween handle this frame.",
      "page": "tween-value.html"
    },
    "tween-stop": {
      "id": "tween-stop",
      "name": "Tween.stop",
      "sig": "Tween.stop(handle)",
      "kind": "namespace-method",
      "category": "tween",
      "section": "Tween",
      "tip": "Stop and dispose a tween handle, freezing its value.",
      "page": "tween-stop.html"
    },
    "tween-parallel": {
      "id": "tween-parallel",
      "name": "Tween.parallel",
      "sig": "Tween.parallel(a, b) -> bool",
      "kind": "namespace-method",
      "category": "tween",
      "section": "Tween",
      "tip": "Are two tween handles both finished? — a parallel completion query.",
      "page": "tween-parallel.html"
    },
    "query-count": {
      "id": "query-count",
      "name": "Query.count",
      "sig": "Query.count(prop) -> int",
      "kind": "namespace-method",
      "category": "query",
      "section": "Query",
      "tip": "How many live entities carry a property.",
      "page": "query-count.html"
    },
    "query-first": {
      "id": "query-first",
      "name": "Query.first",
      "sig": "Query.first(prop) -> int",
      "kind": "namespace-method",
      "category": "query",
      "section": "Query",
      "tip": "The lowest-id live entity carrying a property, or -1.",
      "page": "query-first.html"
    },
    "query-nearest": {
      "id": "query-nearest",
      "name": "Query.nearest",
      "sig": "Query.nearest(prop, pos, x_field, y_field, x, y) -> int",
      "kind": "namespace-method",
      "category": "query",
      "section": "Query",
      "tip": "The bearer of prop closest to a point, by squared distance.",
      "page": "query-nearest.html"
    },
    "query-within": {
      "id": "query-within",
      "name": "Query.within",
      "sig": "Query.within(prop, pos, x, y, radius, x_field, y_field) -> []int",
      "kind": "namespace-method",
      "category": "query",
      "section": "Query",
      "tip": "Every bearer of prop inside a radius of a point.",
      "page": "query-within.html"
    },
    "reflect-prop": {
      "id": "reflect-prop",
      "name": "Reflect.prop",
      "sig": "Reflect.prop(name) -> int",
      "kind": "namespace-method",
      "category": "reflect",
      "section": "Reflect",
      "tip": "The property id for a property name, or -1 if unknown.",
      "page": "reflect-prop.html"
    },
    "reflect-field": {
      "id": "reflect-field",
      "name": "Reflect.field",
      "sig": "Reflect.field(prop, name) -> int",
      "kind": "namespace-method",
      "category": "reflect",
      "section": "Reflect",
      "tip": "The field id of a named field within a property, or -1.",
      "page": "reflect-field.html"
    },
    "reflect-prop_count": {
      "id": "reflect-prop_count",
      "name": "Reflect.prop_count",
      "sig": "Reflect.prop_count() -> int",
      "kind": "namespace-method",
      "category": "reflect",
      "section": "Reflect",
      "tip": "How many properties the world schema defines.",
      "page": "reflect-prop_count.html"
    },
    "reflect-prop_name": {
      "id": "reflect-prop_name",
      "name": "Reflect.prop_name",
      "sig": "Reflect.prop_name(index) -> string",
      "kind": "namespace-method",
      "category": "reflect",
      "section": "Reflect",
      "tip": "The name of the property at an index (or \"\").",
      "page": "reflect-prop_name.html"
    },
    "reflect-field_count": {
      "id": "reflect-field_count",
      "name": "Reflect.field_count",
      "sig": "Reflect.field_count(prop) -> int",
      "kind": "namespace-method",
      "category": "reflect",
      "section": "Reflect",
      "tip": "How many fields a property has.",
      "page": "reflect-field_count.html"
    },
    "reflect-field_name": {
      "id": "reflect-field_name",
      "name": "Reflect.field_name",
      "sig": "Reflect.field_name(prop, index) -> string",
      "kind": "namespace-method",
      "category": "reflect",
      "section": "Reflect",
      "tip": "The name of the field at an index within a property.",
      "page": "reflect-field_name.html"
    },
    "reflect-field_type": {
      "id": "reflect-field_type",
      "name": "Reflect.field_type",
      "sig": "Reflect.field_type(prop, index) -> string",
      "kind": "namespace-method",
      "category": "reflect",
      "section": "Reflect",
      "tip": "The type name of the field at an index within a property.",
      "page": "reflect-field_type.html"
    },
    "reflect-get": {
      "id": "reflect-get",
      "name": "Reflect.get",
      "sig": "Reflect.get(entity, prop, field) -> int",
      "kind": "namespace-method",
      "category": "reflect",
      "section": "Reflect",
      "tip": "Read one field of an entity by (prop, field) id.",
      "page": "reflect-get.html"
    },
    "reflect-set": {
      "id": "reflect-set",
      "name": "Reflect.set",
      "sig": "Reflect.set(entity, prop, field, value)",
      "kind": "namespace-method",
      "category": "reflect",
      "section": "Reflect",
      "tip": "Write one field of an entity by (prop, field) id.",
      "page": "reflect-set.html"
    },
    "reflect-has": {
      "id": "reflect-has",
      "name": "Reflect.has",
      "sig": "Reflect.has(entity, prop) -> bool",
      "kind": "namespace-method",
      "category": "reflect",
      "section": "Reflect",
      "tip": "Does an entity carry a property?",
      "page": "reflect-has.html"
    },
    "reflect-kind": {
      "id": "reflect-kind",
      "name": "Reflect.kind",
      "sig": "Reflect.kind(entity) -> int",
      "kind": "namespace-method",
      "category": "reflect",
      "section": "Reflect",
      "tip": "The model id of an entity.",
      "page": "reflect-kind.html"
    },
    "reflect-model": {
      "id": "reflect-model",
      "name": "Reflect.model",
      "sig": "Reflect.model(name) -> int",
      "kind": "namespace-method",
      "category": "reflect",
      "section": "Reflect",
      "tip": "The model id for a model name, or -1 if unknown.",
      "page": "reflect-model.html"
    },
    "reflect-serialize": {
      "id": "reflect-serialize",
      "name": "Reflect.serialize",
      "sig": "Reflect.serialize(entity) -> value",
      "kind": "namespace-method",
      "category": "reflect",
      "section": "Reflect",
      "tip": "Walk an entity's components into a value tree.",
      "page": "reflect-serialize.html"
    },
    "reflect-apply": {
      "id": "reflect-apply",
      "name": "Reflect.apply",
      "sig": "Reflect.apply(entity, value) -> int",
      "kind": "namespace-method",
      "category": "reflect",
      "section": "Reflect",
      "tip": "Write a value tree's fields back into an entity.",
      "page": "reflect-apply.html"
    },
    "camera-set": {
      "id": "camera-set",
      "name": "Camera.set",
      "sig": "Camera.set(x, y)",
      "kind": "namespace-method",
      "category": "camera",
      "section": "Camera",
      "tip": "Place the camera at a world-space offset.",
      "page": "camera-set.html"
    },
    "camera-follow": {
      "id": "camera-follow",
      "name": "Camera.follow",
      "sig": "Camera.follow(x, y, lerp)",
      "kind": "namespace-method",
      "category": "camera",
      "section": "Camera",
      "tip": "Ease the camera toward centring a target point.",
      "page": "camera-follow.html"
    },
    "camera-shake": {
      "id": "camera-shake",
      "name": "Camera.shake",
      "sig": "Camera.shake(amount)",
      "kind": "namespace-method",
      "category": "camera",
      "section": "Camera",
      "tip": "Jitter the camera by up to +/- amount pixels (seeded RNG).",
      "page": "camera-shake.html"
    },
    "camera-zoom": {
      "id": "camera-zoom",
      "name": "Camera.zoom",
      "sig": "Camera.zoom(scale)",
      "kind": "namespace-method",
      "category": "camera",
      "section": "Camera",
      "tip": "Scale the whole view about the screen centre by a Q16.16 factor (1.0 = none).",
      "page": "camera-zoom.html"
    },
    "camera-shake_for": {
      "id": "camera-shake_for",
      "name": "Camera.shake_for",
      "sig": "Camera.shake_for(amount: px, frames: n)",
      "kind": "namespace-method",
      "category": "camera",
      "section": "Camera",
      "tip": "Shake for a number of frames, then stop, with no bookkeeping.",
      "page": "camera-shake_for.html"
    },
    "light-ambient": {
      "id": "light-ambient",
      "name": "Light.ambient",
      "sig": "Light.ambient(color)",
      "kind": "namespace-method",
      "category": "light",
      "section": "Light",
      "tip": "Multiply the whole scene by a tint — the night/cave modulate.",
      "page": "light-ambient.html"
    },
    "light-point": {
      "id": "light-point",
      "name": "Light.point",
      "sig": "Light.point(x, y, radius, color, energy)",
      "kind": "namespace-method",
      "category": "light",
      "section": "Light",
      "tip": "Add a radial glow that falls off with distance.",
      "page": "light-point.html"
    },
    "light-occlude": {
      "id": "light-occlude",
      "name": "Light.occlude",
      "sig": "Light.occlude(x, y, width, height)",
      "kind": "namespace-method",
      "category": "light",
      "section": "Light",
      "tip": "Register a rectangle that blocks light — a hard shadow caster.",
      "page": "light-occlude.html"
    },
    "light-clear_occluders": {
      "id": "light-clear_occluders",
      "name": "Light.clear_occluders",
      "sig": "Light.clear_occluders()",
      "kind": "namespace-method",
      "category": "light",
      "section": "Light",
      "tip": "Forget every occluder — call once per frame before re-registering.",
      "page": "light-clear_occluders.html"
    },
    "light-spot": {
      "id": "light-spot",
      "name": "Light.spot",
      "sig": "Light.spot(x, y, radius, color, energy, direction, spread)",
      "kind": "namespace-method",
      "category": "light",
      "section": "Light",
      "tip": "A cone / flashlight light aimed at a direction with a half-angle spread.",
      "page": "light-spot.html"
    },
    "light-falloff": {
      "id": "light-falloff",
      "name": "Light.falloff",
      "sig": "Light.falloff(exponent)",
      "kind": "namespace-method",
      "category": "light",
      "section": "Light",
      "tip": "Set the brightness-ramp exponent for later lights (1 linear, 2 quadratic…).",
      "page": "light-falloff.html"
    },
    "light-soft": {
      "id": "light-soft",
      "name": "Light.soft",
      "sig": "Light.soft(radius)",
      "kind": "namespace-method",
      "category": "light",
      "section": "Light",
      "tip": "Soft shadows — an occluder edge fades through a penumbra of this radius.",
      "page": "light-soft.html"
    },
    "light-gel": {
      "id": "light-gel",
      "name": "Light.gel",
      "sig": "Light.gel(color)",
      "kind": "namespace-method",
      "category": "light",
      "section": "Light",
      "tip": "A colour cookie — later lights gel from their centre colour to this rim colour.",
      "page": "light-gel.html"
    },
    "light-clear_gel": {
      "id": "light-clear_gel",
      "name": "Light.clear_gel",
      "sig": "Light.clear_gel()",
      "kind": "namespace-method",
      "category": "light",
      "section": "Light",
      "tip": "Clear the gel — later lights are a flat single colour again.",
      "page": "light-clear_gel.html"
    },
    "light-normal": {
      "id": "light-normal",
      "name": "Light.normal",
      "sig": "Light.normal(x, y, width, height, nx, ny)",
      "kind": "namespace-method",
      "category": "light",
      "section": "Light",
      "tip": "Stamp a surface normal over a rectangle so lights shade it by facing (N·L).",
      "page": "light-normal.html"
    },
    "light-clear_normals": {
      "id": "light-clear_normals",
      "name": "Light.clear_normals",
      "sig": "Light.clear_normals()",
      "kind": "namespace-method",
      "category": "light",
      "section": "Light",
      "tip": "Forget every stamped normal — call once per frame before re-stamping.",
      "page": "light-clear_normals.html"
    },
    "light-height": {
      "id": "light-height",
      "name": "Light.height",
      "sig": "Light.height(height)",
      "kind": "namespace-method",
      "category": "light",
      "section": "Light",
      "tip": "Set the virtual height of lights above the surface, for normal-map shading.",
      "page": "light-height.html"
    },
    "light-time_of_day": {
      "id": "light-time_of_day",
      "name": "Light.time_of_day",
      "sig": "Light.time_of_day(t)",
      "kind": "namespace-method",
      "category": "light",
      "section": "Light",
      "tip": "Set the ambient tint from a 0..1 time-of-day — a day/night cycle in one value.",
      "page": "light-time_of_day.html"
    },
    "sprite-sheet": {
      "id": "sprite-sheet",
      "name": "Sprite.sheet",
      "sig": "Sprite.sheet(path, cellw, cellh) -> int",
      "kind": "namespace-method",
      "category": "sprite",
      "section": "Sprite",
      "tip": "Load a spritesheet and remember its cell grid; returns a sheet handle.",
      "page": "sprite-sheet.html"
    },
    "sprite-cell": {
      "id": "sprite-cell",
      "name": "Sprite.cell",
      "sig": "Sprite.cell(sheet, col, row) -> int",
      "kind": "namespace-method",
      "category": "sprite",
      "section": "Sprite",
      "tip": "One cell of a sheet, by grid coords; returns a sprite id.",
      "page": "sprite-cell.html"
    },
    "sprite-cell_span": {
      "id": "sprite-cell_span",
      "name": "Sprite.cell_span",
      "sig": "Sprite.cell_span(sheet, col, row, cols, rows) -> int",
      "kind": "namespace-method",
      "category": "sprite",
      "section": "Sprite",
      "tip": "A sprite spanning cols x rows cells (tall/wide art).",
      "page": "sprite-cell_span.html"
    },
    "sprite-define": {
      "id": "sprite-define",
      "name": "Sprite.define",
      "sig": "Sprite.define(name, sheet, col, row) -> int",
      "kind": "namespace-method",
      "category": "sprite",
      "section": "Sprite",
      "tip": "Name a cell for later lookup; returns its sprite id.",
      "page": "sprite-define.html"
    },
    "sprite-named": {
      "id": "sprite-named",
      "name": "Sprite.named",
      "sig": "Sprite.named(name) -> int",
      "kind": "namespace-method",
      "category": "sprite",
      "section": "Sprite",
      "tip": "Look up a named sprite's id, or -1.",
      "page": "sprite-named.html"
    },
    "sprite-draw": {
      "id": "sprite-draw",
      "name": "Sprite.draw",
      "sig": "Sprite.draw(id, x, y)",
      "kind": "namespace-method",
      "category": "sprite",
      "section": "Sprite",
      "tip": "Blit an atlas sprite at (x, y) through the camera/zoom/clip.",
      "page": "sprite-draw.html"
    },
    "sprite-draw_scaled": {
      "id": "sprite-draw_scaled",
      "name": "Sprite.draw_scaled",
      "sig": "Sprite.draw_scaled(id, x, y, scale)",
      "kind": "namespace-method",
      "category": "sprite",
      "section": "Sprite",
      "tip": "Blit an atlas sprite scaled by an integer factor.",
      "page": "sprite-draw_scaled.html"
    },
    "sprite-width": {
      "id": "sprite-width",
      "name": "Sprite.width",
      "sig": "Sprite.width(id) -> int",
      "kind": "namespace-method",
      "category": "sprite",
      "section": "Sprite",
      "tip": "The atlas sprite's width in pixels.",
      "page": "sprite-width.html"
    },
    "sprite-height": {
      "id": "sprite-height",
      "name": "Sprite.height",
      "sig": "Sprite.height(id) -> int",
      "kind": "namespace-method",
      "category": "sprite",
      "section": "Sprite",
      "tip": "The atlas sprite's height in pixels.",
      "page": "sprite-height.html"
    },
    "sprite-strip": {
      "id": "sprite-strip",
      "name": "Sprite.strip",
      "sig": "Sprite.strip(sheet, col, row, count, rows) -> int",
      "kind": "namespace-method",
      "category": "sprite",
      "section": "Sprite",
      "tip": "A run of animation frames as consecutive sprite ids.",
      "page": "sprite-strip.html"
    },
    "sprite-draw_meter": {
      "id": "sprite-draw_meter",
      "name": "Sprite.draw_meter",
      "sig": "Sprite.draw_meter(x:, y:, value:, max:, per_icon:, spacing:, full:, half:, empty:)",
      "kind": "namespace-method",
      "category": "sprite",
      "section": "Sprite",
      "tip": "A value as a row of full / half / empty icons.",
      "page": "sprite-draw_meter.html"
    },
    "assets-image": {
      "id": "assets-image",
      "name": "Assets.image",
      "sig": "Assets.image(path) -> int",
      "kind": "namespace-method",
      "category": "assets",
      "section": "Assets",
      "tip": "Load a whole image file as one sprite; returns its id.",
      "page": "assets-image.html"
    },
    "assets-load": {
      "id": "assets-load",
      "name": "Assets.load",
      "sig": "Assets.load(path) -> int",
      "kind": "namespace-method",
      "category": "assets",
      "section": "Assets",
      "tip": "Alias of Assets.image.",
      "page": "assets-load.html"
    },
    "assets-get": {
      "id": "assets-get",
      "name": "Assets.get",
      "sig": "Assets.get(name) -> int",
      "kind": "namespace-method",
      "category": "assets",
      "section": "Assets",
      "tip": "Look up a named sprite's id (alias of Sprite.named).",
      "page": "assets-get.html"
    },
    "assets-enqueue": {
      "id": "assets-enqueue",
      "name": "Assets.enqueue",
      "sig": "Assets.enqueue(name, path)",
      "kind": "namespace-method",
      "category": "assets",
      "section": "Assets",
      "tip": "Queue a named image file to preload later.",
      "page": "assets-enqueue.html"
    },
    "assets-pump": {
      "id": "assets-pump",
      "name": "Assets.pump",
      "sig": "Assets.pump(max) -> int",
      "kind": "namespace-method",
      "category": "assets",
      "section": "Assets",
      "tip": "Load up to max queued assets this frame; returns how many it loaded.",
      "page": "assets-pump.html"
    },
    "assets-total": {
      "id": "assets-total",
      "name": "Assets.total",
      "sig": "Assets.total() -> int",
      "kind": "namespace-method",
      "category": "assets",
      "section": "Assets",
      "tip": "How many assets are enqueued.",
      "page": "assets-total.html"
    },
    "assets-loaded": {
      "id": "assets-loaded",
      "name": "Assets.loaded",
      "sig": "Assets.loaded() -> int",
      "kind": "namespace-method",
      "category": "assets",
      "section": "Assets",
      "tip": "How many enqueued assets have loaded so far.",
      "page": "assets-loaded.html"
    },
    "assets-ready": {
      "id": "assets-ready",
      "name": "Assets.ready",
      "sig": "Assets.ready() -> int",
      "kind": "namespace-method",
      "category": "assets",
      "section": "Assets",
      "tip": "1 once every enqueued asset has loaded.",
      "page": "assets-ready.html"
    },
    "assets-font": {
      "id": "assets-font",
      "name": "Assets.font",
      "sig": "Assets.font(name: s) -> int",
      "kind": "namespace-method",
      "category": "assets",
      "section": "Assets",
      "tip": "A font loaded through the preload queue, by name.",
      "page": "assets-font.html"
    },
    "assets-progress": {
      "id": "assets-progress",
      "name": "Assets.progress",
      "sig": "Assets.progress() -> int",
      "kind": "namespace-method",
      "category": "assets",
      "section": "Assets",
      "tip": "Loading progress as a 0..100 percent.",
      "page": "assets-progress.html"
    },
    "assets-enqueue_dir": {
      "id": "assets-enqueue_dir",
      "name": "Assets.enqueue_dir",
      "sig": "Assets.enqueue_dir(path: dir)",
      "kind": "namespace-method",
      "category": "assets",
      "section": "Assets",
      "tip": "Enqueue every file of a directory, named by its file name.",
      "page": "assets-enqueue_dir.html"
    },
    "kw-test": {
      "id": "kw-test",
      "name": "test",
      "sig": "test \"name\" { … }",
      "kind": "keyword",
      "category": "testing",
      "section": "Testing",
      "tip": "A named test block, run automatically with pass/fail reporting.",
      "page": "kw-test.html"
    },
    "pool-live": {
      "id": "pool-live",
      "name": "Pool.live",
      "sig": "Pool.live() -> int",
      "kind": "namespace-method",
      "category": "pool",
      "section": "Pool",
      "tip": "How many entities are currently alive.",
      "page": "pool-live.html"
    },
    "pool-free": {
      "id": "pool-free",
      "name": "Pool.free",
      "sig": "Pool.free() -> int",
      "kind": "namespace-method",
      "category": "pool",
      "section": "Pool",
      "tip": "How many freed slots are waiting to be reused.",
      "page": "pool-free.html"
    },
    "pool-reserved": {
      "id": "pool-reserved",
      "name": "Pool.reserved",
      "sig": "Pool.reserved() -> int",
      "kind": "namespace-method",
      "category": "pool",
      "section": "Pool",
      "tip": "High-water: how many slots have ever been allocated.",
      "page": "pool-reserved.html"
    },
    "pool-capacity": {
      "id": "pool-capacity",
      "name": "Pool.capacity",
      "sig": "Pool.capacity() -> int",
      "kind": "namespace-method",
      "category": "pool",
      "section": "Pool",
      "tip": "The maximum number of entities.",
      "page": "pool-capacity.html"
    },
    "value-null": {
      "id": "value-null",
      "name": "Value.null",
      "sig": "Value.null() -> value",
      "kind": "namespace-method",
      "category": "value",
      "section": "Value",
      "tip": "An empty null node.",
      "page": "value-null.html"
    },
    "value-int": {
      "id": "value-int",
      "name": "Value.int",
      "sig": "Value.int(n: int) -> value",
      "kind": "namespace-method",
      "category": "value",
      "section": "Value",
      "tip": "Wrap an int in a value node.",
      "page": "value-int.html"
    },
    "value-fixed": {
      "id": "value-fixed",
      "name": "Value.fixed",
      "sig": "Value.fixed(f: fixed) -> value",
      "kind": "namespace-method",
      "category": "value",
      "section": "Value",
      "tip": "Wrap a fixed in a value node.",
      "page": "value-fixed.html"
    },
    "value-bool": {
      "id": "value-bool",
      "name": "Value.bool",
      "sig": "Value.bool(b: bool) -> value",
      "kind": "namespace-method",
      "category": "value",
      "section": "Value",
      "tip": "Wrap a bool in a value node.",
      "page": "value-bool.html"
    },
    "value-str": {
      "id": "value-str",
      "name": "Value.str",
      "sig": "Value.str(s: string) -> value",
      "kind": "namespace-method",
      "category": "value",
      "section": "Value",
      "tip": "Wrap a string in a value node.",
      "page": "value-str.html"
    },
    "value-list": {
      "id": "value-list",
      "name": "Value.list",
      "sig": "Value.list() -> value",
      "kind": "namespace-method",
      "category": "value",
      "section": "Value",
      "tip": "An empty list node.",
      "page": "value-list.html"
    },
    "value-object": {
      "id": "value-object",
      "name": "Value.object",
      "sig": "Value.object() -> value",
      "kind": "namespace-method",
      "category": "value",
      "section": "Value",
      "tip": "An empty object node.",
      "page": "value-object.html"
    },
    "value-add": {
      "id": "value-add",
      "name": "Value.add",
      "sig": "Value.add(list, item) -> value",
      "kind": "namespace-method",
      "category": "value",
      "section": "Value",
      "tip": "Append an item to a list; returns the list.",
      "page": "value-add.html"
    },
    "value-put": {
      "id": "value-put",
      "name": "Value.put",
      "sig": "Value.put(obj, key: string, item) -> value",
      "kind": "namespace-method",
      "category": "value",
      "section": "Value",
      "tip": "Set a key on an object; returns the object.",
      "page": "value-put.html"
    },
    "value-get": {
      "id": "value-get",
      "name": "Value.get",
      "sig": "Value.get(obj, key: string) -> value",
      "kind": "namespace-method",
      "category": "value",
      "section": "Value",
      "tip": "Read a member of an object by key.",
      "page": "value-get.html"
    },
    "value-has": {
      "id": "value-has",
      "name": "Value.has",
      "sig": "Value.has(obj, key: string) -> bool",
      "kind": "namespace-method",
      "category": "value",
      "section": "Value",
      "tip": "Whether an object has a member.",
      "page": "value-has.html"
    },
    "value-at": {
      "id": "value-at",
      "name": "Value.at",
      "sig": "Value.at(list, index: int) -> value",
      "kind": "namespace-method",
      "category": "value",
      "section": "Value",
      "tip": "Read a list item by index.",
      "page": "value-at.html"
    },
    "value-key_at": {
      "id": "value-key_at",
      "name": "Value.key_at",
      "sig": "Value.key_at(obj, index: int) -> string",
      "kind": "namespace-method",
      "category": "value",
      "section": "Value",
      "tip": "The key of an object member by position.",
      "page": "value-key_at.html"
    },
    "value-count": {
      "id": "value-count",
      "name": "Value.count",
      "sig": "Value.count(value) -> int",
      "kind": "namespace-method",
      "category": "value",
      "section": "Value",
      "tip": "Number of items/members in a list or object.",
      "page": "value-count.html"
    },
    "value-kind": {
      "id": "value-kind",
      "name": "Value.kind",
      "sig": "Value.kind(value) -> int",
      "kind": "namespace-method",
      "category": "value",
      "section": "Value",
      "tip": "The node's kind tag.",
      "page": "value-kind.html"
    },
    "value-as_int": {
      "id": "value-as_int",
      "name": "Value.as_int",
      "sig": "Value.as_int(value) -> int",
      "kind": "namespace-method",
      "category": "value",
      "section": "Value",
      "tip": "Read a scalar node as an int.",
      "page": "value-as_int.html"
    },
    "value-as_str": {
      "id": "value-as_str",
      "name": "Value.as_str",
      "sig": "Value.as_str(value) -> string",
      "kind": "namespace-method",
      "category": "value",
      "section": "Value",
      "tip": "Read a str node's text.",
      "page": "value-as_str.html"
    },
    "json-encode": {
      "id": "json-encode",
      "name": "Json.encode",
      "sig": "Json.encode(value) -> string",
      "kind": "namespace-method",
      "category": "json",
      "section": "Json",
      "tip": "Serialize a value tree to compact JSON text.",
      "page": "json-encode.html"
    },
    "json-parse": {
      "id": "json-parse",
      "name": "Json.parse",
      "sig": "Json.parse(text: string) -> value",
      "kind": "namespace-method",
      "category": "json",
      "section": "Json",
      "tip": "Parse JSON text into a value tree.",
      "page": "json-parse.html"
    },
    "job-defer": {
      "id": "job-defer",
      "name": "Job.defer",
      "sig": "Job.defer() -> Job",
      "kind": "namespace-method",
      "category": "job",
      "section": "Job",
      "tip": "A future you resolve yourself later.",
      "page": "job-defer.html"
    },
    "job-run": {
      "id": "job-run",
      "name": "Job.run",
      "sig": "Job.run(kind, arg) -> Job",
      "kind": "namespace-method",
      "category": "job",
      "section": "Job",
      "tip": "Start a background compute job.",
      "page": "job-run.html"
    },
    "job-fulfill": {
      "id": "job-fulfill",
      "name": "Job.fulfill",
      "sig": "Job.fulfill(handle, value) -> void",
      "kind": "namespace-method",
      "category": "job",
      "section": "Job",
      "tip": "Resolve a pending job with a value.",
      "page": "job-fulfill.html"
    },
    "job-fail": {
      "id": "job-fail",
      "name": "Job.fail",
      "sig": "Job.fail(handle, error) -> void",
      "kind": "namespace-method",
      "category": "job",
      "section": "Job",
      "tip": "Resolve a pending job as failed.",
      "page": "job-fail.html"
    },
    "job-cancel": {
      "id": "job-cancel",
      "name": "Job.cancel",
      "sig": "Job.cancel(handle) -> void",
      "kind": "namespace-method",
      "category": "job",
      "section": "Job",
      "tip": "Cancel a job before it finishes.",
      "page": "job-cancel.html"
    },
    "job-pump": {
      "id": "job-pump",
      "name": "Job.pump",
      "sig": "Job.pump(budget) -> int",
      "kind": "namespace-method",
      "category": "job",
      "section": "Job",
      "tip": "Advance background jobs; collect results.",
      "page": "job-pump.html"
    },
    "job-done": {
      "id": "job-done",
      "name": "Job.done",
      "sig": "Job.done(handle) -> bool",
      "kind": "namespace-method",
      "category": "job",
      "section": "Job",
      "tip": "Has the job resolved (any outcome)?",
      "page": "job-done.html"
    },
    "job-ok": {
      "id": "job-ok",
      "name": "Job.ok",
      "sig": "Job.ok(handle) -> bool",
      "kind": "namespace-method",
      "category": "job",
      "section": "Job",
      "tip": "Did the job succeed?",
      "page": "job-ok.html"
    },
    "job-failed": {
      "id": "job-failed",
      "name": "Job.failed",
      "sig": "Job.failed(handle) -> bool",
      "kind": "namespace-method",
      "category": "job",
      "section": "Job",
      "tip": "Did the job fail?",
      "page": "job-failed.html"
    },
    "job-cancelled": {
      "id": "job-cancelled",
      "name": "Job.cancelled",
      "sig": "Job.cancelled(handle) -> bool",
      "kind": "namespace-method",
      "category": "job",
      "section": "Job",
      "tip": "Was the job cancelled?",
      "page": "job-cancelled.html"
    },
    "job-result": {
      "id": "job-result",
      "name": "Job.result",
      "sig": "Job.result(handle) -> int",
      "kind": "namespace-method",
      "category": "job",
      "section": "Job",
      "tip": "The success value of a done job.",
      "page": "job-result.html"
    },
    "job-error": {
      "id": "job-error",
      "name": "Job.error",
      "sig": "Job.error(handle) -> int",
      "kind": "namespace-method",
      "category": "job",
      "section": "Job",
      "tip": "The error code of a failed job.",
      "page": "job-error.html"
    },
    "job-pending": {
      "id": "job-pending",
      "name": "Job.pending",
      "sig": "Job.pending() -> int",
      "kind": "namespace-method",
      "category": "job",
      "section": "Job",
      "tip": "How many jobs are still unresolved.",
      "page": "job-pending.html"
    },
    "job-free": {
      "id": "job-free",
      "name": "Job.free",
      "sig": "Job.free(handle) -> void",
      "kind": "namespace-method",
      "category": "job",
      "section": "Job",
      "tip": "Release a job slot back to the pool.",
      "page": "job-free.html"
    },
    "job-parallel_for": {
      "id": "job-parallel_for",
      "name": "Job.parallel_for",
      "sig": "Job.parallel_for(count, work, ctx) -> void",
      "kind": "namespace-method",
      "category": "job",
      "section": "Job",
      "tip": "Run work(i, ctx) for every i in [0, count) across all cores; returns when every call is done.",
      "page": "job-parallel_for.html"
    },
    "job-is_worker": {
      "id": "job-is_worker",
      "name": "Job.is_worker",
      "sig": "Job.is_worker() -> bool",
      "kind": "namespace-method",
      "category": "job",
      "section": "Job",
      "tip": "True on a Job.parallel_for pool thread, false on the main thread.",
      "page": "job-is_worker.html"
    },
    "promise-all": {
      "id": "promise-all",
      "name": "Promise.all",
      "sig": "Promise.all(handles) -> Job",
      "kind": "namespace-method",
      "category": "promise",
      "section": "Promise",
      "tip": "Succeeds when every member succeeds.",
      "page": "promise-all.html"
    },
    "promise-race": {
      "id": "promise-race",
      "name": "Promise.race",
      "sig": "Promise.race(handles) -> Job",
      "kind": "namespace-method",
      "category": "promise",
      "section": "Promise",
      "tip": "Succeeds when the first member does.",
      "page": "promise-race.html"
    },
    "promise-count_done": {
      "id": "promise-count_done",
      "name": "Promise.count_done",
      "sig": "Promise.count_done(handles) -> int",
      "kind": "namespace-method",
      "category": "promise",
      "section": "Promise",
      "tip": "How many members have resolved.",
      "page": "promise-count_done.html"
    },
    "promise-all_done": {
      "id": "promise-all_done",
      "name": "Promise.all_done",
      "sig": "Promise.all_done(handles) -> bool",
      "kind": "namespace-method",
      "category": "promise",
      "section": "Promise",
      "tip": "Have all members resolved?",
      "page": "promise-all_done.html"
    },
    "sync-mutex": {
      "id": "sync-mutex",
      "name": "Sync.mutex",
      "sig": "Sync.mutex() -> int",
      "kind": "namespace-method",
      "category": "sync",
      "section": "Sync",
      "tip": "Create a cooperative lock.",
      "page": "sync-mutex.html"
    },
    "sync-lock": {
      "id": "sync-lock",
      "name": "Sync.lock",
      "sig": "Sync.lock(mutex) -> void",
      "kind": "namespace-method",
      "category": "sync",
      "section": "Sync",
      "tip": "Take the lock.",
      "page": "sync-lock.html"
    },
    "sync-unlock": {
      "id": "sync-unlock",
      "name": "Sync.unlock",
      "sig": "Sync.unlock(mutex) -> void",
      "kind": "namespace-method",
      "category": "sync",
      "section": "Sync",
      "tip": "Release the lock.",
      "page": "sync-unlock.html"
    },
    "sync-try_lock": {
      "id": "sync-try_lock",
      "name": "Sync.try_lock",
      "sig": "Sync.try_lock(mutex) -> bool",
      "kind": "namespace-method",
      "category": "sync",
      "section": "Sync",
      "tip": "Take the lock only if it is free.",
      "page": "sync-try_lock.html"
    },
    "sync-atomic": {
      "id": "sync-atomic",
      "name": "Sync.atomic",
      "sig": "Sync.atomic() -> int",
      "kind": "namespace-method",
      "category": "sync",
      "section": "Sync",
      "tip": "Create an atomic counter (starts at 0).",
      "page": "sync-atomic.html"
    },
    "sync-get": {
      "id": "sync-get",
      "name": "Sync.get",
      "sig": "Sync.get(atomic) -> int",
      "kind": "namespace-method",
      "category": "sync",
      "section": "Sync",
      "tip": "Read the counter.",
      "page": "sync-get.html"
    },
    "sync-set": {
      "id": "sync-set",
      "name": "Sync.set",
      "sig": "Sync.set(atomic, value) -> void",
      "kind": "namespace-method",
      "category": "sync",
      "section": "Sync",
      "tip": "Store a value in the counter.",
      "page": "sync-set.html"
    },
    "sync-add": {
      "id": "sync-add",
      "name": "Sync.add",
      "sig": "Sync.add(atomic, delta) -> int",
      "kind": "namespace-method",
      "category": "sync",
      "section": "Sync",
      "tip": "Add to the counter; return the new value.",
      "page": "sync-add.html"
    },
    "sync-cas": {
      "id": "sync-cas",
      "name": "Sync.cas",
      "sig": "Sync.cas(atomic, expect, next) -> bool",
      "kind": "namespace-method",
      "category": "sync",
      "section": "Sync",
      "tip": "Compare-and-set the counter.",
      "page": "sync-cas.html"
    },
    "sync-channel": {
      "id": "sync-channel",
      "name": "Sync.channel",
      "sig": "Sync.channel() -> int",
      "kind": "namespace-method",
      "category": "sync",
      "section": "Sync",
      "tip": "Create a bounded int FIFO channel.",
      "page": "sync-channel.html"
    },
    "sync-send": {
      "id": "sync-send",
      "name": "Sync.send",
      "sig": "Sync.send(channel, value) -> bool",
      "kind": "namespace-method",
      "category": "sync",
      "section": "Sync",
      "tip": "Enqueue a value (false if full).",
      "page": "sync-send.html"
    },
    "sync-recv": {
      "id": "sync-recv",
      "name": "Sync.recv",
      "sig": "Sync.recv(channel) -> int",
      "kind": "namespace-method",
      "category": "sync",
      "section": "Sync",
      "tip": "Dequeue the oldest value.",
      "page": "sync-recv.html"
    },
    "sync-can_recv": {
      "id": "sync-can_recv",
      "name": "Sync.can_recv",
      "sig": "Sync.can_recv(channel) -> bool",
      "kind": "namespace-method",
      "category": "sync",
      "section": "Sync",
      "tip": "Is there a value waiting?",
      "page": "sync-can_recv.html"
    },
    "sync-len": {
      "id": "sync-len",
      "name": "Sync.len",
      "sig": "Sync.len(channel) -> int",
      "kind": "namespace-method",
      "category": "sync",
      "section": "Sync",
      "tip": "How many values are queued.",
      "page": "sync-len.html"
    },
    "sync-cpu_count": {
      "id": "sync-cpu_count",
      "name": "Sync.cpu_count",
      "sig": "Sync.cpu_count() -> int",
      "kind": "namespace-method",
      "category": "sync",
      "section": "Sync",
      "tip": "The machine's logical cores (1 to 64); Job.parallel_for uses one thread per core.",
      "page": "sync-cpu_count.html"
    },
    "xml-parse": {
      "id": "xml-parse",
      "name": "Xml.parse",
      "sig": "Xml.parse(text: string) -> xml",
      "kind": "namespace-method",
      "category": "xml",
      "section": "Xml",
      "tip": "Parse XML text into an element tree.",
      "page": "xml-parse.html"
    },
    "xml-tag": {
      "id": "xml-tag",
      "name": "Xml.tag",
      "sig": "Xml.tag(node) -> string",
      "kind": "namespace-method",
      "category": "xml",
      "section": "Xml",
      "tip": "The element's tag name.",
      "page": "xml-tag.html"
    },
    "xml-text": {
      "id": "xml-text",
      "name": "Xml.text",
      "sig": "Xml.text(node) -> string",
      "kind": "namespace-method",
      "category": "xml",
      "section": "Xml",
      "tip": "The element's character data.",
      "page": "xml-text.html"
    },
    "xml-attr": {
      "id": "xml-attr",
      "name": "Xml.attr",
      "sig": "Xml.attr(node, key: string) -> string",
      "kind": "namespace-method",
      "category": "xml",
      "section": "Xml",
      "tip": "An attribute's value by name.",
      "page": "xml-attr.html"
    },
    "xml-attr_int": {
      "id": "xml-attr_int",
      "name": "Xml.attr_int",
      "sig": "Xml.attr_int(node, key: string, dflt: int) -> int",
      "kind": "namespace-method",
      "category": "xml",
      "section": "Xml",
      "tip": "An attribute parsed as an integer.",
      "page": "xml-attr_int.html"
    },
    "xml-has": {
      "id": "xml-has",
      "name": "Xml.has",
      "sig": "Xml.has(node, key: string) -> int",
      "kind": "namespace-method",
      "category": "xml",
      "section": "Xml",
      "tip": "Whether an attribute is present.",
      "page": "xml-has.html"
    },
    "xml-attr_count": {
      "id": "xml-attr_count",
      "name": "Xml.attr_count",
      "sig": "Xml.attr_count(node) -> int",
      "kind": "namespace-method",
      "category": "xml",
      "section": "Xml",
      "tip": "How many attributes the element has.",
      "page": "xml-attr_count.html"
    },
    "xml-child_count": {
      "id": "xml-child_count",
      "name": "Xml.child_count",
      "sig": "Xml.child_count(node) -> int",
      "kind": "namespace-method",
      "category": "xml",
      "section": "Xml",
      "tip": "How many child elements.",
      "page": "xml-child_count.html"
    },
    "xml-child": {
      "id": "xml-child",
      "name": "Xml.child",
      "sig": "Xml.child(node, index: int) -> xml",
      "kind": "namespace-method",
      "category": "xml",
      "section": "Xml",
      "tip": "A child element by index.",
      "page": "xml-child.html"
    },
    "xml-find": {
      "id": "xml-find",
      "name": "Xml.find",
      "sig": "Xml.find(node, tag: string) -> xml",
      "kind": "namespace-method",
      "category": "xml",
      "section": "Xml",
      "tip": "The first child with a given tag.",
      "page": "xml-find.html"
    },
    "xml-count": {
      "id": "xml-count",
      "name": "Xml.count",
      "sig": "Xml.count(node, tag: string) -> int",
      "kind": "namespace-method",
      "category": "xml",
      "section": "Xml",
      "tip": "How many children have a given tag.",
      "page": "xml-count.html"
    },
    "base64-decode": {
      "id": "base64-decode",
      "name": "Base64.decode",
      "sig": "Base64.decode(src: string) -> string",
      "kind": "namespace-method",
      "category": "base64",
      "section": "Base64",
      "tip": "Decode standard base64 text to bytes.",
      "page": "base64-decode.html"
    },
    "base64-encode": {
      "id": "base64-encode",
      "name": "Base64.encode",
      "sig": "Base64.encode(src: string) -> string",
      "kind": "namespace-method",
      "category": "base64",
      "section": "Base64",
      "tip": "Encode bytes as standard base64 text.",
      "page": "base64-encode.html"
    },
    "tiled-read": {
      "id": "tiled-read",
      "name": "Tiled.read",
      "sig": "Tiled.read(path: string) -> value",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "Read a map file into the intermediate value tree.",
      "page": "tiled-read.html"
    },
    "tiled-read_tsx": {
      "id": "tiled-read_tsx",
      "name": "Tiled.read_tsx",
      "sig": "Tiled.read_tsx(path: string) -> value",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "Read a tileset file into a value object.",
      "page": "tiled-read_tsx.html"
    },
    "tiled-load": {
      "id": "tiled-load",
      "name": "Tiled.load",
      "sig": "Tiled.load(path: string) -> map",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "Load a map file into the runtime map model.",
      "page": "tiled-load.html"
    },
    "tiled-gid": {
      "id": "tiled-gid",
      "name": "Tiled.gid",
      "sig": "Tiled.gid(map, layer: int, x: int, y: int) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "The raw GID at a cell in a tile layer.",
      "page": "tiled-gid.html"
    },
    "tiled-resolve": {
      "id": "tiled-resolve",
      "name": "Tiled.resolve",
      "sig": "Tiled.resolve(map, gid: int) -> gidinfo",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "Decode a GID into tileset, local id and flip flags.",
      "page": "tiled-resolve.html"
    },
    "tiled-width": {
      "id": "tiled-width",
      "name": "Tiled.width",
      "sig": "Tiled.width(map) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "The map width in tiles.",
      "page": "tiled-width.html"
    },
    "tiled-height": {
      "id": "tiled-height",
      "name": "Tiled.height",
      "sig": "Tiled.height(map) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "The map height in tiles.",
      "page": "tiled-height.html"
    },
    "tiled-layer_count": {
      "id": "tiled-layer_count",
      "name": "Tiled.layer_count",
      "sig": "Tiled.layer_count(map) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "How many layers the map has.",
      "page": "tiled-layer_count.html"
    },
    "tiled-layer_name": {
      "id": "tiled-layer_name",
      "name": "Tiled.layer_name",
      "sig": "Tiled.layer_name(map, index: int) -> string",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "A layer's name by index.",
      "page": "tiled-layer_name.html"
    },
    "tiled-draw": {
      "id": "tiled-draw",
      "name": "Tiled.draw",
      "sig": "Tiled.draw(map, camx: int, camy: int) -> void",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "Draw every visible tile layer.",
      "page": "tiled-draw.html"
    },
    "tiled-project": {
      "id": "tiled-project",
      "name": "Tiled.project",
      "sig": "Tiled.project(map, layer: int) -> void",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "Project a collision layer to the byte tilemap.",
      "page": "tiled-project.html"
    },
    "tiled-tree": {
      "id": "tiled-tree",
      "name": "Tiled.tree",
      "sig": "Tiled.tree(map) -> value",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "The underlying intermediate value tree.",
      "page": "tiled-tree.html"
    },
    "tiled-tile_prop": {
      "id": "tiled-tile_prop",
      "name": "Tiled.tile_prop",
      "sig": "Tiled.tile_prop(map, gid: int, name: string) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "Whether a GID's tile carries a bool property.",
      "page": "tiled-tile_prop.html"
    },
    "tiled-collide": {
      "id": "tiled-collide",
      "name": "Tiled.collide",
      "sig": "Tiled.collide(map, layer: int) -> void",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "Drive collision from per-tile metadata.",
      "page": "tiled-collide.html"
    },
    "tiled-collision_kind": {
      "id": "tiled-collision_kind",
      "name": "Tiled.collision_kind",
      "sig": "Tiled.collision_kind(map, gid: int) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "Classify a GID's collision from its tile metadata.",
      "page": "tiled-collision_kind.html"
    },
    "tiled-tile_shapes": {
      "id": "tiled-tile_shapes",
      "name": "Tiled.tile_shapes",
      "sig": "Tiled.tile_shapes(map, gid: int) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "Whether a GID's tile has a collision shape.",
      "page": "tiled-tile_shapes.html"
    },
    "tiled-draw_anim": {
      "id": "tiled-draw_anim",
      "name": "Tiled.draw_anim",
      "sig": "Tiled.draw_anim(map, camx: int, camy: int, frame: int) -> void",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "Draw with animated tiles advanced to a frame.",
      "page": "tiled-draw_anim.html"
    },
    "tiled-frame_gid": {
      "id": "tiled-frame_gid",
      "name": "Tiled.frame_gid",
      "sig": "Tiled.frame_gid(map, gid: int, frame: int) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "The current GID of an animated tile at a frame.",
      "page": "tiled-frame_gid.html"
    },
    "tiled-animated": {
      "id": "tiled-animated",
      "name": "Tiled.animated",
      "sig": "Tiled.animated(map, gid: int) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "Whether a GID's tile is animated.",
      "page": "tiled-animated.html"
    },
    "tiled-object_count": {
      "id": "tiled-object_count",
      "name": "Tiled.object_count",
      "sig": "Tiled.object_count(map, layer: int) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "How many objects an object layer holds.",
      "page": "tiled-object_count.html"
    },
    "tiled-object": {
      "id": "tiled-object",
      "name": "Tiled.object",
      "sig": "Tiled.object(map, layer: int, index: int) -> value",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "An object on an object layer by index.",
      "page": "tiled-object.html"
    },
    "tiled-object_shape": {
      "id": "tiled-object_shape",
      "name": "Tiled.object_shape",
      "sig": "Tiled.object_shape(object) -> string",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "Classify an object's shape.",
      "page": "tiled-object_shape.html"
    },
    "tiled-prop": {
      "id": "tiled-prop",
      "name": "Tiled.prop",
      "sig": "Tiled.prop(container, name: string) -> string",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "A custom property's value, with class-default fallback.",
      "page": "tiled-prop.html"
    },
    "tiled-prop_int": {
      "id": "tiled-prop_int",
      "name": "Tiled.prop_int",
      "sig": "Tiled.prop_int(container, name: string) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "A custom property parsed as an integer.",
      "page": "tiled-prop_int.html"
    },
    "tiled-prop_type": {
      "id": "tiled-prop_type",
      "name": "Tiled.prop_type",
      "sig": "Tiled.prop_type(container, name: string) -> string",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "A custom property's declared type.",
      "page": "tiled-prop_type.html"
    },
    "tiled-load_types": {
      "id": "tiled-load_types",
      "name": "Tiled.load_types",
      "sig": "Tiled.load_types(path: string) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "Load a project custom-type table.",
      "page": "tiled-load_types.html"
    },
    "tiled-template": {
      "id": "tiled-template",
      "name": "Tiled.template",
      "sig": "Tiled.template(path: string) -> value",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "Read a template file into an object value.",
      "page": "tiled-template.html"
    },
    "tiled-spawn": {
      "id": "tiled-spawn",
      "name": "Tiled.spawn",
      "sig": "Tiled.spawn(map, object, model: string) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "Spawn a Ludic entity from an object.",
      "page": "tiled-spawn.html"
    },
    "tiled-spawn_layer": {
      "id": "tiled-spawn_layer",
      "name": "Tiled.spawn_layer",
      "sig": "Tiled.spawn_layer(map, layer: int, model: string) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "Spawn every object on a layer.",
      "page": "tiled-spawn_layer.html"
    },
    "tiled-cell_x": {
      "id": "tiled-cell_x",
      "name": "Tiled.cell_x",
      "sig": "Tiled.cell_x(map, x: int, y: int) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "The screen x of a tile cell for the map orientation.",
      "page": "tiled-cell_x.html"
    },
    "tiled-cell_y": {
      "id": "tiled-cell_y",
      "name": "Tiled.cell_y",
      "sig": "Tiled.cell_y(map, x: int, y: int) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "The screen y of a tile cell for the map orientation.",
      "page": "tiled-cell_y.html"
    },
    "tiled-layer_kind": {
      "id": "tiled-layer_kind",
      "name": "Tiled.layer_kind",
      "sig": "Tiled.layer_kind(map, layer: int) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "A layer's kind.",
      "page": "tiled-layer_kind.html"
    },
    "tiled-layer_opacity": {
      "id": "tiled-layer_opacity",
      "name": "Tiled.layer_opacity",
      "sig": "Tiled.layer_opacity(map, layer: int) -> string",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "A layer's opacity.",
      "page": "tiled-layer_opacity.html"
    },
    "tiled-layer_tint": {
      "id": "tiled-layer_tint",
      "name": "Tiled.layer_tint",
      "sig": "Tiled.layer_tint(map, layer: int) -> string",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "A layer's tint colour.",
      "page": "tiled-layer_tint.html"
    },
    "tiled-layer_offsetx": {
      "id": "tiled-layer_offsetx",
      "name": "Tiled.layer_offsetx",
      "sig": "Tiled.layer_offsetx(map, layer: int) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "A layer's horizontal offset.",
      "page": "tiled-layer_offsetx.html"
    },
    "tiled-layer_offsety": {
      "id": "tiled-layer_offsety",
      "name": "Tiled.layer_offsety",
      "sig": "Tiled.layer_offsety(map, layer: int) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "A layer's vertical offset.",
      "page": "tiled-layer_offsety.html"
    },
    "tiled-world": {
      "id": "tiled-world",
      "name": "Tiled.world",
      "sig": "Tiled.world(path: string) -> value",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "Read a .world file.",
      "page": "tiled-world.html"
    },
    "tiled-world_count": {
      "id": "tiled-world_count",
      "name": "Tiled.world_count",
      "sig": "Tiled.world_count(world) -> int",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "How many maps a world stitches.",
      "page": "tiled-world_count.html"
    },
    "tiled-world_map": {
      "id": "tiled-world_map",
      "name": "Tiled.world_map",
      "sig": "Tiled.world_map(world, index: int) -> value",
      "kind": "namespace-method",
      "category": "tiled",
      "section": "Tiled",
      "tip": "A world member map by index.",
      "page": "tiled-world_map.html"
    },
    "ui-build": {
      "id": "ui-build",
      "name": "Ui.build",
      "sig": "Ui.build()",
      "kind": "namespace-method",
      "category": "ui",
      "section": "Ui",
      "tip": "Construct every declared ui block (loads skins, measures fonts).",
      "page": "ui-build.html"
    },
    "ui-open": {
      "id": "ui-open",
      "name": "Ui.open",
      "sig": "Ui.open(id: UI_Name)",
      "kind": "namespace-method",
      "category": "ui",
      "section": "Ui",
      "tip": "Make one menu active and focus its first button.",
      "page": "ui-open.html"
    },
    "ui-close": {
      "id": "ui-close",
      "name": "Ui.close",
      "sig": "Ui.close()",
      "kind": "namespace-method",
      "category": "ui",
      "section": "Ui",
      "tip": "Deactivate the menu: no menu is open.",
      "page": "ui-close.html"
    },
    "ui-tick": {
      "id": "ui-tick",
      "name": "Ui.tick",
      "sig": "Ui.tick(key: k)",
      "kind": "namespace-method",
      "category": "ui",
      "section": "Ui",
      "tip": "Advance navigation by one key (the frame loop does this for you).",
      "page": "ui-tick.html"
    },
    "ui-clicked": {
      "id": "ui-clicked",
      "name": "Ui.clicked",
      "sig": "Ui.clicked(id: UI_Name) -> bool",
      "kind": "namespace-method",
      "category": "ui",
      "section": "Ui",
      "tip": "Was this control activated this frame? (polled form of UiClicked)",
      "page": "ui-clicked.html"
    },
    "ui-set_text": {
      "id": "ui-set_text",
      "name": "Ui.set_text",
      "sig": "Ui.set_text(id: UI_Name, text: s)",
      "kind": "namespace-method",
      "category": "ui",
      "section": "Ui",
      "tip": "Replace a label's or button's text.",
      "page": "ui-set_text.html"
    },
    "ui-render": {
      "id": "ui-render",
      "name": "Ui.render",
      "sig": "Ui.render()",
      "kind": "namespace-method",
      "category": "ui",
      "section": "Ui",
      "tip": "Draw the active menu.",
      "page": "ui-render.html"
    },
    "file-open": {
      "id": "file-open",
      "name": "File.open",
      "sig": "File.open(path: p, mode: m) -> pointer",
      "kind": "namespace-method",
      "category": "file",
      "section": "File",
      "tip": "Open a file (fopen); null when it cannot be opened.",
      "page": "file-open.html"
    },
    "file-read": {
      "id": "file-read",
      "name": "File.read",
      "sig": "File.read(file: f, buffer: b, count: n) -> int",
      "kind": "namespace-method",
      "category": "file",
      "section": "File",
      "tip": "Read up to n bytes into a buffer; returns the bytes read.",
      "page": "file-read.html"
    },
    "file-write": {
      "id": "file-write",
      "name": "File.write",
      "sig": "File.write(file: f, buffer: b, count: n) -> int",
      "kind": "namespace-method",
      "category": "file",
      "section": "File",
      "tip": "Write n bytes from a buffer; returns the bytes written.",
      "page": "file-write.html"
    },
    "file-seek": {
      "id": "file-seek",
      "name": "File.seek",
      "sig": "File.seek(file: f, offset: o, whence: w)",
      "kind": "namespace-method",
      "category": "file",
      "section": "File",
      "tip": "Move the file cursor (0 start, 1 current, 2 end).",
      "page": "file-seek.html"
    },
    "file-tell": {
      "id": "file-tell",
      "name": "File.tell",
      "sig": "File.tell(file: f) -> int",
      "kind": "namespace-method",
      "category": "file",
      "section": "File",
      "tip": "The cursor position in bytes.",
      "page": "file-tell.html"
    },
    "file-close": {
      "id": "file-close",
      "name": "File.close",
      "sig": "File.close(file: f)",
      "kind": "namespace-method",
      "category": "file",
      "section": "File",
      "tip": "Close a handle from File.open.",
      "page": "file-close.html"
    },
    "font-load": {
      "id": "font-load",
      "name": "Font.load",
      "sig": "Font.load(path: p) -> int",
      "kind": "namespace-method",
      "category": "font",
      "section": "Font",
      "tip": "Load a TrueType font; returns a font handle.",
      "page": "font-load.html"
    },
    "fx-sparks": {
      "id": "fx-sparks",
      "name": "Fx.sparks",
      "sig": "Fx.sparks(x: px, y: px, color: c, count: n)",
      "kind": "namespace-method",
      "category": "fx",
      "section": "Fx",
      "tip": "A burst of sparks flying out of a point.",
      "page": "fx-sparks.html"
    },
    "fx-number": {
      "id": "fx-number",
      "name": "Fx.number",
      "sig": "Fx.number(x: px, y: px, value: n, color: c)",
      "kind": "namespace-method",
      "category": "fx",
      "section": "Fx",
      "tip": "A number that floats up from a point and fades.",
      "page": "fx-number.html"
    },
    "fx-clear": {
      "id": "fx-clear",
      "name": "Fx.clear",
      "sig": "Fx.clear()",
      "kind": "namespace-method",
      "category": "fx",
      "section": "Fx",
      "tip": "Drop every spark and number at once.",
      "page": "fx-clear.html"
    },
    "prefab-spawn": {
      "id": "prefab-spawn",
      "name": "Prefab.spawn",
      "sig": "Prefab.spawn(name: s) -> entity",
      "kind": "namespace-method",
      "category": "prefab",
      "section": "Prefab",
      "tip": "Spawn a prefab chosen by name at runtime; -1 if none has that name.",
      "page": "prefab-spawn.html"
    },
    "prefab-spawn_at": {
      "id": "prefab-spawn_at",
      "name": "Prefab.spawn_at",
      "sig": "Prefab.spawn_at(name: s, at: IVec2) -> entity",
      "kind": "namespace-method",
      "category": "prefab",
      "section": "Prefab",
      "tip": "Spawn a prefab by name and place it.",
      "page": "prefab-spawn_at.html"
    },
    "app-splash_hide": {
      "id": "app-splash_hide",
      "name": "App.splash_hide",
      "sig": "App.splash_hide() -> void",
      "kind": "namespace-method",
      "category": "app",
      "section": "App",
      "tip": "Dismiss the boot splash.",
      "page": "app-splash_hide.html"
    },
    "app-set_icon": {
      "id": "app-set_icon",
      "name": "App.set_icon",
      "sig": "App.set_icon(path) -> void",
      "kind": "namespace-method",
      "category": "app",
      "section": "App",
      "tip": "Set the Dock icon from an image the game ships.",
      "page": "app-set_icon.html"
    },
    "app-window_hide": {
      "id": "app-window_hide",
      "name": "App.window_hide",
      "sig": "App.window_hide() -> void",
      "kind": "namespace-method",
      "category": "app",
      "section": "App",
      "tip": "Take the game's window off the screen.",
      "page": "app-window_hide.html"
    },
    "app-window_show": {
      "id": "app-window_show",
      "name": "App.window_show",
      "sig": "App.window_show() -> void",
      "kind": "namespace-method",
      "category": "app",
      "section": "App",
      "tip": "Bring the game's window back.",
      "page": "app-window_show.html"
    },
    "phase-start": {
      "id": "phase-start",
      "name": "Start",
      "sig": "phase Start",
      "kind": "phase",
      "category": "phases",
      "section": "Phases",
      "tip": "Runs once at boot, before the game loop — the place to set up initial state.",
      "page": "phase-start.html"
    },
    "phase-input": {
      "id": "phase-input",
      "name": "Input",
      "sig": "phase Input",
      "kind": "phase",
      "category": "phases",
      "section": "Phases",
      "tip": "The first per-frame phase — read the keyboard and record the player's intent.",
      "page": "phase-input.html"
    },
    "phase-fixedupdate": {
      "id": "phase-fixedupdate",
      "name": "FixedUpdate",
      "sig": "phase FixedUpdate",
      "kind": "phase",
      "category": "phases",
      "section": "Phases",
      "tip": "The deterministic simulation step — physics and gameplay meant to be reproducible.",
      "page": "phase-fixedupdate.html"
    },
    "phase-update": {
      "id": "phase-update",
      "name": "Update",
      "sig": "phase Update",
      "kind": "phase",
      "category": "phases",
      "section": "Phases",
      "tip": "The ordinary per-frame game-logic step, run after Input and FixedUpdate.",
      "page": "phase-update.html"
    },
    "phase-lateupdate": {
      "id": "phase-lateupdate",
      "name": "LateUpdate",
      "sig": "phase LateUpdate",
      "kind": "phase",
      "category": "phases",
      "section": "Phases",
      "tip": "Runs each frame after Update and before Render.",
      "page": "phase-lateupdate.html"
    },
    "phase-render": {
      "id": "phase-render",
      "name": "Render",
      "sig": "phase Render",
      "kind": "phase",
      "category": "phases",
      "section": "Phases",
      "tip": "The last per-frame phase — draw the world, then call Screen.show() once.",
      "page": "phase-render.html"
    },
    "phase-overlay": {
      "id": "phase-overlay",
      "name": "Overlay",
      "sig": "phase Overlay",
      "kind": "phase",
      "category": "phases",
      "section": "Phases",
      "tip": "The HUD pass — runs after Render and after every engine-owned drawing system.",
      "page": "phase-overlay.html"
    }
  },
  "highlight": {
    "keywords": {
      "program": "kw-program",
      "property": "kw-property",
      "model": "kw-model",
      "handler": "kw-handler",
      "phase": "kw-phase",
      "const": "kw-const",
      "var": "kw-var",
      "let": "kw-let",
      "function": "kw-function",
      "fn": "kw-fn",
      "prefab": "kw-prefab",
      "return": "kw-return",
      "entry": "kw-entry",
      "import": "kw-import",
      "public": "kw-public",
      "extern": "kw-extern",
      "new": "kw-new",
      "namespace": "kw-namespace",
      "enum": "kw-enum",
      "ui": "kw-ui",
      "spawn": "kw-spawn",
      "despawn": "kw-despawn",
      "query": "kw-query",
      "self": "kw-self",
      "enable": "kw-enable",
      "disable": "kw-disable",
      "attach": "kw-attach",
      "detach": "kw-detach",
      "if": "kw-if",
      "else": "kw-if",
      "while": "kw-while",
      "for": "kw-for",
      "in": "kw-in",
      "match": "kw-match",
      "machine": "kw-machine",
      "state": "kw-state",
      "become": "kw-become",
      "break": "kw-break",
      "continue": "kw-continue",
      "where": "kw-where",
      "try": "kw-try",
      "scene": "kw-scene",
      "layer": "kw-layer",
      "on": "kw-on",
      "enter": "kw-enter",
      "exit": "kw-exit",
      "start": "kw-start",
      "event": "kw-event",
      "emit": "kw-emit",
      "cancel": "kw-cancel",
      "cancellable": "kw-cancellable",
      "test": "kw-test"
    },
    "types": {
      "int": "type-int",
      "fixed": "type-fixed",
      "long": "type-long",
      "bool": "type-bool",
      "float": "type-float",
      "string": "type-string",
      "double": "type-double",
      "entity": "type-entity",
      "pointer": "type-pointer",
      "words": "type-words",
      "byte": "type-byte",
      "fixeds": "type-fixeds",
      "countdown": "type-countdown",
      "floats": "type-floats",
      "doubles": "type-floats",
      "pointers": "type-pointers",
      "Vector": "type-vector",
      "IVec2": "type-ivec2",
      "Rect": "type-rect",
      "void": "type-void"
    },
    "phases": {
      "Start": "phase-start",
      "Input": "phase-input",
      "FixedUpdate": "phase-fixedupdate",
      "Update": "phase-update",
      "LateUpdate": "phase-lateupdate",
      "Render": "phase-render",
      "Overlay": "phase-overlay"
    },
    "builtins": {
      "world_attach_dyn": {
        "id": "fn-world_attach_dyn",
        "params": [
          "target",
          "property"
        ]
      },
      "world_count": {
        "id": "fn-world_count",
        "params": []
      },
      "world_detach_dyn": {
        "id": "fn-world_detach_dyn",
        "params": [
          "target",
          "property"
        ]
      },
      "world_field_id": {
        "id": "fn-world_field_id",
        "params": [
          "property",
          "name"
        ]
      },
      "world_get": {
        "id": "fn-world_get",
        "params": [
          "target",
          "property",
          "field"
        ]
      },
      "world_has": {
        "id": "fn-world_has",
        "params": [
          "target",
          "property"
        ]
      },
      "world_kind": {
        "id": "fn-world_kind",
        "params": [
          "target"
        ]
      },
      "world_load": {
        "id": "fn-world_load",
        "params": [
          "buf",
          "len"
        ]
      },
      "world_model_id": {
        "id": "fn-world_model_id",
        "params": [
          "name"
        ]
      },
      "world_prop_id": {
        "id": "fn-world_prop_id",
        "params": [
          "name"
        ]
      },
      "world_query_next": {
        "id": "fn-world_query_next",
        "params": [
          "property",
          "cursor"
        ]
      },
      "world_register_prop": {
        "id": "fn-world_register_prop",
        "params": [
          "name",
          "fields"
        ]
      },
      "world_save": {
        "id": "fn-world_save",
        "params": [
          "buf"
        ]
      },
      "world_set": {
        "id": "fn-world_set",
        "params": [
          "target",
          "property",
          "field",
          "value"
        ]
      },
      "world_size": {
        "id": "fn-world_size",
        "params": []
      },
      "world_spawn": {
        "id": "fn-world_spawn",
        "params": [
          "model"
        ]
      },
      "print": {
        "id": "fn-print",
        "params": [
          "x"
        ]
      },
      "string": {
        "id": "fn-string",
        "params": [
          "x"
        ]
      },
      "quit": {
        "id": "fn-quit",
        "params": []
      },
      "save": {
        "id": "fn-save",
        "params": []
      },
      "load": {
        "id": "fn-load",
        "params": []
      },
      "len": {
        "id": "fn-len",
        "params": [
          "x"
        ]
      },
      "push": {
        "id": "fn-push",
        "params": [
          "slice",
          "x"
        ]
      },
      "abs": {
        "id": "fn-abs",
        "params": [
          "a"
        ]
      },
      "clamp": {
        "id": "fn-clamp",
        "params": [
          "v",
          "lo",
          "hi"
        ]
      },
      "panic": {
        "id": "fn-panic",
        "params": [
          "msg"
        ]
      },
      "assert": {
        "id": "fn-assert",
        "params": [
          "cond",
          "msg"
        ]
      },
      "ok": {
        "id": "fn-ok",
        "params": [
          "v"
        ]
      },
      "err": {
        "id": "fn-err",
        "params": [
          "msg"
        ]
      },
      "is_ok": {
        "id": "fn-is_ok",
        "params": [
          "r"
        ]
      },
      "is_err": {
        "id": "fn-is_err",
        "params": [
          "r"
        ]
      },
      "some": {
        "id": "fn-some",
        "params": [
          "v"
        ]
      },
      "none": {
        "id": "fn-none",
        "params": []
      },
      "is_some": {
        "id": "fn-is_some",
        "params": [
          "o"
        ]
      },
      "is_none": {
        "id": "fn-is_none",
        "params": [
          "o"
        ]
      },
      "unwrap_or": {
        "id": "fn-unwrap_or",
        "params": [
          "o",
          "fallback"
        ]
      },
      "exit": {
        "id": "fn-exit",
        "params": [
          "code"
        ]
      },
      "run": {
        "id": "fn-run",
        "params": [
          "cmd"
        ]
      },
      "getenv": {
        "id": "fn-getenv",
        "params": [
          "name"
        ]
      },
      "read_char": {
        "id": "fn-read_char",
        "params": []
      },
      "arg": {
        "id": "fn-arg",
        "params": [
          "i"
        ]
      },
      "arg_count": {
        "id": "fn-arg_count",
        "params": []
      },
      "bytes": {
        "id": "fn-bytes",
        "params": [
          "n"
        ]
      },
      "file_stderr": {
        "id": "fn-file_stderr",
        "params": []
      },
      "file_stdout": {
        "id": "fn-file_stdout",
        "params": []
      },
      "file_write": {
        "id": "fn-file_write",
        "params": [
          "handle",
          "buf",
          "len"
        ]
      },
      "fixed": {
        "id": "fn-fixed",
        "params": [
          "x"
        ]
      },
      "floor": {
        "id": "fn-floor",
        "params": [
          "x"
        ]
      },
      "max": {
        "id": "fn-max",
        "params": [
          "a",
          "b"
        ]
      },
      "min": {
        "id": "fn-min",
        "params": [
          "a",
          "b"
        ]
      },
      "ui_build": {
        "id": "fn-ui_build",
        "params": []
      },
      "words": {
        "id": "fn-words",
        "params": [
          "n"
        ]
      },
      "float": {
        "id": "fn-float",
        "params": [
          "x"
        ]
      },
      "double": {
        "id": "fn-float",
        "params": [
          "x"
        ]
      },
      "int": {
        "id": "fn-int",
        "params": [
          "x"
        ]
      },
      "long": {
        "id": "fn-int",
        "params": [
          "x"
        ]
      },
      "float_bits": {
        "id": "fn-float_bits",
        "params": [
          "x"
        ]
      },
      "float_from_bits": {
        "id": "fn-float_bits",
        "params": [
          "x"
        ]
      },
      "double_bits": {
        "id": "fn-float_bits",
        "params": [
          "x"
        ]
      },
      "double_from_bits": {
        "id": "fn-float_bits",
        "params": [
          "x"
        ]
      }
    },
    "nsmethods": {
      "Screen.clear": {
        "id": "screen-clear",
        "params": [
          "color"
        ]
      },
      "Screen.fill_rectangle": {
        "id": "screen-fill_rectangle",
        "params": [
          "x",
          "y",
          "width",
          "height",
          "color"
        ]
      },
      "Screen.draw_rectangle": {
        "id": "screen-draw_rectangle",
        "params": [
          "x",
          "y",
          "width",
          "height",
          "color"
        ]
      },
      "Screen.put_pixel": {
        "id": "screen-put_pixel",
        "params": [
          "x",
          "y",
          "color"
        ]
      },
      "Screen.draw_text": {
        "id": "screen-draw_text",
        "params": [
          "x",
          "y",
          "text",
          "color",
          "scale"
        ]
      },
      "Screen.draw_number": {
        "id": "screen-draw_number",
        "params": [
          "x",
          "y",
          "value",
          "color",
          "scale"
        ]
      },
      "Screen.show": {
        "id": "screen-show",
        "params": []
      },
      "Screen.width": {
        "id": "screen-width",
        "params": []
      },
      "Screen.height": {
        "id": "screen-height",
        "params": []
      },
      "Screen.status": {
        "id": "screen-status",
        "params": [
          "text"
        ]
      },
      "Screen.line": {
        "id": "screen-line",
        "params": []
      },
      "Screen.circle": {
        "id": "screen-circle",
        "params": []
      },
      "Screen.fill_circle": {
        "id": "screen-fill_circle",
        "params": []
      },
      "Screen.triangle": {
        "id": "screen-triangle",
        "params": []
      },
      "Screen.fill_triangle": {
        "id": "screen-fill_triangle",
        "params": []
      },
      "Screen.sprite": {
        "id": "screen-sprite",
        "params": []
      },
      "Screen.sprite_scaled": {
        "id": "screen-sprite_scaled",
        "params": []
      },
      "Screen.oval": {
        "id": "screen-oval",
        "params": []
      },
      "Screen.camera": {
        "id": "screen-camera",
        "params": []
      },
      "Screen.clip": {
        "id": "screen-clip",
        "params": []
      },
      "Screen.clip_reset": {
        "id": "screen-clip_reset",
        "params": []
      },
      "Screen.blend_mode": {
        "id": "screen-blend_mode",
        "params": []
      },
      "Screen.measure_text": {
        "id": "screen-measure_text",
        "params": []
      },
      "Screen.pixel": {
        "id": "screen-pixel",
        "params": []
      },
      "Screen.bar": {
        "id": "screen-bar",
        "params": []
      },
      "Clock.now": {
        "id": "clock-now",
        "params": []
      },
      "Clock.set": {
        "id": "clock-set",
        "params": []
      },
      "Clock.advance": {
        "id": "clock-advance",
        "params": []
      },
      "Clock.reset": {
        "id": "clock-reset",
        "params": []
      },
      "Collision.rects": {
        "id": "collision-rects",
        "params": []
      },
      "Collision.point_rect": {
        "id": "collision-point_rect",
        "params": []
      },
      "Collision.circles": {
        "id": "collision-circles",
        "params": []
      },
      "Collision.rect_circle": {
        "id": "collision-rect_circle",
        "params": []
      },
      "Color.rgb": {
        "id": "color-rgb",
        "params": []
      },
      "Color.rgba": {
        "id": "color-rgba",
        "params": []
      },
      "Color.lerp": {
        "id": "color-lerp",
        "params": []
      },
      "Color.darken": {
        "id": "color-darken",
        "params": []
      },
      "Color.lighten": {
        "id": "color-lighten",
        "params": []
      },
      "Color.with_alpha": {
        "id": "color-with_alpha",
        "params": []
      },
      "Crypto.sha256": {
        "id": "crypto-sha256",
        "params": [
          "s"
        ]
      },
      "Crypto.hmac_sha256": {
        "id": "crypto-hmac_sha256",
        "params": [
          "key",
          "msg"
        ]
      },
      "Crypto.verify_hmac": {
        "id": "crypto-verify_hmac",
        "params": [
          "key",
          "msg",
          "mac"
        ]
      },
      "Crypto.hex": {
        "id": "crypto-hex",
        "params": [
          "s"
        ]
      },
      "Crypto.ct_equal": {
        "id": "crypto-ct_equal",
        "params": [
          "a",
          "b"
        ]
      },
      "Crypto.random_bytes": {
        "id": "crypto-random_bytes",
        "params": [
          "n"
        ]
      },
      "Crypto.random_hex": {
        "id": "crypto-random_hex",
        "params": [
          "n"
        ]
      },
      "Crypto.random_u32": {
        "id": "crypto-random_u32",
        "params": []
      },
      "Crypto.base64": {
        "id": "crypto-base64",
        "params": [
          "s"
        ]
      },
      "Date.new": {
        "id": "date-new",
        "params": []
      },
      "Date.year": {
        "id": "date-year",
        "params": []
      },
      "Date.month": {
        "id": "date-month",
        "params": []
      },
      "Date.day": {
        "id": "date-day",
        "params": []
      },
      "Date.weekday": {
        "id": "date-weekday",
        "params": []
      },
      "Date.is_leap": {
        "id": "date-is_leap",
        "params": []
      },
      "Date.days_in_month": {
        "id": "date-days_in_month",
        "params": []
      },
      "Date.to_epoch": {
        "id": "date-to_epoch",
        "params": []
      },
      "Date.add_days": {
        "id": "date-add_days",
        "params": []
      },
      "Date.diff_days": {
        "id": "date-diff_days",
        "params": []
      },
      "DateTime.from": {
        "id": "datetime-from",
        "params": []
      },
      "DateTime.date": {
        "id": "datetime-date",
        "params": []
      },
      "DateTime.add": {
        "id": "datetime-add",
        "params": []
      },
      "DateTime.year": {
        "id": "datetime-year",
        "params": []
      },
      "DateTime.month": {
        "id": "datetime-month",
        "params": []
      },
      "DateTime.day": {
        "id": "datetime-day",
        "params": []
      },
      "DateTime.weekday": {
        "id": "datetime-weekday",
        "params": []
      },
      "DateTime.hour": {
        "id": "datetime-hour",
        "params": []
      },
      "DateTime.minute": {
        "id": "datetime-minute",
        "params": []
      },
      "DateTime.second": {
        "id": "datetime-second",
        "params": []
      },
      "DateTime.format": {
        "id": "datetime-format",
        "params": []
      },
      "DateTime.parse": {
        "id": "datetime-parse",
        "params": []
      },
      "Duration.seconds": {
        "id": "duration-seconds",
        "params": []
      },
      "Duration.minutes": {
        "id": "duration-minutes",
        "params": []
      },
      "Duration.hours": {
        "id": "duration-hours",
        "params": []
      },
      "Duration.days": {
        "id": "duration-days",
        "params": []
      },
      "Duration.as_seconds": {
        "id": "duration-as_seconds",
        "params": []
      },
      "Duration.as_minutes": {
        "id": "duration-as_minutes",
        "params": []
      },
      "Duration.as_hours": {
        "id": "duration-as_hours",
        "params": []
      },
      "Duration.as_days": {
        "id": "duration-as_days",
        "params": []
      },
      "Ease.in": {
        "id": "ease-in",
        "params": []
      },
      "Ease.out": {
        "id": "ease-out",
        "params": []
      },
      "Ease.in_out": {
        "id": "ease-in_out",
        "params": []
      },
      "Ease.back": {
        "id": "ease-back",
        "params": []
      },
      "Ease.bounce": {
        "id": "ease-bounce",
        "params": []
      },
      "Ease.elastic": {
        "id": "ease-elastic",
        "params": []
      },
      "Fs.exists": {
        "id": "fs-exists",
        "params": [
          "p"
        ]
      },
      "Fs.is_dir": {
        "id": "fs-is_dir",
        "params": [
          "p"
        ]
      },
      "Fs.read_text": {
        "id": "fs-read_text",
        "params": [
          "p"
        ]
      },
      "Fs.write_text": {
        "id": "fs-write_text",
        "params": [
          "p",
          "s"
        ]
      },
      "Fs.append_text": {
        "id": "fs-append_text",
        "params": [
          "p",
          "s"
        ]
      },
      "Fs.remove": {
        "id": "fs-remove",
        "params": [
          "p"
        ]
      },
      "Fs.size": {
        "id": "fs-size",
        "params": [
          "p"
        ]
      },
      "Fs.mkdir": {
        "id": "fs-mkdir",
        "params": [
          "p"
        ]
      },
      "Fs.copy": {
        "id": "fs-copy",
        "params": [
          "src",
          "dst"
        ]
      },
      "Fs.list": {
        "id": "fs-list",
        "params": [
          "dir"
        ]
      },
      "Hash.of": {
        "id": "hash-of",
        "params": [
          "s"
        ]
      },
      "Hash.fnv1a": {
        "id": "hash-fnv1a",
        "params": [
          "s"
        ]
      },
      "Hash.crc32": {
        "id": "hash-crc32",
        "params": [
          "s"
        ]
      },
      "Hash.mix": {
        "id": "hash-mix",
        "params": [
          "x"
        ]
      },
      "Hash.combine": {
        "id": "hash-combine",
        "params": []
      },
      "Hash.of64": {
        "id": "hash-of64",
        "params": [
          "s"
        ]
      },
      "Hash.fnv1a_64": {
        "id": "hash-fnv1a_64",
        "params": [
          "s"
        ]
      },
      "Hash.mix64": {
        "id": "hash-mix64",
        "params": [
          "x"
        ]
      },
      "Input.key": {
        "id": "input-key",
        "params": []
      },
      "Input.bind": {
        "id": "input-bind",
        "params": []
      },
      "Input.rebind": {
        "id": "input-rebind",
        "params": []
      },
      "Input.poll": {
        "id": "input-poll",
        "params": []
      },
      "Input.down": {
        "id": "input-down",
        "params": []
      },
      "Input.pressed": {
        "id": "input-pressed",
        "params": []
      },
      "Input.record": {
        "id": "input-record",
        "params": []
      },
      "Input.replay": {
        "id": "input-replay",
        "params": []
      },
      "Input.key_down": {
        "id": "input-key_down",
        "params": []
      },
      "Input.key_pressed": {
        "id": "input-key_pressed",
        "params": []
      },
      "Input.key_released": {
        "id": "input-key_released",
        "params": []
      },
      "Input.key_label": {
        "id": "input-key_label",
        "params": []
      },
      "Input.press": {
        "id": "input-press",
        "params": []
      },
      "Input.release": {
        "id": "input-release",
        "params": []
      },
      "Input.axis": {
        "id": "input-axis",
        "params": []
      },
      "Input.axis_i": {
        "id": "input-axis_i",
        "params": []
      },
      "Input.vector": {
        "id": "input-vector",
        "params": []
      },
      "Input.strength": {
        "id": "input-strength",
        "params": []
      },
      "Input.mouse_x": {
        "id": "input-mouse_x",
        "params": []
      },
      "Input.mouse_y": {
        "id": "input-mouse_y",
        "params": []
      },
      "Input.mouse_dx": {
        "id": "input-mouse_dx",
        "params": []
      },
      "Input.mouse_dy": {
        "id": "input-mouse_dy",
        "params": []
      },
      "Input.mouse_down": {
        "id": "input-mouse_down",
        "params": []
      },
      "Input.wheel": {
        "id": "input-wheel",
        "params": []
      },
      "Input.set_mouse": {
        "id": "input-set_mouse",
        "params": []
      },
      "Input.pad_connected": {
        "id": "input-pad_connected",
        "params": []
      },
      "Input.pad_button": {
        "id": "input-pad_button",
        "params": []
      },
      "Input.pad_axis": {
        "id": "input-pad_axis",
        "params": []
      },
      "Input.set_pad": {
        "id": "input-set_pad",
        "params": []
      },
      "Input.touch_count": {
        "id": "input-touch_count",
        "params": []
      },
      "Input.touch_x": {
        "id": "input-touch_x",
        "params": []
      },
      "Input.touch_y": {
        "id": "input-touch_y",
        "params": []
      },
      "Input.set_touch": {
        "id": "input-set_touch",
        "params": []
      },
      "Input.action": {
        "id": "input-action",
        "params": []
      },
      "Input.bind_pad": {
        "id": "input-bind_pad",
        "params": []
      },
      "Input.active": {
        "id": "input-active",
        "params": []
      },
      "Input.just_pressed": {
        "id": "input-just_pressed",
        "params": []
      },
      "Input.just_released": {
        "id": "input-just_released",
        "params": []
      },
      "Input.cursor_mode": {
        "id": "input-cursor_mode",
        "params": []
      },
      "Input.move_i": {
        "id": "input-move_i",
        "params": []
      },
      "List.len": {
        "id": "list-len",
        "params": [
          "s"
        ]
      },
      "List.push": {
        "id": "list-push",
        "params": [
          "s",
          "v"
        ]
      },
      "List.clear": {
        "id": "list-clear",
        "params": [
          "s"
        ]
      },
      "List.first": {
        "id": "list-first",
        "params": [
          "s"
        ]
      },
      "List.last": {
        "id": "list-last",
        "params": [
          "s"
        ]
      },
      "List.pop": {
        "id": "list-pop",
        "params": [
          "s"
        ]
      },
      "List.swap": {
        "id": "list-swap",
        "params": [
          "s",
          "i",
          "j"
        ]
      },
      "List.contains": {
        "id": "list-contains",
        "params": [
          "s",
          "v"
        ]
      },
      "List.index_of": {
        "id": "list-index_of",
        "params": [
          "s",
          "v"
        ]
      },
      "List.reverse": {
        "id": "list-reverse",
        "params": [
          "s"
        ]
      },
      "List.insert": {
        "id": "list-insert",
        "params": []
      },
      "List.remove_at": {
        "id": "list-remove_at",
        "params": []
      },
      "List.remove": {
        "id": "list-remove",
        "params": []
      },
      "List.sort": {
        "id": "list-sort",
        "params": []
      },
      "List.sort_by": {
        "id": "list-sort_by",
        "params": []
      },
      "List.sort_desc_by": {
        "id": "list-sort_desc_by",
        "params": []
      },
      "List.sort_with": {
        "id": "list-sort_with",
        "params": []
      },
      "List.sample": {
        "id": "list-sample",
        "params": []
      },
      "Log.trace": {
        "id": "log-trace",
        "params": [
          "msg"
        ]
      },
      "Log.debug": {
        "id": "log-debug",
        "params": [
          "msg"
        ]
      },
      "Log.info": {
        "id": "log-info",
        "params": [
          "msg"
        ]
      },
      "Log.warn": {
        "id": "log-warn",
        "params": [
          "msg"
        ]
      },
      "Log.error": {
        "id": "log-error",
        "params": [
          "msg"
        ]
      },
      "Log.set_level": {
        "id": "log-set_level",
        "params": [
          "n"
        ]
      },
      "Log.level": {
        "id": "log-level",
        "params": []
      },
      "Math.min": {
        "id": "math-min",
        "params": [
          "a",
          "b"
        ]
      },
      "Math.max": {
        "id": "math-max",
        "params": [
          "a",
          "b"
        ]
      },
      "Math.abs": {
        "id": "math-abs",
        "params": [
          "x"
        ]
      },
      "Math.clamp": {
        "id": "math-clamp",
        "params": [
          "v",
          "lo",
          "hi"
        ]
      },
      "Math.sign": {
        "id": "math-sign",
        "params": [
          "x"
        ]
      },
      "Math.floor": {
        "id": "math-floor",
        "params": [
          "x"
        ]
      },
      "Math.ceil": {
        "id": "math-ceil",
        "params": [
          "x"
        ]
      },
      "Math.round": {
        "id": "math-round",
        "params": [
          "x"
        ]
      },
      "Math.lerp": {
        "id": "math-lerp",
        "params": [
          "a",
          "b",
          "t"
        ]
      },
      "Math.inverse_lerp": {
        "id": "math-inverse_lerp",
        "params": [
          "a",
          "b",
          "v"
        ]
      },
      "Math.remap": {
        "id": "math-remap",
        "params": [
          "v",
          "in0",
          "in1",
          "out0",
          "out1"
        ]
      },
      "Math.sqrt": {
        "id": "math-sqrt",
        "params": []
      },
      "Math.sin": {
        "id": "math-sin",
        "params": []
      },
      "Math.cos": {
        "id": "math-cos",
        "params": []
      },
      "Math.tan": {
        "id": "math-tan",
        "params": []
      },
      "Math.hypot": {
        "id": "math-hypot",
        "params": []
      },
      "Math.dist": {
        "id": "math-dist",
        "params": []
      },
      "Math.dist2": {
        "id": "math-dist2",
        "params": []
      },
      "Math.deg_to_rad": {
        "id": "math-deg_to_rad",
        "params": []
      },
      "Math.rad_to_deg": {
        "id": "math-rad_to_deg",
        "params": []
      },
      "Math.posmod": {
        "id": "math-posmod",
        "params": []
      },
      "Math.wrap": {
        "id": "math-wrap",
        "params": []
      },
      "Math.ping_pong": {
        "id": "math-ping_pong",
        "params": []
      },
      "Math.snapped": {
        "id": "math-snapped",
        "params": []
      },
      "Math.move_toward": {
        "id": "math-move_toward",
        "params": []
      },
      "Math.smoothstep": {
        "id": "math-smoothstep",
        "params": []
      },
      "Math.atan2": {
        "id": "math-atan2",
        "params": []
      },
      "Math.asin": {
        "id": "math-asin",
        "params": []
      },
      "Math.acos": {
        "id": "math-acos",
        "params": []
      },
      "Math.exp": {
        "id": "math-exp",
        "params": []
      },
      "Math.log": {
        "id": "math-log",
        "params": []
      },
      "Math.pow": {
        "id": "math-pow",
        "params": []
      },
      "Memory.bytes": {
        "id": "memory-bytes",
        "params": []
      },
      "Memory.words": {
        "id": "memory-words",
        "params": []
      },
      "Memory.copy": {
        "id": "memory-copy",
        "params": []
      },
      "Memory.fill": {
        "id": "memory-fill",
        "params": []
      },
      "Memory.peek": {
        "id": "memory-peek",
        "params": []
      },
      "Memory.poke": {
        "id": "memory-poke",
        "params": []
      },
      "Mime.of": {
        "id": "mime-of",
        "params": [
          "path"
        ]
      },
      "Mime.sniff": {
        "id": "mime-sniff",
        "params": [
          "path"
        ]
      },
      "Network.send": {
        "id": "network-send",
        "params": []
      },
      "Network.poll": {
        "id": "network-poll",
        "params": []
      },
      "Network.serialize": {
        "id": "network-serialize",
        "params": []
      },
      "Network.apply": {
        "id": "network-apply",
        "params": []
      },
      "Network.owner": {
        "id": "network-owner",
        "params": []
      },
      "Network.set_owner": {
        "id": "network-set_owner",
        "params": []
      },
      "Network.is_server": {
        "id": "network-is_server",
        "params": []
      },
      "Network.is_owner": {
        "id": "network-is_owner",
        "params": []
      },
      "Network.local_id": {
        "id": "network-local_id",
        "params": []
      },
      "Noise.value2": {
        "id": "noise-value2",
        "params": [
          "seed"
        ]
      },
      "Noise.perlin2": {
        "id": "noise-perlin2",
        "params": [
          "seed"
        ]
      },
      "Noise.simplex2": {
        "id": "noise-simplex2",
        "params": [
          "seed"
        ]
      },
      "Noise.fbm2": {
        "id": "noise-fbm2",
        "params": [
          "seed",
          "octaves"
        ]
      },
      "Noise.cellular2": {
        "id": "noise-cellular2",
        "params": [
          "seed"
        ]
      },
      "Noise.cellular2_id": {
        "id": "noise-cellular2_id",
        "params": [
          "seed"
        ]
      },
      "Noise.unit": {
        "id": "noise-unit",
        "params": [
          "n"
        ]
      },
      "Os.args": {
        "id": "os-args",
        "params": []
      },
      "Os.arg_count": {
        "id": "os-arg_count",
        "params": []
      },
      "Os.arg": {
        "id": "os-arg",
        "params": [
          "i"
        ]
      },
      "Os.env": {
        "id": "os-env",
        "params": [
          "name"
        ]
      },
      "Os.env_or": {
        "id": "os-env_or",
        "params": [
          "name",
          "fallback"
        ]
      },
      "Os.has_env": {
        "id": "os-has_env",
        "params": [
          "name"
        ]
      },
      "Os.set_env": {
        "id": "os-set_env",
        "params": [
          "name",
          "value"
        ]
      },
      "Os.unset_env": {
        "id": "os-unset_env",
        "params": [
          "name"
        ]
      },
      "Os.exit": {
        "id": "os-exit",
        "params": [
          "code"
        ]
      },
      "Os.platform": {
        "id": "os-platform",
        "params": []
      },
      "Os.arch": {
        "id": "os-arch",
        "params": []
      },
      "Os.stdout_write": {
        "id": "os-stdout_write",
        "params": [
          "s"
        ]
      },
      "Os.stderr_write": {
        "id": "os-stderr_write",
        "params": [
          "s"
        ]
      },
      "Os.save_dir": {
        "id": "os-save_dir",
        "params": [
          "app"
        ]
      },
      "Os.config_dir": {
        "id": "os-config_dir",
        "params": [
          "app"
        ]
      },
      "Os.cache_dir": {
        "id": "os-cache_dir",
        "params": [
          "app"
        ]
      },
      "Os.temp_dir": {
        "id": "os-temp_dir",
        "params": []
      },
      "Os.pid": {
        "id": "os-pid",
        "params": []
      },
      "Path.join": {
        "id": "path-join",
        "params": [
          "a",
          "b"
        ]
      },
      "Path.dir": {
        "id": "path-dir",
        "params": [
          "p"
        ]
      },
      "Path.base": {
        "id": "path-base",
        "params": [
          "p"
        ]
      },
      "Path.ext": {
        "id": "path-ext",
        "params": [
          "p"
        ]
      },
      "Path.stem": {
        "id": "path-stem",
        "params": [
          "p"
        ]
      },
      "Path.normalize": {
        "id": "path-normalize",
        "params": [
          "p"
        ]
      },
      "Save.write": {
        "id": "save-write",
        "params": []
      },
      "Save.read": {
        "id": "save-read",
        "params": []
      },
      "System.run": {
        "id": "system-run",
        "params": []
      },
      "System.read_char": {
        "id": "system-read_char",
        "params": []
      },
      "System.file_open": {
        "id": "system-file_open",
        "params": []
      },
      "System.file_read": {
        "id": "system-file_read",
        "params": []
      },
      "System.file_write": {
        "id": "system-file_write",
        "params": []
      },
      "System.file_seek": {
        "id": "system-file_seek",
        "params": []
      },
      "System.file_tell": {
        "id": "system-file_tell",
        "params": []
      },
      "System.file_close": {
        "id": "system-file_close",
        "params": []
      },
      "Text.length": {
        "id": "text-length",
        "params": [
          "s"
        ]
      },
      "Text.char_at": {
        "id": "text-char_at",
        "params": [
          "s",
          "i"
        ]
      },
      "Text.slice": {
        "id": "text-slice",
        "params": [
          "s",
          "a",
          "b"
        ]
      },
      "Text.starts_with": {
        "id": "text-starts_with",
        "params": [
          "s",
          "prefix"
        ]
      },
      "Text.ends_with": {
        "id": "text-ends_with",
        "params": [
          "s",
          "suffix"
        ]
      },
      "Text.contains": {
        "id": "text-contains",
        "params": [
          "s",
          "sub"
        ]
      },
      "Text.index_of": {
        "id": "text-index_of",
        "params": [
          "s",
          "sub"
        ]
      },
      "Text.equals": {
        "id": "text-equals",
        "params": [
          "a",
          "b"
        ]
      },
      "Text.concat": {
        "id": "text-concat",
        "params": [
          "a",
          "b"
        ]
      },
      "Text.to_int": {
        "id": "text-to_int",
        "params": [
          "s"
        ]
      },
      "Text.from_int": {
        "id": "text-from_int",
        "params": [
          "n"
        ]
      },
      "Text.upper": {
        "id": "text-upper",
        "params": []
      },
      "Text.lower": {
        "id": "text-lower",
        "params": []
      },
      "Text.trim": {
        "id": "text-trim",
        "params": []
      },
      "Text.repeat": {
        "id": "text-repeat",
        "params": []
      },
      "Text.pad_left": {
        "id": "text-pad_left",
        "params": []
      },
      "Text.pad_right": {
        "id": "text-pad_right",
        "params": []
      },
      "Text.split": {
        "id": "text-split",
        "params": []
      },
      "Text.join": {
        "id": "text-join",
        "params": []
      },
      "Text.replace": {
        "id": "text-replace",
        "params": []
      },
      "Time.frame": {
        "id": "time-frame",
        "params": []
      },
      "Time.delta": {
        "id": "time-delta",
        "params": []
      },
      "Time.elapsed": {
        "id": "time-elapsed",
        "params": []
      },
      "Time.now": {
        "id": "time-now",
        "params": []
      },
      "Time.since": {
        "id": "time-since",
        "params": []
      },
      "Unicode.len": {
        "id": "unicode-len",
        "params": [
          "s"
        ]
      },
      "Unicode.byte_len": {
        "id": "unicode-byte_len",
        "params": [
          "s"
        ]
      },
      "Unicode.is_valid_utf8": {
        "id": "unicode-is_valid_utf8",
        "params": [
          "s"
        ]
      },
      "Unicode.char_at": {
        "id": "unicode-char_at",
        "params": [
          "s",
          "i"
        ]
      },
      "Unicode.chars": {
        "id": "unicode-chars",
        "params": [
          "s"
        ]
      },
      "Unicode.upper": {
        "id": "unicode-upper",
        "params": [
          "s"
        ]
      },
      "Unicode.lower": {
        "id": "unicode-lower",
        "params": [
          "s"
        ]
      },
      "Unicode.truncate": {
        "id": "unicode-truncate",
        "params": [
          "s",
          "n"
        ]
      },
      "Unicode.grapheme_len": {
        "id": "unicode-grapheme_len",
        "params": [
          "s"
        ]
      },
      "Uuid.new": {
        "id": "uuid-new",
        "params": []
      },
      "Uuid.v4": {
        "id": "uuid-v4",
        "params": []
      },
      "Uuid.new_v7": {
        "id": "uuid-new_v7",
        "params": []
      },
      "Uuid.v7": {
        "id": "uuid-v7",
        "params": []
      },
      "Uuid.parse": {
        "id": "uuid-parse",
        "params": [
          "s"
        ]
      },
      "Uuid.is_valid": {
        "id": "uuid-is_valid",
        "params": [
          "s"
        ]
      },
      "Uuid.to_text": {
        "id": "uuid-to_text",
        "params": [
          "id"
        ]
      },
      "Uuid.equals": {
        "id": "uuid-equals",
        "params": []
      },
      "Uuid.nil": {
        "id": "uuid-nil",
        "params": []
      },
      "World.get": {
        "id": "world-get",
        "params": []
      },
      "World.set": {
        "id": "world-set",
        "params": []
      },
      "World.has": {
        "id": "world-has",
        "params": []
      },
      "World.count": {
        "id": "world-count",
        "params": []
      },
      "World.size": {
        "id": "world-size",
        "params": []
      },
      "World.spawn": {
        "id": "world-spawn",
        "params": []
      },
      "World.save": {
        "id": "world-save",
        "params": []
      },
      "World.load": {
        "id": "world-load",
        "params": []
      },
      "World.prop_id": {
        "id": "world-prop_id",
        "params": []
      },
      "World.field_id": {
        "id": "world-field_id",
        "params": []
      },
      "World.model_id": {
        "id": "world-model_id",
        "params": []
      },
      "World.kind": {
        "id": "world-kind",
        "params": []
      },
      "World.register_prop": {
        "id": "world-register_prop",
        "params": []
      },
      "World.attach": {
        "id": "world-attach",
        "params": []
      },
      "World.detach": {
        "id": "world-detach",
        "params": []
      },
      "World.query_next": {
        "id": "world-query_next",
        "params": []
      },
      "World.despawn": {
        "id": "world-despawn",
        "params": []
      },
      "Audio.load": {
        "id": "audio-load",
        "params": []
      },
      "Audio.play": {
        "id": "audio-play",
        "params": []
      },
      "Audio.play_at": {
        "id": "audio-play_at",
        "params": []
      },
      "Audio.play_sound": {
        "id": "audio-play_sound",
        "params": []
      },
      "Audio.play_music": {
        "id": "audio-play_music",
        "params": []
      },
      "Audio.stop": {
        "id": "audio-stop",
        "params": []
      },
      "Audio.stop_music": {
        "id": "audio-stop_music",
        "params": []
      },
      "Audio.stop_all": {
        "id": "audio-stop_all",
        "params": []
      },
      "Audio.volume": {
        "id": "audio-volume",
        "params": []
      },
      "Audio.pitch": {
        "id": "audio-pitch",
        "params": []
      },
      "Audio.is_playing": {
        "id": "audio-is_playing",
        "params": []
      },
      "Audio.define": {
        "id": "audio-define",
        "params": []
      },
      "Audio.named": {
        "id": "audio-named",
        "params": []
      },
      "Random.range": {
        "id": "random-range",
        "params": [
          "low",
          "high"
        ]
      },
      "Random.chance": {
        "id": "random-chance",
        "params": [
          "percent"
        ]
      },
      "Random.seed": {
        "id": "random-seed",
        "params": [
          "value"
        ]
      },
      "Random.value": {
        "id": "random-value",
        "params": []
      },
      "Random.int": {
        "id": "random-int",
        "params": []
      },
      "Random.sign": {
        "id": "random-sign",
        "params": []
      },
      "Random.weighted": {
        "id": "random-weighted",
        "params": []
      },
      "Vector.make": {
        "id": "vector-make",
        "params": []
      },
      "Vector.zero": {
        "id": "vector-zero",
        "params": []
      },
      "Vector.x": {
        "id": "vector-x",
        "params": []
      },
      "Vector.y": {
        "id": "vector-y",
        "params": []
      },
      "Vector.add": {
        "id": "vector-add",
        "params": []
      },
      "Vector.sub": {
        "id": "vector-sub",
        "params": []
      },
      "Vector.scale": {
        "id": "vector-scale",
        "params": []
      },
      "Vector.dot": {
        "id": "vector-dot",
        "params": []
      },
      "Vector.length": {
        "id": "vector-length",
        "params": []
      },
      "Vector.distance": {
        "id": "vector-distance",
        "params": []
      },
      "Vector.normalize": {
        "id": "vector-normalize",
        "params": []
      },
      "Vector.lerp": {
        "id": "vector-lerp",
        "params": []
      },
      "Vector.rotate": {
        "id": "vector-rotate",
        "params": []
      },
      "Vector.angle": {
        "id": "vector-angle",
        "params": []
      },
      "Vector.from_angle": {
        "id": "vector-from_angle",
        "params": []
      },
      "Http.get": {
        "id": "http-get",
        "params": []
      },
      "Http.post": {
        "id": "http-post",
        "params": []
      },
      "Http.request": {
        "id": "http-request",
        "params": []
      },
      "Http.open": {
        "id": "http-open",
        "params": []
      },
      "Http.set": {
        "id": "http-set",
        "params": []
      },
      "Http.body": {
        "id": "http-body",
        "params": []
      },
      "Http.body_bytes": {
        "id": "http-body_bytes",
        "params": []
      },
      "Http.send": {
        "id": "http-send",
        "params": []
      },
      "Http.poll": {
        "id": "http-poll",
        "params": []
      },
      "Http.status": {
        "id": "http-status",
        "params": []
      },
      "Http.ok": {
        "id": "http-ok",
        "params": []
      },
      "Http.text": {
        "id": "http-text",
        "params": []
      },
      "Http.body_len": {
        "id": "http-body_len",
        "params": []
      },
      "Http.header": {
        "id": "http-header",
        "params": []
      },
      "Http.free": {
        "id": "http-free",
        "params": []
      },
      "Http.parse": {
        "id": "http-parse",
        "params": []
      },
      "Http.save_to": {
        "id": "http-save_to",
        "params": []
      },
      "Http.received": {
        "id": "http-received",
        "params": []
      },
      "Http.expected": {
        "id": "http-expected",
        "params": []
      },
      "IVec2.make": {
        "id": "ivec2-make",
        "params": []
      },
      "IVec2.zero": {
        "id": "ivec2-zero",
        "params": []
      },
      "IVec2.x": {
        "id": "ivec2-x",
        "params": []
      },
      "IVec2.y": {
        "id": "ivec2-y",
        "params": []
      },
      "IVec2.add": {
        "id": "ivec2-add",
        "params": []
      },
      "IVec2.sub": {
        "id": "ivec2-sub",
        "params": []
      },
      "IVec2.scale": {
        "id": "ivec2-scale",
        "params": []
      },
      "IVec2.dot": {
        "id": "ivec2-dot",
        "params": []
      },
      "IVec2.equal": {
        "id": "ivec2-equal",
        "params": []
      },
      "IVec2.manhattan": {
        "id": "ivec2-manhattan",
        "params": []
      },
      "IVec2.to_vector": {
        "id": "ivec2-to_vector",
        "params": []
      },
      "IVec2.distance2": {
        "id": "ivec2-distance2",
        "params": []
      },
      "IVec2.within": {
        "id": "ivec2-within",
        "params": []
      },
      "IVec2.heading": {
        "id": "ivec2-heading",
        "params": []
      },
      "IVec2.along": {
        "id": "ivec2-along",
        "params": []
      },
      "IVec2.step": {
        "id": "ivec2-step",
        "params": []
      },
      "Map.size": {
        "id": "map-size",
        "params": [
          "width",
          "height"
        ]
      },
      "Map.row": {
        "id": "map-row",
        "params": [
          "y",
          "cells"
        ]
      },
      "Map.tile": {
        "id": "map-tile",
        "params": [
          "x",
          "y"
        ]
      },
      "Map.get": {
        "id": "map-get",
        "params": []
      },
      "Map.set": {
        "id": "map-set",
        "params": []
      },
      "Map.fill": {
        "id": "map-fill",
        "params": []
      },
      "Map.rect": {
        "id": "map-rect",
        "params": []
      },
      "Map.border": {
        "id": "map-border",
        "params": []
      },
      "Map.random_cell": {
        "id": "map-random_cell",
        "params": []
      },
      "Map.is_solid": {
        "id": "map-is_solid",
        "params": []
      },
      "Map.is_solid_at": {
        "id": "map-is_solid_at",
        "params": []
      },
      "Map.width": {
        "id": "map-width",
        "params": []
      },
      "Map.height": {
        "id": "map-height",
        "params": []
      },
      "Map.random_cell_far": {
        "id": "map-random_cell_far",
        "params": []
      },
      "Map.to_tile": {
        "id": "map-to_tile",
        "params": []
      },
      "Rect.make": {
        "id": "rect-make",
        "params": []
      },
      "Rect.x": {
        "id": "rect-x",
        "params": []
      },
      "Rect.y": {
        "id": "rect-y",
        "params": []
      },
      "Rect.w": {
        "id": "rect-w",
        "params": []
      },
      "Rect.h": {
        "id": "rect-h",
        "params": []
      },
      "Rect.right": {
        "id": "rect-right",
        "params": []
      },
      "Rect.bottom": {
        "id": "rect-bottom",
        "params": []
      },
      "Rect.center": {
        "id": "rect-center",
        "params": []
      },
      "Rect.contains": {
        "id": "rect-contains",
        "params": []
      },
      "Rect.intersects": {
        "id": "rect-intersects",
        "params": []
      },
      "Udp.open": {
        "id": "udp-open",
        "params": []
      },
      "Udp.port": {
        "id": "udp-port",
        "params": []
      },
      "Udp.send": {
        "id": "udp-send",
        "params": []
      },
      "Udp.recv": {
        "id": "udp-recv",
        "params": []
      },
      "Udp.from_ip": {
        "id": "udp-from_ip",
        "params": []
      },
      "Udp.from_port": {
        "id": "udp-from_port",
        "params": []
      },
      "Udp.close": {
        "id": "udp-close",
        "params": []
      },
      "Udp.resolve": {
        "id": "udp-resolve",
        "params": []
      },
      "Udp.local_ip": {
        "id": "udp-local_ip",
        "params": []
      },
      "Udp.ip": {
        "id": "udp-ip",
        "params": []
      },
      "Udp.ip_text": {
        "id": "udp-ip_text",
        "params": []
      },
      "BigInt.from": {
        "id": "bigint-from",
        "params": []
      },
      "BigInt.parse": {
        "id": "bigint-parse",
        "params": []
      },
      "BigInt.add": {
        "id": "bigint-add",
        "params": []
      },
      "BigInt.sub": {
        "id": "bigint-sub",
        "params": []
      },
      "BigInt.mul": {
        "id": "bigint-mul",
        "params": []
      },
      "BigInt.neg": {
        "id": "bigint-neg",
        "params": []
      },
      "BigInt.pow": {
        "id": "bigint-pow",
        "params": []
      },
      "BigInt.div": {
        "id": "bigint-div",
        "params": []
      },
      "BigInt.mod": {
        "id": "bigint-mod",
        "params": []
      },
      "BigInt.cmp": {
        "id": "bigint-cmp",
        "params": []
      },
      "BigInt.eq": {
        "id": "bigint-eq",
        "params": []
      },
      "BigInt.is_zero": {
        "id": "bigint-is_zero",
        "params": []
      },
      "BigInt.to_int": {
        "id": "bigint-to_int",
        "params": []
      },
      "BigInt.str": {
        "id": "bigint-str",
        "params": []
      },
      "Process.spawn": {
        "id": "process-spawn",
        "params": []
      },
      "Process.poll": {
        "id": "process-poll",
        "params": []
      },
      "Process.kill": {
        "id": "process-kill",
        "params": []
      },
      "Process.free": {
        "id": "process-free",
        "params": []
      },
      "Decimal.from": {
        "id": "decimal-from",
        "params": []
      },
      "Decimal.parse": {
        "id": "decimal-parse",
        "params": []
      },
      "Decimal.add": {
        "id": "decimal-add",
        "params": []
      },
      "Decimal.sub": {
        "id": "decimal-sub",
        "params": []
      },
      "Decimal.mul": {
        "id": "decimal-mul",
        "params": []
      },
      "Decimal.neg": {
        "id": "decimal-neg",
        "params": []
      },
      "Decimal.cmp": {
        "id": "decimal-cmp",
        "params": []
      },
      "Decimal.eq": {
        "id": "decimal-eq",
        "params": []
      },
      "Decimal.scale": {
        "id": "decimal-scale",
        "params": []
      },
      "Decimal.rescale": {
        "id": "decimal-rescale",
        "params": []
      },
      "Decimal.str": {
        "id": "decimal-str",
        "params": []
      },
      "Dict.new": {
        "id": "dict-new",
        "params": []
      },
      "Dict.set": {
        "id": "dict-set",
        "params": []
      },
      "Dict.get": {
        "id": "dict-get",
        "params": []
      },
      "Dict.get_or": {
        "id": "dict-get_or",
        "params": []
      },
      "Dict.has": {
        "id": "dict-has",
        "params": []
      },
      "Dict.remove": {
        "id": "dict-remove",
        "params": []
      },
      "Dict.size": {
        "id": "dict-size",
        "params": []
      },
      "Dict.clear": {
        "id": "dict-clear",
        "params": []
      },
      "Dict.keys": {
        "id": "dict-keys",
        "params": []
      },
      "Set.new": {
        "id": "set-new",
        "params": []
      },
      "Set.add": {
        "id": "set-add",
        "params": []
      },
      "Set.has": {
        "id": "set-has",
        "params": []
      },
      "Set.remove": {
        "id": "set-remove",
        "params": []
      },
      "Set.size": {
        "id": "set-size",
        "params": []
      },
      "Set.clear": {
        "id": "set-clear",
        "params": []
      },
      "Set.members": {
        "id": "set-members",
        "params": []
      },
      "Huge.from": {
        "id": "huge-from",
        "params": []
      },
      "Huge.add": {
        "id": "huge-add",
        "params": []
      },
      "Huge.sub": {
        "id": "huge-sub",
        "params": []
      },
      "Huge.mul": {
        "id": "huge-mul",
        "params": []
      },
      "Huge.neg": {
        "id": "huge-neg",
        "params": []
      },
      "Huge.cmp": {
        "id": "huge-cmp",
        "params": []
      },
      "Huge.sign": {
        "id": "huge-sign",
        "params": []
      },
      "Huge.mantissa": {
        "id": "huge-mantissa",
        "params": []
      },
      "Huge.exp": {
        "id": "huge-exp",
        "params": []
      },
      "Huge.str": {
        "id": "huge-str",
        "params": []
      },
      "Angle.from_degrees": {
        "id": "angle-from_degrees",
        "params": []
      },
      "Angle.to_degrees": {
        "id": "angle-to_degrees",
        "params": []
      },
      "Angle.wrap": {
        "id": "angle-wrap",
        "params": []
      },
      "Angle.sin": {
        "id": "angle-sin",
        "params": []
      },
      "Angle.cos": {
        "id": "angle-cos",
        "params": []
      },
      "Angle.add": {
        "id": "angle-add",
        "params": []
      },
      "Angle.diff": {
        "id": "angle-diff",
        "params": []
      },
      "Angle.lerp": {
        "id": "angle-lerp",
        "params": []
      },
      "Angle.diff_degrees": {
        "id": "angle-diff_degrees",
        "params": []
      },
      "Percent.clamp": {
        "id": "percent-clamp",
        "params": []
      },
      "Percent.of": {
        "id": "percent-of",
        "params": []
      },
      "Percent.lerp": {
        "id": "percent-lerp",
        "params": []
      },
      "Percent.apply": {
        "id": "percent-apply",
        "params": []
      },
      "Regex.compile": {
        "id": "regex-compile",
        "params": [
          "pattern"
        ]
      },
      "Regex.valid": {
        "id": "regex-valid",
        "params": [
          "pattern"
        ]
      },
      "Regex.matches": {
        "id": "regex-matches",
        "params": [
          "text",
          "pattern"
        ]
      },
      "Regex.test": {
        "id": "regex-test",
        "params": [
          "text",
          "re"
        ]
      },
      "Regex.find": {
        "id": "regex-find",
        "params": [
          "text",
          "pattern"
        ]
      },
      "Regex.exec": {
        "id": "regex-exec",
        "params": [
          "text",
          "re"
        ]
      },
      "Regex.next": {
        "id": "regex-next",
        "params": [
          "text",
          "re",
          "from"
        ]
      },
      "Regex.replace": {
        "id": "regex-replace",
        "params": [
          "text",
          "pattern",
          "replacement"
        ]
      },
      "Regex.group": {
        "id": "regex-group",
        "params": [
          "match",
          "n"
        ]
      },
      "Regex.group_count": {
        "id": "regex-group_count",
        "params": [
          "match"
        ]
      },
      "Regex.start": {
        "id": "regex-start",
        "params": [
          "match",
          "n"
        ]
      },
      "Regex.end": {
        "id": "regex-end",
        "params": [
          "match",
          "n"
        ]
      },
      "Regex.ok": {
        "id": "regex-ok",
        "params": [
          "match"
        ]
      },
      "Grid.line": {
        "id": "grid-line",
        "params": []
      },
      "Grid.blocked": {
        "id": "grid-blocked",
        "params": [
          "wall"
        ]
      },
      "Grid.line_of_sight": {
        "id": "grid-line_of_sight",
        "params": [
          "wall"
        ]
      },
      "Grid.flood": {
        "id": "grid-flood",
        "params": [
          "wall"
        ]
      },
      "Grid.a_star": {
        "id": "grid-a_star",
        "params": [
          "wall"
        ]
      },
      "Anim.frame": {
        "id": "anim-frame",
        "params": [
          "timer",
          "fps",
          "count"
        ]
      },
      "Anim.once": {
        "id": "anim-once",
        "params": [
          "timer",
          "fps",
          "count"
        ]
      },
      "Anim.pingpong": {
        "id": "anim-pingpong",
        "params": [
          "timer",
          "fps",
          "count"
        ]
      },
      "Anim.finished": {
        "id": "anim-finished",
        "params": [
          "timer",
          "fps",
          "count"
        ]
      },
      "Anim.duration": {
        "id": "anim-duration",
        "params": [
          "fps",
          "count"
        ]
      },
      "Anim.cell_x": {
        "id": "anim-cell_x",
        "params": [
          "frame",
          "cols",
          "cell_w"
        ]
      },
      "Anim.cell_y": {
        "id": "anim-cell_y",
        "params": [
          "frame",
          "cols",
          "cell_h"
        ]
      },
      "Anim.play": {
        "id": "anim-play",
        "params": [
          "entity",
          "clip"
        ]
      },
      "Anim.clip": {
        "id": "anim-clip",
        "params": [
          "name",
          "frames",
          "fps",
          "mode"
        ]
      },
      "Anim.on_frame": {
        "id": "anim-on_frame",
        "params": [
          "entity",
          "frame"
        ]
      },
      "Anim.fired": {
        "id": "anim-fired",
        "params": [
          "entity"
        ]
      },
      "Motion.to": {
        "id": "motion-to",
        "params": [
          "entity",
          "dur",
          "ease"
        ]
      },
      "Tween.progress": {
        "id": "tween-progress",
        "params": [
          "timer",
          "duration"
        ]
      },
      "Tween.loop": {
        "id": "tween-loop",
        "params": [
          "timer",
          "duration"
        ]
      },
      "Tween.yoyo": {
        "id": "tween-yoyo",
        "params": [
          "timer",
          "duration"
        ]
      },
      "Tween.done": {
        "id": "tween-done",
        "params": [
          "timer",
          "duration"
        ]
      },
      "Tween.ease": {
        "id": "tween-ease",
        "params": [
          "t",
          "mode"
        ]
      },
      "Tween.number": {
        "id": "tween-number",
        "params": [
          "from",
          "to",
          "t"
        ]
      },
      "Tween.round": {
        "id": "tween-round",
        "params": [
          "from",
          "to",
          "t"
        ]
      },
      "Tween.point": {
        "id": "tween-point",
        "params": [
          "from",
          "to",
          "t"
        ]
      },
      "Tween.tint": {
        "id": "tween-tint",
        "params": [
          "from",
          "to",
          "t"
        ]
      },
      "Tween.to": {
        "id": "tween-to",
        "params": [
          "dur",
          "ease"
        ]
      },
      "Tween.chain": {
        "id": "tween-chain",
        "params": [
          "handle",
          "to",
          "dur",
          "ease"
        ]
      },
      "Tween.delay": {
        "id": "tween-delay",
        "params": [
          "handle",
          "ticks"
        ]
      },
      "Tween.value": {
        "id": "tween-value",
        "params": [
          "handle"
        ]
      },
      "Tween.stop": {
        "id": "tween-stop",
        "params": [
          "handle"
        ]
      },
      "Tween.parallel": {
        "id": "tween-parallel",
        "params": []
      },
      "Query.count": {
        "id": "query-count",
        "params": [
          "prop"
        ]
      },
      "Query.first": {
        "id": "query-first",
        "params": [
          "prop"
        ]
      },
      "Query.nearest": {
        "id": "query-nearest",
        "params": [
          "prop",
          "pos"
        ]
      },
      "Query.within": {
        "id": "query-within",
        "params": [
          "prop",
          "pos",
          "radius"
        ]
      },
      "Reflect.prop": {
        "id": "reflect-prop",
        "params": [
          "name"
        ]
      },
      "Reflect.field": {
        "id": "reflect-field",
        "params": [
          "prop",
          "name"
        ]
      },
      "Reflect.prop_count": {
        "id": "reflect-prop_count",
        "params": []
      },
      "Reflect.prop_name": {
        "id": "reflect-prop_name",
        "params": [
          "index"
        ]
      },
      "Reflect.field_count": {
        "id": "reflect-field_count",
        "params": [
          "prop"
        ]
      },
      "Reflect.field_name": {
        "id": "reflect-field_name",
        "params": [
          "prop",
          "index"
        ]
      },
      "Reflect.field_type": {
        "id": "reflect-field_type",
        "params": [
          "prop",
          "index"
        ]
      },
      "Reflect.get": {
        "id": "reflect-get",
        "params": [
          "entity",
          "prop",
          "field"
        ]
      },
      "Reflect.set": {
        "id": "reflect-set",
        "params": [
          "entity",
          "prop",
          "field",
          "value"
        ]
      },
      "Reflect.has": {
        "id": "reflect-has",
        "params": [
          "entity",
          "prop"
        ]
      },
      "Reflect.kind": {
        "id": "reflect-kind",
        "params": [
          "entity"
        ]
      },
      "Reflect.model": {
        "id": "reflect-model",
        "params": [
          "name"
        ]
      },
      "Reflect.serialize": {
        "id": "reflect-serialize",
        "params": []
      },
      "Reflect.apply": {
        "id": "reflect-apply",
        "params": []
      },
      "Camera.set": {
        "id": "camera-set",
        "params": []
      },
      "Camera.follow": {
        "id": "camera-follow",
        "params": [
          "lerp"
        ]
      },
      "Camera.shake": {
        "id": "camera-shake",
        "params": [
          "amount"
        ]
      },
      "Camera.zoom": {
        "id": "camera-zoom",
        "params": [
          "scale"
        ]
      },
      "Camera.shake_for": {
        "id": "camera-shake_for",
        "params": []
      },
      "Light.ambient": {
        "id": "light-ambient",
        "params": [
          "color"
        ]
      },
      "Light.point": {
        "id": "light-point",
        "params": [
          "radius",
          "color",
          "energy"
        ]
      },
      "Light.occlude": {
        "id": "light-occlude",
        "params": []
      },
      "Light.clear_occluders": {
        "id": "light-clear_occluders",
        "params": []
      },
      "Light.spot": {
        "id": "light-spot",
        "params": [
          "radius",
          "color",
          "energy",
          "direction",
          "spread"
        ]
      },
      "Light.falloff": {
        "id": "light-falloff",
        "params": [
          "exponent"
        ]
      },
      "Light.soft": {
        "id": "light-soft",
        "params": [
          "radius"
        ]
      },
      "Light.gel": {
        "id": "light-gel",
        "params": [
          "color"
        ]
      },
      "Light.clear_gel": {
        "id": "light-clear_gel",
        "params": []
      },
      "Light.normal": {
        "id": "light-normal",
        "params": []
      },
      "Light.clear_normals": {
        "id": "light-clear_normals",
        "params": []
      },
      "Light.height": {
        "id": "light-height",
        "params": [
          "height"
        ]
      },
      "Light.time_of_day": {
        "id": "light-time_of_day",
        "params": [
          "t"
        ]
      },
      "Sprite.sheet": {
        "id": "sprite-sheet",
        "params": []
      },
      "Sprite.cell": {
        "id": "sprite-cell",
        "params": []
      },
      "Sprite.cell_span": {
        "id": "sprite-cell_span",
        "params": []
      },
      "Sprite.define": {
        "id": "sprite-define",
        "params": []
      },
      "Sprite.named": {
        "id": "sprite-named",
        "params": []
      },
      "Sprite.draw": {
        "id": "sprite-draw",
        "params": []
      },
      "Sprite.draw_scaled": {
        "id": "sprite-draw_scaled",
        "params": []
      },
      "Sprite.width": {
        "id": "sprite-width",
        "params": []
      },
      "Sprite.height": {
        "id": "sprite-height",
        "params": []
      },
      "Sprite.strip": {
        "id": "sprite-strip",
        "params": []
      },
      "Sprite.draw_meter": {
        "id": "sprite-draw_meter",
        "params": []
      },
      "Assets.image": {
        "id": "assets-image",
        "params": []
      },
      "Assets.load": {
        "id": "assets-load",
        "params": []
      },
      "Assets.get": {
        "id": "assets-get",
        "params": []
      },
      "Assets.enqueue": {
        "id": "assets-enqueue",
        "params": []
      },
      "Assets.pump": {
        "id": "assets-pump",
        "params": []
      },
      "Assets.total": {
        "id": "assets-total",
        "params": []
      },
      "Assets.loaded": {
        "id": "assets-loaded",
        "params": []
      },
      "Assets.ready": {
        "id": "assets-ready",
        "params": []
      },
      "Assets.font": {
        "id": "assets-font",
        "params": []
      },
      "Assets.progress": {
        "id": "assets-progress",
        "params": []
      },
      "Assets.enqueue_dir": {
        "id": "assets-enqueue_dir",
        "params": []
      },
      "Pool.live": {
        "id": "pool-live",
        "params": []
      },
      "Pool.free": {
        "id": "pool-free",
        "params": []
      },
      "Pool.reserved": {
        "id": "pool-reserved",
        "params": []
      },
      "Pool.capacity": {
        "id": "pool-capacity",
        "params": []
      },
      "Value.null": {
        "id": "value-null",
        "params": []
      },
      "Value.int": {
        "id": "value-int",
        "params": []
      },
      "Value.fixed": {
        "id": "value-fixed",
        "params": []
      },
      "Value.bool": {
        "id": "value-bool",
        "params": []
      },
      "Value.str": {
        "id": "value-str",
        "params": []
      },
      "Value.list": {
        "id": "value-list",
        "params": []
      },
      "Value.object": {
        "id": "value-object",
        "params": []
      },
      "Value.add": {
        "id": "value-add",
        "params": []
      },
      "Value.put": {
        "id": "value-put",
        "params": []
      },
      "Value.get": {
        "id": "value-get",
        "params": []
      },
      "Value.has": {
        "id": "value-has",
        "params": []
      },
      "Value.at": {
        "id": "value-at",
        "params": []
      },
      "Value.key_at": {
        "id": "value-key_at",
        "params": []
      },
      "Value.count": {
        "id": "value-count",
        "params": []
      },
      "Value.kind": {
        "id": "value-kind",
        "params": []
      },
      "Value.as_int": {
        "id": "value-as_int",
        "params": []
      },
      "Value.as_str": {
        "id": "value-as_str",
        "params": []
      },
      "Json.encode": {
        "id": "json-encode",
        "params": []
      },
      "Json.parse": {
        "id": "json-parse",
        "params": []
      },
      "Job.defer": {
        "id": "job-defer",
        "params": []
      },
      "Job.run": {
        "id": "job-run",
        "params": []
      },
      "Job.fulfill": {
        "id": "job-fulfill",
        "params": []
      },
      "Job.fail": {
        "id": "job-fail",
        "params": []
      },
      "Job.cancel": {
        "id": "job-cancel",
        "params": []
      },
      "Job.pump": {
        "id": "job-pump",
        "params": []
      },
      "Job.done": {
        "id": "job-done",
        "params": []
      },
      "Job.ok": {
        "id": "job-ok",
        "params": []
      },
      "Job.failed": {
        "id": "job-failed",
        "params": []
      },
      "Job.cancelled": {
        "id": "job-cancelled",
        "params": []
      },
      "Job.result": {
        "id": "job-result",
        "params": []
      },
      "Job.error": {
        "id": "job-error",
        "params": []
      },
      "Job.pending": {
        "id": "job-pending",
        "params": []
      },
      "Job.free": {
        "id": "job-free",
        "params": []
      },
      "Job.parallel_for": {
        "id": "job-parallel_for",
        "params": []
      },
      "Job.is_worker": {
        "id": "job-is_worker",
        "params": []
      },
      "Promise.all": {
        "id": "promise-all",
        "params": []
      },
      "Promise.race": {
        "id": "promise-race",
        "params": []
      },
      "Promise.count_done": {
        "id": "promise-count_done",
        "params": []
      },
      "Promise.all_done": {
        "id": "promise-all_done",
        "params": []
      },
      "Sync.mutex": {
        "id": "sync-mutex",
        "params": []
      },
      "Sync.lock": {
        "id": "sync-lock",
        "params": []
      },
      "Sync.unlock": {
        "id": "sync-unlock",
        "params": []
      },
      "Sync.try_lock": {
        "id": "sync-try_lock",
        "params": []
      },
      "Sync.atomic": {
        "id": "sync-atomic",
        "params": []
      },
      "Sync.get": {
        "id": "sync-get",
        "params": []
      },
      "Sync.set": {
        "id": "sync-set",
        "params": []
      },
      "Sync.add": {
        "id": "sync-add",
        "params": []
      },
      "Sync.cas": {
        "id": "sync-cas",
        "params": []
      },
      "Sync.channel": {
        "id": "sync-channel",
        "params": []
      },
      "Sync.send": {
        "id": "sync-send",
        "params": []
      },
      "Sync.recv": {
        "id": "sync-recv",
        "params": []
      },
      "Sync.can_recv": {
        "id": "sync-can_recv",
        "params": []
      },
      "Sync.len": {
        "id": "sync-len",
        "params": []
      },
      "Sync.cpu_count": {
        "id": "sync-cpu_count",
        "params": []
      },
      "Xml.parse": {
        "id": "xml-parse",
        "params": []
      },
      "Xml.tag": {
        "id": "xml-tag",
        "params": []
      },
      "Xml.text": {
        "id": "xml-text",
        "params": []
      },
      "Xml.attr": {
        "id": "xml-attr",
        "params": []
      },
      "Xml.attr_int": {
        "id": "xml-attr_int",
        "params": []
      },
      "Xml.has": {
        "id": "xml-has",
        "params": []
      },
      "Xml.attr_count": {
        "id": "xml-attr_count",
        "params": []
      },
      "Xml.child_count": {
        "id": "xml-child_count",
        "params": []
      },
      "Xml.child": {
        "id": "xml-child",
        "params": []
      },
      "Xml.find": {
        "id": "xml-find",
        "params": []
      },
      "Xml.count": {
        "id": "xml-count",
        "params": []
      },
      "Base64.decode": {
        "id": "base64-decode",
        "params": []
      },
      "Base64.encode": {
        "id": "base64-encode",
        "params": []
      },
      "Tiled.read": {
        "id": "tiled-read",
        "params": []
      },
      "Tiled.read_tsx": {
        "id": "tiled-read_tsx",
        "params": []
      },
      "Tiled.load": {
        "id": "tiled-load",
        "params": []
      },
      "Tiled.gid": {
        "id": "tiled-gid",
        "params": []
      },
      "Tiled.resolve": {
        "id": "tiled-resolve",
        "params": []
      },
      "Tiled.width": {
        "id": "tiled-width",
        "params": []
      },
      "Tiled.height": {
        "id": "tiled-height",
        "params": []
      },
      "Tiled.layer_count": {
        "id": "tiled-layer_count",
        "params": []
      },
      "Tiled.layer_name": {
        "id": "tiled-layer_name",
        "params": []
      },
      "Tiled.draw": {
        "id": "tiled-draw",
        "params": []
      },
      "Tiled.project": {
        "id": "tiled-project",
        "params": []
      },
      "Tiled.tree": {
        "id": "tiled-tree",
        "params": []
      },
      "Tiled.tile_prop": {
        "id": "tiled-tile_prop",
        "params": []
      },
      "Tiled.collide": {
        "id": "tiled-collide",
        "params": []
      },
      "Tiled.collision_kind": {
        "id": "tiled-collision_kind",
        "params": []
      },
      "Tiled.tile_shapes": {
        "id": "tiled-tile_shapes",
        "params": []
      },
      "Tiled.draw_anim": {
        "id": "tiled-draw_anim",
        "params": []
      },
      "Tiled.frame_gid": {
        "id": "tiled-frame_gid",
        "params": []
      },
      "Tiled.animated": {
        "id": "tiled-animated",
        "params": []
      },
      "Tiled.object_count": {
        "id": "tiled-object_count",
        "params": []
      },
      "Tiled.object": {
        "id": "tiled-object",
        "params": []
      },
      "Tiled.object_shape": {
        "id": "tiled-object_shape",
        "params": []
      },
      "Tiled.prop": {
        "id": "tiled-prop",
        "params": []
      },
      "Tiled.prop_int": {
        "id": "tiled-prop_int",
        "params": []
      },
      "Tiled.prop_type": {
        "id": "tiled-prop_type",
        "params": []
      },
      "Tiled.load_types": {
        "id": "tiled-load_types",
        "params": []
      },
      "Tiled.template": {
        "id": "tiled-template",
        "params": []
      },
      "Tiled.spawn": {
        "id": "tiled-spawn",
        "params": []
      },
      "Tiled.spawn_layer": {
        "id": "tiled-spawn_layer",
        "params": []
      },
      "Tiled.cell_x": {
        "id": "tiled-cell_x",
        "params": []
      },
      "Tiled.cell_y": {
        "id": "tiled-cell_y",
        "params": []
      },
      "Tiled.layer_kind": {
        "id": "tiled-layer_kind",
        "params": []
      },
      "Tiled.layer_opacity": {
        "id": "tiled-layer_opacity",
        "params": []
      },
      "Tiled.layer_tint": {
        "id": "tiled-layer_tint",
        "params": []
      },
      "Tiled.layer_offsetx": {
        "id": "tiled-layer_offsetx",
        "params": []
      },
      "Tiled.layer_offsety": {
        "id": "tiled-layer_offsety",
        "params": []
      },
      "Tiled.world": {
        "id": "tiled-world",
        "params": []
      },
      "Tiled.world_count": {
        "id": "tiled-world_count",
        "params": []
      },
      "Tiled.world_map": {
        "id": "tiled-world_map",
        "params": []
      },
      "Ui.build": {
        "id": "ui-build",
        "params": []
      },
      "Ui.open": {
        "id": "ui-open",
        "params": []
      },
      "Ui.close": {
        "id": "ui-close",
        "params": []
      },
      "Ui.tick": {
        "id": "ui-tick",
        "params": []
      },
      "Ui.clicked": {
        "id": "ui-clicked",
        "params": []
      },
      "Ui.set_text": {
        "id": "ui-set_text",
        "params": []
      },
      "Ui.render": {
        "id": "ui-render",
        "params": []
      },
      "File.open": {
        "id": "file-open",
        "params": []
      },
      "File.read": {
        "id": "file-read",
        "params": []
      },
      "File.write": {
        "id": "file-write",
        "params": []
      },
      "File.seek": {
        "id": "file-seek",
        "params": []
      },
      "File.tell": {
        "id": "file-tell",
        "params": []
      },
      "File.close": {
        "id": "file-close",
        "params": []
      },
      "Font.load": {
        "id": "font-load",
        "params": []
      },
      "Fx.sparks": {
        "id": "fx-sparks",
        "params": []
      },
      "Fx.number": {
        "id": "fx-number",
        "params": []
      },
      "Fx.clear": {
        "id": "fx-clear",
        "params": []
      },
      "Prefab.spawn": {
        "id": "prefab-spawn",
        "params": []
      },
      "Prefab.spawn_at": {
        "id": "prefab-spawn_at",
        "params": []
      },
      "App.splash_hide": {
        "id": "app-splash_hide",
        "params": []
      },
      "App.set_icon": {
        "id": "app-set_icon",
        "params": [
          "path"
        ]
      },
      "App.window_hide": {
        "id": "app-window_hide",
        "params": []
      },
      "App.window_show": {
        "id": "app-window_show",
        "params": []
      }
    },
    "annotations": {
      "@Queries": "annot-queries",
      "@Computed": "annot-computed",
      "@On": "annot-on",
      "@export": "annot-export",
      "@Sync": "annot-sync",
      "@Handles": "annot-handles",
      "@OnAttach": "annot-onattach",
      "@OnDespawn": "annot-ondespawn",
      "@OnDetach": "annot-ondetach",
      "@OnDisable": "annot-ondisable",
      "@OnEnable": "annot-onenable",
      "@OnQuit": "annot-onquit",
      "@OnSpawn": "annot-onspawn",
      "@OnStart": "annot-onstart",
      "@Owned": "annot-owned",
      "@Predicted": "annot-predicted",
      "@Public": "annot-public",
      "@Reads": "annot-reads",
      "@Server": "annot-server",
      "@ToClients": "annot-toclients",
      "@ToServer": "annot-toserver",
      "@Writes": "annot-writes",
      "@EngineSystem": "annot-enginesystem",
      "@Namespace": "annot-namespace",
      "\"@ClearColor\"": "annot-clearcolor",
      "@System": "annot-system"
    },
    "namespaces": {
      "Angle": "ns-angle",
      "Anim": "ns-anim",
      "App": "ns-app",
      "Assets": "ns-assets",
      "Audio": "ns-audio",
      "Base64": "ns-base64",
      "BigInt": "ns-bigint",
      "Camera": "ns-camera",
      "Clock": "ns-clock",
      "Collision": "ns-collision",
      "Color": "ns-color",
      "Crypto": "ns-crypto",
      "Date": "ns-date",
      "DateTime": "ns-datetime",
      "Decimal": "ns-decimal",
      "Dict": "ns-dict",
      "Duration": "ns-duration",
      "Ease": "ns-ease",
      "File": "ns-file",
      "Font": "ns-font",
      "Fs": "ns-fs",
      "Fx": "ns-fx",
      "Grid": "ns-grid",
      "Hash": "ns-hash",
      "Http": "ns-http",
      "Huge": "ns-huge",
      "IVec2": "ns-ivec2",
      "Input": "ns-input",
      "Job": "ns-job",
      "Json": "ns-json",
      "Light": "ns-light",
      "List": "ns-list",
      "Log": "ns-log",
      "Map": "ns-map",
      "Math": "ns-math",
      "Memory": "ns-memory",
      "Mime": "ns-mime",
      "Motion": "ns-motion",
      "Network": "ns-network",
      "Noise": "ns-noise",
      "Os": "ns-os",
      "Path": "ns-path",
      "Percent": "ns-percent",
      "Pool": "ns-pool",
      "Prefab": "ns-prefab",
      "Process": "ns-process",
      "Promise": "ns-promise",
      "Query": "ns-query",
      "Random": "ns-random",
      "Rect": "ns-rect",
      "Reflect": "ns-reflect",
      "Regex": "ns-regex",
      "Save": "ns-save",
      "Screen": "ns-screen",
      "Set": "ns-set",
      "Sprite": "ns-sprite",
      "Sync": "ns-sync",
      "System": "ns-system",
      "Text": "ns-text",
      "Tiled": "ns-tiled",
      "Time": "ns-time",
      "Tween": "ns-tween",
      "Udp": "ns-udp",
      "Ui": "ns-ui",
      "Unicode": "ns-unicode",
      "Uuid": "ns-uuid",
      "Value": "ns-value",
      "Vector": "ns-vector",
      "World": "ns-world",
      "Xml": "ns-xml"
    },
    "tips": {
      "program": "The top-level unit — one program compiles to one native game.",
      "property": "A named record of typed fields — a per-model component, or a plain heap record.",
      "model": "A named kind of thing — a fixed bundle of properties you spawn by one name.",
      "handler": "A named block the engine runs each frame during phase P.",
      "phase": "Names which stage of the frame a handler runs in.",
      "const": "A compile-time constant, folded into the code with no storage.",
      "var": "A mutable binding — at program scope, your game's persistent named state.",
      "let": "An immutable binding — the default choice for a value that never changes.",
      "function": "A function — reusable logic called positionally or with named arguments.",
      "fn": "A top-level function named as a value - the entry point handed to Job.parallel_for.",
      "prefab": "A model with preset component fields — spawn it, override what varies.",
      "return": "Hand a value back from a function and stop running it.",
      "entry": "The program's main block — runs once, top to bottom.",
      "import": "Splice another Ludic file's declarations into this program.",
      "public": "Expose a declaration's lifecycle on the public event bus.",
      "extern": "Bind a name to an external native symbol — the seam for platform and library calls.",
      "new": "Allocate a property record or an empty slice on the heap.",
      "namespace": "Group functions into a Name.* namespace and control its public surface.",
      "enum": "A named set of integer constants — names for a magic-number space.",
      "ui": "Declare a retained widget tree as data; the engine lays it out and draws it.",
      "spawn": "Create a model instance carrying the listed properties, seeding their fields.",
      "despawn": "Remove a model instance from the world, firing any @OnDespawn hooks.",
      "query": "Match every model instance carrying all the listed properties.",
      "self": "The model instance currently bound by the enclosing query loop.",
      "enable": "Re-activate a disabled property, model, or handler — its data is intact.",
      "disable": "Deactivate a property, model, or handler without destroying its data.",
      "attach": "Structurally add a property to a live model instance, seeding its fields.",
      "detach": "Structurally remove a property from a live model instance.",
      "world_attach_dyn": "Attach a property to an instance by numeric id at runtime (dynamic ECS).",
      "world_count": "The total number of live model instances in the world.",
      "world_detach_dyn": "Detach a property from an instance by numeric id at runtime (dynamic ECS).",
      "world_field_id": "Resolve a field name within a property to its numeric index.",
      "world_get": "Read one field of a model instance by numeric id (reflection ABI).",
      "world_has": "Test whether a model instance currently carries a property.",
      "world_kind": "The model id of an instance — which kind of thing it is.",
      "world_load": "Restore the whole world from a serialized byte buffer.",
      "world_model_id": "Resolve a model's name to its stable numeric id.",
      "world_prop_id": "Resolve a property's name to its stable numeric id.",
      "world_query_next": "Step to the next instance carrying a property, walking the world by id.",
      "world_register_prop": "Register a brand-new property at runtime and get its id (dynamic ECS).",
      "world_save": "Serialize the whole world into a buffer; returns the number of bytes written.",
      "world_set": "Write one field of a model instance by numeric id (reflection ABI).",
      "world_size": "The number of live model instances in the world.",
      "world_spawn": "Spawn an instance of a model chosen by numeric id at runtime.",
      "if": "A branch — run one block when a condition holds, another when it doesn't.",
      "else": "A branch — run one block when a condition holds, another when it doesn't.",
      "while": "Loop as long as a condition holds, re-checking it before each pass.",
      "for": "Range loop — iterate the half-open range from a up to but not including b.",
      "in": "The part of a for loop that names what to iterate — a range or a query.",
      "match": "Multi-way branch on one value, matching one or more literals per arm.",
      "machine": "An explicit state machine over an int var — dispatches on the store's value.",
      "state": "One state of a machine — its body runs while the machine sits in it.",
      "become": "Transition to another state of the enclosing machine, or to another scene.",
      "break": "Leave the enclosing loop immediately.",
      "continue": "Skip to the next iteration of the loop.",
      "where": "Filter a query loop to entities that satisfy a condition.",
      "try": "Recover a fallible result as a value, with a fallback — no exceptions, no unwinding.",
      "scene": "A mutually-exclusive game state — a title screen, the overworld, a battle.",
      "layer": "A named group of handlers inside a scene; layers render in declaration order.",
      "on": "Scene lifecycle hooks that fire as a scene becomes active or is left.",
      "enter": "The scene-entry hook — runs once as a scene becomes active.",
      "exit": "Terminate the process immediately with a status code.",
      "start": "Marks the one scene the game begins in.",
      "event": "Declare a public event carrying a flat payload that listeners react to.",
      "emit": "Fire an event, running every listener; as an expression it yields the veto flag.",
      "cancel": "Inside a listener, veto the cancellable event being emitted.",
      "cancellable": "Marks an event whose listeners may veto it with cancel.",
      "Screen.clear": "Fill the whole framebuffer with one color to start a fresh frame.",
      "Screen.fill_rectangle": "Draw a solid, filled rectangle at a pixel position.",
      "Screen.draw_rectangle": "Draw a one-pixel-thick rectangle outline (not filled).",
      "Screen.put_pixel": "Set a single pixel at a pixel coordinate to one color.",
      "Screen.draw_text": "Draw a string with the built-in font at an integer scale.",
      "Screen.draw_number": "Draw an integer directly, with no string allocation or conversion.",
      "Screen.show": "Present the finished frame — copy everything drawn this frame to the window.",
      "Screen.width": "The framebuffer width in pixels.",
      "Screen.height": "The framebuffer height in pixels.",
      "Screen.status": "Set the persistent one-line status/HUD string shown by the runtime.",
      "Screen.line": "Draw a straight line between two points.",
      "Screen.circle": "Draw a circle outline.",
      "Screen.fill_circle": "Draw a filled disc.",
      "Screen.triangle": "Draw a triangle outline.",
      "Screen.fill_triangle": "Draw a filled triangle.",
      "Screen.sprite": "Blit a sprite at its natural size.",
      "Screen.sprite_scaled": "Blit a sprite at an integer scale.",
      "Screen.oval": "Draw an axis-aligned ellipse outline.",
      "Screen.camera": "Set the world-space camera offset for the draw path.",
      "Screen.clip": "Restrict drawing to a screen-space rectangle.",
      "Screen.clip_reset": "Lift the clip rectangle (draw to the whole screen again).",
      "Screen.blend_mode": "Choose replace or additive pixel blending.",
      "Screen.measure_text": "The pixel advance width of text in the built-in font.",
      "Screen.pixel": "Read a framebuffer pixel (0x00RRGGBB), or 0 if off-screen.",
      "Screen.bar": "A filled meter: value of max over a track.",
      "Clock.now": "The current simulated instant.",
      "Clock.set": "Set the clock to an instant.",
      "Clock.advance": "Move the clock forward by a Duration.",
      "Clock.reset": "Reset the clock to the epoch (0).",
      "Collision.rects": "Do two rectangles overlap?",
      "Collision.point_rect": "Is a point inside a rectangle?",
      "Collision.circles": "Do two circles overlap?",
      "Collision.rect_circle": "Does a rectangle overlap a circle?",
      "Color.rgb": "Build a color from red, green, blue.",
      "Color.rgba": "Build a color with an alpha byte.",
      "Color.lerp": "Blend between two colors.",
      "Color.darken": "Scale a color toward black.",
      "Color.lighten": "Scale a color toward white.",
      "Color.with_alpha": "Replace a color's alpha byte.",
      "Crypto.sha256": "SHA-256 of a string, as 64 hex characters.",
      "Crypto.hmac_sha256": "Sign a message with a shared secret key.",
      "Crypto.verify_hmac": "Constant-time check that a MAC matches.",
      "Crypto.hex": "Lowercase hex of a string's bytes.",
      "Crypto.ct_equal": "Constant-time string equality for secrets.",
      "Crypto.random_bytes": "n bytes from the OS CSPRNG, as a 2n-character hex string.",
      "Crypto.random_hex": "Alias for random_bytes — n secure bytes as a 2n-char hex string.",
      "Crypto.random_u32": "One CSPRNG-drawn 32-bit integer.",
      "Crypto.base64": "Standard base64 (RFC 4648) of a string's bytes.",
      "Date.new": "A calendar day as days-since-1970.",
      "Date.year": "The calendar year of a date.",
      "Date.month": "The month (1-12) of a date.",
      "Date.day": "The day of the month (1-31) of a date.",
      "Date.weekday": "Day of the week, 0=Sunday..6=Saturday.",
      "Date.is_leap": "True if the year is a leap year.",
      "Date.days_in_month": "Number of days in a given month.",
      "Date.to_epoch": "Midnight UTC of the day, as a DateTime.",
      "Date.add_days": "The date n days later (n may be negative).",
      "Date.diff_days": "Whole days from b to a (a - b).",
      "DateTime.from": "Build an instant from its calendar parts.",
      "DateTime.date": "The calendar day the instant falls on.",
      "DateTime.add": "The instant `span` seconds later.",
      "DateTime.year": "The calendar year of an instant.",
      "DateTime.month": "The month (1-12) of an instant.",
      "DateTime.day": "The day of the month (1-31) of an instant.",
      "DateTime.weekday": "Day of the week, 0=Sunday..6=Saturday.",
      "DateTime.hour": "The hour of day (0-23) of an instant.",
      "DateTime.minute": "The minute of the hour (0-59) of an instant.",
      "DateTime.second": "The second of the minute (0-59) of an instant.",
      "DateTime.format": "Render an instant as text using a token pattern.",
      "DateTime.parse": "Parse text into an instant; -1 on failure.",
      "Duration.seconds": "A span of n whole seconds.",
      "Duration.minutes": "A span of n minutes, in seconds.",
      "Duration.hours": "A span of n hours, in seconds.",
      "Duration.days": "A span of n days, in seconds.",
      "Duration.as_seconds": "The span in whole seconds.",
      "Duration.as_minutes": "The span in whole minutes.",
      "Duration.as_hours": "The span in whole hours.",
      "Duration.as_days": "The span in whole days.",
      "Ease.in": "Accelerate from rest (quadratic ease-in).",
      "Ease.out": "Decelerate to rest (quadratic ease-out).",
      "Ease.in_out": "Ease in and then out (smoothstep).",
      "Ease.back": "Ease in with a small backward anticipation.",
      "Ease.bounce": "Ease out with a settling bounce.",
      "Ease.elastic": "Ease out with a springy wobble.",
      "Fs.exists": "Does a path exist?",
      "Fs.is_dir": "Is a path a directory?",
      "Fs.read_text": "Read a whole file as a string.",
      "Fs.write_text": "Write a string to a file (atomically).",
      "Fs.append_text": "Append a string to a file.",
      "Fs.remove": "Delete a file.",
      "Fs.size": "File size in bytes.",
      "Fs.mkdir": "Create a directory and its parents.",
      "Fs.copy": "Copy a file byte-for-byte.",
      "Fs.list": "Directory entries, sorted.",
      "Hash.of": "The fast default string hash.",
      "Hash.fnv1a": "FNV-1a 32-bit, named explicitly.",
      "Hash.crc32": "CRC-32 checksum for corruption detection.",
      "Hash.mix": "Avalanche one integer into a well-scrambled value.",
      "Hash.combine": "Fold several ints into one deterministic seed.",
      "Hash.of64": "The fast default 64-bit string hash.",
      "Hash.fnv1a_64": "FNV-1a 64-bit, named explicitly.",
      "Hash.mix64": "Avalanche one 64-bit integer into a well-scrambled value.",
      "Input.key": "The key pressed this frame as a character code (0 when nothing is pressed).",
      "Input.bind": "Bind a physical key to a named action, so gameplay reads the action, not the key.",
      "Input.rebind": "Remap an action from one key to another at runtime (rebinding menus).",
      "Input.poll": "Advance one frame of input; the single per-frame read behind actions and replay.",
      "Input.down": "Is a named action held on the frame last polled?",
      "Input.pressed": "Did a named action go down this frame (a one-shot edge)?",
      "Input.record": "Start recording polled input each frame (for deterministic replay).",
      "Input.replay": "Replay recorded input; poll then reads the tape, not the device.",
      "Input.key_down": "Is a physical key held this frame?",
      "Input.key_pressed": "Did a key go down this frame (edge)?",
      "Input.key_released": "Did a key go up this frame (edge)?",
      "Input.key_label": "The name to show a player for a key - in their own keyboard layout.",
      "Input.press": "Inject a held key (AI, tutorial, testing, network).",
      "Input.release": "Release an injected key.",
      "Input.axis": "A -1..+1 axis from two keys.",
      "Input.axis_i": "A -1/0/1 directional intent as a plain int, no bool->int glue.",
      "Input.vector": "A normalized 2D vector from four keys.",
      "Input.strength": "0..1 strength of a named action.",
      "Input.mouse_x": "The mouse x position this frame.",
      "Input.mouse_y": "The mouse y position this frame.",
      "Input.mouse_dx": "Mouse x movement since the last poll.",
      "Input.mouse_dy": "Mouse y movement since the last poll.",
      "Input.mouse_down": "Is a mouse button held?",
      "Input.wheel": "Scroll-wheel delta this frame.",
      "Input.set_mouse": "Inject the mouse state (headless / AI / testing).",
      "Input.pad_connected": "Is a gamepad connected?",
      "Input.pad_button": "Is a gamepad button held?",
      "Input.pad_axis": "A gamepad analog axis, -1..+1.",
      "Input.set_pad": "Inject a gamepad's whole state.",
      "Input.touch_count": "How many touch points are active?",
      "Input.touch_x": "The x of a touch point.",
      "Input.touch_y": "The y of a touch point.",
      "Input.set_touch": "Inject a touch point.",
      "Input.action": "Register a default key binding for an action (kept if already bound).",
      "Input.bind_pad": "Also fire a named action from a gamepad button (device-agnostic).",
      "Input.active": "Is a named action active right now (any bound key held, or pad button down)?",
      "Input.just_pressed": "Did a named action go active this frame (the deterministic on-press)?",
      "Input.just_released": "Did a named action go inactive this frame (the on-release edge)?",
      "Input.cursor_mode": "Hide / lock / confine the OS mouse cursor to the window (windowed).",
      "Input.move_i": "The standard top-down movement intent, -1/0/1 per axis.",
      "List.len": "The number of elements in a slice.",
      "List.push": "Append an element to the end of a slice.",
      "List.clear": "Remove all elements, keeping capacity.",
      "List.first": "The first element of a slice.",
      "List.last": "The last element of a slice.",
      "List.pop": "Remove and return the last element.",
      "List.swap": "Exchange the elements at two indices.",
      "List.contains": "Whether a value appears in a slice.",
      "List.index_of": "The index of a value in a slice, or -1 if absent.",
      "List.reverse": "Reverse the order of a slice in place.",
      "List.insert": "Insert an element at an index, shifting the rest up.",
      "List.remove_at": "Remove the element at an index, shifting the rest down.",
      "List.remove": "Remove the first element equal to a value.",
      "List.sort": "Sort a slice in ascending order, in place.",
      "List.sort_by": "Sort a slice ascending by a key each element maps to.",
      "List.sort_desc_by": "Sort a slice descending by a key each element maps to.",
      "List.sort_with": "Sort a slice with a full two-argument comparator.",
      "List.sample": "Random picks from an int slice, distinct while it can.",
      "Log.trace": "Log at the trace level (0) — the most verbose.",
      "Log.debug": "Log at the debug level (1) — development detail.",
      "Log.info": "Log at the info level (2) — normal operation.",
      "Log.warn": "Log at the warn level (3) — something looks wrong.",
      "Log.error": "Log at the error level (4) — a failure.",
      "Log.set_level": "Show only messages at level n or above (0 = all).",
      "Log.level": "The current logging threshold.",
      "Math.min": "The smaller of two values.",
      "Math.max": "The larger of two values.",
      "Math.abs": "The magnitude of a value, dropping its sign.",
      "Math.clamp": "Constrain a value to the range [lo, hi].",
      "Math.sign": "The sign of a value as -1, 0, or 1.",
      "Math.floor": "Round a fixed value down to the nearest whole int.",
      "Math.ceil": "Round a fixed value up to the nearest whole int.",
      "Math.round": "Round a fixed value to the nearest whole int.",
      "Math.lerp": "Blend between two values by a 0..1 amount.",
      "Math.inverse_lerp": "Find where a value sits between two endpoints as a 0..1 fraction.",
      "Math.remap": "Rescale a value from one range into another.",
      "Math.sqrt": "The square root of a fixed value.",
      "Math.sin": "Sine of an angle in radians.",
      "Math.cos": "Cosine of an angle in radians.",
      "Math.tan": "Tangent of an angle in radians.",
      "Math.hypot": "Length of the vector (x, y).",
      "Math.dist": "Distance between two points.",
      "Math.dist2": "Squared distance between two points.",
      "Math.deg_to_rad": "Convert degrees to radians.",
      "Math.rad_to_deg": "Convert radians to degrees.",
      "Math.posmod": "Modulo that is always non-negative.",
      "Math.wrap": "Wrap a value into the range [lo, hi).",
      "Math.ping_pong": "Bounce a counter back and forth in [0, len].",
      "Math.snapped": "Round a value to the nearest multiple of step.",
      "Math.move_toward": "Step from one value toward another by at most delta.",
      "Math.smoothstep": "A smooth 0..1 ramp between two edges.",
      "Math.atan2": "The angle of the vector (x, y), in radians.",
      "Math.asin": "The arcsine of a value, in radians.",
      "Math.acos": "The arccosine of a value, in radians.",
      "Math.exp": "e raised to the power x.",
      "Math.log": "The natural logarithm of x.",
      "Math.pow": "base raised to a fixed exponent.",
      "Memory.bytes": "Allocate n bytes.",
      "Memory.words": "Allocate n 32-bit words.",
      "Memory.copy": "Copy n bytes between buffers.",
      "Memory.fill": "Set n bytes to a value.",
      "Memory.peek": "Read one byte.",
      "Memory.poke": "Write one byte.",
      "Mime.of": "MIME type from a file extension.",
      "Mime.sniff": "MIME type refined by magic bytes.",
      "Network.send": "Put a datagram on the wire.",
      "Network.poll": "Read an inbound datagram.",
      "Network.serialize": "Serialize an entity's synced state.",
      "Network.apply": "Apply serialized state to an entity.",
      "Network.owner": "The peer that owns an entity.",
      "Network.set_owner": "Assign ownership of an entity.",
      "Network.is_server": "Is this peer the server?",
      "Network.is_owner": "Does this peer own the entity?",
      "Network.local_id": "This peer's own id.",
      "Noise.value2": "2D value (lattice) noise, deterministic, in [-1, 1].",
      "Noise.perlin2": "2D Perlin gradient noise, deterministic, in [-1, 1].",
      "Noise.simplex2": "2D simplex noise, the organic default, in [-1, 1].",
      "Noise.fbm2": "Fractal Brownian motion — octaves of simplex, in [-1, 1].",
      "Noise.cellular2": "Worley (cellular) F1 distance to the nearest cell point.",
      "Noise.cellular2_id": "The id of the nearest Worley cell — stable per cell.",
      "Noise.unit": "Remap a [-1,1] noise sample to [0,1].",
      "Os.args": "Every command-line argument, as a list.",
      "Os.arg_count": "How many command-line arguments there are.",
      "Os.arg": "The i-th command-line argument.",
      "Os.env": "Read an environment variable (null if unset).",
      "Os.env_or": "Read an environment variable, or a fallback.",
      "Os.has_env": "Is an environment variable set?",
      "Os.set_env": "Set an environment variable.",
      "Os.unset_env": "Remove an environment variable.",
      "Os.exit": "Terminate the process with a status code.",
      "Os.platform": "The host platform id.",
      "Os.arch": "The host CPU architecture.",
      "Os.stdout_write": "Write a string to standard output.",
      "Os.stderr_write": "Write a string to standard error.",
      "Os.save_dir": "Per-user save directory for an app.",
      "Os.config_dir": "Per-user config directory for an app.",
      "Os.cache_dir": "Per-user cache directory for an app.",
      "Os.temp_dir": "The system temporary directory.",
      "Os.pid": "This process's id.",
      "Path.join": "Join two path segments with the separator.",
      "Path.dir": "The directory part of a path.",
      "Path.base": "The final component of a path.",
      "Path.ext": "The file extension, including the dot.",
      "Path.stem": "The final component without its extension.",
      "Path.normalize": "Collapse . / .. / duplicate separators.",
      "Save.write": "Save a snapshot of the world.",
      "Save.read": "Restore the saved snapshot.",
      "System.run": "Run a shell command.",
      "System.read_char": "Read one byte from standard input.",
      "System.file_open": "Open a file.",
      "System.file_read": "Read bytes from a file.",
      "System.file_write": "Write bytes to a file.",
      "System.file_seek": "Move a file's read/write position.",
      "System.file_tell": "The current file position.",
      "System.file_close": "Close a file.",
      "Text.length": "The number of bytes in a string.",
      "Text.char_at": "The byte value at an index, 0..255.",
      "Text.slice": "A substring covering bytes [a, b).",
      "Text.starts_with": "Whether a string begins with a given prefix.",
      "Text.ends_with": "Whether a string ends with a given suffix.",
      "Text.contains": "Whether a substring appears anywhere in a string.",
      "Text.index_of": "The byte index of a substring, or -1 if absent.",
      "Text.equals": "Whether two strings have identical bytes.",
      "Text.concat": "Join two strings into a new one.",
      "Text.to_int": "Parse a leading integer from a string.",
      "Text.from_int": "Render an integer as a string.",
      "Text.upper": "An uppercased copy of a string.",
      "Text.lower": "A lowercased copy of a string.",
      "Text.trim": "A copy with surrounding whitespace removed.",
      "Text.repeat": "A string repeated n times.",
      "Text.pad_left": "Pad with spaces on the left to a width.",
      "Text.pad_right": "Pad with spaces on the right to a width.",
      "Text.split": "Split a string on a separator into a list.",
      "Text.join": "Join a list of strings with a separator.",
      "Text.replace": "Replace every occurrence of a substring.",
      "Time.frame": "The number of frames elapsed since start.",
      "Time.delta": "Seconds per frame (a fixed 1/60).",
      "Time.elapsed": "Seconds since start (deterministic).",
      "Time.now": "Wall-clock seconds (non-deterministic).",
      "Time.since": "Seconds elapsed from a past instant to now (non-deterministic).",
      "Unicode.len": "Number of code points in a string (not bytes).",
      "Unicode.byte_len": "Number of bytes in a string.",
      "Unicode.is_valid_utf8": "Is a string well-formed UTF-8?",
      "Unicode.char_at": "The i-th code point of a string.",
      "Unicode.chars": "Every code point of a string, in order.",
      "Unicode.upper": "Uppercase a string.",
      "Unicode.lower": "Lowercase a string.",
      "Unicode.truncate": "First n code points of a string.",
      "Unicode.grapheme_len": "Number of user-perceived characters.",
      "Uuid.new": "A new random (v4) UUID as a canonical 36-char string.",
      "Uuid.v4": "Explicit alias for Uuid.new — a random (v4) UUID.",
      "Uuid.new_v7": "A new time-ordered (v7) UUID; sorts by creation time.",
      "Uuid.v7": "Explicit alias for Uuid.new_v7 — a time-ordered UUID.",
      "Uuid.parse": "Normalise an untrusted string to a lowercase UUID, or the nil UUID.",
      "Uuid.is_valid": "Is s a well-formed UUID string?",
      "Uuid.to_text": "The canonical text form of a UUID.",
      "Uuid.equals": "Case-insensitive UUID equality.",
      "Uuid.nil": "The all-zero UUID.",
      "World.get": "Read a component field by id.",
      "World.set": "Write a component field by id.",
      "World.has": "Does an entity have a component?",
      "World.count": "The number of live entities.",
      "World.size": "The serialized size of the world.",
      "World.spawn": "Spawn an entity of a model by id.",
      "World.save": "Serialize the world into a buffer.",
      "World.load": "Restore the world from a buffer.",
      "World.prop_id": "Look up a component's id by name.",
      "World.field_id": "Look up a field's id by name.",
      "World.model_id": "Look up a model's id by name.",
      "World.kind": "The model id of an entity.",
      "World.register_prop": "Register a new component at runtime.",
      "World.attach": "Attach a component to an entity at runtime.",
      "World.detach": "Detach a component from an entity at runtime.",
      "World.query_next": "Advance a reflective query.",
      "World.despawn": "Despawn an entity by id — runs its @OnDespawn hooks and frees the slot.",
      "Audio.load": "Load a sound file into a handle.",
      "Audio.play": "Fire a one-shot sound.",
      "Audio.play_at": "Fire a one-shot with its own gain, pitch and stereo position.",
      "Audio.play_sound": "Fire a one-shot sound (alias of play).",
      "Audio.play_music": "Loop a sound as background music.",
      "Audio.stop": "Stop one sound.",
      "Audio.stop_music": "Stop the music channel.",
      "Audio.stop_all": "Stop every sound.",
      "Audio.volume": "Set the master volume.",
      "Audio.pitch": "Set the playback rate / pitch.",
      "Audio.is_playing": "Is this sound playing?",
      "Audio.define": "Load a sound into the bank under a name.",
      "Audio.named": "The handle registered under a name, or 0.",
      "Random.range": "A random integer in the inclusive range [low, high].",
      "Random.chance": "Return true with the given percent probability.",
      "Random.seed": "Seed the random generator so runs are reproducible.",
      "Random.value": "A random fixed value in [0, 1).",
      "Random.int": "A random integer in [0, max).",
      "Random.sign": "A random +1 or -1.",
      "Random.weighted": "An index drawn in proportion to its weight.",
      "Vector.make": "Build a vector from x and y components.",
      "Vector.zero": "The zero vector, (0, 0).",
      "Vector.x": "The x component of a vector.",
      "Vector.y": "The y component of a vector.",
      "Vector.add": "Component-wise sum a + b.",
      "Vector.sub": "Component-wise difference a - b.",
      "Vector.scale": "Scale a vector by a scalar.",
      "Vector.dot": "The dot product of two vectors.",
      "Vector.length": "The length (magnitude) of a vector.",
      "Vector.distance": "The distance between two points.",
      "Vector.normalize": "A unit vector in the same direction.",
      "Vector.lerp": "Linear interpolation between two vectors.",
      "Vector.rotate": "Rotate a vector by an angle in radians.",
      "Vector.angle": "The angle of a vector in radians.",
      "Vector.from_angle": "A unit vector pointing at an angle.",
      "Http.get": "Start an async GET request.",
      "Http.post": "Start an async POST with a body.",
      "Http.request": "Start a request with any method.",
      "Http.open": "Open a request to configure before sending.",
      "Http.set": "Set a request header before sending.",
      "Http.body": "Set a string request body.",
      "Http.body_bytes": "Set a raw byte request body.",
      "Http.send": "Dispatch an opened request.",
      "Http.poll": "Poll a request; -1 pending, 0 error, else status.",
      "Http.status": "The response HTTP status code.",
      "Http.ok": "Was the response status 2xx?",
      "Http.text": "The response body as text.",
      "Http.body_len": "The response body length in bytes.",
      "Http.header": "A response header value (case-insensitive).",
      "Http.free": "Release a request's resources.",
      "Http.parse": "Parse a raw HTTP response into a handle.",
      "Http.save_to": "Stream the response body to a file.",
      "Http.received": "Body bytes received so far.",
      "Http.expected": "The body length the server announced, or -1.",
      "IVec2.make": "Build an integer vector from x and y components.",
      "IVec2.zero": "The origin cell, (0, 0).",
      "IVec2.x": "The x component of an integer vector.",
      "IVec2.y": "The y component of an integer vector.",
      "IVec2.add": "Component-wise sum of two integer vectors.",
      "IVec2.sub": "Component-wise difference of two integer vectors.",
      "IVec2.scale": "Multiply both components by an integer.",
      "IVec2.dot": "The dot product ax*bx + ay*by.",
      "IVec2.equal": "True when both components match.",
      "IVec2.manhattan": "Grid distance |dx| + |dy|.",
      "IVec2.to_vector": "Widen to a fixed-point Vector.",
      "IVec2.distance2": "The squared distance between two points.",
      "IVec2.within": "Are two points within a radius of each other?",
      "IVec2.heading": "The direction from one point to another, in degrees.",
      "IVec2.along": "The point a distance along a heading.",
      "IVec2.step": "A -1/0/1 unit step along a heading.",
      "Map.size": "Set the tilemap dimensions in cells before filling rows.",
      "Map.row": "Fill one row of the tilemap from a string of tile characters.",
      "Map.tile": "Read the tile character at a cell (out-of-bounds reads answer '#').",
      "Map.get": "The glyph at a cell ('#' outside the map).",
      "Map.set": "Write one cell in place.",
      "Map.fill": "Every cell becomes the glyph.",
      "Map.rect": "Fill a rectangle of cells.",
      "Map.border": "The outermost ring of cells.",
      "Map.random_cell": "A random cell holding the glyph (seeded RNG).",
      "Map.is_solid": "Is a cell solid, per the Solids config?",
      "Map.is_solid_at": "Is the cell under a pixel position solid?",
      "Map.width": "The map's width in cells.",
      "Map.height": "The map's height in cells.",
      "Map.random_cell_far": "A random cell with the glyph, at least a distance from a point.",
      "Map.to_tile": "The tile under a pixel position.",
      "Rect.make": "Build a rectangle from a corner and a size.",
      "Rect.x": "The left edge (x position).",
      "Rect.y": "The top edge (y position).",
      "Rect.w": "The width.",
      "Rect.h": "The height.",
      "Rect.right": "The right edge, x + w.",
      "Rect.bottom": "The bottom edge, y + h.",
      "Rect.center": "The center point as a Vector.",
      "Rect.contains": "True when the point is inside.",
      "Rect.intersects": "True when two rectangles overlap.",
      "Udp.open": "Open a socket on a port.",
      "Udp.port": "The port a socket is bound to.",
      "Udp.send": "Send one datagram.",
      "Udp.recv": "Read the next waiting datagram.",
      "Udp.from_ip": "The sender of the last datagram read.",
      "Udp.from_port": "The sender's port.",
      "Udp.close": "Close a socket.",
      "Udp.resolve": "Look a host name up.",
      "Udp.local_ip": "This machine's address.",
      "Udp.ip": "Parse a dotted address.",
      "Udp.ip_text": "Format an address.",
      "BigInt.from": "Turn a plain int into a BigInt.",
      "BigInt.parse": "Parse decimal text into a BigInt.",
      "BigInt.add": "Exact sum of two big integers.",
      "BigInt.sub": "Exact difference of two big integers.",
      "BigInt.mul": "Exact product of two big integers.",
      "BigInt.neg": "Negate a big integer.",
      "BigInt.pow": "Raise a big integer to an int power.",
      "BigInt.div": "Divide a big integer by an int (toward zero).",
      "BigInt.mod": "Remainder of a big integer divided by an int.",
      "BigInt.cmp": "Compare two big integers: -1, 0, or 1.",
      "BigInt.eq": "True when two big integers are equal.",
      "BigInt.is_zero": "True when a big integer is zero.",
      "BigInt.to_int": "Narrow a big integer to a plain int (clamped).",
      "BigInt.str": "Render a big integer as decimal text.",
      "Process.spawn": "Start a program; never blocks.",
      "Process.poll": "-1 while running, else the exit code.",
      "Process.kill": "End a running child.",
      "Process.free": "Let a process handle go.",
      "Decimal.from": "Turn a whole int into a Decimal.",
      "Decimal.parse": "Parse decimal text like \"19.99\".",
      "Decimal.add": "Exact sum of two decimals.",
      "Decimal.sub": "Exact difference of two decimals.",
      "Decimal.mul": "Exact product of two decimals.",
      "Decimal.neg": "Negate a decimal.",
      "Decimal.cmp": "Compare two decimals: -1, 0, or 1.",
      "Decimal.eq": "True when two decimals are equal in value.",
      "Decimal.scale": "The number of digits after the point.",
      "Decimal.rescale": "Change precision (truncates toward zero).",
      "Decimal.str": "Render a decimal as text.",
      "int": "Convert a number to a whole number, truncating toward zero.",
      "fixed": "Convert an int (or a float) into a Q16.16 fixed-point value.",
      "long": "Convert a number to a whole number, truncating toward zero.",
      "bool": "A truth value — the result of comparisons and of and / or / not.",
      "float": "Convert any number to a float (or double).",
      "string": "Convert an int, bool, or fixed value to text; a string passes through unchanged.",
      "double": "Convert any number to a float (or double).",
      "entity": "The id/handle of a spawned model instance, as returned by self().",
      "pointer": "A raw address into memory — a byte buffer from bytes(n), or an FFI handle.",
      "words": "Allocate a raw buffer of n 32-bit words, indexable with [i].",
      "byte": "A raw buffer indexed one byte at a time — each buffer[i] reads or writes a byte.",
      "fixeds": "A buffer of fixed-point values — f[i] reads and writes a fixed.",
      "countdown": "An int component field the engine steps toward 0 once per Update.",
      "floats": "A buffer of floats (or doubles) — v[i] reads and writes one.",
      "doubles": "A buffer of floats (or doubles) — v[i] reads and writes one.",
      "pointers": "A buffer of pointers — p[i] reads and writes a pointer.",
      "Vector": "A 2D vector — two fixed components (x, y), copied by value.",
      "IVec2": "An integer 2D vector — two int components (x, y), copied by value.",
      "Rect": "A rectangle — position (x, y) and size (w, h), copied by value.",
      "void": "The absence of a value — the return type of a function that returns nothing.",
      "Dict.new": "Create an empty string-keyed map.",
      "Dict.set": "Insert or update a key.",
      "Dict.get": "Look up a key (0 if absent).",
      "Dict.get_or": "Look up a key with an explicit default.",
      "Dict.has": "Is a key present?",
      "Dict.remove": "Delete a key.",
      "Dict.size": "How many keys are stored.",
      "Dict.clear": "Remove every key.",
      "Dict.keys": "Every key, as a slice of strings.",
      "and": "The boolean combinators, spelled as words — never && or || or a bare !.",
      "or": "The boolean combinators, spelled as words — never && or || or a bare !.",
      "not": "The boolean combinators, spelled as words — never && or || or a bare !.",
      "print": "Print an int or string followed by a newline — for headless tests and debugging.",
      "quit": "Stop the game loop cleanly after the current frame finishes.",
      "save": "Serialize the whole world — every model instance, property, and program var — in one call.",
      "load": "Restore the world from a snapshot previously written by save().",
      "len": "The number of elements in a slice, or the byte length of a string.",
      "push": "Append one element to the end of a growable slice.",
      "abs": "The absolute value of an integer (its magnitude, never negative).",
      "clamp": "Constrain a value to the inclusive range [lo, hi].",
      "panic": "Abort with a located error message instead of crashing.",
      "assert": "Abort with a located message when an invariant is false.",
      "ok": "Wrap a success payload in a result — the happy half of try/else.",
      "err": "Wrap a failure message in a result — the sad half, recovered by try/else.",
      "is_ok": "True when a result carries a success payload.",
      "is_err": "True when a result carries a failure.",
      "some": "Wrap a present value in an option.",
      "none": "The empty option — a missing value.",
      "is_some": "True when an option holds a value.",
      "is_none": "True when an option is empty.",
      "unwrap_or": "The option value, or a fallback if empty.",
      "run": "Run a string as a shell command.",
      "getenv": "Read an environment variable, returning empty when it is unset.",
      "read_char": "Read one byte from standard input, or -1 at end of input.",
      "arg": "The i-th command-line argument as a string.",
      "arg_count": "The number of command-line arguments, counting the program name.",
      "bytes": "Allocate a raw buffer of n bytes and return a pointer to it.",
      "file_stderr": "The standard-error stream handle for use with file_write.",
      "file_stdout": "The standard-output stream handle for use with file_write.",
      "file_write": "Write a run of raw bytes to a stream handle.",
      "floor": "Floor a fixed-point value down to the nearest integer.",
      "max": "The larger of two integers.",
      "min": "The smaller of two integers.",
      "ui_build": "Build the declared UI tree so it can be opened and rendered.",
      "float_bits": "A float's IEEE bit pattern as an int, and back.",
      "float_from_bits": "A float's IEEE bit pattern as an int, and back.",
      "double_bits": "A float's IEEE bit pattern as an int, and back.",
      "double_from_bits": "A float's IEEE bit pattern as an int, and back.",
      "Set.new": "Create an empty string set.",
      "Set.add": "Add a member (duplicates ignored).",
      "Set.has": "Is a member present?",
      "Set.remove": "Remove a member.",
      "Set.size": "How many members.",
      "Set.clear": "Remove every member.",
      "Set.members": "Every member, as a slice of strings.",
      "@Queries": "Declare the properties a handler operates on, binding their fields by name in the body.",
      "@Computed": "A derived field expanded inline wherever it is read, never stored.",
      "@On": "Register a compile-time listener that runs whenever an event is emitted.",
      "@export": "Expose a function as a native symbol so a host can call it.",
      "@Sync": "Mark fields as replicated and models as owned so the compiler generates networking.",
      "@Handles": "Declarative hint naming the event or subsystem a handler is responsible for.",
      "@OnAttach": "Run a handler when a property is structurally attached to a live instance.",
      "@OnDespawn": "Run a handler when a model instance is torn down, optionally knowing why.",
      "@OnDetach": "Run a handler when a property is structurally detached from a live instance.",
      "@OnDisable": "Run a handler when a property is paused (disabled) on an instance.",
      "@OnEnable": "Run a handler when a paused property is re-enabled on an instance.",
      "@OnQuit": "Run a handler once at shutdown, after the last frame.",
      "@OnSpawn": "Run a handler once each time an instance of a model is spawned.",
      "@OnStart": "Run a handler once at boot instead of assigning it a frame phase.",
      "@Owned": "Give a model a network owner slot so its instances can be assigned to a peer.",
      "@Predicted": "Run a control handler on the owning client speculatively and on the server authoritatively.",
      "@Public": "Promote a lifecycle hook to a public event other modules can listen for.",
      "@Reads": "Declare that a handler reads a property — an analysis and scheduling hint.",
      "@Server": "Run a handler only on the authority; clients receive the result via @Sync.",
      "@ToClients": "A remote event broadcast from the server to clients — a server→clients notification.",
      "@ToServer": "A remote event sent from a client to the server — a client→server request.",
      "@Writes": "Declare that a handler writes a property — an analysis and scheduling hint.",
      "@EngineSystem": "Register a package's engine-owned system so the frame loop runs it each phase.",
      "@Namespace": "Let a package provide a Name.method(…) namespace that dispatches to name_method.",
      "\"@ClearColor\"": "Declare a clear colour so the Render phase auto-clears + auto-presents for you.",
      "@System": "Register a prebuilt binary module's system with the host at load, per phase.",
      "Huge.from": "Turn an int into a Huge.",
      "Huge.add": "Sum of two big numbers.",
      "Huge.sub": "Difference of two big numbers.",
      "Huge.mul": "Product of two big numbers.",
      "Huge.neg": "Negate a big number.",
      "Huge.cmp": "Compare two big numbers: -1, 0, or 1.",
      "Huge.sign": "The sign: -1, 0, or 1.",
      "Huge.mantissa": "The mantissa in [1, 10).",
      "Huge.exp": "The base-10 exponent.",
      "Huge.str": "Render as scientific text like 1.23e45.",
      "Angle.from_degrees": "Degrees to a wrapped radian angle.",
      "Angle.to_degrees": "Radians back to degrees.",
      "Angle.wrap": "Normalize any radian value to [-pi, pi).",
      "Angle.sin": "Sine of an angle.",
      "Angle.cos": "Cosine of an angle.",
      "Angle.add": "Add two angles (wrapped).",
      "Angle.diff": "Shortest signed rotation from a to b.",
      "Angle.lerp": "Interpolate along the shortest arc.",
      "Angle.diff_degrees": "The signed difference between two headings in whole degrees.",
      "Percent.clamp": "Clamp any fixed into [0, 1].",
      "Percent.of": "Clamped ratio num / den.",
      "Percent.lerp": "Interpolate a..b by a clamped t.",
      "Percent.apply": "Scale a value by a clamped percent.",
      "Regex.compile": "Compile a pattern once for reuse; returns an error value (null) if it is invalid.",
      "Regex.valid": "True if the pattern is well-formed (compiles without error).",
      "Regex.matches": "True if the pattern matches anywhere in the text (a search).",
      "Regex.test": "Like matches, but reuses an already-compiled Regex.",
      "Regex.find": "The first match of the pattern in the text (a Match, or null if none).",
      "Regex.exec": "Like find, but with an already-compiled Regex.",
      "Regex.next": "The next match at or after byte offset from — the basis of a find-all loop.",
      "Regex.replace": "Replace every match; the replacement expands \\0..\\9 group references.",
      "Regex.group": "The text of capture group n (group 0 is the whole match); empty if unset.",
      "Regex.group_count": "How many capture groups the match's pattern has.",
      "Regex.start": "The start byte offset of group n, or -1 if it did not participate.",
      "Regex.end": "The end byte offset of group n, or -1 if it did not participate.",
      "Regex.ok": "True if the match succeeded (the Match is non-null).",
      "Grid.line": "Every cell a straight line from (x0,y0) to (x1,y1) crosses (Bresenham).",
      "Grid.blocked": "True if the cell is out of bounds or holds the wall tile.",
      "Grid.line_of_sight": "True if the straight line between two cells crosses no wall.",
      "Grid.flood": "Every passable cell reachable from (x,y), 4-connected, in BFS order.",
      "Grid.a_star": "The shortest 4-connected path between two cells (A*), or an empty list.",
      "Anim.frame": "The looping frame index for an elapsed timer at a given fps.",
      "Anim.once": "A non-looping frame index that clamps on the last frame.",
      "Anim.pingpong": "A frame index that bounces 0..count-1..0 and repeats.",
      "Anim.finished": "True once a one-shot clip has run past its last frame.",
      "Anim.duration": "Seconds for one full cycle of a clip: count / fps.",
      "Anim.cell_x": "The source x (pixels) of a frame on a grid spritesheet.",
      "Anim.cell_y": "The source y (pixels) of a frame on a grid spritesheet.",
      "Anim.play": "Start (or restart) a spritesheet clip on an entity in one call.",
      "Anim.clip": "Register a named spritesheet clip so Anim.play can play it by name.",
      "Anim.on_frame": "Arm a frame event — the engine flags the tick a clip lands on this frame.",
      "Anim.fired": "Did the entity's clip land on its armed frame event this tick?",
      "Motion.to": "Start a value tween on an entity's Motion component in one call.",
      "Tween.progress": "A one-shot 0..1 amount, clamped, for timer over duration.",
      "Tween.loop": "A repeating 0..1 sawtooth amount over duration.",
      "Tween.yoyo": "A repeating 0..1..0 triangle amount over duration.",
      "Tween.done": "True once a one-shot tween's timer reaches its duration.",
      "Tween.ease": "Shape a 0..1 amount through an easing curve chosen by a literal mode.",
      "Tween.number": "Linear blend of two fixeds by amount t.",
      "Tween.round": "Linear blend of two ints by amount t, rounded to the nearest int.",
      "Tween.point": "Component-wise blend of two Vectors by amount t.",
      "Tween.tint": "Per-channel blend of two colors by amount t.",
      "Tween.to": "Start a fluent, engine-advanced tween and return a handle.",
      "Tween.chain": "Append a tween segment that runs after the handle's current queue.",
      "Tween.delay": "Append a pause to a tween handle's sequence.",
      "Tween.value": "The current value of a fluent tween handle this frame.",
      "Tween.stop": "Stop and dispose a tween handle, freezing its value.",
      "Tween.parallel": "Are two tween handles both finished? — a parallel completion query.",
      "Query.count": "How many live entities carry a property.",
      "Query.first": "The lowest-id live entity carrying a property, or -1.",
      "Query.nearest": "The bearer of prop closest to a point, by squared distance.",
      "Query.within": "Every bearer of prop inside a radius of a point.",
      "Reflect.prop": "The property id for a property name, or -1 if unknown.",
      "Reflect.field": "The field id of a named field within a property, or -1.",
      "Reflect.prop_count": "How many properties the world schema defines.",
      "Reflect.prop_name": "The name of the property at an index (or \"\").",
      "Reflect.field_count": "How many fields a property has.",
      "Reflect.field_name": "The name of the field at an index within a property.",
      "Reflect.field_type": "The type name of the field at an index within a property.",
      "Reflect.get": "Read one field of an entity by (prop, field) id.",
      "Reflect.set": "Write one field of an entity by (prop, field) id.",
      "Reflect.has": "Does an entity carry a property?",
      "Reflect.kind": "The model id of an entity.",
      "Reflect.model": "The model id for a model name, or -1 if unknown.",
      "Reflect.serialize": "Walk an entity's components into a value tree.",
      "Reflect.apply": "Write a value tree's fields back into an entity.",
      "Camera.set": "Place the camera at a world-space offset.",
      "Camera.follow": "Ease the camera toward centring a target point.",
      "Camera.shake": "Jitter the camera by up to +/- amount pixels (seeded RNG).",
      "Camera.zoom": "Scale the whole view about the screen centre by a Q16.16 factor (1.0 = none).",
      "Camera.shake_for": "Shake for a number of frames, then stop, with no bookkeeping.",
      "Light.ambient": "Multiply the whole scene by a tint — the night/cave modulate.",
      "Light.point": "Add a radial glow that falls off with distance.",
      "Light.occlude": "Register a rectangle that blocks light — a hard shadow caster.",
      "Light.clear_occluders": "Forget every occluder — call once per frame before re-registering.",
      "Light.spot": "A cone / flashlight light aimed at a direction with a half-angle spread.",
      "Light.falloff": "Set the brightness-ramp exponent for later lights (1 linear, 2 quadratic…).",
      "Light.soft": "Soft shadows — an occluder edge fades through a penumbra of this radius.",
      "Light.gel": "A colour cookie — later lights gel from their centre colour to this rim colour.",
      "Light.clear_gel": "Clear the gel — later lights are a flat single colour again.",
      "Light.normal": "Stamp a surface normal over a rectangle so lights shade it by facing (N·L).",
      "Light.clear_normals": "Forget every stamped normal — call once per frame before re-stamping.",
      "Light.height": "Set the virtual height of lights above the surface, for normal-map shading.",
      "Light.time_of_day": "Set the ambient tint from a 0..1 time-of-day — a day/night cycle in one value.",
      "Sprite.sheet": "Load a spritesheet and remember its cell grid; returns a sheet handle.",
      "Sprite.cell": "One cell of a sheet, by grid coords; returns a sprite id.",
      "Sprite.cell_span": "A sprite spanning cols x rows cells (tall/wide art).",
      "Sprite.define": "Name a cell for later lookup; returns its sprite id.",
      "Sprite.named": "Look up a named sprite's id, or -1.",
      "Sprite.draw": "Blit an atlas sprite at (x, y) through the camera/zoom/clip.",
      "Sprite.draw_scaled": "Blit an atlas sprite scaled by an integer factor.",
      "Sprite.width": "The atlas sprite's width in pixels.",
      "Sprite.height": "The atlas sprite's height in pixels.",
      "Sprite.strip": "A run of animation frames as consecutive sprite ids.",
      "Sprite.draw_meter": "A value as a row of full / half / empty icons.",
      "Assets.image": "Load a whole image file as one sprite; returns its id.",
      "Assets.load": "Alias of Assets.image.",
      "Assets.get": "Look up a named sprite's id (alias of Sprite.named).",
      "Assets.enqueue": "Queue a named image file to preload later.",
      "Assets.pump": "Load up to max queued assets this frame; returns how many it loaded.",
      "Assets.total": "How many assets are enqueued.",
      "Assets.loaded": "How many enqueued assets have loaded so far.",
      "Assets.ready": "1 once every enqueued asset has loaded.",
      "Assets.font": "A font loaded through the preload queue, by name.",
      "Assets.progress": "Loading progress as a 0..100 percent.",
      "Assets.enqueue_dir": "Enqueue every file of a directory, named by its file name.",
      "test": "A named test block, run automatically with pass/fail reporting.",
      "Pool.live": "How many entities are currently alive.",
      "Pool.free": "How many freed slots are waiting to be reused.",
      "Pool.reserved": "High-water: how many slots have ever been allocated.",
      "Pool.capacity": "The maximum number of entities.",
      "Value.null": "An empty null node.",
      "Value.int": "Wrap an int in a value node.",
      "Value.fixed": "Wrap a fixed in a value node.",
      "Value.bool": "Wrap a bool in a value node.",
      "Value.str": "Wrap a string in a value node.",
      "Value.list": "An empty list node.",
      "Value.object": "An empty object node.",
      "Value.add": "Append an item to a list; returns the list.",
      "Value.put": "Set a key on an object; returns the object.",
      "Value.get": "Read a member of an object by key.",
      "Value.has": "Whether an object has a member.",
      "Value.at": "Read a list item by index.",
      "Value.key_at": "The key of an object member by position.",
      "Value.count": "Number of items/members in a list or object.",
      "Value.kind": "The node's kind tag.",
      "Value.as_int": "Read a scalar node as an int.",
      "Value.as_str": "Read a str node's text.",
      "Json.encode": "Serialize a value tree to compact JSON text.",
      "Json.parse": "Parse JSON text into a value tree.",
      "Job.defer": "A future you resolve yourself later.",
      "Job.run": "Start a background compute job.",
      "Job.fulfill": "Resolve a pending job with a value.",
      "Job.fail": "Resolve a pending job as failed.",
      "Job.cancel": "Cancel a job before it finishes.",
      "Job.pump": "Advance background jobs; collect results.",
      "Job.done": "Has the job resolved (any outcome)?",
      "Job.ok": "Did the job succeed?",
      "Job.failed": "Did the job fail?",
      "Job.cancelled": "Was the job cancelled?",
      "Job.result": "The success value of a done job.",
      "Job.error": "The error code of a failed job.",
      "Job.pending": "How many jobs are still unresolved.",
      "Job.free": "Release a job slot back to the pool.",
      "Job.parallel_for": "Run work(i, ctx) for every i in [0, count) across all cores; returns when every call is done.",
      "Job.is_worker": "True on a Job.parallel_for pool thread, false on the main thread.",
      "Promise.all": "Succeeds when every member succeeds.",
      "Promise.race": "Succeeds when the first member does.",
      "Promise.count_done": "How many members have resolved.",
      "Promise.all_done": "Have all members resolved?",
      "Sync.mutex": "Create a cooperative lock.",
      "Sync.lock": "Take the lock.",
      "Sync.unlock": "Release the lock.",
      "Sync.try_lock": "Take the lock only if it is free.",
      "Sync.atomic": "Create an atomic counter (starts at 0).",
      "Sync.get": "Read the counter.",
      "Sync.set": "Store a value in the counter.",
      "Sync.add": "Add to the counter; return the new value.",
      "Sync.cas": "Compare-and-set the counter.",
      "Sync.channel": "Create a bounded int FIFO channel.",
      "Sync.send": "Enqueue a value (false if full).",
      "Sync.recv": "Dequeue the oldest value.",
      "Sync.can_recv": "Is there a value waiting?",
      "Sync.len": "How many values are queued.",
      "Sync.cpu_count": "The machine's logical cores (1 to 64); Job.parallel_for uses one thread per core.",
      "Xml.parse": "Parse XML text into an element tree.",
      "Xml.tag": "The element's tag name.",
      "Xml.text": "The element's character data.",
      "Xml.attr": "An attribute's value by name.",
      "Xml.attr_int": "An attribute parsed as an integer.",
      "Xml.has": "Whether an attribute is present.",
      "Xml.attr_count": "How many attributes the element has.",
      "Xml.child_count": "How many child elements.",
      "Xml.child": "A child element by index.",
      "Xml.find": "The first child with a given tag.",
      "Xml.count": "How many children have a given tag.",
      "Base64.decode": "Decode standard base64 text to bytes.",
      "Base64.encode": "Encode bytes as standard base64 text.",
      "Tiled.read": "Read a map file into the intermediate value tree.",
      "Tiled.read_tsx": "Read a tileset file into a value object.",
      "Tiled.load": "Load a map file into the runtime map model.",
      "Tiled.gid": "The raw GID at a cell in a tile layer.",
      "Tiled.resolve": "Decode a GID into tileset, local id and flip flags.",
      "Tiled.width": "The map width in tiles.",
      "Tiled.height": "The map height in tiles.",
      "Tiled.layer_count": "How many layers the map has.",
      "Tiled.layer_name": "A layer's name by index.",
      "Tiled.draw": "Draw every visible tile layer.",
      "Tiled.project": "Project a collision layer to the byte tilemap.",
      "Tiled.tree": "The underlying intermediate value tree.",
      "Tiled.tile_prop": "Whether a GID's tile carries a bool property.",
      "Tiled.collide": "Drive collision from per-tile metadata.",
      "Tiled.collision_kind": "Classify a GID's collision from its tile metadata.",
      "Tiled.tile_shapes": "Whether a GID's tile has a collision shape.",
      "Tiled.draw_anim": "Draw with animated tiles advanced to a frame.",
      "Tiled.frame_gid": "The current GID of an animated tile at a frame.",
      "Tiled.animated": "Whether a GID's tile is animated.",
      "Tiled.object_count": "How many objects an object layer holds.",
      "Tiled.object": "An object on an object layer by index.",
      "Tiled.object_shape": "Classify an object's shape.",
      "Tiled.prop": "A custom property's value, with class-default fallback.",
      "Tiled.prop_int": "A custom property parsed as an integer.",
      "Tiled.prop_type": "A custom property's declared type.",
      "Tiled.load_types": "Load a project custom-type table.",
      "Tiled.template": "Read a template file into an object value.",
      "Tiled.spawn": "Spawn a Ludic entity from an object.",
      "Tiled.spawn_layer": "Spawn every object on a layer.",
      "Tiled.cell_x": "The screen x of a tile cell for the map orientation.",
      "Tiled.cell_y": "The screen y of a tile cell for the map orientation.",
      "Tiled.layer_kind": "A layer's kind.",
      "Tiled.layer_opacity": "A layer's opacity.",
      "Tiled.layer_tint": "A layer's tint colour.",
      "Tiled.layer_offsetx": "A layer's horizontal offset.",
      "Tiled.layer_offsety": "A layer's vertical offset.",
      "Tiled.world": "Read a .world file.",
      "Tiled.world_count": "How many maps a world stitches.",
      "Tiled.world_map": "A world member map by index.",
      "Ui.build": "Construct every declared ui block (loads skins, measures fonts).",
      "Ui.open": "Make one menu active and focus its first button.",
      "Ui.close": "Deactivate the menu: no menu is open.",
      "Ui.tick": "Advance navigation by one key (the frame loop does this for you).",
      "Ui.clicked": "Was this control activated this frame? (polled form of UiClicked)",
      "Ui.set_text": "Replace a label's or button's text.",
      "Ui.render": "Draw the active menu.",
      "File.open": "Open a file (fopen); null when it cannot be opened.",
      "File.read": "Read up to n bytes into a buffer; returns the bytes read.",
      "File.write": "Write n bytes from a buffer; returns the bytes written.",
      "File.seek": "Move the file cursor (0 start, 1 current, 2 end).",
      "File.tell": "The cursor position in bytes.",
      "File.close": "Close a handle from File.open.",
      "Font.load": "Load a TrueType font; returns a font handle.",
      "Fx.sparks": "A burst of sparks flying out of a point.",
      "Fx.number": "A number that floats up from a point and fades.",
      "Fx.clear": "Drop every spark and number at once.",
      "Prefab.spawn": "Spawn a prefab chosen by name at runtime; -1 if none has that name.",
      "Prefab.spawn_at": "Spawn a prefab by name and place it.",
      "App.splash_hide": "Dismiss the boot splash.",
      "App.set_icon": "Set the Dock icon from an image the game ships.",
      "App.window_hide": "Take the game's window off the screen.",
      "App.window_show": "Bring the game's window back.",
      "Start": "Runs once at boot, before the game loop — the place to set up initial state.",
      "Input": "The first per-frame phase — read the keyboard and record the player's intent.",
      "FixedUpdate": "The deterministic simulation step — physics and gameplay meant to be reproducible.",
      "Update": "The ordinary per-frame game-logic step, run after Input and FixedUpdate.",
      "LateUpdate": "Runs each frame after Update and before Render.",
      "Render": "The last per-frame phase — draw the world, then call Screen.show() once.",
      "Overlay": "The HUD pass — runs after Render and after every engine-owned drawing system."
    },
    "cards": {
      "kw-program": {
        "name": "program",
        "sig": "program Name { … }",
        "tip": "The top-level unit — one program compiles to one native game.",
        "kind": "keyword",
        "page": "kw-program.html",
        "section": "Program structure"
      },
      "kw-property": {
        "name": "property",
        "sig": "property Name { field: T = default, … }",
        "tip": "A named record of typed fields — a per-model component, or a plain heap record.",
        "kind": "keyword",
        "page": "kw-property.html",
        "section": "Program structure"
      },
      "kw-model": {
        "name": "model",
        "sig": "model Name { PropA, PropB, … }",
        "tip": "A named kind of thing — a fixed bundle of properties you spawn by one name.",
        "kind": "keyword",
        "page": "kw-model.html",
        "section": "Program structure"
      },
      "kw-handler": {
        "name": "handler",
        "sig": "handler Name phase P { … }",
        "tip": "A named block the engine runs each frame during phase P.",
        "kind": "keyword",
        "page": "kw-handler.html",
        "section": "Program structure"
      },
      "kw-phase": {
        "name": "phase",
        "sig": "phase Start | Input | Update | FixedUpdate | Render",
        "tip": "Names which stage of the frame a handler runs in.",
        "kind": "keyword",
        "page": "kw-phase.html",
        "section": "Program structure"
      },
      "kw-const": {
        "name": "const",
        "sig": "const NAME: T = value",
        "tip": "A compile-time constant, folded into the code with no storage.",
        "kind": "keyword",
        "page": "kw-const.html",
        "section": "Program structure"
      },
      "kw-var": {
        "name": "var",
        "sig": "var name: T = value",
        "tip": "A mutable binding — at program scope, your game's persistent named state.",
        "kind": "keyword",
        "page": "kw-var.html",
        "section": "Program structure"
      },
      "kw-let": {
        "name": "let",
        "sig": "let name = value",
        "tip": "An immutable binding — the default choice for a value that never changes.",
        "kind": "keyword",
        "page": "kw-let.html",
        "section": "Program structure"
      },
      "kw-function": {
        "name": "function",
        "sig": "function name(a: T, b: T) -> R { … }",
        "tip": "A function — reusable logic called positionally or with named arguments.",
        "kind": "keyword",
        "page": "kw-function.html",
        "section": "Program structure"
      },
      "kw-fn": {
        "name": "fn",
        "sig": "fn name",
        "tip": "A top-level function named as a value - the entry point handed to Job.parallel_for.",
        "kind": "keyword",
        "page": "kw-fn.html",
        "section": "Program structure"
      },
      "kw-prefab": {
        "name": "prefab",
        "sig": "prefab Name: Model { Comp { field: value }, … }",
        "tip": "A model with preset component fields — spawn it, override what varies.",
        "kind": "keyword",
        "page": "kw-prefab.html",
        "section": "Program structure"
      },
      "kw-return": {
        "name": "return",
        "sig": "return value",
        "tip": "Hand a value back from a function and stop running it.",
        "kind": "keyword",
        "page": "kw-return.html",
        "section": "Program structure"
      },
      "kw-entry": {
        "name": "entry",
        "sig": "entry { … }",
        "tip": "The program's main block — runs once, top to bottom.",
        "kind": "keyword",
        "page": "kw-entry.html",
        "section": "Program structure"
      },
      "kw-import": {
        "name": "import",
        "sig": "import \"file.ludic\"",
        "tip": "Splice another Ludic file's declarations into this program.",
        "kind": "keyword",
        "page": "kw-import.html",
        "section": "Program structure"
      },
      "kw-public": {
        "name": "public",
        "sig": "scene Name start public { … }",
        "tip": "Expose a declaration's lifecycle on the public event bus.",
        "kind": "keyword",
        "page": "kw-public.html",
        "section": "Program structure"
      },
      "kw-extern": {
        "name": "extern",
        "sig": "extern function name(a: T) -> R = \"symbol\"",
        "tip": "Bind a name to an external native symbol — the seam for platform and library calls.",
        "kind": "keyword",
        "page": "kw-extern.html",
        "section": "Program structure"
      },
      "kw-new": {
        "name": "new",
        "sig": "new Record { … }   new []T",
        "tip": "Allocate a property record or an empty slice on the heap.",
        "kind": "keyword",
        "page": "kw-new.html",
        "section": "Program structure"
      },
      "kw-namespace": {
        "name": "namespace",
        "sig": "namespace Name { export function foo(…) … internal function bar(…) … }",
        "tip": "Group functions into a Name.* namespace and control its public surface.",
        "kind": "keyword",
        "page": "kw-namespace.html",
        "section": "Program structure"
      },
      "kw-enum": {
        "name": "enum",
        "sig": "enum Name { A, B, C }",
        "tip": "A named set of integer constants — names for a magic-number space.",
        "kind": "keyword",
        "page": "kw-enum.html",
        "section": "Program structure"
      },
      "kw-ui": {
        "name": "ui",
        "sig": "ui { panel { … } }",
        "tip": "Declare a retained widget tree as data; the engine lays it out and draws it.",
        "kind": "keyword",
        "page": "kw-ui.html",
        "section": "Program structure"
      },
      "kw-spawn": {
        "name": "spawn",
        "sig": "spawn Label { Prop { field: v }; … }",
        "tip": "Create a model instance carrying the listed properties, seeding their fields.",
        "kind": "keyword",
        "page": "kw-spawn.html",
        "section": "Entities & the ECS"
      },
      "kw-despawn": {
        "name": "despawn",
        "sig": "despawn entity",
        "tip": "Remove a model instance from the world, firing any @OnDespawn hooks.",
        "kind": "keyword",
        "page": "kw-despawn.html",
        "section": "Entities & the ECS"
      },
      "kw-query": {
        "name": "query",
        "sig": "query [PropA, PropB, {Tag}]",
        "tip": "Match every model instance carrying all the listed properties.",
        "kind": "keyword",
        "page": "kw-query.html",
        "section": "Entities & the ECS"
      },
      "kw-self": {
        "name": "self",
        "sig": "self()",
        "tip": "The model instance currently bound by the enclosing query loop.",
        "kind": "keyword",
        "page": "kw-self.html",
        "section": "Entities & the ECS"
      },
      "kw-enable": {
        "name": "enable",
        "sig": "enable Prop on entity",
        "tip": "Re-activate a disabled property, model, or handler — its data is intact.",
        "kind": "keyword",
        "page": "kw-enable.html",
        "section": "Entities & the ECS"
      },
      "kw-disable": {
        "name": "disable",
        "sig": "disable Prop on entity",
        "tip": "Deactivate a property, model, or handler without destroying its data.",
        "kind": "keyword",
        "page": "kw-disable.html",
        "section": "Entities & the ECS"
      },
      "kw-attach": {
        "name": "attach",
        "sig": "attach Prop on entity { overrides }",
        "tip": "Structurally add a property to a live model instance, seeding its fields.",
        "kind": "keyword",
        "page": "kw-attach.html",
        "section": "Entities & the ECS"
      },
      "kw-detach": {
        "name": "detach",
        "sig": "detach Prop on entity",
        "tip": "Structurally remove a property from a live model instance.",
        "kind": "keyword",
        "page": "kw-detach.html",
        "section": "Entities & the ECS"
      },
      "fn-world_attach_dyn": {
        "name": "world_attach_dyn",
        "sig": "world_attach_dyn(target, property)",
        "tip": "Attach a property to an instance by numeric id at runtime (dynamic ECS).",
        "kind": "builtin",
        "page": "fn-world_attach_dyn.html",
        "section": "Entities & the ECS"
      },
      "fn-world_count": {
        "name": "world_count",
        "sig": "world_count() -> int",
        "tip": "The total number of live model instances in the world.",
        "kind": "builtin",
        "page": "fn-world_count.html",
        "section": "Entities & the ECS"
      },
      "fn-world_detach_dyn": {
        "name": "world_detach_dyn",
        "sig": "world_detach_dyn(target, property)",
        "tip": "Detach a property from an instance by numeric id at runtime (dynamic ECS).",
        "kind": "builtin",
        "page": "fn-world_detach_dyn.html",
        "section": "Entities & the ECS"
      },
      "fn-world_field_id": {
        "name": "world_field_id",
        "sig": "world_field_id(property, name) -> int",
        "tip": "Resolve a field name within a property to its numeric index.",
        "kind": "builtin",
        "page": "fn-world_field_id.html",
        "section": "Entities & the ECS"
      },
      "fn-world_get": {
        "name": "world_get",
        "sig": "world_get(target, property, field) -> int",
        "tip": "Read one field of a model instance by numeric id (reflection ABI).",
        "kind": "builtin",
        "page": "fn-world_get.html",
        "section": "Entities & the ECS"
      },
      "fn-world_has": {
        "name": "world_has",
        "sig": "world_has(target, property) -> bool",
        "tip": "Test whether a model instance currently carries a property.",
        "kind": "builtin",
        "page": "fn-world_has.html",
        "section": "Entities & the ECS"
      },
      "fn-world_kind": {
        "name": "world_kind",
        "sig": "world_kind(target) -> int",
        "tip": "The model id of an instance — which kind of thing it is.",
        "kind": "builtin",
        "page": "fn-world_kind.html",
        "section": "Entities & the ECS"
      },
      "fn-world_load": {
        "name": "world_load",
        "sig": "world_load(buf, len)",
        "tip": "Restore the whole world from a serialized byte buffer.",
        "kind": "builtin",
        "page": "fn-world_load.html",
        "section": "Entities & the ECS"
      },
      "fn-world_model_id": {
        "name": "world_model_id",
        "sig": "world_model_id(name) -> int",
        "tip": "Resolve a model's name to its stable numeric id.",
        "kind": "builtin",
        "page": "fn-world_model_id.html",
        "section": "Entities & the ECS"
      },
      "fn-world_prop_id": {
        "name": "world_prop_id",
        "sig": "world_prop_id(name) -> int",
        "tip": "Resolve a property's name to its stable numeric id.",
        "kind": "builtin",
        "page": "fn-world_prop_id.html",
        "section": "Entities & the ECS"
      },
      "fn-world_query_next": {
        "name": "world_query_next",
        "sig": "world_query_next(property, cursor) -> entity",
        "tip": "Step to the next instance carrying a property, walking the world by id.",
        "kind": "builtin",
        "page": "fn-world_query_next.html",
        "section": "Entities & the ECS"
      },
      "fn-world_register_prop": {
        "name": "world_register_prop",
        "sig": "world_register_prop(name, fields) -> int",
        "tip": "Register a brand-new property at runtime and get its id (dynamic ECS).",
        "kind": "builtin",
        "page": "fn-world_register_prop.html",
        "section": "Entities & the ECS"
      },
      "fn-world_save": {
        "name": "world_save",
        "sig": "world_save(buf) -> int",
        "tip": "Serialize the whole world into a buffer; returns the number of bytes written.",
        "kind": "builtin",
        "page": "fn-world_save.html",
        "section": "Entities & the ECS"
      },
      "fn-world_set": {
        "name": "world_set",
        "sig": "world_set(target, property, field, value)",
        "tip": "Write one field of a model instance by numeric id (reflection ABI).",
        "kind": "builtin",
        "page": "fn-world_set.html",
        "section": "Entities & the ECS"
      },
      "fn-world_size": {
        "name": "world_size",
        "sig": "world_size() -> int",
        "tip": "The number of live model instances in the world.",
        "kind": "builtin",
        "page": "fn-world_size.html",
        "section": "Entities & the ECS"
      },
      "fn-world_spawn": {
        "name": "world_spawn",
        "sig": "world_spawn(model) -> entity",
        "tip": "Spawn an instance of a model chosen by numeric id at runtime.",
        "kind": "builtin",
        "page": "fn-world_spawn.html",
        "section": "Entities & the ECS"
      },
      "kw-if": {
        "name": "if / else",
        "sig": "if cond { … } else { … }",
        "tip": "A branch — run one block when a condition holds, another when it doesn't.",
        "kind": "keyword",
        "page": "kw-if.html",
        "section": "Control flow"
      },
      "kw-while": {
        "name": "while",
        "sig": "while cond { … }",
        "tip": "Loop as long as a condition holds, re-checking it before each pass.",
        "kind": "keyword",
        "page": "kw-while.html",
        "section": "Control flow"
      },
      "kw-for": {
        "name": "for … in",
        "sig": "for name in a .. b { … }",
        "tip": "Range loop — iterate the half-open range from a up to but not including b.",
        "kind": "keyword",
        "page": "kw-for.html",
        "section": "Control flow"
      },
      "kw-in": {
        "name": "in",
        "sig": "for x in range | query",
        "tip": "The part of a for loop that names what to iterate — a range or a query.",
        "kind": "keyword",
        "page": "kw-in.html",
        "section": "Control flow"
      },
      "kw-match": {
        "name": "match",
        "sig": "match value { 0, 1 => … _ => … }",
        "tip": "Multi-way branch on one value, matching one or more literals per arm.",
        "kind": "keyword",
        "page": "kw-match.html",
        "section": "Control flow"
      },
      "kw-machine": {
        "name": "machine",
        "sig": "machine store { state Name { … } }",
        "tip": "An explicit state machine over an int var — dispatches on the store's value.",
        "kind": "keyword",
        "page": "kw-machine.html",
        "section": "Control flow"
      },
      "kw-state": {
        "name": "state",
        "sig": "state Name { … }",
        "tip": "One state of a machine — its body runs while the machine sits in it.",
        "kind": "keyword",
        "page": "kw-state.html",
        "section": "Control flow"
      },
      "kw-become": {
        "name": "become",
        "sig": "become Name",
        "tip": "Transition to another state of the enclosing machine, or to another scene.",
        "kind": "keyword",
        "page": "kw-become.html",
        "section": "Control flow"
      },
      "kw-break": {
        "name": "break",
        "sig": "break",
        "tip": "Leave the enclosing loop immediately.",
        "kind": "keyword",
        "page": "kw-break.html",
        "section": "Control flow"
      },
      "kw-continue": {
        "name": "continue",
        "sig": "continue",
        "tip": "Skip to the next iteration of the loop.",
        "kind": "keyword",
        "page": "kw-continue.html",
        "section": "Control flow"
      },
      "kw-where": {
        "name": "where",
        "sig": "for (Binds) in query [Comps] where cond { … }",
        "tip": "Filter a query loop to entities that satisfy a condition.",
        "kind": "keyword",
        "page": "kw-where.html",
        "section": "Control flow"
      },
      "kw-try": {
        "name": "try",
        "sig": "try EXPR else { … }",
        "tip": "Recover a fallible result as a value, with a fallback — no exceptions, no unwinding.",
        "kind": "keyword",
        "page": "kw-try.html",
        "section": "Control flow"
      },
      "kw-scene": {
        "name": "scene",
        "sig": "scene Name [start] { on enter{} on exit{} layer … }",
        "tip": "A mutually-exclusive game state — a title screen, the overworld, a battle.",
        "kind": "keyword",
        "page": "kw-scene.html",
        "section": "Scenes & layers"
      },
      "kw-layer": {
        "name": "layer",
        "sig": "layer Name { handlers }",
        "tip": "A named group of handlers inside a scene; layers render in declaration order.",
        "kind": "keyword",
        "page": "kw-layer.html",
        "section": "Scenes & layers"
      },
      "kw-on": {
        "name": "on enter / on exit",
        "sig": "on enter { … }   on exit { … }",
        "tip": "Scene lifecycle hooks that fire as a scene becomes active or is left.",
        "kind": "keyword",
        "page": "kw-on.html",
        "section": "Scenes & layers"
      },
      "kw-enter": {
        "name": "enter",
        "sig": "on enter { … }",
        "tip": "The scene-entry hook — runs once as a scene becomes active.",
        "kind": "keyword",
        "page": "kw-enter.html",
        "section": "Scenes & layers"
      },
      "kw-exit": {
        "name": "exit",
        "sig": "on exit { … }",
        "tip": "The scene-exit hook — runs once as a scene is left.",
        "kind": "keyword",
        "page": "kw-exit.html",
        "section": "Scenes & layers"
      },
      "kw-start": {
        "name": "start",
        "sig": "scene Name start { … }",
        "tip": "Marks the one scene the game begins in.",
        "kind": "keyword",
        "page": "kw-start.html",
        "section": "Scenes & layers"
      },
      "kw-event": {
        "name": "event",
        "sig": "event Name { field: T = default }",
        "tip": "Declare a public event carrying a flat payload that listeners react to.",
        "kind": "keyword",
        "page": "kw-event.html",
        "section": "Events"
      },
      "kw-emit": {
        "name": "emit",
        "sig": "emit Name(field: value)",
        "tip": "Fire an event, running every listener; as an expression it yields the veto flag.",
        "kind": "keyword",
        "page": "kw-emit.html",
        "section": "Events"
      },
      "kw-cancel": {
        "name": "cancel",
        "sig": "cancel",
        "tip": "Inside a listener, veto the cancellable event being emitted.",
        "kind": "keyword",
        "page": "kw-cancel.html",
        "section": "Events"
      },
      "kw-cancellable": {
        "name": "cancellable",
        "sig": "event cancellable Name { … }",
        "tip": "Marks an event whose listeners may veto it with cancel.",
        "kind": "keyword",
        "page": "kw-cancellable.html",
        "section": "Events"
      },
      "screen-clear": {
        "name": "Screen.clear",
        "sig": "Screen.clear(color)",
        "tip": "Fill the whole framebuffer with one color to start a fresh frame.",
        "kind": "namespace-method",
        "page": "screen-clear.html",
        "section": "Screen — drawing"
      },
      "screen-fill_rectangle": {
        "name": "Screen.fill_rectangle",
        "sig": "Screen.fill_rectangle(x, y, width, height, color)",
        "tip": "Draw a solid, filled rectangle at a pixel position.",
        "kind": "namespace-method",
        "page": "screen-fill_rectangle.html",
        "section": "Screen — drawing"
      },
      "screen-draw_rectangle": {
        "name": "Screen.draw_rectangle",
        "sig": "Screen.draw_rectangle(x, y, width, height, color)",
        "tip": "Draw a one-pixel-thick rectangle outline (not filled).",
        "kind": "namespace-method",
        "page": "screen-draw_rectangle.html",
        "section": "Screen — drawing"
      },
      "screen-put_pixel": {
        "name": "Screen.put_pixel",
        "sig": "Screen.put_pixel(x, y, color)",
        "tip": "Set a single pixel at a pixel coordinate to one color.",
        "kind": "namespace-method",
        "page": "screen-put_pixel.html",
        "section": "Screen — drawing"
      },
      "screen-draw_text": {
        "name": "Screen.draw_text",
        "sig": "Screen.draw_text(x, y, text, color, scale)",
        "tip": "Draw a string with the built-in font at an integer scale.",
        "kind": "namespace-method",
        "page": "screen-draw_text.html",
        "section": "Screen — drawing"
      },
      "screen-draw_number": {
        "name": "Screen.draw_number",
        "sig": "Screen.draw_number(x, y, value, color, scale)",
        "tip": "Draw an integer directly, with no string allocation or conversion.",
        "kind": "namespace-method",
        "page": "screen-draw_number.html",
        "section": "Screen — drawing"
      },
      "screen-show": {
        "name": "Screen.show",
        "sig": "Screen.show()",
        "tip": "Present the finished frame — copy everything drawn this frame to the window.",
        "kind": "namespace-method",
        "page": "screen-show.html",
        "section": "Screen — drawing"
      },
      "screen-width": {
        "name": "Screen.width",
        "sig": "Screen.width() -> int",
        "tip": "The framebuffer width in pixels.",
        "kind": "namespace-method",
        "page": "screen-width.html",
        "section": "Screen — drawing"
      },
      "screen-height": {
        "name": "Screen.height",
        "sig": "Screen.height() -> int",
        "tip": "The framebuffer height in pixels.",
        "kind": "namespace-method",
        "page": "screen-height.html",
        "section": "Screen — drawing"
      },
      "screen-status": {
        "name": "Screen.status",
        "sig": "Screen.status(text)",
        "tip": "Set the persistent one-line status/HUD string shown by the runtime.",
        "kind": "namespace-method",
        "page": "screen-status.html",
        "section": "Screen — drawing"
      },
      "screen-line": {
        "name": "Screen.line",
        "sig": "Screen.line(x1, y1, x2, y2, color)",
        "tip": "Draw a straight line between two points.",
        "kind": "namespace-method",
        "page": "screen-line.html",
        "section": "Screen — drawing"
      },
      "screen-circle": {
        "name": "Screen.circle",
        "sig": "Screen.circle(x, y, radius, color)",
        "tip": "Draw a circle outline.",
        "kind": "namespace-method",
        "page": "screen-circle.html",
        "section": "Screen — drawing"
      },
      "screen-fill_circle": {
        "name": "Screen.fill_circle",
        "sig": "Screen.fill_circle(x, y, radius, color)",
        "tip": "Draw a filled disc.",
        "kind": "namespace-method",
        "page": "screen-fill_circle.html",
        "section": "Screen — drawing"
      },
      "screen-triangle": {
        "name": "Screen.triangle",
        "sig": "Screen.triangle(x1, y1, x2, y2, x3, y3, color)",
        "tip": "Draw a triangle outline.",
        "kind": "namespace-method",
        "page": "screen-triangle.html",
        "section": "Screen — drawing"
      },
      "screen-fill_triangle": {
        "name": "Screen.fill_triangle",
        "sig": "Screen.fill_triangle(x1, y1, x2, y2, x3, y3, color)",
        "tip": "Draw a filled triangle.",
        "kind": "namespace-method",
        "page": "screen-fill_triangle.html",
        "section": "Screen — drawing"
      },
      "screen-sprite": {
        "name": "Screen.sprite",
        "sig": "Screen.sprite(id, x, y)",
        "tip": "Blit a sprite at its natural size.",
        "kind": "namespace-method",
        "page": "screen-sprite.html",
        "section": "Screen — drawing"
      },
      "screen-sprite_scaled": {
        "name": "Screen.sprite_scaled",
        "sig": "Screen.sprite_scaled(id, x, y, scale)",
        "tip": "Blit a sprite at an integer scale.",
        "kind": "namespace-method",
        "page": "screen-sprite_scaled.html",
        "section": "Screen — drawing"
      },
      "screen-oval": {
        "name": "Screen.oval",
        "sig": "Screen.oval(x, y, rx, ry, color)",
        "tip": "Draw an axis-aligned ellipse outline.",
        "kind": "namespace-method",
        "page": "screen-oval.html",
        "section": "Screen — drawing"
      },
      "screen-camera": {
        "name": "Screen.camera",
        "sig": "Screen.camera(x, y)",
        "tip": "Set the world-space camera offset for the draw path.",
        "kind": "namespace-method",
        "page": "screen-camera.html",
        "section": "Screen — drawing"
      },
      "screen-clip": {
        "name": "Screen.clip",
        "sig": "Screen.clip(x, y, width, height)",
        "tip": "Restrict drawing to a screen-space rectangle.",
        "kind": "namespace-method",
        "page": "screen-clip.html",
        "section": "Screen — drawing"
      },
      "screen-clip_reset": {
        "name": "Screen.clip_reset",
        "sig": "Screen.clip_reset()",
        "tip": "Lift the clip rectangle (draw to the whole screen again).",
        "kind": "namespace-method",
        "page": "screen-clip_reset.html",
        "section": "Screen — drawing"
      },
      "screen-blend_mode": {
        "name": "Screen.blend_mode",
        "sig": "Screen.blend_mode(mode)",
        "tip": "Choose replace or additive pixel blending.",
        "kind": "namespace-method",
        "page": "screen-blend_mode.html",
        "section": "Screen — drawing"
      },
      "screen-measure_text": {
        "name": "Screen.measure_text",
        "sig": "Screen.measure_text(text) -> int",
        "tip": "The pixel advance width of text in the built-in font.",
        "kind": "namespace-method",
        "page": "screen-measure_text.html",
        "section": "Screen — drawing"
      },
      "screen-pixel": {
        "name": "Screen.pixel",
        "sig": "Screen.pixel(x, y) -> int",
        "tip": "Read a framebuffer pixel (0x00RRGGBB), or 0 if off-screen.",
        "kind": "namespace-method",
        "page": "screen-pixel.html",
        "section": "Screen — drawing"
      },
      "screen-bar": {
        "name": "Screen.bar",
        "sig": "Screen.bar(x:, y:, width:, height:, value:, max:, color:, back:)",
        "tip": "A filled meter: value of max over a track.",
        "kind": "namespace-method",
        "page": "screen-bar.html",
        "section": "Screen — drawing"
      },
      "clock-now": {
        "name": "Clock.now",
        "sig": "Clock.now() -> int",
        "tip": "The current simulated instant.",
        "kind": "namespace-method",
        "page": "clock-now.html",
        "section": "Clock"
      },
      "clock-set": {
        "name": "Clock.set",
        "sig": "Clock.set(t)",
        "tip": "Set the clock to an instant.",
        "kind": "namespace-method",
        "page": "clock-set.html",
        "section": "Clock"
      },
      "clock-advance": {
        "name": "Clock.advance",
        "sig": "Clock.advance(span)",
        "tip": "Move the clock forward by a Duration.",
        "kind": "namespace-method",
        "page": "clock-advance.html",
        "section": "Clock"
      },
      "clock-reset": {
        "name": "Clock.reset",
        "sig": "Clock.reset()",
        "tip": "Reset the clock to the epoch (0).",
        "kind": "namespace-method",
        "page": "clock-reset.html",
        "section": "Clock"
      },
      "collision-rects": {
        "name": "Collision.rects",
        "sig": "Collision.rects(ax, ay, aw, ah, bx, by, bw, bh) -> bool",
        "tip": "Do two rectangles overlap?",
        "kind": "namespace-method",
        "page": "collision-rects.html",
        "section": "Collision"
      },
      "collision-point_rect": {
        "name": "Collision.point_rect",
        "sig": "Collision.point_rect(px, py, rx, ry, rw, rh) -> bool",
        "tip": "Is a point inside a rectangle?",
        "kind": "namespace-method",
        "page": "collision-point_rect.html",
        "section": "Collision"
      },
      "collision-circles": {
        "name": "Collision.circles",
        "sig": "Collision.circles(ax, ay, ar, bx, by, br) -> bool",
        "tip": "Do two circles overlap?",
        "kind": "namespace-method",
        "page": "collision-circles.html",
        "section": "Collision"
      },
      "collision-rect_circle": {
        "name": "Collision.rect_circle",
        "sig": "Collision.rect_circle(rx, ry, rw, rh, cx, cy, cr) -> bool",
        "tip": "Does a rectangle overlap a circle?",
        "kind": "namespace-method",
        "page": "collision-rect_circle.html",
        "section": "Collision"
      },
      "color-rgb": {
        "name": "Color.rgb",
        "sig": "Color.rgb(r, g, b) -> int",
        "tip": "Build a color from red, green, blue.",
        "kind": "namespace-method",
        "page": "color-rgb.html",
        "section": "Color functions"
      },
      "color-rgba": {
        "name": "Color.rgba",
        "sig": "Color.rgba(r, g, b, a) -> int",
        "tip": "Build a color with an alpha byte.",
        "kind": "namespace-method",
        "page": "color-rgba.html",
        "section": "Color functions"
      },
      "color-lerp": {
        "name": "Color.lerp",
        "sig": "Color.lerp(c0, c1, t) -> int",
        "tip": "Blend between two colors.",
        "kind": "namespace-method",
        "page": "color-lerp.html",
        "section": "Color functions"
      },
      "color-darken": {
        "name": "Color.darken",
        "sig": "Color.darken(c, amount) -> int",
        "tip": "Scale a color toward black.",
        "kind": "namespace-method",
        "page": "color-darken.html",
        "section": "Color functions"
      },
      "color-lighten": {
        "name": "Color.lighten",
        "sig": "Color.lighten(c, amount) -> int",
        "tip": "Scale a color toward white.",
        "kind": "namespace-method",
        "page": "color-lighten.html",
        "section": "Color functions"
      },
      "color-with_alpha": {
        "name": "Color.with_alpha",
        "sig": "Color.with_alpha(c, a) -> int",
        "tip": "Replace a color's alpha byte.",
        "kind": "namespace-method",
        "page": "color-with_alpha.html",
        "section": "Color functions"
      },
      "crypto-sha256": {
        "name": "Crypto.sha256",
        "sig": "Crypto.sha256(s) -> string",
        "tip": "SHA-256 of a string, as 64 hex characters.",
        "kind": "namespace-method",
        "page": "crypto-sha256.html",
        "section": "Crypto"
      },
      "crypto-hmac_sha256": {
        "name": "Crypto.hmac_sha256",
        "sig": "Crypto.hmac_sha256(key, msg) -> string",
        "tip": "Sign a message with a shared secret key.",
        "kind": "namespace-method",
        "page": "crypto-hmac_sha256.html",
        "section": "Crypto"
      },
      "crypto-verify_hmac": {
        "name": "Crypto.verify_hmac",
        "sig": "Crypto.verify_hmac(key, msg, mac) -> bool",
        "tip": "Constant-time check that a MAC matches.",
        "kind": "namespace-method",
        "page": "crypto-verify_hmac.html",
        "section": "Crypto"
      },
      "crypto-hex": {
        "name": "Crypto.hex",
        "sig": "Crypto.hex(s) -> string",
        "tip": "Lowercase hex of a string's bytes.",
        "kind": "namespace-method",
        "page": "crypto-hex.html",
        "section": "Crypto"
      },
      "crypto-ct_equal": {
        "name": "Crypto.ct_equal",
        "sig": "Crypto.ct_equal(a, b) -> bool",
        "tip": "Constant-time string equality for secrets.",
        "kind": "namespace-method",
        "page": "crypto-ct_equal.html",
        "section": "Crypto"
      },
      "crypto-random_bytes": {
        "name": "Crypto.random_bytes",
        "sig": "Crypto.random_bytes(n) -> string",
        "tip": "n bytes from the OS CSPRNG, as a 2n-character hex string.",
        "kind": "namespace-method",
        "page": "crypto-random_bytes.html",
        "section": "Crypto"
      },
      "crypto-random_hex": {
        "name": "Crypto.random_hex",
        "sig": "Crypto.random_hex(n) -> string",
        "tip": "Alias for random_bytes — n secure bytes as a 2n-char hex string.",
        "kind": "namespace-method",
        "page": "crypto-random_hex.html",
        "section": "Crypto"
      },
      "crypto-random_u32": {
        "name": "Crypto.random_u32",
        "sig": "Crypto.random_u32() -> int",
        "tip": "One CSPRNG-drawn 32-bit integer.",
        "kind": "namespace-method",
        "page": "crypto-random_u32.html",
        "section": "Crypto"
      },
      "crypto-base64": {
        "name": "Crypto.base64",
        "sig": "Crypto.base64(s) -> string",
        "tip": "Standard base64 (RFC 4648) of a string's bytes.",
        "kind": "namespace-method",
        "page": "crypto-base64.html",
        "section": "Crypto"
      },
      "date-new": {
        "name": "Date.new",
        "sig": "Date.new(year, month, day) -> int",
        "tip": "A calendar day as days-since-1970.",
        "kind": "namespace-method",
        "page": "date-new.html",
        "section": "Date"
      },
      "date-year": {
        "name": "Date.year",
        "sig": "Date.year(date) -> int",
        "tip": "The calendar year of a date.",
        "kind": "namespace-method",
        "page": "date-year.html",
        "section": "Date"
      },
      "date-month": {
        "name": "Date.month",
        "sig": "Date.month(date) -> int",
        "tip": "The month (1-12) of a date.",
        "kind": "namespace-method",
        "page": "date-month.html",
        "section": "Date"
      },
      "date-day": {
        "name": "Date.day",
        "sig": "Date.day(date) -> int",
        "tip": "The day of the month (1-31) of a date.",
        "kind": "namespace-method",
        "page": "date-day.html",
        "section": "Date"
      },
      "date-weekday": {
        "name": "Date.weekday",
        "sig": "Date.weekday(date) -> int",
        "tip": "Day of the week, 0=Sunday..6=Saturday.",
        "kind": "namespace-method",
        "page": "date-weekday.html",
        "section": "Date"
      },
      "date-is_leap": {
        "name": "Date.is_leap",
        "sig": "Date.is_leap(year) -> bool",
        "tip": "True if the year is a leap year.",
        "kind": "namespace-method",
        "page": "date-is_leap.html",
        "section": "Date"
      },
      "date-days_in_month": {
        "name": "Date.days_in_month",
        "sig": "Date.days_in_month(year, month) -> int",
        "tip": "Number of days in a given month.",
        "kind": "namespace-method",
        "page": "date-days_in_month.html",
        "section": "Date"
      },
      "date-to_epoch": {
        "name": "Date.to_epoch",
        "sig": "Date.to_epoch(date) -> int",
        "tip": "Midnight UTC of the day, as a DateTime.",
        "kind": "namespace-method",
        "page": "date-to_epoch.html",
        "section": "Date"
      },
      "date-add_days": {
        "name": "Date.add_days",
        "sig": "Date.add_days(date, n) -> int",
        "tip": "The date n days later (n may be negative).",
        "kind": "namespace-method",
        "page": "date-add_days.html",
        "section": "Date"
      },
      "date-diff_days": {
        "name": "Date.diff_days",
        "sig": "Date.diff_days(a, b) -> int",
        "tip": "Whole days from b to a (a - b).",
        "kind": "namespace-method",
        "page": "date-diff_days.html",
        "section": "Date"
      },
      "datetime-from": {
        "name": "DateTime.from",
        "sig": "DateTime.from(year, month, day, hour, minute, second) -> int",
        "tip": "Build an instant from its calendar parts.",
        "kind": "namespace-method",
        "page": "datetime-from.html",
        "section": "DateTime"
      },
      "datetime-date": {
        "name": "DateTime.date",
        "sig": "DateTime.date(dt) -> int",
        "tip": "The calendar day the instant falls on.",
        "kind": "namespace-method",
        "page": "datetime-date.html",
        "section": "DateTime"
      },
      "datetime-add": {
        "name": "DateTime.add",
        "sig": "DateTime.add(dt, span) -> int",
        "tip": "The instant `span` seconds later.",
        "kind": "namespace-method",
        "page": "datetime-add.html",
        "section": "DateTime"
      },
      "datetime-year": {
        "name": "DateTime.year",
        "sig": "DateTime.year(dt) -> int",
        "tip": "The calendar year of an instant.",
        "kind": "namespace-method",
        "page": "datetime-year.html",
        "section": "DateTime"
      },
      "datetime-month": {
        "name": "DateTime.month",
        "sig": "DateTime.month(dt) -> int",
        "tip": "The month (1-12) of an instant.",
        "kind": "namespace-method",
        "page": "datetime-month.html",
        "section": "DateTime"
      },
      "datetime-day": {
        "name": "DateTime.day",
        "sig": "DateTime.day(dt) -> int",
        "tip": "The day of the month (1-31) of an instant.",
        "kind": "namespace-method",
        "page": "datetime-day.html",
        "section": "DateTime"
      },
      "datetime-weekday": {
        "name": "DateTime.weekday",
        "sig": "DateTime.weekday(dt) -> int",
        "tip": "Day of the week, 0=Sunday..6=Saturday.",
        "kind": "namespace-method",
        "page": "datetime-weekday.html",
        "section": "DateTime"
      },
      "datetime-hour": {
        "name": "DateTime.hour",
        "sig": "DateTime.hour(dt) -> int",
        "tip": "The hour of day (0-23) of an instant.",
        "kind": "namespace-method",
        "page": "datetime-hour.html",
        "section": "DateTime"
      },
      "datetime-minute": {
        "name": "DateTime.minute",
        "sig": "DateTime.minute(dt) -> int",
        "tip": "The minute of the hour (0-59) of an instant.",
        "kind": "namespace-method",
        "page": "datetime-minute.html",
        "section": "DateTime"
      },
      "datetime-second": {
        "name": "DateTime.second",
        "sig": "DateTime.second(dt) -> int",
        "tip": "The second of the minute (0-59) of an instant.",
        "kind": "namespace-method",
        "page": "datetime-second.html",
        "section": "DateTime"
      },
      "datetime-format": {
        "name": "DateTime.format",
        "sig": "DateTime.format(dt, pattern) -> string",
        "tip": "Render an instant as text using a token pattern.",
        "kind": "namespace-method",
        "page": "datetime-format.html",
        "section": "DateTime"
      },
      "datetime-parse": {
        "name": "DateTime.parse",
        "sig": "DateTime.parse(text, pattern) -> int",
        "tip": "Parse text into an instant; -1 on failure.",
        "kind": "namespace-method",
        "page": "datetime-parse.html",
        "section": "DateTime"
      },
      "duration-seconds": {
        "name": "Duration.seconds",
        "sig": "Duration.seconds(n) -> int",
        "tip": "A span of n whole seconds.",
        "kind": "namespace-method",
        "page": "duration-seconds.html",
        "section": "Duration"
      },
      "duration-minutes": {
        "name": "Duration.minutes",
        "sig": "Duration.minutes(n) -> int",
        "tip": "A span of n minutes, in seconds.",
        "kind": "namespace-method",
        "page": "duration-minutes.html",
        "section": "Duration"
      },
      "duration-hours": {
        "name": "Duration.hours",
        "sig": "Duration.hours(n) -> int",
        "tip": "A span of n hours, in seconds.",
        "kind": "namespace-method",
        "page": "duration-hours.html",
        "section": "Duration"
      },
      "duration-days": {
        "name": "Duration.days",
        "sig": "Duration.days(n) -> int",
        "tip": "A span of n days, in seconds.",
        "kind": "namespace-method",
        "page": "duration-days.html",
        "section": "Duration"
      },
      "duration-as_seconds": {
        "name": "Duration.as_seconds",
        "sig": "Duration.as_seconds(span) -> int",
        "tip": "The span in whole seconds.",
        "kind": "namespace-method",
        "page": "duration-as_seconds.html",
        "section": "Duration"
      },
      "duration-as_minutes": {
        "name": "Duration.as_minutes",
        "sig": "Duration.as_minutes(span) -> int",
        "tip": "The span in whole minutes.",
        "kind": "namespace-method",
        "page": "duration-as_minutes.html",
        "section": "Duration"
      },
      "duration-as_hours": {
        "name": "Duration.as_hours",
        "sig": "Duration.as_hours(span) -> int",
        "tip": "The span in whole hours.",
        "kind": "namespace-method",
        "page": "duration-as_hours.html",
        "section": "Duration"
      },
      "duration-as_days": {
        "name": "Duration.as_days",
        "sig": "Duration.as_days(span) -> int",
        "tip": "The span in whole days.",
        "kind": "namespace-method",
        "page": "duration-as_days.html",
        "section": "Duration"
      },
      "ease-in": {
        "name": "Ease.in",
        "sig": "Ease.in(t) -> fixed",
        "tip": "Accelerate from rest (quadratic ease-in).",
        "kind": "namespace-method",
        "page": "ease-in.html",
        "section": "Ease"
      },
      "ease-out": {
        "name": "Ease.out",
        "sig": "Ease.out(t) -> fixed",
        "tip": "Decelerate to rest (quadratic ease-out).",
        "kind": "namespace-method",
        "page": "ease-out.html",
        "section": "Ease"
      },
      "ease-in_out": {
        "name": "Ease.in_out",
        "sig": "Ease.in_out(t) -> fixed",
        "tip": "Ease in and then out (smoothstep).",
        "kind": "namespace-method",
        "page": "ease-in_out.html",
        "section": "Ease"
      },
      "ease-back": {
        "name": "Ease.back",
        "sig": "Ease.back(t) -> fixed",
        "tip": "Ease in with a small backward anticipation.",
        "kind": "namespace-method",
        "page": "ease-back.html",
        "section": "Ease"
      },
      "ease-bounce": {
        "name": "Ease.bounce",
        "sig": "Ease.bounce(t) -> fixed",
        "tip": "Ease out with a settling bounce.",
        "kind": "namespace-method",
        "page": "ease-bounce.html",
        "section": "Ease"
      },
      "ease-elastic": {
        "name": "Ease.elastic",
        "sig": "Ease.elastic(t) -> fixed",
        "tip": "Ease out with a springy wobble.",
        "kind": "namespace-method",
        "page": "ease-elastic.html",
        "section": "Ease"
      },
      "fs-exists": {
        "name": "Fs.exists",
        "sig": "Fs.exists(p) -> bool",
        "tip": "Does a path exist?",
        "kind": "namespace-method",
        "page": "fs-exists.html",
        "section": "Fs"
      },
      "fs-is_dir": {
        "name": "Fs.is_dir",
        "sig": "Fs.is_dir(p) -> bool",
        "tip": "Is a path a directory?",
        "kind": "namespace-method",
        "page": "fs-is_dir.html",
        "section": "Fs"
      },
      "fs-read_text": {
        "name": "Fs.read_text",
        "sig": "Fs.read_text(p) -> string",
        "tip": "Read a whole file as a string.",
        "kind": "namespace-method",
        "page": "fs-read_text.html",
        "section": "Fs"
      },
      "fs-write_text": {
        "name": "Fs.write_text",
        "sig": "Fs.write_text(p, s) -> bool",
        "tip": "Write a string to a file (atomically).",
        "kind": "namespace-method",
        "page": "fs-write_text.html",
        "section": "Fs"
      },
      "fs-append_text": {
        "name": "Fs.append_text",
        "sig": "Fs.append_text(p, s) -> bool",
        "tip": "Append a string to a file.",
        "kind": "namespace-method",
        "page": "fs-append_text.html",
        "section": "Fs"
      },
      "fs-remove": {
        "name": "Fs.remove",
        "sig": "Fs.remove(p) -> bool",
        "tip": "Delete a file.",
        "kind": "namespace-method",
        "page": "fs-remove.html",
        "section": "Fs"
      },
      "fs-size": {
        "name": "Fs.size",
        "sig": "Fs.size(p) -> int",
        "tip": "File size in bytes.",
        "kind": "namespace-method",
        "page": "fs-size.html",
        "section": "Fs"
      },
      "fs-mkdir": {
        "name": "Fs.mkdir",
        "sig": "Fs.mkdir(p) -> bool",
        "tip": "Create a directory and its parents.",
        "kind": "namespace-method",
        "page": "fs-mkdir.html",
        "section": "Fs"
      },
      "fs-copy": {
        "name": "Fs.copy",
        "sig": "Fs.copy(src, dst) -> bool",
        "tip": "Copy a file byte-for-byte.",
        "kind": "namespace-method",
        "page": "fs-copy.html",
        "section": "Fs"
      },
      "fs-list": {
        "name": "Fs.list",
        "sig": "Fs.list(dir) -> []string",
        "tip": "Directory entries, sorted.",
        "kind": "namespace-method",
        "page": "fs-list.html",
        "section": "Fs"
      },
      "hash-of": {
        "name": "Hash.of",
        "sig": "Hash.of(s) -> int",
        "tip": "The fast default string hash.",
        "kind": "namespace-method",
        "page": "hash-of.html",
        "section": "Hash"
      },
      "hash-fnv1a": {
        "name": "Hash.fnv1a",
        "sig": "Hash.fnv1a(s) -> int",
        "tip": "FNV-1a 32-bit, named explicitly.",
        "kind": "namespace-method",
        "page": "hash-fnv1a.html",
        "section": "Hash"
      },
      "hash-crc32": {
        "name": "Hash.crc32",
        "sig": "Hash.crc32(s) -> int",
        "tip": "CRC-32 checksum for corruption detection.",
        "kind": "namespace-method",
        "page": "hash-crc32.html",
        "section": "Hash"
      },
      "hash-mix": {
        "name": "Hash.mix",
        "sig": "Hash.mix(x) -> int",
        "tip": "Avalanche one integer into a well-scrambled value.",
        "kind": "namespace-method",
        "page": "hash-mix.html",
        "section": "Hash"
      },
      "hash-combine": {
        "name": "Hash.combine",
        "sig": "Hash.combine(...) -> int",
        "tip": "Fold several ints into one deterministic seed.",
        "kind": "namespace-method",
        "page": "hash-combine.html",
        "section": "Hash"
      },
      "hash-of64": {
        "name": "Hash.of64",
        "sig": "Hash.of64(s) -> long",
        "tip": "The fast default 64-bit string hash.",
        "kind": "namespace-method",
        "page": "hash-of64.html",
        "section": "Hash"
      },
      "hash-fnv1a_64": {
        "name": "Hash.fnv1a_64",
        "sig": "Hash.fnv1a_64(s) -> long",
        "tip": "FNV-1a 64-bit, named explicitly.",
        "kind": "namespace-method",
        "page": "hash-fnv1a_64.html",
        "section": "Hash"
      },
      "hash-mix64": {
        "name": "Hash.mix64",
        "sig": "Hash.mix64(x) -> long",
        "tip": "Avalanche one 64-bit integer into a well-scrambled value.",
        "kind": "namespace-method",
        "page": "hash-mix64.html",
        "section": "Hash"
      },
      "input-key": {
        "name": "Input.key",
        "sig": "Input.key() -> int",
        "tip": "The key pressed this frame as a character code (0 when nothing is pressed).",
        "kind": "namespace-method",
        "page": "input-key.html",
        "section": "Input"
      },
      "input-bind": {
        "name": "Input.bind",
        "sig": "Input.bind(action: str, key: int) -> void",
        "tip": "Bind a physical key to a named action, so gameplay reads the action, not the key.",
        "kind": "namespace-method",
        "page": "input-bind.html",
        "section": "Input"
      },
      "input-rebind": {
        "name": "Input.rebind",
        "sig": "Input.rebind(action: str, from: int, to: int) -> void",
        "tip": "Remap an action from one key to another at runtime (rebinding menus).",
        "kind": "namespace-method",
        "page": "input-rebind.html",
        "section": "Input"
      },
      "input-poll": {
        "name": "Input.poll",
        "sig": "Input.poll() -> int",
        "tip": "Advance one frame of input; the single per-frame read behind actions and replay.",
        "kind": "namespace-method",
        "page": "input-poll.html",
        "section": "Input"
      },
      "input-down": {
        "name": "Input.down",
        "sig": "Input.down(action: str) -> bool",
        "tip": "Is a named action held on the frame last polled?",
        "kind": "namespace-method",
        "page": "input-down.html",
        "section": "Input"
      },
      "input-pressed": {
        "name": "Input.pressed",
        "sig": "Input.pressed(action: str) -> bool",
        "tip": "Did a named action go down this frame (a one-shot edge)?",
        "kind": "namespace-method",
        "page": "input-pressed.html",
        "section": "Input"
      },
      "input-record": {
        "name": "Input.record",
        "sig": "Input.record() -> void",
        "tip": "Start recording polled input each frame (for deterministic replay).",
        "kind": "namespace-method",
        "page": "input-record.html",
        "section": "Input"
      },
      "input-replay": {
        "name": "Input.replay",
        "sig": "Input.replay() -> void",
        "tip": "Replay recorded input; poll then reads the tape, not the device.",
        "kind": "namespace-method",
        "page": "input-replay.html",
        "section": "Input"
      },
      "input-key_down": {
        "name": "Input.key_down",
        "sig": "Input.key_down(key) -> bool",
        "tip": "Is a physical key held this frame?",
        "kind": "namespace-method",
        "page": "input-key_down.html",
        "section": "Input"
      },
      "input-key_pressed": {
        "name": "Input.key_pressed",
        "sig": "Input.key_pressed(key) -> bool",
        "tip": "Did a key go down this frame (edge)?",
        "kind": "namespace-method",
        "page": "input-key_pressed.html",
        "section": "Input"
      },
      "input-key_released": {
        "name": "Input.key_released",
        "sig": "Input.key_released(key) -> bool",
        "tip": "Did a key go up this frame (edge)?",
        "kind": "namespace-method",
        "page": "input-key_released.html",
        "section": "Input"
      },
      "input-key_label": {
        "name": "Input.key_label",
        "sig": "Input.key_label(key) -> string",
        "tip": "The name to show a player for a key - in their own keyboard layout.",
        "kind": "namespace-method",
        "page": "input-key_label.html",
        "section": "Input"
      },
      "input-press": {
        "name": "Input.press",
        "sig": "Input.press(key)",
        "tip": "Inject a held key (AI, tutorial, testing, network).",
        "kind": "namespace-method",
        "page": "input-press.html",
        "section": "Input"
      },
      "input-release": {
        "name": "Input.release",
        "sig": "Input.release(key)",
        "tip": "Release an injected key.",
        "kind": "namespace-method",
        "page": "input-release.html",
        "section": "Input"
      },
      "input-axis": {
        "name": "Input.axis",
        "sig": "Input.axis(neg, pos) -> fixed",
        "tip": "A -1..+1 axis from two keys.",
        "kind": "namespace-method",
        "page": "input-axis.html",
        "section": "Input"
      },
      "input-axis_i": {
        "name": "Input.axis_i",
        "sig": "Input.axis_i(neg, pos) -> int",
        "tip": "A -1/0/1 directional intent as a plain int, no bool->int glue.",
        "kind": "namespace-method",
        "page": "input-axis_i.html",
        "section": "Input"
      },
      "input-vector": {
        "name": "Input.vector",
        "sig": "Input.vector(left, right, up, down) -> Vector",
        "tip": "A normalized 2D vector from four keys.",
        "kind": "namespace-method",
        "page": "input-vector.html",
        "section": "Input"
      },
      "input-strength": {
        "name": "Input.strength",
        "sig": "Input.strength(action) -> fixed",
        "tip": "0..1 strength of a named action.",
        "kind": "namespace-method",
        "page": "input-strength.html",
        "section": "Input"
      },
      "input-mouse_x": {
        "name": "Input.mouse_x",
        "sig": "Input.mouse_x() -> int",
        "tip": "The mouse x position this frame.",
        "kind": "namespace-method",
        "page": "input-mouse_x.html",
        "section": "Input"
      },
      "input-mouse_y": {
        "name": "Input.mouse_y",
        "sig": "Input.mouse_y() -> int",
        "tip": "The mouse y position this frame.",
        "kind": "namespace-method",
        "page": "input-mouse_y.html",
        "section": "Input"
      },
      "input-mouse_dx": {
        "name": "Input.mouse_dx",
        "sig": "Input.mouse_dx() -> int",
        "tip": "Mouse x movement since the last poll.",
        "kind": "namespace-method",
        "page": "input-mouse_dx.html",
        "section": "Input"
      },
      "input-mouse_dy": {
        "name": "Input.mouse_dy",
        "sig": "Input.mouse_dy() -> int",
        "tip": "Mouse y movement since the last poll.",
        "kind": "namespace-method",
        "page": "input-mouse_dy.html",
        "section": "Input"
      },
      "input-mouse_down": {
        "name": "Input.mouse_down",
        "sig": "Input.mouse_down(button) -> bool",
        "tip": "Is a mouse button held?",
        "kind": "namespace-method",
        "page": "input-mouse_down.html",
        "section": "Input"
      },
      "input-wheel": {
        "name": "Input.wheel",
        "sig": "Input.wheel() -> int",
        "tip": "Scroll-wheel delta this frame.",
        "kind": "namespace-method",
        "page": "input-wheel.html",
        "section": "Input"
      },
      "input-set_mouse": {
        "name": "Input.set_mouse",
        "sig": "Input.set_mouse(x, y, buttons, wheel)",
        "tip": "Inject the mouse state (headless / AI / testing).",
        "kind": "namespace-method",
        "page": "input-set_mouse.html",
        "section": "Input"
      },
      "input-pad_connected": {
        "name": "Input.pad_connected",
        "sig": "Input.pad_connected(pad) -> bool",
        "tip": "Is a gamepad connected?",
        "kind": "namespace-method",
        "page": "input-pad_connected.html",
        "section": "Input"
      },
      "input-pad_button": {
        "name": "Input.pad_button",
        "sig": "Input.pad_button(pad, button) -> bool",
        "tip": "Is a gamepad button held?",
        "kind": "namespace-method",
        "page": "input-pad_button.html",
        "section": "Input"
      },
      "input-pad_axis": {
        "name": "Input.pad_axis",
        "sig": "Input.pad_axis(pad, axis) -> fixed",
        "tip": "A gamepad analog axis, -1..+1.",
        "kind": "namespace-method",
        "page": "input-pad_axis.html",
        "section": "Input"
      },
      "input-set_pad": {
        "name": "Input.set_pad",
        "sig": "Input.set_pad(pad, connected, buttons, lx, ly, rx, ry)",
        "tip": "Inject a gamepad's whole state.",
        "kind": "namespace-method",
        "page": "input-set_pad.html",
        "section": "Input"
      },
      "input-touch_count": {
        "name": "Input.touch_count",
        "sig": "Input.touch_count() -> int",
        "tip": "How many touch points are active?",
        "kind": "namespace-method",
        "page": "input-touch_count.html",
        "section": "Input"
      },
      "input-touch_x": {
        "name": "Input.touch_x",
        "sig": "Input.touch_x(index) -> int",
        "tip": "The x of a touch point.",
        "kind": "namespace-method",
        "page": "input-touch_x.html",
        "section": "Input"
      },
      "input-touch_y": {
        "name": "Input.touch_y",
        "sig": "Input.touch_y(index) -> int",
        "tip": "The y of a touch point.",
        "kind": "namespace-method",
        "page": "input-touch_y.html",
        "section": "Input"
      },
      "input-set_touch": {
        "name": "Input.set_touch",
        "sig": "Input.set_touch(index, x, y, active)",
        "tip": "Inject a touch point.",
        "kind": "namespace-method",
        "page": "input-set_touch.html",
        "section": "Input"
      },
      "input-action": {
        "name": "Input.action",
        "sig": "Input.action(action: str, key: int) -> void",
        "tip": "Register a default key binding for an action (kept if already bound).",
        "kind": "namespace-method",
        "page": "input-action.html",
        "section": "Input"
      },
      "input-bind_pad": {
        "name": "Input.bind_pad",
        "sig": "Input.bind_pad(action: str, button: int) -> void",
        "tip": "Also fire a named action from a gamepad button (device-agnostic).",
        "kind": "namespace-method",
        "page": "input-bind_pad.html",
        "section": "Input"
      },
      "input-active": {
        "name": "Input.active",
        "sig": "Input.active(action: str) -> bool",
        "tip": "Is a named action active right now (any bound key held, or pad button down)?",
        "kind": "namespace-method",
        "page": "input-active.html",
        "section": "Input"
      },
      "input-just_pressed": {
        "name": "Input.just_pressed",
        "sig": "Input.just_pressed(action: str) -> bool",
        "tip": "Did a named action go active this frame (the deterministic on-press)?",
        "kind": "namespace-method",
        "page": "input-just_pressed.html",
        "section": "Input"
      },
      "input-just_released": {
        "name": "Input.just_released",
        "sig": "Input.just_released(action: str) -> bool",
        "tip": "Did a named action go inactive this frame (the on-release edge)?",
        "kind": "namespace-method",
        "page": "input-just_released.html",
        "section": "Input"
      },
      "input-cursor_mode": {
        "name": "Input.cursor_mode",
        "sig": "Input.cursor_mode(mode)",
        "tip": "Hide / lock / confine the OS mouse cursor to the window (windowed).",
        "kind": "namespace-method",
        "page": "input-cursor_mode.html",
        "section": "Input"
      },
      "input-move_i": {
        "name": "Input.move_i",
        "sig": "Input.move_i() -> IVec2",
        "tip": "The standard top-down movement intent, -1/0/1 per axis.",
        "kind": "namespace-method",
        "page": "input-move_i.html",
        "section": "Input"
      },
      "list-len": {
        "name": "List.len",
        "sig": "List.len(s) -> int",
        "tip": "The number of elements in a slice.",
        "kind": "namespace-method",
        "page": "list-len.html",
        "section": "List"
      },
      "list-push": {
        "name": "List.push",
        "sig": "List.push(s, v) -> void",
        "tip": "Append an element to the end of a slice.",
        "kind": "namespace-method",
        "page": "list-push.html",
        "section": "List"
      },
      "list-clear": {
        "name": "List.clear",
        "sig": "List.clear(s) -> void",
        "tip": "Remove all elements, keeping capacity.",
        "kind": "namespace-method",
        "page": "list-clear.html",
        "section": "List"
      },
      "list-first": {
        "name": "List.first",
        "sig": "List.first(s) -> T",
        "tip": "The first element of a slice.",
        "kind": "namespace-method",
        "page": "list-first.html",
        "section": "List"
      },
      "list-last": {
        "name": "List.last",
        "sig": "List.last(s) -> T",
        "tip": "The last element of a slice.",
        "kind": "namespace-method",
        "page": "list-last.html",
        "section": "List"
      },
      "list-pop": {
        "name": "List.pop",
        "sig": "List.pop(s) -> T",
        "tip": "Remove and return the last element.",
        "kind": "namespace-method",
        "page": "list-pop.html",
        "section": "List"
      },
      "list-swap": {
        "name": "List.swap",
        "sig": "List.swap(s, i, j) -> void",
        "tip": "Exchange the elements at two indices.",
        "kind": "namespace-method",
        "page": "list-swap.html",
        "section": "List"
      },
      "list-contains": {
        "name": "List.contains",
        "sig": "List.contains(s, v) -> bool",
        "tip": "Whether a value appears in a slice.",
        "kind": "namespace-method",
        "page": "list-contains.html",
        "section": "List"
      },
      "list-index_of": {
        "name": "List.index_of",
        "sig": "List.index_of(s, v) -> int",
        "tip": "The index of a value in a slice, or -1 if absent.",
        "kind": "namespace-method",
        "page": "list-index_of.html",
        "section": "List"
      },
      "list-reverse": {
        "name": "List.reverse",
        "sig": "List.reverse(s) -> void",
        "tip": "Reverse the order of a slice in place.",
        "kind": "namespace-method",
        "page": "list-reverse.html",
        "section": "List"
      },
      "list-insert": {
        "name": "List.insert",
        "sig": "List.insert(s, i, v) -> void",
        "tip": "Insert an element at an index, shifting the rest up.",
        "kind": "namespace-method",
        "page": "list-insert.html",
        "section": "List"
      },
      "list-remove_at": {
        "name": "List.remove_at",
        "sig": "List.remove_at(s, i) -> void",
        "tip": "Remove the element at an index, shifting the rest down.",
        "kind": "namespace-method",
        "page": "list-remove_at.html",
        "section": "List"
      },
      "list-remove": {
        "name": "List.remove",
        "sig": "List.remove(s, v) -> void",
        "tip": "Remove the first element equal to a value.",
        "kind": "namespace-method",
        "page": "list-remove.html",
        "section": "List"
      },
      "list-sort": {
        "name": "List.sort",
        "sig": "List.sort(s) -> void",
        "tip": "Sort a slice in ascending order, in place.",
        "kind": "namespace-method",
        "page": "list-sort.html",
        "section": "List"
      },
      "list-sort_by": {
        "name": "List.sort_by",
        "sig": "List.sort_by(s, key) -> void",
        "tip": "Sort a slice ascending by a key each element maps to.",
        "kind": "namespace-method",
        "page": "list-sort_by.html",
        "section": "List"
      },
      "list-sort_desc_by": {
        "name": "List.sort_desc_by",
        "sig": "List.sort_desc_by(s, key) -> void",
        "tip": "Sort a slice descending by a key each element maps to.",
        "kind": "namespace-method",
        "page": "list-sort_desc_by.html",
        "section": "List"
      },
      "list-sort_with": {
        "name": "List.sort_with",
        "sig": "List.sort_with(s, cmp) -> void",
        "tip": "Sort a slice with a full two-argument comparator.",
        "kind": "namespace-method",
        "page": "list-sort_with.html",
        "section": "List"
      },
      "list-sample": {
        "name": "List.sample",
        "sig": "List.sample(pool, count) -> []int",
        "tip": "Random picks from an int slice, distinct while it can.",
        "kind": "namespace-method",
        "page": "list-sample.html",
        "section": "List"
      },
      "log-trace": {
        "name": "Log.trace",
        "sig": "Log.trace(msg, [key, value]...) -> void",
        "tip": "Log at the trace level (0) — the most verbose.",
        "kind": "namespace-method",
        "page": "log-trace.html",
        "section": "Log"
      },
      "log-debug": {
        "name": "Log.debug",
        "sig": "Log.debug(msg, [key, value]...) -> void",
        "tip": "Log at the debug level (1) — development detail.",
        "kind": "namespace-method",
        "page": "log-debug.html",
        "section": "Log"
      },
      "log-info": {
        "name": "Log.info",
        "sig": "Log.info(msg, [key, value]...) -> void",
        "tip": "Log at the info level (2) — normal operation.",
        "kind": "namespace-method",
        "page": "log-info.html",
        "section": "Log"
      },
      "log-warn": {
        "name": "Log.warn",
        "sig": "Log.warn(msg, [key, value]...) -> void",
        "tip": "Log at the warn level (3) — something looks wrong.",
        "kind": "namespace-method",
        "page": "log-warn.html",
        "section": "Log"
      },
      "log-error": {
        "name": "Log.error",
        "sig": "Log.error(msg, [key, value]...) -> void",
        "tip": "Log at the error level (4) — a failure.",
        "kind": "namespace-method",
        "page": "log-error.html",
        "section": "Log"
      },
      "log-set_level": {
        "name": "Log.set_level",
        "sig": "Log.set_level(n) -> void",
        "tip": "Show only messages at level n or above (0 = all).",
        "kind": "namespace-method",
        "page": "log-set_level.html",
        "section": "Log"
      },
      "log-level": {
        "name": "Log.level",
        "sig": "Log.level() -> int",
        "tip": "The current logging threshold.",
        "kind": "namespace-method",
        "page": "log-level.html",
        "section": "Log"
      },
      "math-min": {
        "name": "Math.min",
        "sig": "Math.min(a, b) -> int",
        "tip": "The smaller of two values.",
        "kind": "namespace-method",
        "page": "math-min.html",
        "section": "Math"
      },
      "math-max": {
        "name": "Math.max",
        "sig": "Math.max(a, b) -> int",
        "tip": "The larger of two values.",
        "kind": "namespace-method",
        "page": "math-max.html",
        "section": "Math"
      },
      "math-abs": {
        "name": "Math.abs",
        "sig": "Math.abs(x) -> int",
        "tip": "The magnitude of a value, dropping its sign.",
        "kind": "namespace-method",
        "page": "math-abs.html",
        "section": "Math"
      },
      "math-clamp": {
        "name": "Math.clamp",
        "sig": "Math.clamp(v, lo, hi) -> int",
        "tip": "Constrain a value to the range [lo, hi].",
        "kind": "namespace-method",
        "page": "math-clamp.html",
        "section": "Math"
      },
      "math-sign": {
        "name": "Math.sign",
        "sig": "Math.sign(x) -> int",
        "tip": "The sign of a value as -1, 0, or 1.",
        "kind": "namespace-method",
        "page": "math-sign.html",
        "section": "Math"
      },
      "math-floor": {
        "name": "Math.floor",
        "sig": "Math.floor(x) -> int",
        "tip": "Round a fixed value down to the nearest whole int.",
        "kind": "namespace-method",
        "page": "math-floor.html",
        "section": "Math"
      },
      "math-ceil": {
        "name": "Math.ceil",
        "sig": "Math.ceil(x) -> int",
        "tip": "Round a fixed value up to the nearest whole int.",
        "kind": "namespace-method",
        "page": "math-ceil.html",
        "section": "Math"
      },
      "math-round": {
        "name": "Math.round",
        "sig": "Math.round(x) -> int",
        "tip": "Round a fixed value to the nearest whole int.",
        "kind": "namespace-method",
        "page": "math-round.html",
        "section": "Math"
      },
      "math-lerp": {
        "name": "Math.lerp",
        "sig": "Math.lerp(a, b, t) -> fixed",
        "tip": "Blend between two values by a 0..1 amount.",
        "kind": "namespace-method",
        "page": "math-lerp.html",
        "section": "Math"
      },
      "math-inverse_lerp": {
        "name": "Math.inverse_lerp",
        "sig": "Math.inverse_lerp(a, b, v) -> fixed",
        "tip": "Find where a value sits between two endpoints as a 0..1 fraction.",
        "kind": "namespace-method",
        "page": "math-inverse_lerp.html",
        "section": "Math"
      },
      "math-remap": {
        "name": "Math.remap",
        "sig": "Math.remap(v, in0, in1, out0, out1) -> fixed",
        "tip": "Rescale a value from one range into another.",
        "kind": "namespace-method",
        "page": "math-remap.html",
        "section": "Math"
      },
      "math-sqrt": {
        "name": "Math.sqrt",
        "sig": "Math.sqrt(x) -> fixed",
        "tip": "The square root of a fixed value.",
        "kind": "namespace-method",
        "page": "math-sqrt.html",
        "section": "Math"
      },
      "math-sin": {
        "name": "Math.sin",
        "sig": "Math.sin(radians) -> fixed",
        "tip": "Sine of an angle in radians.",
        "kind": "namespace-method",
        "page": "math-sin.html",
        "section": "Math"
      },
      "math-cos": {
        "name": "Math.cos",
        "sig": "Math.cos(radians) -> fixed",
        "tip": "Cosine of an angle in radians.",
        "kind": "namespace-method",
        "page": "math-cos.html",
        "section": "Math"
      },
      "math-tan": {
        "name": "Math.tan",
        "sig": "Math.tan(radians) -> fixed",
        "tip": "Tangent of an angle in radians.",
        "kind": "namespace-method",
        "page": "math-tan.html",
        "section": "Math"
      },
      "math-hypot": {
        "name": "Math.hypot",
        "sig": "Math.hypot(x, y) -> fixed",
        "tip": "Length of the vector (x, y).",
        "kind": "namespace-method",
        "page": "math-hypot.html",
        "section": "Math"
      },
      "math-dist": {
        "name": "Math.dist",
        "sig": "Math.dist(x0, y0, x1, y1) -> fixed",
        "tip": "Distance between two points.",
        "kind": "namespace-method",
        "page": "math-dist.html",
        "section": "Math"
      },
      "math-dist2": {
        "name": "Math.dist2",
        "sig": "Math.dist2(x0, y0, x1, y1) -> fixed",
        "tip": "Squared distance between two points.",
        "kind": "namespace-method",
        "page": "math-dist2.html",
        "section": "Math"
      },
      "math-deg_to_rad": {
        "name": "Math.deg_to_rad",
        "sig": "Math.deg_to_rad(degrees) -> fixed",
        "tip": "Convert degrees to radians.",
        "kind": "namespace-method",
        "page": "math-deg_to_rad.html",
        "section": "Math"
      },
      "math-rad_to_deg": {
        "name": "Math.rad_to_deg",
        "sig": "Math.rad_to_deg(radians) -> fixed",
        "tip": "Convert radians to degrees.",
        "kind": "namespace-method",
        "page": "math-rad_to_deg.html",
        "section": "Math"
      },
      "math-posmod": {
        "name": "Math.posmod",
        "sig": "Math.posmod(a, m) -> int",
        "tip": "Modulo that is always non-negative.",
        "kind": "namespace-method",
        "page": "math-posmod.html",
        "section": "Math"
      },
      "math-wrap": {
        "name": "Math.wrap",
        "sig": "Math.wrap(v, lo, hi) -> int",
        "tip": "Wrap a value into the range [lo, hi).",
        "kind": "namespace-method",
        "page": "math-wrap.html",
        "section": "Math"
      },
      "math-ping_pong": {
        "name": "Math.ping_pong",
        "sig": "Math.ping_pong(t, len) -> int",
        "tip": "Bounce a counter back and forth in [0, len].",
        "kind": "namespace-method",
        "page": "math-ping_pong.html",
        "section": "Math"
      },
      "math-snapped": {
        "name": "Math.snapped",
        "sig": "Math.snapped(v, step) -> fixed",
        "tip": "Round a value to the nearest multiple of step.",
        "kind": "namespace-method",
        "page": "math-snapped.html",
        "section": "Math"
      },
      "math-move_toward": {
        "name": "Math.move_toward",
        "sig": "Math.move_toward(from, to, delta) -> fixed",
        "tip": "Step from one value toward another by at most delta.",
        "kind": "namespace-method",
        "page": "math-move_toward.html",
        "section": "Math"
      },
      "math-smoothstep": {
        "name": "Math.smoothstep",
        "sig": "Math.smoothstep(e0, e1, x) -> fixed",
        "tip": "A smooth 0..1 ramp between two edges.",
        "kind": "namespace-method",
        "page": "math-smoothstep.html",
        "section": "Math"
      },
      "math-atan2": {
        "name": "Math.atan2",
        "sig": "Math.atan2(y, x) -> fixed",
        "tip": "The angle of the vector (x, y), in radians.",
        "kind": "namespace-method",
        "page": "math-atan2.html",
        "section": "Math"
      },
      "math-asin": {
        "name": "Math.asin",
        "sig": "Math.asin(x) -> fixed",
        "tip": "The arcsine of a value, in radians.",
        "kind": "namespace-method",
        "page": "math-asin.html",
        "section": "Math"
      },
      "math-acos": {
        "name": "Math.acos",
        "sig": "Math.acos(x) -> fixed",
        "tip": "The arccosine of a value, in radians.",
        "kind": "namespace-method",
        "page": "math-acos.html",
        "section": "Math"
      },
      "math-exp": {
        "name": "Math.exp",
        "sig": "Math.exp(x) -> fixed",
        "tip": "e raised to the power x.",
        "kind": "namespace-method",
        "page": "math-exp.html",
        "section": "Math"
      },
      "math-log": {
        "name": "Math.log",
        "sig": "Math.log(x) -> fixed",
        "tip": "The natural logarithm of x.",
        "kind": "namespace-method",
        "page": "math-log.html",
        "section": "Math"
      },
      "math-pow": {
        "name": "Math.pow",
        "sig": "Math.pow(base, exp) -> fixed",
        "tip": "base raised to a fixed exponent.",
        "kind": "namespace-method",
        "page": "math-pow.html",
        "section": "Math"
      },
      "memory-bytes": {
        "name": "Memory.bytes",
        "sig": "Memory.bytes(n) -> pointer",
        "tip": "Allocate n bytes.",
        "kind": "namespace-method",
        "page": "memory-bytes.html",
        "section": "Memory"
      },
      "memory-words": {
        "name": "Memory.words",
        "sig": "Memory.words(n) -> words",
        "tip": "Allocate n 32-bit words.",
        "kind": "namespace-method",
        "page": "memory-words.html",
        "section": "Memory"
      },
      "memory-copy": {
        "name": "Memory.copy",
        "sig": "Memory.copy(dst, src, n) -> void",
        "tip": "Copy n bytes between buffers.",
        "kind": "namespace-method",
        "page": "memory-copy.html",
        "section": "Memory"
      },
      "memory-fill": {
        "name": "Memory.fill",
        "sig": "Memory.fill(buf, value, n) -> void",
        "tip": "Set n bytes to a value.",
        "kind": "namespace-method",
        "page": "memory-fill.html",
        "section": "Memory"
      },
      "memory-peek": {
        "name": "Memory.peek",
        "sig": "Memory.peek(buf, i) -> int",
        "tip": "Read one byte.",
        "kind": "namespace-method",
        "page": "memory-peek.html",
        "section": "Memory"
      },
      "memory-poke": {
        "name": "Memory.poke",
        "sig": "Memory.poke(buf, i, value) -> void",
        "tip": "Write one byte.",
        "kind": "namespace-method",
        "page": "memory-poke.html",
        "section": "Memory"
      },
      "mime-of": {
        "name": "Mime.of",
        "sig": "Mime.of(path) -> string",
        "tip": "MIME type from a file extension.",
        "kind": "namespace-method",
        "page": "mime-of.html",
        "section": "Mime"
      },
      "mime-sniff": {
        "name": "Mime.sniff",
        "sig": "Mime.sniff(path) -> string",
        "tip": "MIME type refined by magic bytes.",
        "kind": "namespace-method",
        "page": "mime-sniff.html",
        "section": "Mime"
      },
      "network-send": {
        "name": "Network.send",
        "sig": "Network.send(peer, buf, len) -> void",
        "tip": "Put a datagram on the wire.",
        "kind": "namespace-method",
        "page": "network-send.html",
        "section": "Network"
      },
      "network-poll": {
        "name": "Network.poll",
        "sig": "Network.poll(buf, cap) -> int",
        "tip": "Read an inbound datagram.",
        "kind": "namespace-method",
        "page": "network-poll.html",
        "section": "Network"
      },
      "network-serialize": {
        "name": "Network.serialize",
        "sig": "Network.serialize(entity, buf) -> int",
        "tip": "Serialize an entity's synced state.",
        "kind": "namespace-method",
        "page": "network-serialize.html",
        "section": "Network"
      },
      "network-apply": {
        "name": "Network.apply",
        "sig": "Network.apply(entity, buf) -> int",
        "tip": "Apply serialized state to an entity.",
        "kind": "namespace-method",
        "page": "network-apply.html",
        "section": "Network"
      },
      "network-owner": {
        "name": "Network.owner",
        "sig": "Network.owner(entity) -> int",
        "tip": "The peer that owns an entity.",
        "kind": "namespace-method",
        "page": "network-owner.html",
        "section": "Network"
      },
      "network-set_owner": {
        "name": "Network.set_owner",
        "sig": "Network.set_owner(entity, peer) -> void",
        "tip": "Assign ownership of an entity.",
        "kind": "namespace-method",
        "page": "network-set_owner.html",
        "section": "Network"
      },
      "network-is_server": {
        "name": "Network.is_server",
        "sig": "Network.is_server() -> bool",
        "tip": "Is this peer the server?",
        "kind": "namespace-method",
        "page": "network-is_server.html",
        "section": "Network"
      },
      "network-is_owner": {
        "name": "Network.is_owner",
        "sig": "Network.is_owner(entity) -> bool",
        "tip": "Does this peer own the entity?",
        "kind": "namespace-method",
        "page": "network-is_owner.html",
        "section": "Network"
      },
      "network-local_id": {
        "name": "Network.local_id",
        "sig": "Network.local_id() -> int",
        "tip": "This peer's own id.",
        "kind": "namespace-method",
        "page": "network-local_id.html",
        "section": "Network"
      },
      "noise-value2": {
        "name": "Noise.value2",
        "sig": "Noise.value2(x, y, seed) -> fixed",
        "tip": "2D value (lattice) noise, deterministic, in [-1, 1].",
        "kind": "namespace-method",
        "page": "noise-value2.html",
        "section": "Noise"
      },
      "noise-perlin2": {
        "name": "Noise.perlin2",
        "sig": "Noise.perlin2(x, y, seed) -> fixed",
        "tip": "2D Perlin gradient noise, deterministic, in [-1, 1].",
        "kind": "namespace-method",
        "page": "noise-perlin2.html",
        "section": "Noise"
      },
      "noise-simplex2": {
        "name": "Noise.simplex2",
        "sig": "Noise.simplex2(x, y, seed) -> fixed",
        "tip": "2D simplex noise, the organic default, in [-1, 1].",
        "kind": "namespace-method",
        "page": "noise-simplex2.html",
        "section": "Noise"
      },
      "noise-fbm2": {
        "name": "Noise.fbm2",
        "sig": "Noise.fbm2(x, y, seed, octaves) -> fixed",
        "tip": "Fractal Brownian motion — octaves of simplex, in [-1, 1].",
        "kind": "namespace-method",
        "page": "noise-fbm2.html",
        "section": "Noise"
      },
      "noise-cellular2": {
        "name": "Noise.cellular2",
        "sig": "Noise.cellular2(x, y, seed) -> fixed",
        "tip": "Worley (cellular) F1 distance to the nearest cell point.",
        "kind": "namespace-method",
        "page": "noise-cellular2.html",
        "section": "Noise"
      },
      "noise-cellular2_id": {
        "name": "Noise.cellular2_id",
        "sig": "Noise.cellular2_id(x, y, seed) -> int",
        "tip": "The id of the nearest Worley cell — stable per cell.",
        "kind": "namespace-method",
        "page": "noise-cellular2_id.html",
        "section": "Noise"
      },
      "noise-unit": {
        "name": "Noise.unit",
        "sig": "Noise.unit(n) -> fixed",
        "tip": "Remap a [-1,1] noise sample to [0,1].",
        "kind": "namespace-method",
        "page": "noise-unit.html",
        "section": "Noise"
      },
      "os-args": {
        "name": "Os.args",
        "sig": "Os.args() -> []string",
        "tip": "Every command-line argument, as a list.",
        "kind": "namespace-method",
        "page": "os-args.html",
        "section": "Os"
      },
      "os-arg_count": {
        "name": "Os.arg_count",
        "sig": "Os.arg_count() -> int",
        "tip": "How many command-line arguments there are.",
        "kind": "namespace-method",
        "page": "os-arg_count.html",
        "section": "Os"
      },
      "os-arg": {
        "name": "Os.arg",
        "sig": "Os.arg(i) -> string",
        "tip": "The i-th command-line argument.",
        "kind": "namespace-method",
        "page": "os-arg.html",
        "section": "Os"
      },
      "os-env": {
        "name": "Os.env",
        "sig": "Os.env(name) -> string",
        "tip": "Read an environment variable (null if unset).",
        "kind": "namespace-method",
        "page": "os-env.html",
        "section": "Os"
      },
      "os-env_or": {
        "name": "Os.env_or",
        "sig": "Os.env_or(name, fallback) -> string",
        "tip": "Read an environment variable, or a fallback.",
        "kind": "namespace-method",
        "page": "os-env_or.html",
        "section": "Os"
      },
      "os-has_env": {
        "name": "Os.has_env",
        "sig": "Os.has_env(name) -> bool",
        "tip": "Is an environment variable set?",
        "kind": "namespace-method",
        "page": "os-has_env.html",
        "section": "Os"
      },
      "os-set_env": {
        "name": "Os.set_env",
        "sig": "Os.set_env(name, value) -> bool",
        "tip": "Set an environment variable.",
        "kind": "namespace-method",
        "page": "os-set_env.html",
        "section": "Os"
      },
      "os-unset_env": {
        "name": "Os.unset_env",
        "sig": "Os.unset_env(name) -> bool",
        "tip": "Remove an environment variable.",
        "kind": "namespace-method",
        "page": "os-unset_env.html",
        "section": "Os"
      },
      "os-exit": {
        "name": "Os.exit",
        "sig": "Os.exit(code)",
        "tip": "Terminate the process with a status code.",
        "kind": "namespace-method",
        "page": "os-exit.html",
        "section": "Os"
      },
      "os-platform": {
        "name": "Os.platform",
        "sig": "Os.platform() -> string",
        "tip": "The host platform id.",
        "kind": "namespace-method",
        "page": "os-platform.html",
        "section": "Os"
      },
      "os-arch": {
        "name": "Os.arch",
        "sig": "Os.arch() -> string",
        "tip": "The host CPU architecture.",
        "kind": "namespace-method",
        "page": "os-arch.html",
        "section": "Os"
      },
      "os-stdout_write": {
        "name": "Os.stdout_write",
        "sig": "Os.stdout_write(s)",
        "tip": "Write a string to standard output.",
        "kind": "namespace-method",
        "page": "os-stdout_write.html",
        "section": "Os"
      },
      "os-stderr_write": {
        "name": "Os.stderr_write",
        "sig": "Os.stderr_write(s)",
        "tip": "Write a string to standard error.",
        "kind": "namespace-method",
        "page": "os-stderr_write.html",
        "section": "Os"
      },
      "os-save_dir": {
        "name": "Os.save_dir",
        "sig": "Os.save_dir(app) -> string",
        "tip": "Per-user save directory for an app.",
        "kind": "namespace-method",
        "page": "os-save_dir.html",
        "section": "Os"
      },
      "os-config_dir": {
        "name": "Os.config_dir",
        "sig": "Os.config_dir(app) -> string",
        "tip": "Per-user config directory for an app.",
        "kind": "namespace-method",
        "page": "os-config_dir.html",
        "section": "Os"
      },
      "os-cache_dir": {
        "name": "Os.cache_dir",
        "sig": "Os.cache_dir(app) -> string",
        "tip": "Per-user cache directory for an app.",
        "kind": "namespace-method",
        "page": "os-cache_dir.html",
        "section": "Os"
      },
      "os-temp_dir": {
        "name": "Os.temp_dir",
        "sig": "Os.temp_dir() -> string",
        "tip": "The system temporary directory.",
        "kind": "namespace-method",
        "page": "os-temp_dir.html",
        "section": "Os"
      },
      "os-pid": {
        "name": "Os.pid",
        "sig": "Os.pid() -> int",
        "tip": "This process's id.",
        "kind": "namespace-method",
        "page": "os-pid.html",
        "section": "Os"
      },
      "path-join": {
        "name": "Path.join",
        "sig": "Path.join(a, b) -> string",
        "tip": "Join two path segments with the separator.",
        "kind": "namespace-method",
        "page": "path-join.html",
        "section": "Path"
      },
      "path-dir": {
        "name": "Path.dir",
        "sig": "Path.dir(p) -> string",
        "tip": "The directory part of a path.",
        "kind": "namespace-method",
        "page": "path-dir.html",
        "section": "Path"
      },
      "path-base": {
        "name": "Path.base",
        "sig": "Path.base(p) -> string",
        "tip": "The final component of a path.",
        "kind": "namespace-method",
        "page": "path-base.html",
        "section": "Path"
      },
      "path-ext": {
        "name": "Path.ext",
        "sig": "Path.ext(p) -> string",
        "tip": "The file extension, including the dot.",
        "kind": "namespace-method",
        "page": "path-ext.html",
        "section": "Path"
      },
      "path-stem": {
        "name": "Path.stem",
        "sig": "Path.stem(p) -> string",
        "tip": "The final component without its extension.",
        "kind": "namespace-method",
        "page": "path-stem.html",
        "section": "Path"
      },
      "path-normalize": {
        "name": "Path.normalize",
        "sig": "Path.normalize(p) -> string",
        "tip": "Collapse . / .. / duplicate separators.",
        "kind": "namespace-method",
        "page": "path-normalize.html",
        "section": "Path"
      },
      "save-write": {
        "name": "Save.write",
        "sig": "Save.write() -> void",
        "tip": "Save a snapshot of the world.",
        "kind": "namespace-method",
        "page": "save-write.html",
        "section": "Save"
      },
      "save-read": {
        "name": "Save.read",
        "sig": "Save.read() -> bool",
        "tip": "Restore the saved snapshot.",
        "kind": "namespace-method",
        "page": "save-read.html",
        "section": "Save"
      },
      "system-run": {
        "name": "System.run",
        "sig": "System.run(command) -> int",
        "tip": "Run a shell command.",
        "kind": "namespace-method",
        "page": "system-run.html",
        "section": "System"
      },
      "system-read_char": {
        "name": "System.read_char",
        "sig": "System.read_char() -> int",
        "tip": "Read one byte from standard input.",
        "kind": "namespace-method",
        "page": "system-read_char.html",
        "section": "System"
      },
      "system-file_open": {
        "name": "System.file_open",
        "sig": "System.file_open(path, mode) -> pointer",
        "tip": "Open a file.",
        "kind": "namespace-method",
        "page": "system-file_open.html",
        "section": "System"
      },
      "system-file_read": {
        "name": "System.file_read",
        "sig": "System.file_read(file, buf, n) -> int",
        "tip": "Read bytes from a file.",
        "kind": "namespace-method",
        "page": "system-file_read.html",
        "section": "System"
      },
      "system-file_write": {
        "name": "System.file_write",
        "sig": "System.file_write(file, buf, n) -> int",
        "tip": "Write bytes to a file.",
        "kind": "namespace-method",
        "page": "system-file_write.html",
        "section": "System"
      },
      "system-file_seek": {
        "name": "System.file_seek",
        "sig": "System.file_seek(file, offset, whence) -> int",
        "tip": "Move a file's read/write position.",
        "kind": "namespace-method",
        "page": "system-file_seek.html",
        "section": "System"
      },
      "system-file_tell": {
        "name": "System.file_tell",
        "sig": "System.file_tell(file) -> int",
        "tip": "The current file position.",
        "kind": "namespace-method",
        "page": "system-file_tell.html",
        "section": "System"
      },
      "system-file_close": {
        "name": "System.file_close",
        "sig": "System.file_close(file) -> void",
        "tip": "Close a file.",
        "kind": "namespace-method",
        "page": "system-file_close.html",
        "section": "System"
      },
      "text-length": {
        "name": "Text.length",
        "sig": "Text.length(s) -> int",
        "tip": "The number of bytes in a string.",
        "kind": "namespace-method",
        "page": "text-length.html",
        "section": "Text"
      },
      "text-char_at": {
        "name": "Text.char_at",
        "sig": "Text.char_at(s, i) -> int",
        "tip": "The byte value at an index, 0..255.",
        "kind": "namespace-method",
        "page": "text-char_at.html",
        "section": "Text"
      },
      "text-slice": {
        "name": "Text.slice",
        "sig": "Text.slice(s, a, b) -> string",
        "tip": "A substring covering bytes [a, b).",
        "kind": "namespace-method",
        "page": "text-slice.html",
        "section": "Text"
      },
      "text-starts_with": {
        "name": "Text.starts_with",
        "sig": "Text.starts_with(s, prefix) -> bool",
        "tip": "Whether a string begins with a given prefix.",
        "kind": "namespace-method",
        "page": "text-starts_with.html",
        "section": "Text"
      },
      "text-ends_with": {
        "name": "Text.ends_with",
        "sig": "Text.ends_with(s, suffix) -> bool",
        "tip": "Whether a string ends with a given suffix.",
        "kind": "namespace-method",
        "page": "text-ends_with.html",
        "section": "Text"
      },
      "text-contains": {
        "name": "Text.contains",
        "sig": "Text.contains(s, sub) -> bool",
        "tip": "Whether a substring appears anywhere in a string.",
        "kind": "namespace-method",
        "page": "text-contains.html",
        "section": "Text"
      },
      "text-index_of": {
        "name": "Text.index_of",
        "sig": "Text.index_of(s, sub) -> int",
        "tip": "The byte index of a substring, or -1 if absent.",
        "kind": "namespace-method",
        "page": "text-index_of.html",
        "section": "Text"
      },
      "text-equals": {
        "name": "Text.equals",
        "sig": "Text.equals(a, b) -> bool",
        "tip": "Whether two strings have identical bytes.",
        "kind": "namespace-method",
        "page": "text-equals.html",
        "section": "Text"
      },
      "text-concat": {
        "name": "Text.concat",
        "sig": "Text.concat(a, b) -> string",
        "tip": "Join two strings into a new one.",
        "kind": "namespace-method",
        "page": "text-concat.html",
        "section": "Text"
      },
      "text-to_int": {
        "name": "Text.to_int",
        "sig": "Text.to_int(s) -> int",
        "tip": "Parse a leading integer from a string.",
        "kind": "namespace-method",
        "page": "text-to_int.html",
        "section": "Text"
      },
      "text-from_int": {
        "name": "Text.from_int",
        "sig": "Text.from_int(n) -> string",
        "tip": "Render an integer as a string.",
        "kind": "namespace-method",
        "page": "text-from_int.html",
        "section": "Text"
      },
      "text-upper": {
        "name": "Text.upper",
        "sig": "Text.upper(s) -> string",
        "tip": "An uppercased copy of a string.",
        "kind": "namespace-method",
        "page": "text-upper.html",
        "section": "Text"
      },
      "text-lower": {
        "name": "Text.lower",
        "sig": "Text.lower(s) -> string",
        "tip": "A lowercased copy of a string.",
        "kind": "namespace-method",
        "page": "text-lower.html",
        "section": "Text"
      },
      "text-trim": {
        "name": "Text.trim",
        "sig": "Text.trim(s) -> string",
        "tip": "A copy with surrounding whitespace removed.",
        "kind": "namespace-method",
        "page": "text-trim.html",
        "section": "Text"
      },
      "text-repeat": {
        "name": "Text.repeat",
        "sig": "Text.repeat(s, n) -> string",
        "tip": "A string repeated n times.",
        "kind": "namespace-method",
        "page": "text-repeat.html",
        "section": "Text"
      },
      "text-pad_left": {
        "name": "Text.pad_left",
        "sig": "Text.pad_left(s, width) -> string",
        "tip": "Pad with spaces on the left to a width.",
        "kind": "namespace-method",
        "page": "text-pad_left.html",
        "section": "Text"
      },
      "text-pad_right": {
        "name": "Text.pad_right",
        "sig": "Text.pad_right(s, width) -> string",
        "tip": "Pad with spaces on the right to a width.",
        "kind": "namespace-method",
        "page": "text-pad_right.html",
        "section": "Text"
      },
      "text-split": {
        "name": "Text.split",
        "sig": "Text.split(s, sep) -> []string",
        "tip": "Split a string on a separator into a list.",
        "kind": "namespace-method",
        "page": "text-split.html",
        "section": "Text"
      },
      "text-join": {
        "name": "Text.join",
        "sig": "Text.join(parts, sep) -> string",
        "tip": "Join a list of strings with a separator.",
        "kind": "namespace-method",
        "page": "text-join.html",
        "section": "Text"
      },
      "text-replace": {
        "name": "Text.replace",
        "sig": "Text.replace(s, from, to) -> string",
        "tip": "Replace every occurrence of a substring.",
        "kind": "namespace-method",
        "page": "text-replace.html",
        "section": "Text"
      },
      "time-frame": {
        "name": "Time.frame",
        "sig": "Time.frame() -> int",
        "tip": "The number of frames elapsed since start.",
        "kind": "namespace-method",
        "page": "time-frame.html",
        "section": "Time"
      },
      "time-delta": {
        "name": "Time.delta",
        "sig": "Time.delta() -> fixed",
        "tip": "Seconds per frame (a fixed 1/60).",
        "kind": "namespace-method",
        "page": "time-delta.html",
        "section": "Time"
      },
      "time-elapsed": {
        "name": "Time.elapsed",
        "sig": "Time.elapsed() -> fixed",
        "tip": "Seconds since start (deterministic).",
        "kind": "namespace-method",
        "page": "time-elapsed.html",
        "section": "Time"
      },
      "time-now": {
        "name": "Time.now",
        "sig": "Time.now() -> int",
        "tip": "Wall-clock seconds (non-deterministic).",
        "kind": "namespace-method",
        "page": "time-now.html",
        "section": "Time"
      },
      "time-since": {
        "name": "Time.since",
        "sig": "Time.since(past) -> int",
        "tip": "Seconds elapsed from a past instant to now (non-deterministic).",
        "kind": "namespace-method",
        "page": "time-since.html",
        "section": "Time"
      },
      "unicode-len": {
        "name": "Unicode.len",
        "sig": "Unicode.len(s) -> int",
        "tip": "Number of code points in a string (not bytes).",
        "kind": "namespace-method",
        "page": "unicode-len.html",
        "section": "Unicode"
      },
      "unicode-byte_len": {
        "name": "Unicode.byte_len",
        "sig": "Unicode.byte_len(s) -> int",
        "tip": "Number of bytes in a string.",
        "kind": "namespace-method",
        "page": "unicode-byte_len.html",
        "section": "Unicode"
      },
      "unicode-is_valid_utf8": {
        "name": "Unicode.is_valid_utf8",
        "sig": "Unicode.is_valid_utf8(s) -> bool",
        "tip": "Is a string well-formed UTF-8?",
        "kind": "namespace-method",
        "page": "unicode-is_valid_utf8.html",
        "section": "Unicode"
      },
      "unicode-char_at": {
        "name": "Unicode.char_at",
        "sig": "Unicode.char_at(s, i) -> int",
        "tip": "The i-th code point of a string.",
        "kind": "namespace-method",
        "page": "unicode-char_at.html",
        "section": "Unicode"
      },
      "unicode-chars": {
        "name": "Unicode.chars",
        "sig": "Unicode.chars(s) -> []int",
        "tip": "Every code point of a string, in order.",
        "kind": "namespace-method",
        "page": "unicode-chars.html",
        "section": "Unicode"
      },
      "unicode-upper": {
        "name": "Unicode.upper",
        "sig": "Unicode.upper(s) -> string",
        "tip": "Uppercase a string.",
        "kind": "namespace-method",
        "page": "unicode-upper.html",
        "section": "Unicode"
      },
      "unicode-lower": {
        "name": "Unicode.lower",
        "sig": "Unicode.lower(s) -> string",
        "tip": "Lowercase a string.",
        "kind": "namespace-method",
        "page": "unicode-lower.html",
        "section": "Unicode"
      },
      "unicode-truncate": {
        "name": "Unicode.truncate",
        "sig": "Unicode.truncate(s, n) -> string",
        "tip": "First n code points of a string.",
        "kind": "namespace-method",
        "page": "unicode-truncate.html",
        "section": "Unicode"
      },
      "unicode-grapheme_len": {
        "name": "Unicode.grapheme_len",
        "sig": "Unicode.grapheme_len(s) -> int",
        "tip": "Number of user-perceived characters.",
        "kind": "namespace-method",
        "page": "unicode-grapheme_len.html",
        "section": "Unicode"
      },
      "uuid-new": {
        "name": "Uuid.new",
        "sig": "Uuid.new() -> string",
        "tip": "A new random (v4) UUID as a canonical 36-char string.",
        "kind": "namespace-method",
        "page": "uuid-new.html",
        "section": "Uuid"
      },
      "uuid-v4": {
        "name": "Uuid.v4",
        "sig": "Uuid.v4() -> string",
        "tip": "Explicit alias for Uuid.new — a random (v4) UUID.",
        "kind": "namespace-method",
        "page": "uuid-v4.html",
        "section": "Uuid"
      },
      "uuid-new_v7": {
        "name": "Uuid.new_v7",
        "sig": "Uuid.new_v7() -> string",
        "tip": "A new time-ordered (v7) UUID; sorts by creation time.",
        "kind": "namespace-method",
        "page": "uuid-new_v7.html",
        "section": "Uuid"
      },
      "uuid-v7": {
        "name": "Uuid.v7",
        "sig": "Uuid.v7() -> string",
        "tip": "Explicit alias for Uuid.new_v7 — a time-ordered UUID.",
        "kind": "namespace-method",
        "page": "uuid-v7.html",
        "section": "Uuid"
      },
      "uuid-parse": {
        "name": "Uuid.parse",
        "sig": "Uuid.parse(s) -> string",
        "tip": "Normalise an untrusted string to a lowercase UUID, or the nil UUID.",
        "kind": "namespace-method",
        "page": "uuid-parse.html",
        "section": "Uuid"
      },
      "uuid-is_valid": {
        "name": "Uuid.is_valid",
        "sig": "Uuid.is_valid(s) -> bool",
        "tip": "Is s a well-formed UUID string?",
        "kind": "namespace-method",
        "page": "uuid-is_valid.html",
        "section": "Uuid"
      },
      "uuid-to_text": {
        "name": "Uuid.to_text",
        "sig": "Uuid.to_text(id) -> string",
        "tip": "The canonical text form of a UUID.",
        "kind": "namespace-method",
        "page": "uuid-to_text.html",
        "section": "Uuid"
      },
      "uuid-equals": {
        "name": "Uuid.equals",
        "sig": "Uuid.equals(a, b) -> bool",
        "tip": "Case-insensitive UUID equality.",
        "kind": "namespace-method",
        "page": "uuid-equals.html",
        "section": "Uuid"
      },
      "uuid-nil": {
        "name": "Uuid.nil",
        "sig": "Uuid.nil() -> string",
        "tip": "The all-zero UUID.",
        "kind": "namespace-method",
        "page": "uuid-nil.html",
        "section": "Uuid"
      },
      "world-get": {
        "name": "World.get",
        "sig": "World.get(prop_id, field_id, entity) -> int",
        "tip": "Read a component field by id.",
        "kind": "namespace-method",
        "page": "world-get.html",
        "section": "World"
      },
      "world-set": {
        "name": "World.set",
        "sig": "World.set(prop_id, field_id, entity, value) -> void",
        "tip": "Write a component field by id.",
        "kind": "namespace-method",
        "page": "world-set.html",
        "section": "World"
      },
      "world-has": {
        "name": "World.has",
        "sig": "World.has(entity, prop_id) -> int",
        "tip": "Does an entity have a component?",
        "kind": "namespace-method",
        "page": "world-has.html",
        "section": "World"
      },
      "world-count": {
        "name": "World.count",
        "sig": "World.count() -> int",
        "tip": "The number of live entities.",
        "kind": "namespace-method",
        "page": "world-count.html",
        "section": "World"
      },
      "world-size": {
        "name": "World.size",
        "sig": "World.size() -> int",
        "tip": "The serialized size of the world.",
        "kind": "namespace-method",
        "page": "world-size.html",
        "section": "World"
      },
      "world-spawn": {
        "name": "World.spawn",
        "sig": "World.spawn(model_id) -> entity",
        "tip": "Spawn an entity of a model by id.",
        "kind": "namespace-method",
        "page": "world-spawn.html",
        "section": "World"
      },
      "world-save": {
        "name": "World.save",
        "sig": "World.save(buf) -> int",
        "tip": "Serialize the world into a buffer.",
        "kind": "namespace-method",
        "page": "world-save.html",
        "section": "World"
      },
      "world-load": {
        "name": "World.load",
        "sig": "World.load(buf, len) -> void",
        "tip": "Restore the world from a buffer.",
        "kind": "namespace-method",
        "page": "world-load.html",
        "section": "World"
      },
      "world-prop_id": {
        "name": "World.prop_id",
        "sig": "World.prop_id(name) -> int",
        "tip": "Look up a component's id by name.",
        "kind": "namespace-method",
        "page": "world-prop_id.html",
        "section": "World"
      },
      "world-field_id": {
        "name": "World.field_id",
        "sig": "World.field_id(prop_id, name) -> int",
        "tip": "Look up a field's id by name.",
        "kind": "namespace-method",
        "page": "world-field_id.html",
        "section": "World"
      },
      "world-model_id": {
        "name": "World.model_id",
        "sig": "World.model_id(name) -> int",
        "tip": "Look up a model's id by name.",
        "kind": "namespace-method",
        "page": "world-model_id.html",
        "section": "World"
      },
      "world-kind": {
        "name": "World.kind",
        "sig": "World.kind(entity) -> int",
        "tip": "The model id of an entity.",
        "kind": "namespace-method",
        "page": "world-kind.html",
        "section": "World"
      },
      "world-register_prop": {
        "name": "World.register_prop",
        "sig": "World.register_prop(name, size) -> int",
        "tip": "Register a new component at runtime.",
        "kind": "namespace-method",
        "page": "world-register_prop.html",
        "section": "World"
      },
      "world-attach": {
        "name": "World.attach",
        "sig": "World.attach(entity, prop_id) -> void",
        "tip": "Attach a component to an entity at runtime.",
        "kind": "namespace-method",
        "page": "world-attach.html",
        "section": "World"
      },
      "world-detach": {
        "name": "World.detach",
        "sig": "World.detach(entity, prop_id) -> void",
        "tip": "Detach a component from an entity at runtime.",
        "kind": "namespace-method",
        "page": "world-detach.html",
        "section": "World"
      },
      "world-query_next": {
        "name": "World.query_next",
        "sig": "World.query_next(query_id, cursor) -> int",
        "tip": "Advance a reflective query.",
        "kind": "namespace-method",
        "page": "world-query_next.html",
        "section": "World"
      },
      "world-despawn": {
        "name": "World.despawn",
        "sig": "World.despawn(entity)",
        "tip": "Despawn an entity by id — runs its @OnDespawn hooks and frees the slot.",
        "kind": "namespace-method",
        "page": "world-despawn.html",
        "section": "World"
      },
      "audio-load": {
        "name": "Audio.load",
        "sig": "Audio.load(path) -> int",
        "tip": "Load a sound file into a handle.",
        "kind": "namespace-method",
        "page": "audio-load.html",
        "section": "Audio"
      },
      "audio-play": {
        "name": "Audio.play",
        "sig": "Audio.play(id) -> void",
        "tip": "Fire a one-shot sound.",
        "kind": "namespace-method",
        "page": "audio-play.html",
        "section": "Audio"
      },
      "audio-play_at": {
        "name": "Audio.play_at",
        "sig": "Audio.play_at(id, gain, pitch, pan) -> void",
        "tip": "Fire a one-shot with its own gain, pitch and stereo position.",
        "kind": "namespace-method",
        "page": "audio-play_at.html",
        "section": "Audio"
      },
      "audio-play_sound": {
        "name": "Audio.play_sound",
        "sig": "Audio.play_sound(id) -> void",
        "tip": "Fire a one-shot sound (alias of play).",
        "kind": "namespace-method",
        "page": "audio-play_sound.html",
        "section": "Audio"
      },
      "audio-play_music": {
        "name": "Audio.play_music",
        "sig": "Audio.play_music(id) -> void",
        "tip": "Loop a sound as background music.",
        "kind": "namespace-method",
        "page": "audio-play_music.html",
        "section": "Audio"
      },
      "audio-stop": {
        "name": "Audio.stop",
        "sig": "Audio.stop(id) -> void",
        "tip": "Stop one sound.",
        "kind": "namespace-method",
        "page": "audio-stop.html",
        "section": "Audio"
      },
      "audio-stop_music": {
        "name": "Audio.stop_music",
        "sig": "Audio.stop_music() -> void",
        "tip": "Stop the music channel.",
        "kind": "namespace-method",
        "page": "audio-stop_music.html",
        "section": "Audio"
      },
      "audio-stop_all": {
        "name": "Audio.stop_all",
        "sig": "Audio.stop_all() -> void",
        "tip": "Stop every sound.",
        "kind": "namespace-method",
        "page": "audio-stop_all.html",
        "section": "Audio"
      },
      "audio-volume": {
        "name": "Audio.volume",
        "sig": "Audio.volume(v) -> void",
        "tip": "Set the master volume.",
        "kind": "namespace-method",
        "page": "audio-volume.html",
        "section": "Audio"
      },
      "audio-pitch": {
        "name": "Audio.pitch",
        "sig": "Audio.pitch(v) -> void",
        "tip": "Set the playback rate / pitch.",
        "kind": "namespace-method",
        "page": "audio-pitch.html",
        "section": "Audio"
      },
      "audio-is_playing": {
        "name": "Audio.is_playing",
        "sig": "Audio.is_playing(id) -> bool",
        "tip": "Is this sound playing?",
        "kind": "namespace-method",
        "page": "audio-is_playing.html",
        "section": "Audio"
      },
      "audio-define": {
        "name": "Audio.define",
        "sig": "Audio.define(name: s, path: p) -> int",
        "tip": "Load a sound into the bank under a name.",
        "kind": "namespace-method",
        "page": "audio-define.html",
        "section": "Audio"
      },
      "audio-named": {
        "name": "Audio.named",
        "sig": "Audio.named(name: s) -> int",
        "tip": "The handle registered under a name, or 0.",
        "kind": "namespace-method",
        "page": "audio-named.html",
        "section": "Audio"
      },
      "random-range": {
        "name": "Random.range",
        "sig": "Random.range(low, high) -> int",
        "tip": "A random integer in the inclusive range [low, high].",
        "kind": "namespace-method",
        "page": "random-range.html",
        "section": "Random"
      },
      "random-chance": {
        "name": "Random.chance",
        "sig": "Random.chance(percent) -> bool",
        "tip": "Return true with the given percent probability.",
        "kind": "namespace-method",
        "page": "random-chance.html",
        "section": "Random"
      },
      "random-seed": {
        "name": "Random.seed",
        "sig": "Random.seed(value)",
        "tip": "Seed the random generator so runs are reproducible.",
        "kind": "namespace-method",
        "page": "random-seed.html",
        "section": "Random"
      },
      "random-value": {
        "name": "Random.value",
        "sig": "Random.value() -> fixed",
        "tip": "A random fixed value in [0, 1).",
        "kind": "namespace-method",
        "page": "random-value.html",
        "section": "Random"
      },
      "random-int": {
        "name": "Random.int",
        "sig": "Random.int(max) -> int",
        "tip": "A random integer in [0, max).",
        "kind": "namespace-method",
        "page": "random-int.html",
        "section": "Random"
      },
      "random-sign": {
        "name": "Random.sign",
        "sig": "Random.sign() -> int",
        "tip": "A random +1 or -1.",
        "kind": "namespace-method",
        "page": "random-sign.html",
        "section": "Random"
      },
      "random-weighted": {
        "name": "Random.weighted",
        "sig": "Random.weighted(weights: []int) -> int",
        "tip": "An index drawn in proportion to its weight.",
        "kind": "namespace-method",
        "page": "random-weighted.html",
        "section": "Random"
      },
      "vector-make": {
        "name": "Vector.make",
        "sig": "Vector.make(x, y) -> Vector",
        "tip": "Build a vector from x and y components.",
        "kind": "namespace-method",
        "page": "vector-make.html",
        "section": "Vector"
      },
      "vector-zero": {
        "name": "Vector.zero",
        "sig": "Vector.zero() -> Vector",
        "tip": "The zero vector, (0, 0).",
        "kind": "namespace-method",
        "page": "vector-zero.html",
        "section": "Vector"
      },
      "vector-x": {
        "name": "Vector.x",
        "sig": "Vector.x(v) -> fixed",
        "tip": "The x component of a vector.",
        "kind": "namespace-method",
        "page": "vector-x.html",
        "section": "Vector"
      },
      "vector-y": {
        "name": "Vector.y",
        "sig": "Vector.y(v) -> fixed",
        "tip": "The y component of a vector.",
        "kind": "namespace-method",
        "page": "vector-y.html",
        "section": "Vector"
      },
      "vector-add": {
        "name": "Vector.add",
        "sig": "Vector.add(a, b) -> Vector",
        "tip": "Component-wise sum a + b.",
        "kind": "namespace-method",
        "page": "vector-add.html",
        "section": "Vector"
      },
      "vector-sub": {
        "name": "Vector.sub",
        "sig": "Vector.sub(a, b) -> Vector",
        "tip": "Component-wise difference a - b.",
        "kind": "namespace-method",
        "page": "vector-sub.html",
        "section": "Vector"
      },
      "vector-scale": {
        "name": "Vector.scale",
        "sig": "Vector.scale(v, s) -> Vector",
        "tip": "Scale a vector by a scalar.",
        "kind": "namespace-method",
        "page": "vector-scale.html",
        "section": "Vector"
      },
      "vector-dot": {
        "name": "Vector.dot",
        "sig": "Vector.dot(a, b) -> fixed",
        "tip": "The dot product of two vectors.",
        "kind": "namespace-method",
        "page": "vector-dot.html",
        "section": "Vector"
      },
      "vector-length": {
        "name": "Vector.length",
        "sig": "Vector.length(v) -> fixed",
        "tip": "The length (magnitude) of a vector.",
        "kind": "namespace-method",
        "page": "vector-length.html",
        "section": "Vector"
      },
      "vector-distance": {
        "name": "Vector.distance",
        "sig": "Vector.distance(a, b) -> fixed",
        "tip": "The distance between two points.",
        "kind": "namespace-method",
        "page": "vector-distance.html",
        "section": "Vector"
      },
      "vector-normalize": {
        "name": "Vector.normalize",
        "sig": "Vector.normalize(v) -> Vector",
        "tip": "A unit vector in the same direction.",
        "kind": "namespace-method",
        "page": "vector-normalize.html",
        "section": "Vector"
      },
      "vector-lerp": {
        "name": "Vector.lerp",
        "sig": "Vector.lerp(a, b, t) -> Vector",
        "tip": "Linear interpolation between two vectors.",
        "kind": "namespace-method",
        "page": "vector-lerp.html",
        "section": "Vector"
      },
      "vector-rotate": {
        "name": "Vector.rotate",
        "sig": "Vector.rotate(v, angle) -> Vector",
        "tip": "Rotate a vector by an angle in radians.",
        "kind": "namespace-method",
        "page": "vector-rotate.html",
        "section": "Vector"
      },
      "vector-angle": {
        "name": "Vector.angle",
        "sig": "Vector.angle(v) -> fixed",
        "tip": "The angle of a vector in radians.",
        "kind": "namespace-method",
        "page": "vector-angle.html",
        "section": "Vector"
      },
      "vector-from_angle": {
        "name": "Vector.from_angle",
        "sig": "Vector.from_angle(a) -> Vector",
        "tip": "A unit vector pointing at an angle.",
        "kind": "namespace-method",
        "page": "vector-from_angle.html",
        "section": "Vector"
      },
      "http-get": {
        "name": "Http.get",
        "sig": "Http.get(url) -> int",
        "tip": "Start an async GET request.",
        "kind": "namespace-method",
        "page": "http-get.html",
        "section": "Http"
      },
      "http-post": {
        "name": "Http.post",
        "sig": "Http.post(url, body) -> int",
        "tip": "Start an async POST with a body.",
        "kind": "namespace-method",
        "page": "http-post.html",
        "section": "Http"
      },
      "http-request": {
        "name": "Http.request",
        "sig": "Http.request(method, url, body) -> int",
        "tip": "Start a request with any method.",
        "kind": "namespace-method",
        "page": "http-request.html",
        "section": "Http"
      },
      "http-open": {
        "name": "Http.open",
        "sig": "Http.open(method, url) -> int",
        "tip": "Open a request to configure before sending.",
        "kind": "namespace-method",
        "page": "http-open.html",
        "section": "Http"
      },
      "http-set": {
        "name": "Http.set",
        "sig": "Http.set(handle, name, value) -> void",
        "tip": "Set a request header before sending.",
        "kind": "namespace-method",
        "page": "http-set.html",
        "section": "Http"
      },
      "http-body": {
        "name": "Http.body",
        "sig": "Http.body(handle, body) -> void",
        "tip": "Set a string request body.",
        "kind": "namespace-method",
        "page": "http-body.html",
        "section": "Http"
      },
      "http-body_bytes": {
        "name": "Http.body_bytes",
        "sig": "Http.body_bytes(handle, bytes, len) -> void",
        "tip": "Set a raw byte request body.",
        "kind": "namespace-method",
        "page": "http-body_bytes.html",
        "section": "Http"
      },
      "http-send": {
        "name": "Http.send",
        "sig": "Http.send(handle) -> void",
        "tip": "Dispatch an opened request.",
        "kind": "namespace-method",
        "page": "http-send.html",
        "section": "Http"
      },
      "http-poll": {
        "name": "Http.poll",
        "sig": "Http.poll(handle) -> int",
        "tip": "Poll a request; -1 pending, 0 error, else status.",
        "kind": "namespace-method",
        "page": "http-poll.html",
        "section": "Http"
      },
      "http-status": {
        "name": "Http.status",
        "sig": "Http.status(handle) -> int",
        "tip": "The response HTTP status code.",
        "kind": "namespace-method",
        "page": "http-status.html",
        "section": "Http"
      },
      "http-ok": {
        "name": "Http.ok",
        "sig": "Http.ok(handle) -> bool",
        "tip": "Was the response status 2xx?",
        "kind": "namespace-method",
        "page": "http-ok.html",
        "section": "Http"
      },
      "http-text": {
        "name": "Http.text",
        "sig": "Http.text(handle) -> str",
        "tip": "The response body as text.",
        "kind": "namespace-method",
        "page": "http-text.html",
        "section": "Http"
      },
      "http-body_len": {
        "name": "Http.body_len",
        "sig": "Http.body_len(handle) -> int",
        "tip": "The response body length in bytes.",
        "kind": "namespace-method",
        "page": "http-body_len.html",
        "section": "Http"
      },
      "http-header": {
        "name": "Http.header",
        "sig": "Http.header(handle, name) -> str",
        "tip": "A response header value (case-insensitive).",
        "kind": "namespace-method",
        "page": "http-header.html",
        "section": "Http"
      },
      "http-free": {
        "name": "Http.free",
        "sig": "Http.free(handle) -> void",
        "tip": "Release a request's resources.",
        "kind": "namespace-method",
        "page": "http-free.html",
        "section": "Http"
      },
      "http-parse": {
        "name": "Http.parse",
        "sig": "Http.parse(bytes, len) -> int",
        "tip": "Parse a raw HTTP response into a handle.",
        "kind": "namespace-method",
        "page": "http-parse.html",
        "section": "Http"
      },
      "http-save_to": {
        "name": "Http.save_to",
        "sig": "Http.save_to(handle, path) -> void",
        "tip": "Stream the response body to a file.",
        "kind": "namespace-method",
        "page": "http-save_to.html",
        "section": "Http"
      },
      "http-received": {
        "name": "Http.received",
        "sig": "Http.received(handle) -> int",
        "tip": "Body bytes received so far.",
        "kind": "namespace-method",
        "page": "http-received.html",
        "section": "Http"
      },
      "http-expected": {
        "name": "Http.expected",
        "sig": "Http.expected(handle) -> int",
        "tip": "The body length the server announced, or -1.",
        "kind": "namespace-method",
        "page": "http-expected.html",
        "section": "Http"
      },
      "ivec2-make": {
        "name": "IVec2.make",
        "sig": "IVec2.make(x, y) -> IVec2",
        "tip": "Build an integer vector from x and y components.",
        "kind": "namespace-method",
        "page": "ivec2-make.html",
        "section": "IVec2"
      },
      "ivec2-zero": {
        "name": "IVec2.zero",
        "sig": "IVec2.zero() -> IVec2",
        "tip": "The origin cell, (0, 0).",
        "kind": "namespace-method",
        "page": "ivec2-zero.html",
        "section": "IVec2"
      },
      "ivec2-x": {
        "name": "IVec2.x",
        "sig": "IVec2.x(v) -> int",
        "tip": "The x component of an integer vector.",
        "kind": "namespace-method",
        "page": "ivec2-x.html",
        "section": "IVec2"
      },
      "ivec2-y": {
        "name": "IVec2.y",
        "sig": "IVec2.y(v) -> int",
        "tip": "The y component of an integer vector.",
        "kind": "namespace-method",
        "page": "ivec2-y.html",
        "section": "IVec2"
      },
      "ivec2-add": {
        "name": "IVec2.add",
        "sig": "IVec2.add(a, b) -> IVec2",
        "tip": "Component-wise sum of two integer vectors.",
        "kind": "namespace-method",
        "page": "ivec2-add.html",
        "section": "IVec2"
      },
      "ivec2-sub": {
        "name": "IVec2.sub",
        "sig": "IVec2.sub(a, b) -> IVec2",
        "tip": "Component-wise difference of two integer vectors.",
        "kind": "namespace-method",
        "page": "ivec2-sub.html",
        "section": "IVec2"
      },
      "ivec2-scale": {
        "name": "IVec2.scale",
        "sig": "IVec2.scale(v, s) -> IVec2",
        "tip": "Multiply both components by an integer.",
        "kind": "namespace-method",
        "page": "ivec2-scale.html",
        "section": "IVec2"
      },
      "ivec2-dot": {
        "name": "IVec2.dot",
        "sig": "IVec2.dot(a, b) -> int",
        "tip": "The dot product ax*bx + ay*by.",
        "kind": "namespace-method",
        "page": "ivec2-dot.html",
        "section": "IVec2"
      },
      "ivec2-equal": {
        "name": "IVec2.equal",
        "sig": "IVec2.equal(a, b) -> bool",
        "tip": "True when both components match.",
        "kind": "namespace-method",
        "page": "ivec2-equal.html",
        "section": "IVec2"
      },
      "ivec2-manhattan": {
        "name": "IVec2.manhattan",
        "sig": "IVec2.manhattan(a, b) -> int",
        "tip": "Grid distance |dx| + |dy|.",
        "kind": "namespace-method",
        "page": "ivec2-manhattan.html",
        "section": "IVec2"
      },
      "ivec2-to_vector": {
        "name": "IVec2.to_vector",
        "sig": "IVec2.to_vector(v) -> Vector",
        "tip": "Widen to a fixed-point Vector.",
        "kind": "namespace-method",
        "page": "ivec2-to_vector.html",
        "section": "IVec2"
      },
      "ivec2-distance2": {
        "name": "IVec2.distance2",
        "sig": "IVec2.distance2(a, b) -> int",
        "tip": "The squared distance between two points.",
        "kind": "namespace-method",
        "page": "ivec2-distance2.html",
        "section": "IVec2"
      },
      "ivec2-within": {
        "name": "IVec2.within",
        "sig": "IVec2.within(a, b, radius) -> bool",
        "tip": "Are two points within a radius of each other?",
        "kind": "namespace-method",
        "page": "ivec2-within.html",
        "section": "IVec2"
      },
      "ivec2-heading": {
        "name": "IVec2.heading",
        "sig": "IVec2.heading(from, to) -> int",
        "tip": "The direction from one point to another, in degrees.",
        "kind": "namespace-method",
        "page": "ivec2-heading.html",
        "section": "IVec2"
      },
      "ivec2-along": {
        "name": "IVec2.along",
        "sig": "IVec2.along(origin, degrees, distance) -> IVec2",
        "tip": "The point a distance along a heading.",
        "kind": "namespace-method",
        "page": "ivec2-along.html",
        "section": "IVec2"
      },
      "ivec2-step": {
        "name": "IVec2.step",
        "sig": "IVec2.step(degrees) -> IVec2",
        "tip": "A -1/0/1 unit step along a heading.",
        "kind": "namespace-method",
        "page": "ivec2-step.html",
        "section": "IVec2"
      },
      "map-size": {
        "name": "Map.size",
        "sig": "Map.size(width, height)",
        "tip": "Set the tilemap dimensions in cells before filling rows.",
        "kind": "namespace-method",
        "page": "map-size.html",
        "section": "Map — tilemap"
      },
      "map-row": {
        "name": "Map.row",
        "sig": "Map.row(y, cells)",
        "tip": "Fill one row of the tilemap from a string of tile characters.",
        "kind": "namespace-method",
        "page": "map-row.html",
        "section": "Map — tilemap"
      },
      "map-tile": {
        "name": "Map.tile",
        "sig": "Map.tile(x, y) -> int",
        "tip": "Read the tile character at a cell (out-of-bounds reads answer '#').",
        "kind": "namespace-method",
        "page": "map-tile.html",
        "section": "Map — tilemap"
      },
      "map-get": {
        "name": "Map.get",
        "sig": "Map.get(x: tx, y: ty) -> int",
        "tip": "The glyph at a cell ('#' outside the map).",
        "kind": "namespace-method",
        "page": "map-get.html",
        "section": "Map — tilemap"
      },
      "map-set": {
        "name": "Map.set",
        "sig": "Map.set(x: tx, y: ty, glyph: g)",
        "tip": "Write one cell in place.",
        "kind": "namespace-method",
        "page": "map-set.html",
        "section": "Map — tilemap"
      },
      "map-fill": {
        "name": "Map.fill",
        "sig": "Map.fill(glyph: g)",
        "tip": "Every cell becomes the glyph.",
        "kind": "namespace-method",
        "page": "map-fill.html",
        "section": "Map — tilemap"
      },
      "map-rect": {
        "name": "Map.rect",
        "sig": "Map.rect(x: tx, y: ty, width: w, height: h, glyph: g)",
        "tip": "Fill a rectangle of cells.",
        "kind": "namespace-method",
        "page": "map-rect.html",
        "section": "Map — tilemap"
      },
      "map-border": {
        "name": "Map.border",
        "sig": "Map.border(glyph: g)",
        "tip": "The outermost ring of cells.",
        "kind": "namespace-method",
        "page": "map-border.html",
        "section": "Map — tilemap"
      },
      "map-random_cell": {
        "name": "Map.random_cell",
        "sig": "Map.random_cell(glyph: g) -> IVec2",
        "tip": "A random cell holding the glyph (seeded RNG).",
        "kind": "namespace-method",
        "page": "map-random_cell.html",
        "section": "Map — tilemap"
      },
      "map-is_solid": {
        "name": "Map.is_solid",
        "sig": "Map.is_solid(x: tx, y: ty) -> bool",
        "tip": "Is a cell solid, per the Solids config?",
        "kind": "namespace-method",
        "page": "map-is_solid.html",
        "section": "Map — tilemap"
      },
      "map-is_solid_at": {
        "name": "Map.is_solid_at",
        "sig": "Map.is_solid_at(x: px, y: py) -> bool",
        "tip": "Is the cell under a pixel position solid?",
        "kind": "namespace-method",
        "page": "map-is_solid_at.html",
        "section": "Map — tilemap"
      },
      "map-width": {
        "name": "Map.width",
        "sig": "Map.width() -> int",
        "tip": "The map's width in cells.",
        "kind": "namespace-method",
        "page": "map-width.html",
        "section": "Map — tilemap"
      },
      "map-height": {
        "name": "Map.height",
        "sig": "Map.height() -> int",
        "tip": "The map's height in cells.",
        "kind": "namespace-method",
        "page": "map-height.html",
        "section": "Map — tilemap"
      },
      "map-random_cell_far": {
        "name": "Map.random_cell_far",
        "sig": "Map.random_cell_far(glyph:, from:, min_tiles:) -> IVec2",
        "tip": "A random cell with the glyph, at least a distance from a point.",
        "kind": "namespace-method",
        "page": "map-random_cell_far.html",
        "section": "Map — tilemap"
      },
      "map-to_tile": {
        "name": "Map.to_tile",
        "sig": "Map.to_tile(pixel: IVec2) -> IVec2",
        "tip": "The tile under a pixel position.",
        "kind": "namespace-method",
        "page": "map-to_tile.html",
        "section": "Map — tilemap"
      },
      "rect-make": {
        "name": "Rect.make",
        "sig": "Rect.make(x, y, w, h) -> Rect",
        "tip": "Build a rectangle from a corner and a size.",
        "kind": "namespace-method",
        "page": "rect-make.html",
        "section": "Rect"
      },
      "rect-x": {
        "name": "Rect.x",
        "sig": "Rect.x(r) -> fixed",
        "tip": "The left edge (x position).",
        "kind": "namespace-method",
        "page": "rect-x.html",
        "section": "Rect"
      },
      "rect-y": {
        "name": "Rect.y",
        "sig": "Rect.y(r) -> fixed",
        "tip": "The top edge (y position).",
        "kind": "namespace-method",
        "page": "rect-y.html",
        "section": "Rect"
      },
      "rect-w": {
        "name": "Rect.w",
        "sig": "Rect.w(r) -> fixed",
        "tip": "The width.",
        "kind": "namespace-method",
        "page": "rect-w.html",
        "section": "Rect"
      },
      "rect-h": {
        "name": "Rect.h",
        "sig": "Rect.h(r) -> fixed",
        "tip": "The height.",
        "kind": "namespace-method",
        "page": "rect-h.html",
        "section": "Rect"
      },
      "rect-right": {
        "name": "Rect.right",
        "sig": "Rect.right(r) -> fixed",
        "tip": "The right edge, x + w.",
        "kind": "namespace-method",
        "page": "rect-right.html",
        "section": "Rect"
      },
      "rect-bottom": {
        "name": "Rect.bottom",
        "sig": "Rect.bottom(r) -> fixed",
        "tip": "The bottom edge, y + h.",
        "kind": "namespace-method",
        "page": "rect-bottom.html",
        "section": "Rect"
      },
      "rect-center": {
        "name": "Rect.center",
        "sig": "Rect.center(r) -> Vector",
        "tip": "The center point as a Vector.",
        "kind": "namespace-method",
        "page": "rect-center.html",
        "section": "Rect"
      },
      "rect-contains": {
        "name": "Rect.contains",
        "sig": "Rect.contains(r, px, py) -> bool",
        "tip": "True when the point is inside.",
        "kind": "namespace-method",
        "page": "rect-contains.html",
        "section": "Rect"
      },
      "rect-intersects": {
        "name": "Rect.intersects",
        "sig": "Rect.intersects(a, b) -> bool",
        "tip": "True when two rectangles overlap.",
        "kind": "namespace-method",
        "page": "rect-intersects.html",
        "section": "Rect"
      },
      "udp-open": {
        "name": "Udp.open",
        "sig": "Udp.open(port) -> int",
        "tip": "Open a socket on a port.",
        "kind": "namespace-method",
        "page": "udp-open.html",
        "section": "Udp"
      },
      "udp-port": {
        "name": "Udp.port",
        "sig": "Udp.port(socket) -> int",
        "tip": "The port a socket is bound to.",
        "kind": "namespace-method",
        "page": "udp-port.html",
        "section": "Udp"
      },
      "udp-send": {
        "name": "Udp.send",
        "sig": "Udp.send(socket, ip, port, bytes, len) -> int",
        "tip": "Send one datagram.",
        "kind": "namespace-method",
        "page": "udp-send.html",
        "section": "Udp"
      },
      "udp-recv": {
        "name": "Udp.recv",
        "sig": "Udp.recv(socket, bytes, cap) -> int",
        "tip": "Read the next waiting datagram.",
        "kind": "namespace-method",
        "page": "udp-recv.html",
        "section": "Udp"
      },
      "udp-from_ip": {
        "name": "Udp.from_ip",
        "sig": "Udp.from_ip(socket) -> int",
        "tip": "The sender of the last datagram read.",
        "kind": "namespace-method",
        "page": "udp-from_ip.html",
        "section": "Udp"
      },
      "udp-from_port": {
        "name": "Udp.from_port",
        "sig": "Udp.from_port(socket) -> int",
        "tip": "The sender's port.",
        "kind": "namespace-method",
        "page": "udp-from_port.html",
        "section": "Udp"
      },
      "udp-close": {
        "name": "Udp.close",
        "sig": "Udp.close(socket) -> void",
        "tip": "Close a socket.",
        "kind": "namespace-method",
        "page": "udp-close.html",
        "section": "Udp"
      },
      "udp-resolve": {
        "name": "Udp.resolve",
        "sig": "Udp.resolve(name) -> int",
        "tip": "Look a host name up.",
        "kind": "namespace-method",
        "page": "udp-resolve.html",
        "section": "Udp"
      },
      "udp-local_ip": {
        "name": "Udp.local_ip",
        "sig": "Udp.local_ip() -> int",
        "tip": "This machine's address.",
        "kind": "namespace-method",
        "page": "udp-local_ip.html",
        "section": "Udp"
      },
      "udp-ip": {
        "name": "Udp.ip",
        "sig": "Udp.ip(text) -> int",
        "tip": "Parse a dotted address.",
        "kind": "namespace-method",
        "page": "udp-ip.html",
        "section": "Udp"
      },
      "udp-ip_text": {
        "name": "Udp.ip_text",
        "sig": "Udp.ip_text(ip) -> string",
        "tip": "Format an address.",
        "kind": "namespace-method",
        "page": "udp-ip_text.html",
        "section": "Udp"
      },
      "bigint-from": {
        "name": "BigInt.from",
        "sig": "BigInt.from(value) -> BigInt",
        "tip": "Turn a plain int into a BigInt.",
        "kind": "namespace-method",
        "page": "bigint-from.html",
        "section": "BigInt"
      },
      "bigint-parse": {
        "name": "BigInt.parse",
        "sig": "BigInt.parse(text) -> BigInt",
        "tip": "Parse decimal text into a BigInt.",
        "kind": "namespace-method",
        "page": "bigint-parse.html",
        "section": "BigInt"
      },
      "bigint-add": {
        "name": "BigInt.add",
        "sig": "BigInt.add(a, b) -> BigInt",
        "tip": "Exact sum of two big integers.",
        "kind": "namespace-method",
        "page": "bigint-add.html",
        "section": "BigInt"
      },
      "bigint-sub": {
        "name": "BigInt.sub",
        "sig": "BigInt.sub(a, b) -> BigInt",
        "tip": "Exact difference of two big integers.",
        "kind": "namespace-method",
        "page": "bigint-sub.html",
        "section": "BigInt"
      },
      "bigint-mul": {
        "name": "BigInt.mul",
        "sig": "BigInt.mul(a, b) -> BigInt",
        "tip": "Exact product of two big integers.",
        "kind": "namespace-method",
        "page": "bigint-mul.html",
        "section": "BigInt"
      },
      "bigint-neg": {
        "name": "BigInt.neg",
        "sig": "BigInt.neg(a) -> BigInt",
        "tip": "Negate a big integer.",
        "kind": "namespace-method",
        "page": "bigint-neg.html",
        "section": "BigInt"
      },
      "bigint-pow": {
        "name": "BigInt.pow",
        "sig": "BigInt.pow(a, exp) -> BigInt",
        "tip": "Raise a big integer to an int power.",
        "kind": "namespace-method",
        "page": "bigint-pow.html",
        "section": "BigInt"
      },
      "bigint-div": {
        "name": "BigInt.div",
        "sig": "BigInt.div(a, d) -> BigInt",
        "tip": "Divide a big integer by an int (toward zero).",
        "kind": "namespace-method",
        "page": "bigint-div.html",
        "section": "BigInt"
      },
      "bigint-mod": {
        "name": "BigInt.mod",
        "sig": "BigInt.mod(a, d) -> int",
        "tip": "Remainder of a big integer divided by an int.",
        "kind": "namespace-method",
        "page": "bigint-mod.html",
        "section": "BigInt"
      },
      "bigint-cmp": {
        "name": "BigInt.cmp",
        "sig": "BigInt.cmp(a, b) -> int",
        "tip": "Compare two big integers: -1, 0, or 1.",
        "kind": "namespace-method",
        "page": "bigint-cmp.html",
        "section": "BigInt"
      },
      "bigint-eq": {
        "name": "BigInt.eq",
        "sig": "BigInt.eq(a, b) -> bool",
        "tip": "True when two big integers are equal.",
        "kind": "namespace-method",
        "page": "bigint-eq.html",
        "section": "BigInt"
      },
      "bigint-is_zero": {
        "name": "BigInt.is_zero",
        "sig": "BigInt.is_zero(a) -> bool",
        "tip": "True when a big integer is zero.",
        "kind": "namespace-method",
        "page": "bigint-is_zero.html",
        "section": "BigInt"
      },
      "bigint-to_int": {
        "name": "BigInt.to_int",
        "sig": "BigInt.to_int(a) -> int",
        "tip": "Narrow a big integer to a plain int (clamped).",
        "kind": "namespace-method",
        "page": "bigint-to_int.html",
        "section": "BigInt"
      },
      "bigint-str": {
        "name": "BigInt.str",
        "sig": "BigInt.str(a) -> string",
        "tip": "Render a big integer as decimal text.",
        "kind": "namespace-method",
        "page": "bigint-str.html",
        "section": "BigInt"
      },
      "process-spawn": {
        "name": "Process.spawn",
        "sig": "Process.spawn(path, args) -> int",
        "tip": "Start a program; never blocks.",
        "kind": "namespace-method",
        "page": "process-spawn.html",
        "section": "Process"
      },
      "process-poll": {
        "name": "Process.poll",
        "sig": "Process.poll(handle) -> int",
        "tip": "-1 while running, else the exit code.",
        "kind": "namespace-method",
        "page": "process-poll.html",
        "section": "Process"
      },
      "process-kill": {
        "name": "Process.kill",
        "sig": "Process.kill(handle) -> void",
        "tip": "End a running child.",
        "kind": "namespace-method",
        "page": "process-kill.html",
        "section": "Process"
      },
      "process-free": {
        "name": "Process.free",
        "sig": "Process.free(handle) -> void",
        "tip": "Let a process handle go.",
        "kind": "namespace-method",
        "page": "process-free.html",
        "section": "Process"
      },
      "decimal-from": {
        "name": "Decimal.from",
        "sig": "Decimal.from(value) -> Decimal",
        "tip": "Turn a whole int into a Decimal.",
        "kind": "namespace-method",
        "page": "decimal-from.html",
        "section": "Decimal"
      },
      "decimal-parse": {
        "name": "Decimal.parse",
        "sig": "Decimal.parse(text) -> Decimal",
        "tip": "Parse decimal text like \"19.99\".",
        "kind": "namespace-method",
        "page": "decimal-parse.html",
        "section": "Decimal"
      },
      "decimal-add": {
        "name": "Decimal.add",
        "sig": "Decimal.add(a, b) -> Decimal",
        "tip": "Exact sum of two decimals.",
        "kind": "namespace-method",
        "page": "decimal-add.html",
        "section": "Decimal"
      },
      "decimal-sub": {
        "name": "Decimal.sub",
        "sig": "Decimal.sub(a, b) -> Decimal",
        "tip": "Exact difference of two decimals.",
        "kind": "namespace-method",
        "page": "decimal-sub.html",
        "section": "Decimal"
      },
      "decimal-mul": {
        "name": "Decimal.mul",
        "sig": "Decimal.mul(a, b) -> Decimal",
        "tip": "Exact product of two decimals.",
        "kind": "namespace-method",
        "page": "decimal-mul.html",
        "section": "Decimal"
      },
      "decimal-neg": {
        "name": "Decimal.neg",
        "sig": "Decimal.neg(a) -> Decimal",
        "tip": "Negate a decimal.",
        "kind": "namespace-method",
        "page": "decimal-neg.html",
        "section": "Decimal"
      },
      "decimal-cmp": {
        "name": "Decimal.cmp",
        "sig": "Decimal.cmp(a, b) -> int",
        "tip": "Compare two decimals: -1, 0, or 1.",
        "kind": "namespace-method",
        "page": "decimal-cmp.html",
        "section": "Decimal"
      },
      "decimal-eq": {
        "name": "Decimal.eq",
        "sig": "Decimal.eq(a, b) -> bool",
        "tip": "True when two decimals are equal in value.",
        "kind": "namespace-method",
        "page": "decimal-eq.html",
        "section": "Decimal"
      },
      "decimal-scale": {
        "name": "Decimal.scale",
        "sig": "Decimal.scale(d) -> int",
        "tip": "The number of digits after the point.",
        "kind": "namespace-method",
        "page": "decimal-scale.html",
        "section": "Decimal"
      },
      "decimal-rescale": {
        "name": "Decimal.rescale",
        "sig": "Decimal.rescale(d, places) -> Decimal",
        "tip": "Change precision (truncates toward zero).",
        "kind": "namespace-method",
        "page": "decimal-rescale.html",
        "section": "Decimal"
      },
      "decimal-str": {
        "name": "Decimal.str",
        "sig": "Decimal.str(d) -> string",
        "tip": "Render a decimal as text.",
        "kind": "namespace-method",
        "page": "decimal-str.html",
        "section": "Decimal"
      },
      "type-int": {
        "name": "int",
        "sig": "int",
        "tip": "The default 32-bit signed integer — also how colors, keys, and tiles are carried.",
        "kind": "type",
        "page": "type-int.html",
        "section": "Types"
      },
      "type-fixed": {
        "name": "fixed",
        "sig": "fixed",
        "tip": "Q16.16 fixed-point for deterministic fractional math — no floats.",
        "kind": "type",
        "page": "type-fixed.html",
        "section": "Types"
      },
      "type-long": {
        "name": "long",
        "sig": "long",
        "tip": "A 64-bit signed integer for values that overflow a 32-bit int.",
        "kind": "type",
        "page": "type-long.html",
        "section": "Types"
      },
      "type-bool": {
        "name": "bool",
        "sig": "bool",
        "tip": "A truth value — the result of comparisons and of and / or / not.",
        "kind": "type",
        "page": "type-bool.html",
        "section": "Types"
      },
      "type-float": {
        "name": "float",
        "sig": "float",
        "tip": "A 32-bit IEEE floating-point number — what the GPU uses.",
        "kind": "type",
        "page": "type-float.html",
        "section": "Types"
      },
      "type-string": {
        "name": "string",
        "sig": "string",
        "tip": "An immutable string — compared by content, sliceable, and interpolatable.",
        "kind": "type",
        "page": "type-string.html",
        "section": "Types"
      },
      "type-double": {
        "name": "double",
        "sig": "double",
        "tip": "A 64-bit IEEE floating-point number for precise math.",
        "kind": "type",
        "page": "type-double.html",
        "section": "Types"
      },
      "type-entity": {
        "name": "entity",
        "sig": "entity",
        "tip": "The id/handle of a spawned model instance, as returned by self().",
        "kind": "type",
        "page": "type-entity.html",
        "section": "Types"
      },
      "type-pointer": {
        "name": "pointer",
        "sig": "pointer",
        "tip": "A raw address into memory — a byte buffer from bytes(n), or an FFI handle.",
        "kind": "type",
        "page": "type-pointer.html",
        "section": "Types"
      },
      "type-words": {
        "name": "words",
        "sig": "words",
        "tip": "A raw buffer indexed as 32-bit words — each buffer[i] reads or writes an int.",
        "kind": "type",
        "page": "type-words.html",
        "section": "Types"
      },
      "type-byte": {
        "name": "byte",
        "sig": "byte",
        "tip": "A raw buffer indexed one byte at a time — each buffer[i] reads or writes a byte.",
        "kind": "type",
        "page": "type-byte.html",
        "section": "Types"
      },
      "type-slices": {
        "name": "[]T (slices)",
        "sig": "[]T",
        "tip": "A growable slice of T — new []T makes one, push appends, len counts, s[i] indexes.",
        "kind": "type",
        "page": "type-slices.html",
        "section": "Types"
      },
      "type-fixeds": {
        "name": "fixeds",
        "sig": "fixeds",
        "tip": "A buffer of fixed-point values — f[i] reads and writes a fixed.",
        "kind": "type",
        "page": "type-fixeds.html",
        "section": "Types"
      },
      "type-countdown": {
        "name": "countdown",
        "sig": "countdown",
        "tip": "An int component field the engine steps toward 0 once per Update.",
        "kind": "type",
        "page": "type-countdown.html",
        "section": "Types"
      },
      "type-floats": {
        "name": "floats",
        "sig": "floats / doubles",
        "tip": "A buffer of floats (or doubles) — v[i] reads and writes one.",
        "kind": "type",
        "page": "type-floats.html",
        "section": "Types"
      },
      "type-pointers": {
        "name": "pointers",
        "sig": "pointers",
        "tip": "A buffer of pointers — p[i] reads and writes a pointer.",
        "kind": "type",
        "page": "type-pointers.html",
        "section": "Types"
      },
      "type-vector": {
        "name": "Vector",
        "sig": "Vector",
        "tip": "A 2D vector — two fixed components (x, y), copied by value.",
        "kind": "type",
        "page": "type-vector.html",
        "section": "Types"
      },
      "type-ivec2": {
        "name": "IVec2",
        "sig": "IVec2",
        "tip": "An integer 2D vector — two int components (x, y), copied by value.",
        "kind": "type",
        "page": "type-ivec2.html",
        "section": "Types"
      },
      "type-rect": {
        "name": "Rect",
        "sig": "Rect",
        "tip": "A rectangle — position (x, y) and size (w, h), copied by value.",
        "kind": "type",
        "page": "type-rect.html",
        "section": "Types"
      },
      "type-void": {
        "name": "void",
        "sig": "void",
        "tip": "The absence of a value — the return type of a function that returns nothing.",
        "kind": "type",
        "page": "type-void.html",
        "section": "Types"
      },
      "dict-new": {
        "name": "Dict.new",
        "sig": "Dict.new() -> Dict",
        "tip": "Create an empty string-keyed map.",
        "kind": "namespace-method",
        "page": "dict-new.html",
        "section": "Dict"
      },
      "dict-set": {
        "name": "Dict.set",
        "sig": "Dict.set(d, key, value)",
        "tip": "Insert or update a key.",
        "kind": "namespace-method",
        "page": "dict-set.html",
        "section": "Dict"
      },
      "dict-get": {
        "name": "Dict.get",
        "sig": "Dict.get(d, key) -> int",
        "tip": "Look up a key (0 if absent).",
        "kind": "namespace-method",
        "page": "dict-get.html",
        "section": "Dict"
      },
      "dict-get_or": {
        "name": "Dict.get_or",
        "sig": "Dict.get_or(d, key, fallback) -> int",
        "tip": "Look up a key with an explicit default.",
        "kind": "namespace-method",
        "page": "dict-get_or.html",
        "section": "Dict"
      },
      "dict-has": {
        "name": "Dict.has",
        "sig": "Dict.has(d, key) -> bool",
        "tip": "Is a key present?",
        "kind": "namespace-method",
        "page": "dict-has.html",
        "section": "Dict"
      },
      "dict-remove": {
        "name": "Dict.remove",
        "sig": "Dict.remove(d, key)",
        "tip": "Delete a key.",
        "kind": "namespace-method",
        "page": "dict-remove.html",
        "section": "Dict"
      },
      "dict-size": {
        "name": "Dict.size",
        "sig": "Dict.size(d) -> int",
        "tip": "How many keys are stored.",
        "kind": "namespace-method",
        "page": "dict-size.html",
        "section": "Dict"
      },
      "dict-clear": {
        "name": "Dict.clear",
        "sig": "Dict.clear(d)",
        "tip": "Remove every key.",
        "kind": "namespace-method",
        "page": "dict-clear.html",
        "section": "Dict"
      },
      "dict-keys": {
        "name": "Dict.keys",
        "sig": "Dict.keys(d) -> []pointer",
        "tip": "Every key, as a slice of strings.",
        "kind": "namespace-method",
        "page": "dict-keys.html",
        "section": "Dict"
      },
      "op-arith": {
        "name": "Arithmetic",
        "sig": "+  -  *  /  %",
        "tip": "Add, subtract, multiply, integer-divide, and remainder — on int and fixed.",
        "kind": "operator",
        "page": "op-arith.html",
        "section": "Operators & tokens"
      },
      "op-compare": {
        "name": "Comparison",
        "sig": "==  !=  <  <=  >  >=",
        "tip": "Compare two values and yield a bool; on strings == compares contents.",
        "kind": "operator",
        "page": "op-compare.html",
        "section": "Operators & tokens"
      },
      "op-logical": {
        "name": "Logical",
        "sig": "and  or  not",
        "tip": "The boolean combinators, spelled as words — never && or || or a bare !.",
        "kind": "operator",
        "page": "op-logical.html",
        "section": "Operators & tokens"
      },
      "op-bitwise": {
        "name": "Bitwise",
        "sig": "&  |  ^  ~  <<  >>",
        "tip": "Bit-level and, or, xor, not, and shifts — with Go-style precedence.",
        "kind": "operator",
        "page": "op-bitwise.html",
        "section": "Operators & tokens"
      },
      "op-range": {
        "name": "Range",
        "sig": "a .. b",
        "tip": "A half-open range for numeric for loops — from a up to but not including b.",
        "kind": "operator",
        "page": "op-range.html",
        "section": "Operators & tokens"
      },
      "op-assign": {
        "name": "Assignment",
        "sig": "name = value",
        "tip": "Store into a var, a field, or an element — a statement, not an expression.",
        "kind": "operator",
        "page": "op-assign.html",
        "section": "Operators & tokens"
      },
      "op-access": {
        "name": "Member & index",
        "sig": "x.field   buffer[i]   text[a..b]",
        "tip": "Field access, element index, and string slice — usable as value or target.",
        "kind": "operator",
        "page": "op-access.html",
        "section": "Operators & tokens"
      },
      "op-interp": {
        "name": "String interpolation",
        "sig": "`text {expr} more`",
        "tip": "A backtick string with {expr} holes, each stringified and concatenated.",
        "kind": "operator",
        "page": "op-interp.html",
        "section": "Operators & tokens"
      },
      "op-literals": {
        "name": "Literals",
        "sig": "42   0x1E90FF   'w'   \"text\"   true   null",
        "tip": "Integer, hex, character, string, boolean, and null-pointer literals.",
        "kind": "operator",
        "page": "op-literals.html",
        "section": "Operators & tokens"
      },
      "op-comment": {
        "name": "Comment",
        "sig": "# to end of line",
        "tip": "Everything after # on a line is a comment, ignored by the compiler.",
        "kind": "operator",
        "page": "op-comment.html",
        "section": "Operators & tokens"
      },
      "fn-print": {
        "name": "print",
        "sig": "print(x)",
        "tip": "Print an int or string followed by a newline — for headless tests and debugging.",
        "kind": "builtin",
        "page": "fn-print.html",
        "section": "Builtin functions"
      },
      "fn-string": {
        "name": "string",
        "sig": "string(x) -> string",
        "tip": "Convert an int, bool, or fixed value to text; a string passes through unchanged.",
        "kind": "builtin",
        "page": "fn-string.html",
        "section": "Builtin functions"
      },
      "fn-quit": {
        "name": "quit",
        "sig": "quit()",
        "tip": "Stop the game loop cleanly after the current frame finishes.",
        "kind": "builtin",
        "page": "fn-quit.html",
        "section": "Builtin functions"
      },
      "fn-save": {
        "name": "save",
        "sig": "save()",
        "tip": "Serialize the whole world — every model instance, property, and program var — in one call.",
        "kind": "builtin",
        "page": "fn-save.html",
        "section": "Builtin functions"
      },
      "fn-load": {
        "name": "load",
        "sig": "load() -> bool",
        "tip": "Restore the world from a snapshot previously written by save().",
        "kind": "builtin",
        "page": "fn-load.html",
        "section": "Builtin functions"
      },
      "fn-len": {
        "name": "len",
        "sig": "len(x) -> int",
        "tip": "The number of elements in a slice, or the byte length of a string.",
        "kind": "builtin",
        "page": "fn-len.html",
        "section": "Builtin functions"
      },
      "fn-push": {
        "name": "push",
        "sig": "push(slice, x)",
        "tip": "Append one element to the end of a growable slice.",
        "kind": "builtin",
        "page": "fn-push.html",
        "section": "Builtin functions"
      },
      "fn-abs": {
        "name": "abs",
        "sig": "abs(a) -> int",
        "tip": "The absolute value of an integer (its magnitude, never negative).",
        "kind": "builtin",
        "page": "fn-abs.html",
        "section": "Builtin functions"
      },
      "fn-clamp": {
        "name": "clamp",
        "sig": "clamp(v, lo, hi) -> int",
        "tip": "Constrain a value to the inclusive range [lo, hi].",
        "kind": "builtin",
        "page": "fn-clamp.html",
        "section": "Builtin functions"
      },
      "fn-panic": {
        "name": "panic",
        "sig": "panic(msg: string)",
        "tip": "Abort with a located error message instead of crashing.",
        "kind": "builtin",
        "page": "fn-panic.html",
        "section": "Builtin functions"
      },
      "fn-assert": {
        "name": "assert",
        "sig": "assert(cond: bool, msg: string)",
        "tip": "Abort with a located message when an invariant is false.",
        "kind": "builtin",
        "page": "fn-assert.html",
        "section": "Builtin functions"
      },
      "fn-ok": {
        "name": "ok",
        "sig": "ok(v) -> result",
        "tip": "Wrap a success payload in a result — the happy half of try/else.",
        "kind": "builtin",
        "page": "fn-ok.html",
        "section": "Builtin functions"
      },
      "fn-err": {
        "name": "err",
        "sig": "err(msg: string) -> result",
        "tip": "Wrap a failure message in a result — the sad half, recovered by try/else.",
        "kind": "builtin",
        "page": "fn-err.html",
        "section": "Builtin functions"
      },
      "fn-is_ok": {
        "name": "is_ok",
        "sig": "is_ok(r: result) -> bool",
        "tip": "True when a result carries a success payload.",
        "kind": "builtin",
        "page": "fn-is_ok.html",
        "section": "Builtin functions"
      },
      "fn-is_err": {
        "name": "is_err",
        "sig": "is_err(r: result) -> bool",
        "tip": "True when a result carries a failure.",
        "kind": "builtin",
        "page": "fn-is_err.html",
        "section": "Builtin functions"
      },
      "fn-some": {
        "name": "some",
        "sig": "some(v) -> option",
        "tip": "Wrap a present value in an option.",
        "kind": "builtin",
        "page": "fn-some.html",
        "section": "Builtin functions"
      },
      "fn-none": {
        "name": "none",
        "sig": "none() -> option",
        "tip": "The empty option — a missing value.",
        "kind": "builtin",
        "page": "fn-none.html",
        "section": "Builtin functions"
      },
      "fn-is_some": {
        "name": "is_some",
        "sig": "is_some(o: option) -> bool",
        "tip": "True when an option holds a value.",
        "kind": "builtin",
        "page": "fn-is_some.html",
        "section": "Builtin functions"
      },
      "fn-is_none": {
        "name": "is_none",
        "sig": "is_none(o: option) -> bool",
        "tip": "True when an option is empty.",
        "kind": "builtin",
        "page": "fn-is_none.html",
        "section": "Builtin functions"
      },
      "fn-unwrap_or": {
        "name": "unwrap_or",
        "sig": "unwrap_or(o: option, fallback) -> int",
        "tip": "The option value, or a fallback if empty.",
        "kind": "builtin",
        "page": "fn-unwrap_or.html",
        "section": "Builtin functions"
      },
      "fn-exit": {
        "name": "exit",
        "sig": "exit(code)",
        "tip": "Terminate the process immediately with a status code.",
        "kind": "builtin",
        "page": "fn-exit.html",
        "section": "Builtin functions"
      },
      "fn-run": {
        "name": "run",
        "sig": "run(cmd)",
        "tip": "Run a string as a shell command.",
        "kind": "builtin",
        "page": "fn-run.html",
        "section": "Builtin functions"
      },
      "fn-getenv": {
        "name": "getenv",
        "sig": "getenv(name) -> string",
        "tip": "Read an environment variable, returning empty when it is unset.",
        "kind": "builtin",
        "page": "fn-getenv.html",
        "section": "Builtin functions"
      },
      "fn-read_char": {
        "name": "read_char",
        "sig": "read_char() -> int",
        "tip": "Read one byte from standard input, or -1 at end of input.",
        "kind": "builtin",
        "page": "fn-read_char.html",
        "section": "Builtin functions"
      },
      "fn-arg": {
        "name": "arg",
        "sig": "arg(i) -> string",
        "tip": "The i-th command-line argument as a string.",
        "kind": "builtin",
        "page": "fn-arg.html",
        "section": "Builtin functions"
      },
      "fn-arg_count": {
        "name": "arg_count",
        "sig": "arg_count() -> int",
        "tip": "The number of command-line arguments, counting the program name.",
        "kind": "builtin",
        "page": "fn-arg_count.html",
        "section": "Builtin functions"
      },
      "fn-bytes": {
        "name": "bytes",
        "sig": "bytes(n) -> pointer",
        "tip": "Allocate a raw buffer of n bytes and return a pointer to it.",
        "kind": "builtin",
        "page": "fn-bytes.html",
        "section": "Builtin functions"
      },
      "fn-file_stderr": {
        "name": "file_stderr",
        "sig": "file_stderr() -> pointer",
        "tip": "The standard-error stream handle for use with file_write.",
        "kind": "builtin",
        "page": "fn-file_stderr.html",
        "section": "Builtin functions"
      },
      "fn-file_stdout": {
        "name": "file_stdout",
        "sig": "file_stdout() -> pointer",
        "tip": "The standard-output stream handle for use with file_write.",
        "kind": "builtin",
        "page": "fn-file_stdout.html",
        "section": "Builtin functions"
      },
      "fn-file_write": {
        "name": "file_write",
        "sig": "file_write(handle, buf, len)",
        "tip": "Write a run of raw bytes to a stream handle.",
        "kind": "builtin",
        "page": "fn-file_write.html",
        "section": "Builtin functions"
      },
      "fn-fixed": {
        "name": "fixed",
        "sig": "fixed(x) -> fixed",
        "tip": "Convert an int (or a float) into a Q16.16 fixed-point value.",
        "kind": "builtin",
        "page": "fn-fixed.html",
        "section": "Builtin functions"
      },
      "fn-floor": {
        "name": "floor",
        "sig": "floor(x) -> int",
        "tip": "Floor a fixed-point value down to the nearest integer.",
        "kind": "builtin",
        "page": "fn-floor.html",
        "section": "Builtin functions"
      },
      "fn-max": {
        "name": "max",
        "sig": "max(a, b) -> int",
        "tip": "The larger of two integers.",
        "kind": "builtin",
        "page": "fn-max.html",
        "section": "Builtin functions"
      },
      "fn-min": {
        "name": "min",
        "sig": "min(a, b) -> int",
        "tip": "The smaller of two integers.",
        "kind": "builtin",
        "page": "fn-min.html",
        "section": "Builtin functions"
      },
      "fn-ui_build": {
        "name": "ui_build",
        "sig": "ui_build()",
        "tip": "Build the declared UI tree so it can be opened and rendered.",
        "kind": "builtin",
        "page": "fn-ui_build.html",
        "section": "Builtin functions"
      },
      "fn-words": {
        "name": "words",
        "sig": "words(n) -> words",
        "tip": "Allocate a raw buffer of n 32-bit words, indexable with [i].",
        "kind": "builtin",
        "page": "fn-words.html",
        "section": "Builtin functions"
      },
      "fn-float": {
        "name": "float",
        "sig": "float(x) -> float / double(x) -> double",
        "tip": "Convert any number to a float (or double).",
        "kind": "builtin",
        "page": "fn-float.html",
        "section": "Builtin functions"
      },
      "fn-int": {
        "name": "int",
        "sig": "int(x) -> int / long(x) -> long",
        "tip": "Convert a number to a whole number, truncating toward zero.",
        "kind": "builtin",
        "page": "fn-int.html",
        "section": "Builtin functions"
      },
      "fn-float_bits": {
        "name": "float_bits",
        "sig": "float_bits(x) -> int / float_from_bits(bits) -> float",
        "tip": "A float's IEEE bit pattern as an int, and back.",
        "kind": "builtin",
        "page": "fn-float_bits.html",
        "section": "Builtin functions"
      },
      "set-new": {
        "name": "Set.new",
        "sig": "Set.new() -> Set",
        "tip": "Create an empty string set.",
        "kind": "namespace-method",
        "page": "set-new.html",
        "section": "Set"
      },
      "set-add": {
        "name": "Set.add",
        "sig": "Set.add(s, key)",
        "tip": "Add a member (duplicates ignored).",
        "kind": "namespace-method",
        "page": "set-add.html",
        "section": "Set"
      },
      "set-has": {
        "name": "Set.has",
        "sig": "Set.has(s, key) -> bool",
        "tip": "Is a member present?",
        "kind": "namespace-method",
        "page": "set-has.html",
        "section": "Set"
      },
      "set-remove": {
        "name": "Set.remove",
        "sig": "Set.remove(s, key)",
        "tip": "Remove a member.",
        "kind": "namespace-method",
        "page": "set-remove.html",
        "section": "Set"
      },
      "set-size": {
        "name": "Set.size",
        "sig": "Set.size(s) -> int",
        "tip": "How many members.",
        "kind": "namespace-method",
        "page": "set-size.html",
        "section": "Set"
      },
      "set-clear": {
        "name": "Set.clear",
        "sig": "Set.clear(s)",
        "tip": "Remove every member.",
        "kind": "namespace-method",
        "page": "set-clear.html",
        "section": "Set"
      },
      "set-members": {
        "name": "Set.members",
        "sig": "Set.members(s) -> []pointer",
        "tip": "Every member, as a slice of strings.",
        "kind": "namespace-method",
        "page": "set-members.html",
        "section": "Set"
      },
      "annot-queries": {
        "name": "@Queries",
        "sig": "@Queries(these: [Position, Velocity])",
        "tip": "Declare the properties a handler operates on, binding their fields by name in the body.",
        "kind": "annotation",
        "page": "annot-queries.html",
        "section": "Annotations"
      },
      "annot-computed": {
        "name": "@Computed",
        "sig": "@Computed on a property field",
        "tip": "A derived field expanded inline wherever it is read, never stored.",
        "kind": "annotation",
        "page": "annot-computed.html",
        "section": "Annotations"
      },
      "annot-on": {
        "name": "@On",
        "sig": "@On(Event) handler Name { … }",
        "tip": "Register a compile-time listener that runs whenever an event is emitted.",
        "kind": "annotation",
        "page": "annot-on.html",
        "section": "Annotations"
      },
      "annot-export": {
        "name": "@export",
        "sig": "@export function name(…) -> R",
        "tip": "Expose a function as a native symbol so a host can call it.",
        "kind": "annotation",
        "page": "annot-export.html",
        "section": "Annotations"
      },
      "annot-sync": {
        "name": "@Sync",
        "sig": "@Sync property … / @Owned",
        "tip": "Mark fields as replicated and models as owned so the compiler generates networking.",
        "kind": "annotation",
        "page": "annot-sync.html",
        "section": "Annotations"
      },
      "annot-handles": {
        "name": "@Handles",
        "sig": "@Handles(Event) handler Name { … }",
        "tip": "Declarative hint naming the event or subsystem a handler is responsible for.",
        "kind": "annotation",
        "page": "annot-handles.html",
        "section": "Annotations"
      },
      "annot-onattach": {
        "name": "@OnAttach",
        "sig": "@OnAttach(Property) handler Name { … }",
        "tip": "Run a handler when a property is structurally attached to a live instance.",
        "kind": "annotation",
        "page": "annot-onattach.html",
        "section": "Annotations"
      },
      "annot-ondespawn": {
        "name": "@OnDespawn",
        "sig": "@OnDespawn(Model, reason: r) handler Name { … }",
        "tip": "Run a handler when a model instance is torn down, optionally knowing why.",
        "kind": "annotation",
        "page": "annot-ondespawn.html",
        "section": "Annotations"
      },
      "annot-ondetach": {
        "name": "@OnDetach",
        "sig": "@OnDetach(Property) handler Name { … }",
        "tip": "Run a handler when a property is structurally detached from a live instance.",
        "kind": "annotation",
        "page": "annot-ondetach.html",
        "section": "Annotations"
      },
      "annot-ondisable": {
        "name": "@OnDisable",
        "sig": "@OnDisable(Property) handler Name { … }",
        "tip": "Run a handler when a property is paused (disabled) on an instance.",
        "kind": "annotation",
        "page": "annot-ondisable.html",
        "section": "Annotations"
      },
      "annot-onenable": {
        "name": "@OnEnable",
        "sig": "@OnEnable(Property) handler Name { … }",
        "tip": "Run a handler when a paused property is re-enabled on an instance.",
        "kind": "annotation",
        "page": "annot-onenable.html",
        "section": "Annotations"
      },
      "annot-onquit": {
        "name": "@OnQuit",
        "sig": "@OnQuit handler Name { … }",
        "tip": "Run a handler once at shutdown, after the last frame.",
        "kind": "annotation",
        "page": "annot-onquit.html",
        "section": "Annotations"
      },
      "annot-onspawn": {
        "name": "@OnSpawn",
        "sig": "@OnSpawn(Model) handler Name { … }",
        "tip": "Run a handler once each time an instance of a model is spawned.",
        "kind": "annotation",
        "page": "annot-onspawn.html",
        "section": "Annotations"
      },
      "annot-onstart": {
        "name": "@OnStart",
        "sig": "@OnStart handler Name { … }",
        "tip": "Run a handler once at boot instead of assigning it a frame phase.",
        "kind": "annotation",
        "page": "annot-onstart.html",
        "section": "Annotations"
      },
      "annot-owned": {
        "name": "@Owned",
        "sig": "@Owned model Name { … }",
        "tip": "Give a model a network owner slot so its instances can be assigned to a peer.",
        "kind": "annotation",
        "page": "annot-owned.html",
        "section": "Annotations"
      },
      "annot-predicted": {
        "name": "@Predicted",
        "sig": "@Predicted handler Name { … }",
        "tip": "Run a control handler on the owning client speculatively and on the server authoritatively.",
        "kind": "annotation",
        "page": "annot-predicted.html",
        "section": "Annotations"
      },
      "annot-public": {
        "name": "@Public",
        "sig": "@Public @OnSpawn(Model) handler … { … }",
        "tip": "Promote a lifecycle hook to a public event other modules can listen for.",
        "kind": "annotation",
        "page": "annot-public.html",
        "section": "Annotations"
      },
      "annot-reads": {
        "name": "@Reads",
        "sig": "@Reads(Property)",
        "tip": "Declare that a handler reads a property — an analysis and scheduling hint.",
        "kind": "annotation",
        "page": "annot-reads.html",
        "section": "Annotations"
      },
      "annot-server": {
        "name": "@Server",
        "sig": "@Server handler Name { … }",
        "tip": "Run a handler only on the authority; clients receive the result via @Sync.",
        "kind": "annotation",
        "page": "annot-server.html",
        "section": "Annotations"
      },
      "annot-toclients": {
        "name": "@ToClients",
        "sig": "@ToClients event Name { … }",
        "tip": "A remote event broadcast from the server to clients — a server→clients notification.",
        "kind": "annotation",
        "page": "annot-toclients.html",
        "section": "Annotations"
      },
      "annot-toserver": {
        "name": "@ToServer",
        "sig": "@ToServer event Name { … }",
        "tip": "A remote event sent from a client to the server — a client→server request.",
        "kind": "annotation",
        "page": "annot-toserver.html",
        "section": "Annotations"
      },
      "annot-writes": {
        "name": "@Writes",
        "sig": "@Writes(Property)",
        "tip": "Declare that a handler writes a property — an analysis and scheduling hint.",
        "kind": "annotation",
        "page": "annot-writes.html",
        "section": "Annotations"
      },
      "annot-enginesystem": {
        "name": "@EngineSystem",
        "sig": "\"@EngineSystem(Component, Phase) function esys_name() { … }\"",
        "tip": "Register a package's engine-owned system so the frame loop runs it each phase.",
        "kind": "annotation",
        "page": "annot-enginesystem.html",
        "section": "Annotations"
      },
      "annot-namespace": {
        "name": "@Namespace",
        "sig": "\"@Namespace(Name) function name_method(…) -> T { … }\"",
        "tip": "Let a package provide a Name.method(…) namespace that dispatches to name_method.",
        "kind": "annotation",
        "page": "annot-namespace.html",
        "section": "Annotations"
      },
      "annot-clearcolor": {
        "name": "\"@ClearColor\"",
        "sig": "\"@ClearColor(0xRRGGBB) handler Draw phase Render { … }\"",
        "tip": "Declare a clear colour so the Render phase auto-clears + auto-presents for you.",
        "kind": "annotation",
        "page": "annot-clearcolor.html",
        "section": "Annotations"
      },
      "annot-system": {
        "name": "@System",
        "sig": "\"@System(Phase) function name() { … }\"",
        "tip": "Register a prebuilt binary module's system with the host at load, per phase.",
        "kind": "annotation",
        "page": "annot-system.html",
        "section": "Annotations"
      },
      "huge-from": {
        "name": "Huge.from",
        "sig": "Huge.from(value) -> Huge",
        "tip": "Turn an int into a Huge.",
        "kind": "namespace-method",
        "page": "huge-from.html",
        "section": "Huge"
      },
      "huge-add": {
        "name": "Huge.add",
        "sig": "Huge.add(a, b) -> Huge",
        "tip": "Sum of two big numbers.",
        "kind": "namespace-method",
        "page": "huge-add.html",
        "section": "Huge"
      },
      "huge-sub": {
        "name": "Huge.sub",
        "sig": "Huge.sub(a, b) -> Huge",
        "tip": "Difference of two big numbers.",
        "kind": "namespace-method",
        "page": "huge-sub.html",
        "section": "Huge"
      },
      "huge-mul": {
        "name": "Huge.mul",
        "sig": "Huge.mul(a, b) -> Huge",
        "tip": "Product of two big numbers.",
        "kind": "namespace-method",
        "page": "huge-mul.html",
        "section": "Huge"
      },
      "huge-neg": {
        "name": "Huge.neg",
        "sig": "Huge.neg(a) -> Huge",
        "tip": "Negate a big number.",
        "kind": "namespace-method",
        "page": "huge-neg.html",
        "section": "Huge"
      },
      "huge-cmp": {
        "name": "Huge.cmp",
        "sig": "Huge.cmp(a, b) -> int",
        "tip": "Compare two big numbers: -1, 0, or 1.",
        "kind": "namespace-method",
        "page": "huge-cmp.html",
        "section": "Huge"
      },
      "huge-sign": {
        "name": "Huge.sign",
        "sig": "Huge.sign(a) -> int",
        "tip": "The sign: -1, 0, or 1.",
        "kind": "namespace-method",
        "page": "huge-sign.html",
        "section": "Huge"
      },
      "huge-mantissa": {
        "name": "Huge.mantissa",
        "sig": "Huge.mantissa(a) -> fixed",
        "tip": "The mantissa in [1, 10).",
        "kind": "namespace-method",
        "page": "huge-mantissa.html",
        "section": "Huge"
      },
      "huge-exp": {
        "name": "Huge.exp",
        "sig": "Huge.exp(a) -> int",
        "tip": "The base-10 exponent.",
        "kind": "namespace-method",
        "page": "huge-exp.html",
        "section": "Huge"
      },
      "huge-str": {
        "name": "Huge.str",
        "sig": "Huge.str(a) -> string",
        "tip": "Render as scientific text like 1.23e45.",
        "kind": "namespace-method",
        "page": "huge-str.html",
        "section": "Huge"
      },
      "angle-from_degrees": {
        "name": "Angle.from_degrees",
        "sig": "Angle.from_degrees(d) -> fixed",
        "tip": "Degrees to a wrapped radian angle.",
        "kind": "namespace-method",
        "page": "angle-from_degrees.html",
        "section": "Angle"
      },
      "angle-to_degrees": {
        "name": "Angle.to_degrees",
        "sig": "Angle.to_degrees(a) -> fixed",
        "tip": "Radians back to degrees.",
        "kind": "namespace-method",
        "page": "angle-to_degrees.html",
        "section": "Angle"
      },
      "angle-wrap": {
        "name": "Angle.wrap",
        "sig": "Angle.wrap(a) -> fixed",
        "tip": "Normalize any radian value to [-pi, pi).",
        "kind": "namespace-method",
        "page": "angle-wrap.html",
        "section": "Angle"
      },
      "angle-sin": {
        "name": "Angle.sin",
        "sig": "Angle.sin(a) -> fixed",
        "tip": "Sine of an angle.",
        "kind": "namespace-method",
        "page": "angle-sin.html",
        "section": "Angle"
      },
      "angle-cos": {
        "name": "Angle.cos",
        "sig": "Angle.cos(a) -> fixed",
        "tip": "Cosine of an angle.",
        "kind": "namespace-method",
        "page": "angle-cos.html",
        "section": "Angle"
      },
      "angle-add": {
        "name": "Angle.add",
        "sig": "Angle.add(a, b) -> fixed",
        "tip": "Add two angles (wrapped).",
        "kind": "namespace-method",
        "page": "angle-add.html",
        "section": "Angle"
      },
      "angle-diff": {
        "name": "Angle.diff",
        "sig": "Angle.diff(a, b) -> fixed",
        "tip": "Shortest signed rotation from a to b.",
        "kind": "namespace-method",
        "page": "angle-diff.html",
        "section": "Angle"
      },
      "angle-lerp": {
        "name": "Angle.lerp",
        "sig": "Angle.lerp(a, b, t) -> fixed",
        "tip": "Interpolate along the shortest arc.",
        "kind": "namespace-method",
        "page": "angle-lerp.html",
        "section": "Angle"
      },
      "angle-diff_degrees": {
        "name": "Angle.diff_degrees",
        "sig": "Angle.diff_degrees(a: int, b: int) -> int",
        "tip": "The signed difference between two headings in whole degrees.",
        "kind": "namespace-method",
        "page": "angle-diff_degrees.html",
        "section": "Angle"
      },
      "percent-clamp": {
        "name": "Percent.clamp",
        "sig": "Percent.clamp(v) -> fixed",
        "tip": "Clamp any fixed into [0, 1].",
        "kind": "namespace-method",
        "page": "percent-clamp.html",
        "section": "Percent"
      },
      "percent-of": {
        "name": "Percent.of",
        "sig": "Percent.of(num, den) -> fixed",
        "tip": "Clamped ratio num / den.",
        "kind": "namespace-method",
        "page": "percent-of.html",
        "section": "Percent"
      },
      "percent-lerp": {
        "name": "Percent.lerp",
        "sig": "Percent.lerp(a, b, t) -> fixed",
        "tip": "Interpolate a..b by a clamped t.",
        "kind": "namespace-method",
        "page": "percent-lerp.html",
        "section": "Percent"
      },
      "percent-apply": {
        "name": "Percent.apply",
        "sig": "Percent.apply(value, p) -> fixed",
        "tip": "Scale a value by a clamped percent.",
        "kind": "namespace-method",
        "page": "percent-apply.html",
        "section": "Percent"
      },
      "regex-compile": {
        "name": "Regex.compile",
        "sig": "Regex.compile(pattern) -> Regex",
        "tip": "Compile a pattern once for reuse; returns an error value (null) if it is invalid.",
        "kind": "namespace-method",
        "page": "regex-compile.html",
        "section": "Regex"
      },
      "regex-valid": {
        "name": "Regex.valid",
        "sig": "Regex.valid(pattern) -> bool",
        "tip": "True if the pattern is well-formed (compiles without error).",
        "kind": "namespace-method",
        "page": "regex-valid.html",
        "section": "Regex"
      },
      "regex-matches": {
        "name": "Regex.matches",
        "sig": "Regex.matches(text, pattern) -> bool",
        "tip": "True if the pattern matches anywhere in the text (a search).",
        "kind": "namespace-method",
        "page": "regex-matches.html",
        "section": "Regex"
      },
      "regex-test": {
        "name": "Regex.test",
        "sig": "Regex.test(text, re) -> bool",
        "tip": "Like matches, but reuses an already-compiled Regex.",
        "kind": "namespace-method",
        "page": "regex-test.html",
        "section": "Regex"
      },
      "regex-find": {
        "name": "Regex.find",
        "sig": "Regex.find(text, pattern) -> Match",
        "tip": "The first match of the pattern in the text (a Match, or null if none).",
        "kind": "namespace-method",
        "page": "regex-find.html",
        "section": "Regex"
      },
      "regex-exec": {
        "name": "Regex.exec",
        "sig": "Regex.exec(text, re) -> Match",
        "tip": "Like find, but with an already-compiled Regex.",
        "kind": "namespace-method",
        "page": "regex-exec.html",
        "section": "Regex"
      },
      "regex-next": {
        "name": "Regex.next",
        "sig": "Regex.next(text, re, from) -> Match",
        "tip": "The next match at or after byte offset from — the basis of a find-all loop.",
        "kind": "namespace-method",
        "page": "regex-next.html",
        "section": "Regex"
      },
      "regex-replace": {
        "name": "Regex.replace",
        "sig": "Regex.replace(text, pattern, replacement) -> string",
        "tip": "Replace every match; the replacement expands \\0..\\9 group references.",
        "kind": "namespace-method",
        "page": "regex-replace.html",
        "section": "Regex"
      },
      "regex-group": {
        "name": "Regex.group",
        "sig": "Regex.group(match, n) -> string",
        "tip": "The text of capture group n (group 0 is the whole match); empty if unset.",
        "kind": "namespace-method",
        "page": "regex-group.html",
        "section": "Regex"
      },
      "regex-group_count": {
        "name": "Regex.group_count",
        "sig": "Regex.group_count(match) -> int",
        "tip": "How many capture groups the match's pattern has.",
        "kind": "namespace-method",
        "page": "regex-group_count.html",
        "section": "Regex"
      },
      "regex-start": {
        "name": "Regex.start",
        "sig": "Regex.start(match, n) -> int",
        "tip": "The start byte offset of group n, or -1 if it did not participate.",
        "kind": "namespace-method",
        "page": "regex-start.html",
        "section": "Regex"
      },
      "regex-end": {
        "name": "Regex.end",
        "sig": "Regex.end(match, n) -> int",
        "tip": "The end byte offset of group n, or -1 if it did not participate.",
        "kind": "namespace-method",
        "page": "regex-end.html",
        "section": "Regex"
      },
      "regex-ok": {
        "name": "Regex.ok",
        "sig": "Regex.ok(match) -> bool",
        "tip": "True if the match succeeded (the Match is non-null).",
        "kind": "namespace-method",
        "page": "regex-ok.html",
        "section": "Regex"
      },
      "grid-line": {
        "name": "Grid.line",
        "sig": "Grid.line(x0, y0, x1, y1) -> []Cell",
        "tip": "Every cell a straight line from (x0,y0) to (x1,y1) crosses (Bresenham).",
        "kind": "namespace-method",
        "page": "grid-line.html",
        "section": "Grid"
      },
      "grid-blocked": {
        "name": "Grid.blocked",
        "sig": "Grid.blocked(x, y, wall) -> bool",
        "tip": "True if the cell is out of bounds or holds the wall tile.",
        "kind": "namespace-method",
        "page": "grid-blocked.html",
        "section": "Grid"
      },
      "grid-line_of_sight": {
        "name": "Grid.line_of_sight",
        "sig": "Grid.line_of_sight(x0, y0, x1, y1, wall) -> bool",
        "tip": "True if the straight line between two cells crosses no wall.",
        "kind": "namespace-method",
        "page": "grid-line_of_sight.html",
        "section": "Grid"
      },
      "grid-flood": {
        "name": "Grid.flood",
        "sig": "Grid.flood(x, y, wall) -> []Cell",
        "tip": "Every passable cell reachable from (x,y), 4-connected, in BFS order.",
        "kind": "namespace-method",
        "page": "grid-flood.html",
        "section": "Grid"
      },
      "grid-a_star": {
        "name": "Grid.a_star",
        "sig": "Grid.a_star(x0, y0, x1, y1, wall) -> []Cell",
        "tip": "The shortest 4-connected path between two cells (A*), or an empty list.",
        "kind": "namespace-method",
        "page": "grid-a_star.html",
        "section": "Grid"
      },
      "anim-frame": {
        "name": "Anim.frame",
        "sig": "Anim.frame(timer, fps, count) -> int",
        "tip": "The looping frame index for an elapsed timer at a given fps.",
        "kind": "namespace-method",
        "page": "anim-frame.html",
        "section": "Anim"
      },
      "anim-once": {
        "name": "Anim.once",
        "sig": "Anim.once(timer, fps, count) -> int",
        "tip": "A non-looping frame index that clamps on the last frame.",
        "kind": "namespace-method",
        "page": "anim-once.html",
        "section": "Anim"
      },
      "anim-pingpong": {
        "name": "Anim.pingpong",
        "sig": "Anim.pingpong(timer, fps, count) -> int",
        "tip": "A frame index that bounces 0..count-1..0 and repeats.",
        "kind": "namespace-method",
        "page": "anim-pingpong.html",
        "section": "Anim"
      },
      "anim-finished": {
        "name": "Anim.finished",
        "sig": "Anim.finished(timer, fps, count) -> bool",
        "tip": "True once a one-shot clip has run past its last frame.",
        "kind": "namespace-method",
        "page": "anim-finished.html",
        "section": "Anim"
      },
      "anim-duration": {
        "name": "Anim.duration",
        "sig": "Anim.duration(fps, count) -> fixed",
        "tip": "Seconds for one full cycle of a clip: count / fps.",
        "kind": "namespace-method",
        "page": "anim-duration.html",
        "section": "Anim"
      },
      "anim-cell_x": {
        "name": "Anim.cell_x",
        "sig": "Anim.cell_x(frame, cols, cell_w) -> int",
        "tip": "The source x (pixels) of a frame on a grid spritesheet.",
        "kind": "namespace-method",
        "page": "anim-cell_x.html",
        "section": "Anim"
      },
      "anim-cell_y": {
        "name": "Anim.cell_y",
        "sig": "Anim.cell_y(frame, cols, cell_h) -> int",
        "tip": "The source y (pixels) of a frame on a grid spritesheet.",
        "kind": "namespace-method",
        "page": "anim-cell_y.html",
        "section": "Anim"
      },
      "anim-play": {
        "name": "Anim.play",
        "sig": "Anim.play(entity, clip) | Anim.play(entity, fps, frames, mode)",
        "tip": "Start (or restart) a spritesheet clip on an entity in one call.",
        "kind": "namespace-method",
        "page": "anim-play.html",
        "section": "Anim"
      },
      "anim-clip": {
        "name": "Anim.clip",
        "sig": "Anim.clip(name, frames, fps, mode)",
        "tip": "Register a named spritesheet clip so Anim.play can play it by name.",
        "kind": "namespace-method",
        "page": "anim-clip.html",
        "section": "Anim"
      },
      "anim-on_frame": {
        "name": "Anim.on_frame",
        "sig": "Anim.on_frame(entity, frame)",
        "tip": "Arm a frame event — the engine flags the tick a clip lands on this frame.",
        "kind": "namespace-method",
        "page": "anim-on_frame.html",
        "section": "Anim"
      },
      "anim-fired": {
        "name": "Anim.fired",
        "sig": "Anim.fired(entity) -> bool",
        "tip": "Did the entity's clip land on its armed frame event this tick?",
        "kind": "namespace-method",
        "page": "anim-fired.html",
        "section": "Anim"
      },
      "motion-to": {
        "name": "Motion.to",
        "sig": "Motion.to(entity, from, to, dur, ease)",
        "tip": "Start a value tween on an entity's Motion component in one call.",
        "kind": "namespace-method",
        "page": "motion-to.html",
        "section": "Motion"
      },
      "tween-progress": {
        "name": "Tween.progress",
        "sig": "Tween.progress(timer, duration) -> fixed",
        "tip": "A one-shot 0..1 amount, clamped, for timer over duration.",
        "kind": "namespace-method",
        "page": "tween-progress.html",
        "section": "Tween"
      },
      "tween-loop": {
        "name": "Tween.loop",
        "sig": "Tween.loop(timer, duration) -> fixed",
        "tip": "A repeating 0..1 sawtooth amount over duration.",
        "kind": "namespace-method",
        "page": "tween-loop.html",
        "section": "Tween"
      },
      "tween-yoyo": {
        "name": "Tween.yoyo",
        "sig": "Tween.yoyo(timer, duration) -> fixed",
        "tip": "A repeating 0..1..0 triangle amount over duration.",
        "kind": "namespace-method",
        "page": "tween-yoyo.html",
        "section": "Tween"
      },
      "tween-done": {
        "name": "Tween.done",
        "sig": "Tween.done(timer, duration) -> bool",
        "tip": "True once a one-shot tween's timer reaches its duration.",
        "kind": "namespace-method",
        "page": "tween-done.html",
        "section": "Tween"
      },
      "tween-ease": {
        "name": "Tween.ease",
        "sig": "Tween.ease(t, mode) -> fixed",
        "tip": "Shape a 0..1 amount through an easing curve chosen by a literal mode.",
        "kind": "namespace-method",
        "page": "tween-ease.html",
        "section": "Tween"
      },
      "tween-number": {
        "name": "Tween.number",
        "sig": "Tween.number(from, to, t) -> fixed",
        "tip": "Linear blend of two fixeds by amount t.",
        "kind": "namespace-method",
        "page": "tween-number.html",
        "section": "Tween"
      },
      "tween-round": {
        "name": "Tween.round",
        "sig": "Tween.round(from, to, t) -> int",
        "tip": "Linear blend of two ints by amount t, rounded to the nearest int.",
        "kind": "namespace-method",
        "page": "tween-round.html",
        "section": "Tween"
      },
      "tween-point": {
        "name": "Tween.point",
        "sig": "Tween.point(from, to, t) -> Vector",
        "tip": "Component-wise blend of two Vectors by amount t.",
        "kind": "namespace-method",
        "page": "tween-point.html",
        "section": "Tween"
      },
      "tween-tint": {
        "name": "Tween.tint",
        "sig": "Tween.tint(from, to, t) -> int",
        "tip": "Per-channel blend of two colors by amount t.",
        "kind": "namespace-method",
        "page": "tween-tint.html",
        "section": "Tween"
      },
      "tween-to": {
        "name": "Tween.to",
        "sig": "Tween.to(from, to, dur, ease) -> handle",
        "tip": "Start a fluent, engine-advanced tween and return a handle.",
        "kind": "namespace-method",
        "page": "tween-to.html",
        "section": "Tween"
      },
      "tween-chain": {
        "name": "Tween.chain",
        "sig": "Tween.chain(handle, to, dur, ease) -> handle",
        "tip": "Append a tween segment that runs after the handle's current queue.",
        "kind": "namespace-method",
        "page": "tween-chain.html",
        "section": "Tween"
      },
      "tween-delay": {
        "name": "Tween.delay",
        "sig": "Tween.delay(handle, ticks) -> handle",
        "tip": "Append a pause to a tween handle's sequence.",
        "kind": "namespace-method",
        "page": "tween-delay.html",
        "section": "Tween"
      },
      "tween-value": {
        "name": "Tween.value",
        "sig": "Tween.value(handle) -> int",
        "tip": "The current value of a fluent tween handle this frame.",
        "kind": "namespace-method",
        "page": "tween-value.html",
        "section": "Tween"
      },
      "tween-stop": {
        "name": "Tween.stop",
        "sig": "Tween.stop(handle)",
        "tip": "Stop and dispose a tween handle, freezing its value.",
        "kind": "namespace-method",
        "page": "tween-stop.html",
        "section": "Tween"
      },
      "tween-parallel": {
        "name": "Tween.parallel",
        "sig": "Tween.parallel(a, b) -> bool",
        "tip": "Are two tween handles both finished? — a parallel completion query.",
        "kind": "namespace-method",
        "page": "tween-parallel.html",
        "section": "Tween"
      },
      "query-count": {
        "name": "Query.count",
        "sig": "Query.count(prop) -> int",
        "tip": "How many live entities carry a property.",
        "kind": "namespace-method",
        "page": "query-count.html",
        "section": "Query"
      },
      "query-first": {
        "name": "Query.first",
        "sig": "Query.first(prop) -> int",
        "tip": "The lowest-id live entity carrying a property, or -1.",
        "kind": "namespace-method",
        "page": "query-first.html",
        "section": "Query"
      },
      "query-nearest": {
        "name": "Query.nearest",
        "sig": "Query.nearest(prop, pos, x_field, y_field, x, y) -> int",
        "tip": "The bearer of prop closest to a point, by squared distance.",
        "kind": "namespace-method",
        "page": "query-nearest.html",
        "section": "Query"
      },
      "query-within": {
        "name": "Query.within",
        "sig": "Query.within(prop, pos, x, y, radius, x_field, y_field) -> []int",
        "tip": "Every bearer of prop inside a radius of a point.",
        "kind": "namespace-method",
        "page": "query-within.html",
        "section": "Query"
      },
      "reflect-prop": {
        "name": "Reflect.prop",
        "sig": "Reflect.prop(name) -> int",
        "tip": "The property id for a property name, or -1 if unknown.",
        "kind": "namespace-method",
        "page": "reflect-prop.html",
        "section": "Reflect"
      },
      "reflect-field": {
        "name": "Reflect.field",
        "sig": "Reflect.field(prop, name) -> int",
        "tip": "The field id of a named field within a property, or -1.",
        "kind": "namespace-method",
        "page": "reflect-field.html",
        "section": "Reflect"
      },
      "reflect-prop_count": {
        "name": "Reflect.prop_count",
        "sig": "Reflect.prop_count() -> int",
        "tip": "How many properties the world schema defines.",
        "kind": "namespace-method",
        "page": "reflect-prop_count.html",
        "section": "Reflect"
      },
      "reflect-prop_name": {
        "name": "Reflect.prop_name",
        "sig": "Reflect.prop_name(index) -> string",
        "tip": "The name of the property at an index (or \"\").",
        "kind": "namespace-method",
        "page": "reflect-prop_name.html",
        "section": "Reflect"
      },
      "reflect-field_count": {
        "name": "Reflect.field_count",
        "sig": "Reflect.field_count(prop) -> int",
        "tip": "How many fields a property has.",
        "kind": "namespace-method",
        "page": "reflect-field_count.html",
        "section": "Reflect"
      },
      "reflect-field_name": {
        "name": "Reflect.field_name",
        "sig": "Reflect.field_name(prop, index) -> string",
        "tip": "The name of the field at an index within a property.",
        "kind": "namespace-method",
        "page": "reflect-field_name.html",
        "section": "Reflect"
      },
      "reflect-field_type": {
        "name": "Reflect.field_type",
        "sig": "Reflect.field_type(prop, index) -> string",
        "tip": "The type name of the field at an index within a property.",
        "kind": "namespace-method",
        "page": "reflect-field_type.html",
        "section": "Reflect"
      },
      "reflect-get": {
        "name": "Reflect.get",
        "sig": "Reflect.get(entity, prop, field) -> int",
        "tip": "Read one field of an entity by (prop, field) id.",
        "kind": "namespace-method",
        "page": "reflect-get.html",
        "section": "Reflect"
      },
      "reflect-set": {
        "name": "Reflect.set",
        "sig": "Reflect.set(entity, prop, field, value)",
        "tip": "Write one field of an entity by (prop, field) id.",
        "kind": "namespace-method",
        "page": "reflect-set.html",
        "section": "Reflect"
      },
      "reflect-has": {
        "name": "Reflect.has",
        "sig": "Reflect.has(entity, prop) -> bool",
        "tip": "Does an entity carry a property?",
        "kind": "namespace-method",
        "page": "reflect-has.html",
        "section": "Reflect"
      },
      "reflect-kind": {
        "name": "Reflect.kind",
        "sig": "Reflect.kind(entity) -> int",
        "tip": "The model id of an entity.",
        "kind": "namespace-method",
        "page": "reflect-kind.html",
        "section": "Reflect"
      },
      "reflect-model": {
        "name": "Reflect.model",
        "sig": "Reflect.model(name) -> int",
        "tip": "The model id for a model name, or -1 if unknown.",
        "kind": "namespace-method",
        "page": "reflect-model.html",
        "section": "Reflect"
      },
      "reflect-serialize": {
        "name": "Reflect.serialize",
        "sig": "Reflect.serialize(entity) -> value",
        "tip": "Walk an entity's components into a value tree.",
        "kind": "namespace-method",
        "page": "reflect-serialize.html",
        "section": "Reflect"
      },
      "reflect-apply": {
        "name": "Reflect.apply",
        "sig": "Reflect.apply(entity, value) -> int",
        "tip": "Write a value tree's fields back into an entity.",
        "kind": "namespace-method",
        "page": "reflect-apply.html",
        "section": "Reflect"
      },
      "camera-set": {
        "name": "Camera.set",
        "sig": "Camera.set(x, y)",
        "tip": "Place the camera at a world-space offset.",
        "kind": "namespace-method",
        "page": "camera-set.html",
        "section": "Camera"
      },
      "camera-follow": {
        "name": "Camera.follow",
        "sig": "Camera.follow(x, y, lerp)",
        "tip": "Ease the camera toward centring a target point.",
        "kind": "namespace-method",
        "page": "camera-follow.html",
        "section": "Camera"
      },
      "camera-shake": {
        "name": "Camera.shake",
        "sig": "Camera.shake(amount)",
        "tip": "Jitter the camera by up to +/- amount pixels (seeded RNG).",
        "kind": "namespace-method",
        "page": "camera-shake.html",
        "section": "Camera"
      },
      "camera-zoom": {
        "name": "Camera.zoom",
        "sig": "Camera.zoom(scale)",
        "tip": "Scale the whole view about the screen centre by a Q16.16 factor (1.0 = none).",
        "kind": "namespace-method",
        "page": "camera-zoom.html",
        "section": "Camera"
      },
      "camera-shake_for": {
        "name": "Camera.shake_for",
        "sig": "Camera.shake_for(amount: px, frames: n)",
        "tip": "Shake for a number of frames, then stop, with no bookkeeping.",
        "kind": "namespace-method",
        "page": "camera-shake_for.html",
        "section": "Camera"
      },
      "light-ambient": {
        "name": "Light.ambient",
        "sig": "Light.ambient(color)",
        "tip": "Multiply the whole scene by a tint — the night/cave modulate.",
        "kind": "namespace-method",
        "page": "light-ambient.html",
        "section": "Light"
      },
      "light-point": {
        "name": "Light.point",
        "sig": "Light.point(x, y, radius, color, energy)",
        "tip": "Add a radial glow that falls off with distance.",
        "kind": "namespace-method",
        "page": "light-point.html",
        "section": "Light"
      },
      "light-occlude": {
        "name": "Light.occlude",
        "sig": "Light.occlude(x, y, width, height)",
        "tip": "Register a rectangle that blocks light — a hard shadow caster.",
        "kind": "namespace-method",
        "page": "light-occlude.html",
        "section": "Light"
      },
      "light-clear_occluders": {
        "name": "Light.clear_occluders",
        "sig": "Light.clear_occluders()",
        "tip": "Forget every occluder — call once per frame before re-registering.",
        "kind": "namespace-method",
        "page": "light-clear_occluders.html",
        "section": "Light"
      },
      "light-spot": {
        "name": "Light.spot",
        "sig": "Light.spot(x, y, radius, color, energy, direction, spread)",
        "tip": "A cone / flashlight light aimed at a direction with a half-angle spread.",
        "kind": "namespace-method",
        "page": "light-spot.html",
        "section": "Light"
      },
      "light-falloff": {
        "name": "Light.falloff",
        "sig": "Light.falloff(exponent)",
        "tip": "Set the brightness-ramp exponent for later lights (1 linear, 2 quadratic…).",
        "kind": "namespace-method",
        "page": "light-falloff.html",
        "section": "Light"
      },
      "light-soft": {
        "name": "Light.soft",
        "sig": "Light.soft(radius)",
        "tip": "Soft shadows — an occluder edge fades through a penumbra of this radius.",
        "kind": "namespace-method",
        "page": "light-soft.html",
        "section": "Light"
      },
      "light-gel": {
        "name": "Light.gel",
        "sig": "Light.gel(color)",
        "tip": "A colour cookie — later lights gel from their centre colour to this rim colour.",
        "kind": "namespace-method",
        "page": "light-gel.html",
        "section": "Light"
      },
      "light-clear_gel": {
        "name": "Light.clear_gel",
        "sig": "Light.clear_gel()",
        "tip": "Clear the gel — later lights are a flat single colour again.",
        "kind": "namespace-method",
        "page": "light-clear_gel.html",
        "section": "Light"
      },
      "light-normal": {
        "name": "Light.normal",
        "sig": "Light.normal(x, y, width, height, nx, ny)",
        "tip": "Stamp a surface normal over a rectangle so lights shade it by facing (N·L).",
        "kind": "namespace-method",
        "page": "light-normal.html",
        "section": "Light"
      },
      "light-clear_normals": {
        "name": "Light.clear_normals",
        "sig": "Light.clear_normals()",
        "tip": "Forget every stamped normal — call once per frame before re-stamping.",
        "kind": "namespace-method",
        "page": "light-clear_normals.html",
        "section": "Light"
      },
      "light-height": {
        "name": "Light.height",
        "sig": "Light.height(height)",
        "tip": "Set the virtual height of lights above the surface, for normal-map shading.",
        "kind": "namespace-method",
        "page": "light-height.html",
        "section": "Light"
      },
      "light-time_of_day": {
        "name": "Light.time_of_day",
        "sig": "Light.time_of_day(t)",
        "tip": "Set the ambient tint from a 0..1 time-of-day — a day/night cycle in one value.",
        "kind": "namespace-method",
        "page": "light-time_of_day.html",
        "section": "Light"
      },
      "sprite-sheet": {
        "name": "Sprite.sheet",
        "sig": "Sprite.sheet(path, cellw, cellh) -> int",
        "tip": "Load a spritesheet and remember its cell grid; returns a sheet handle.",
        "kind": "namespace-method",
        "page": "sprite-sheet.html",
        "section": "Sprite"
      },
      "sprite-cell": {
        "name": "Sprite.cell",
        "sig": "Sprite.cell(sheet, col, row) -> int",
        "tip": "One cell of a sheet, by grid coords; returns a sprite id.",
        "kind": "namespace-method",
        "page": "sprite-cell.html",
        "section": "Sprite"
      },
      "sprite-cell_span": {
        "name": "Sprite.cell_span",
        "sig": "Sprite.cell_span(sheet, col, row, cols, rows) -> int",
        "tip": "A sprite spanning cols x rows cells (tall/wide art).",
        "kind": "namespace-method",
        "page": "sprite-cell_span.html",
        "section": "Sprite"
      },
      "sprite-define": {
        "name": "Sprite.define",
        "sig": "Sprite.define(name, sheet, col, row) -> int",
        "tip": "Name a cell for later lookup; returns its sprite id.",
        "kind": "namespace-method",
        "page": "sprite-define.html",
        "section": "Sprite"
      },
      "sprite-named": {
        "name": "Sprite.named",
        "sig": "Sprite.named(name) -> int",
        "tip": "Look up a named sprite's id, or -1.",
        "kind": "namespace-method",
        "page": "sprite-named.html",
        "section": "Sprite"
      },
      "sprite-draw": {
        "name": "Sprite.draw",
        "sig": "Sprite.draw(id, x, y)",
        "tip": "Blit an atlas sprite at (x, y) through the camera/zoom/clip.",
        "kind": "namespace-method",
        "page": "sprite-draw.html",
        "section": "Sprite"
      },
      "sprite-draw_scaled": {
        "name": "Sprite.draw_scaled",
        "sig": "Sprite.draw_scaled(id, x, y, scale)",
        "tip": "Blit an atlas sprite scaled by an integer factor.",
        "kind": "namespace-method",
        "page": "sprite-draw_scaled.html",
        "section": "Sprite"
      },
      "sprite-width": {
        "name": "Sprite.width",
        "sig": "Sprite.width(id) -> int",
        "tip": "The atlas sprite's width in pixels.",
        "kind": "namespace-method",
        "page": "sprite-width.html",
        "section": "Sprite"
      },
      "sprite-height": {
        "name": "Sprite.height",
        "sig": "Sprite.height(id) -> int",
        "tip": "The atlas sprite's height in pixels.",
        "kind": "namespace-method",
        "page": "sprite-height.html",
        "section": "Sprite"
      },
      "sprite-strip": {
        "name": "Sprite.strip",
        "sig": "Sprite.strip(sheet, col, row, count, rows) -> int",
        "tip": "A run of animation frames as consecutive sprite ids.",
        "kind": "namespace-method",
        "page": "sprite-strip.html",
        "section": "Sprite"
      },
      "sprite-draw_meter": {
        "name": "Sprite.draw_meter",
        "sig": "Sprite.draw_meter(x:, y:, value:, max:, per_icon:, spacing:, full:, half:, empty:)",
        "tip": "A value as a row of full / half / empty icons.",
        "kind": "namespace-method",
        "page": "sprite-draw_meter.html",
        "section": "Sprite"
      },
      "assets-image": {
        "name": "Assets.image",
        "sig": "Assets.image(path) -> int",
        "tip": "Load a whole image file as one sprite; returns its id.",
        "kind": "namespace-method",
        "page": "assets-image.html",
        "section": "Assets"
      },
      "assets-load": {
        "name": "Assets.load",
        "sig": "Assets.load(path) -> int",
        "tip": "Alias of Assets.image.",
        "kind": "namespace-method",
        "page": "assets-load.html",
        "section": "Assets"
      },
      "assets-get": {
        "name": "Assets.get",
        "sig": "Assets.get(name) -> int",
        "tip": "Look up a named sprite's id (alias of Sprite.named).",
        "kind": "namespace-method",
        "page": "assets-get.html",
        "section": "Assets"
      },
      "assets-enqueue": {
        "name": "Assets.enqueue",
        "sig": "Assets.enqueue(name, path)",
        "tip": "Queue a named image file to preload later.",
        "kind": "namespace-method",
        "page": "assets-enqueue.html",
        "section": "Assets"
      },
      "assets-pump": {
        "name": "Assets.pump",
        "sig": "Assets.pump(max) -> int",
        "tip": "Load up to max queued assets this frame; returns how many it loaded.",
        "kind": "namespace-method",
        "page": "assets-pump.html",
        "section": "Assets"
      },
      "assets-total": {
        "name": "Assets.total",
        "sig": "Assets.total() -> int",
        "tip": "How many assets are enqueued.",
        "kind": "namespace-method",
        "page": "assets-total.html",
        "section": "Assets"
      },
      "assets-loaded": {
        "name": "Assets.loaded",
        "sig": "Assets.loaded() -> int",
        "tip": "How many enqueued assets have loaded so far.",
        "kind": "namespace-method",
        "page": "assets-loaded.html",
        "section": "Assets"
      },
      "assets-ready": {
        "name": "Assets.ready",
        "sig": "Assets.ready() -> int",
        "tip": "1 once every enqueued asset has loaded.",
        "kind": "namespace-method",
        "page": "assets-ready.html",
        "section": "Assets"
      },
      "assets-font": {
        "name": "Assets.font",
        "sig": "Assets.font(name: s) -> int",
        "tip": "A font loaded through the preload queue, by name.",
        "kind": "namespace-method",
        "page": "assets-font.html",
        "section": "Assets"
      },
      "assets-progress": {
        "name": "Assets.progress",
        "sig": "Assets.progress() -> int",
        "tip": "Loading progress as a 0..100 percent.",
        "kind": "namespace-method",
        "page": "assets-progress.html",
        "section": "Assets"
      },
      "assets-enqueue_dir": {
        "name": "Assets.enqueue_dir",
        "sig": "Assets.enqueue_dir(path: dir)",
        "tip": "Enqueue every file of a directory, named by its file name.",
        "kind": "namespace-method",
        "page": "assets-enqueue_dir.html",
        "section": "Assets"
      },
      "kw-test": {
        "name": "test",
        "sig": "test \"name\" { … }",
        "tip": "A named test block, run automatically with pass/fail reporting.",
        "kind": "keyword",
        "page": "kw-test.html",
        "section": "Testing"
      },
      "pool-live": {
        "name": "Pool.live",
        "sig": "Pool.live() -> int",
        "tip": "How many entities are currently alive.",
        "kind": "namespace-method",
        "page": "pool-live.html",
        "section": "Pool"
      },
      "pool-free": {
        "name": "Pool.free",
        "sig": "Pool.free() -> int",
        "tip": "How many freed slots are waiting to be reused.",
        "kind": "namespace-method",
        "page": "pool-free.html",
        "section": "Pool"
      },
      "pool-reserved": {
        "name": "Pool.reserved",
        "sig": "Pool.reserved() -> int",
        "tip": "High-water: how many slots have ever been allocated.",
        "kind": "namespace-method",
        "page": "pool-reserved.html",
        "section": "Pool"
      },
      "pool-capacity": {
        "name": "Pool.capacity",
        "sig": "Pool.capacity() -> int",
        "tip": "The maximum number of entities.",
        "kind": "namespace-method",
        "page": "pool-capacity.html",
        "section": "Pool"
      },
      "value-null": {
        "name": "Value.null",
        "sig": "Value.null() -> value",
        "tip": "An empty null node.",
        "kind": "namespace-method",
        "page": "value-null.html",
        "section": "Value"
      },
      "value-int": {
        "name": "Value.int",
        "sig": "Value.int(n: int) -> value",
        "tip": "Wrap an int in a value node.",
        "kind": "namespace-method",
        "page": "value-int.html",
        "section": "Value"
      },
      "value-fixed": {
        "name": "Value.fixed",
        "sig": "Value.fixed(f: fixed) -> value",
        "tip": "Wrap a fixed in a value node.",
        "kind": "namespace-method",
        "page": "value-fixed.html",
        "section": "Value"
      },
      "value-bool": {
        "name": "Value.bool",
        "sig": "Value.bool(b: bool) -> value",
        "tip": "Wrap a bool in a value node.",
        "kind": "namespace-method",
        "page": "value-bool.html",
        "section": "Value"
      },
      "value-str": {
        "name": "Value.str",
        "sig": "Value.str(s: string) -> value",
        "tip": "Wrap a string in a value node.",
        "kind": "namespace-method",
        "page": "value-str.html",
        "section": "Value"
      },
      "value-list": {
        "name": "Value.list",
        "sig": "Value.list() -> value",
        "tip": "An empty list node.",
        "kind": "namespace-method",
        "page": "value-list.html",
        "section": "Value"
      },
      "value-object": {
        "name": "Value.object",
        "sig": "Value.object() -> value",
        "tip": "An empty object node.",
        "kind": "namespace-method",
        "page": "value-object.html",
        "section": "Value"
      },
      "value-add": {
        "name": "Value.add",
        "sig": "Value.add(list, item) -> value",
        "tip": "Append an item to a list; returns the list.",
        "kind": "namespace-method",
        "page": "value-add.html",
        "section": "Value"
      },
      "value-put": {
        "name": "Value.put",
        "sig": "Value.put(obj, key: string, item) -> value",
        "tip": "Set a key on an object; returns the object.",
        "kind": "namespace-method",
        "page": "value-put.html",
        "section": "Value"
      },
      "value-get": {
        "name": "Value.get",
        "sig": "Value.get(obj, key: string) -> value",
        "tip": "Read a member of an object by key.",
        "kind": "namespace-method",
        "page": "value-get.html",
        "section": "Value"
      },
      "value-has": {
        "name": "Value.has",
        "sig": "Value.has(obj, key: string) -> bool",
        "tip": "Whether an object has a member.",
        "kind": "namespace-method",
        "page": "value-has.html",
        "section": "Value"
      },
      "value-at": {
        "name": "Value.at",
        "sig": "Value.at(list, index: int) -> value",
        "tip": "Read a list item by index.",
        "kind": "namespace-method",
        "page": "value-at.html",
        "section": "Value"
      },
      "value-key_at": {
        "name": "Value.key_at",
        "sig": "Value.key_at(obj, index: int) -> string",
        "tip": "The key of an object member by position.",
        "kind": "namespace-method",
        "page": "value-key_at.html",
        "section": "Value"
      },
      "value-count": {
        "name": "Value.count",
        "sig": "Value.count(value) -> int",
        "tip": "Number of items/members in a list or object.",
        "kind": "namespace-method",
        "page": "value-count.html",
        "section": "Value"
      },
      "value-kind": {
        "name": "Value.kind",
        "sig": "Value.kind(value) -> int",
        "tip": "The node's kind tag.",
        "kind": "namespace-method",
        "page": "value-kind.html",
        "section": "Value"
      },
      "value-as_int": {
        "name": "Value.as_int",
        "sig": "Value.as_int(value) -> int",
        "tip": "Read a scalar node as an int.",
        "kind": "namespace-method",
        "page": "value-as_int.html",
        "section": "Value"
      },
      "value-as_str": {
        "name": "Value.as_str",
        "sig": "Value.as_str(value) -> string",
        "tip": "Read a str node's text.",
        "kind": "namespace-method",
        "page": "value-as_str.html",
        "section": "Value"
      },
      "json-encode": {
        "name": "Json.encode",
        "sig": "Json.encode(value) -> string",
        "tip": "Serialize a value tree to compact JSON text.",
        "kind": "namespace-method",
        "page": "json-encode.html",
        "section": "Json"
      },
      "json-parse": {
        "name": "Json.parse",
        "sig": "Json.parse(text: string) -> value",
        "tip": "Parse JSON text into a value tree.",
        "kind": "namespace-method",
        "page": "json-parse.html",
        "section": "Json"
      },
      "job-defer": {
        "name": "Job.defer",
        "sig": "Job.defer() -> Job",
        "tip": "A future you resolve yourself later.",
        "kind": "namespace-method",
        "page": "job-defer.html",
        "section": "Job"
      },
      "job-run": {
        "name": "Job.run",
        "sig": "Job.run(kind, arg) -> Job",
        "tip": "Start a background compute job.",
        "kind": "namespace-method",
        "page": "job-run.html",
        "section": "Job"
      },
      "job-fulfill": {
        "name": "Job.fulfill",
        "sig": "Job.fulfill(handle, value) -> void",
        "tip": "Resolve a pending job with a value.",
        "kind": "namespace-method",
        "page": "job-fulfill.html",
        "section": "Job"
      },
      "job-fail": {
        "name": "Job.fail",
        "sig": "Job.fail(handle, error) -> void",
        "tip": "Resolve a pending job as failed.",
        "kind": "namespace-method",
        "page": "job-fail.html",
        "section": "Job"
      },
      "job-cancel": {
        "name": "Job.cancel",
        "sig": "Job.cancel(handle) -> void",
        "tip": "Cancel a job before it finishes.",
        "kind": "namespace-method",
        "page": "job-cancel.html",
        "section": "Job"
      },
      "job-pump": {
        "name": "Job.pump",
        "sig": "Job.pump(budget) -> int",
        "tip": "Advance background jobs; collect results.",
        "kind": "namespace-method",
        "page": "job-pump.html",
        "section": "Job"
      },
      "job-done": {
        "name": "Job.done",
        "sig": "Job.done(handle) -> bool",
        "tip": "Has the job resolved (any outcome)?",
        "kind": "namespace-method",
        "page": "job-done.html",
        "section": "Job"
      },
      "job-ok": {
        "name": "Job.ok",
        "sig": "Job.ok(handle) -> bool",
        "tip": "Did the job succeed?",
        "kind": "namespace-method",
        "page": "job-ok.html",
        "section": "Job"
      },
      "job-failed": {
        "name": "Job.failed",
        "sig": "Job.failed(handle) -> bool",
        "tip": "Did the job fail?",
        "kind": "namespace-method",
        "page": "job-failed.html",
        "section": "Job"
      },
      "job-cancelled": {
        "name": "Job.cancelled",
        "sig": "Job.cancelled(handle) -> bool",
        "tip": "Was the job cancelled?",
        "kind": "namespace-method",
        "page": "job-cancelled.html",
        "section": "Job"
      },
      "job-result": {
        "name": "Job.result",
        "sig": "Job.result(handle) -> int",
        "tip": "The success value of a done job.",
        "kind": "namespace-method",
        "page": "job-result.html",
        "section": "Job"
      },
      "job-error": {
        "name": "Job.error",
        "sig": "Job.error(handle) -> int",
        "tip": "The error code of a failed job.",
        "kind": "namespace-method",
        "page": "job-error.html",
        "section": "Job"
      },
      "job-pending": {
        "name": "Job.pending",
        "sig": "Job.pending() -> int",
        "tip": "How many jobs are still unresolved.",
        "kind": "namespace-method",
        "page": "job-pending.html",
        "section": "Job"
      },
      "job-free": {
        "name": "Job.free",
        "sig": "Job.free(handle) -> void",
        "tip": "Release a job slot back to the pool.",
        "kind": "namespace-method",
        "page": "job-free.html",
        "section": "Job"
      },
      "job-parallel_for": {
        "name": "Job.parallel_for",
        "sig": "Job.parallel_for(count, work, ctx) -> void",
        "tip": "Run work(i, ctx) for every i in [0, count) across all cores; returns when every call is done.",
        "kind": "namespace-method",
        "page": "job-parallel_for.html",
        "section": "Job"
      },
      "job-is_worker": {
        "name": "Job.is_worker",
        "sig": "Job.is_worker() -> bool",
        "tip": "True on a Job.parallel_for pool thread, false on the main thread.",
        "kind": "namespace-method",
        "page": "job-is_worker.html",
        "section": "Job"
      },
      "promise-all": {
        "name": "Promise.all",
        "sig": "Promise.all(handles) -> Job",
        "tip": "Succeeds when every member succeeds.",
        "kind": "namespace-method",
        "page": "promise-all.html",
        "section": "Promise"
      },
      "promise-race": {
        "name": "Promise.race",
        "sig": "Promise.race(handles) -> Job",
        "tip": "Succeeds when the first member does.",
        "kind": "namespace-method",
        "page": "promise-race.html",
        "section": "Promise"
      },
      "promise-count_done": {
        "name": "Promise.count_done",
        "sig": "Promise.count_done(handles) -> int",
        "tip": "How many members have resolved.",
        "kind": "namespace-method",
        "page": "promise-count_done.html",
        "section": "Promise"
      },
      "promise-all_done": {
        "name": "Promise.all_done",
        "sig": "Promise.all_done(handles) -> bool",
        "tip": "Have all members resolved?",
        "kind": "namespace-method",
        "page": "promise-all_done.html",
        "section": "Promise"
      },
      "sync-mutex": {
        "name": "Sync.mutex",
        "sig": "Sync.mutex() -> int",
        "tip": "Create a cooperative lock.",
        "kind": "namespace-method",
        "page": "sync-mutex.html",
        "section": "Sync"
      },
      "sync-lock": {
        "name": "Sync.lock",
        "sig": "Sync.lock(mutex) -> void",
        "tip": "Take the lock.",
        "kind": "namespace-method",
        "page": "sync-lock.html",
        "section": "Sync"
      },
      "sync-unlock": {
        "name": "Sync.unlock",
        "sig": "Sync.unlock(mutex) -> void",
        "tip": "Release the lock.",
        "kind": "namespace-method",
        "page": "sync-unlock.html",
        "section": "Sync"
      },
      "sync-try_lock": {
        "name": "Sync.try_lock",
        "sig": "Sync.try_lock(mutex) -> bool",
        "tip": "Take the lock only if it is free.",
        "kind": "namespace-method",
        "page": "sync-try_lock.html",
        "section": "Sync"
      },
      "sync-atomic": {
        "name": "Sync.atomic",
        "sig": "Sync.atomic() -> int",
        "tip": "Create an atomic counter (starts at 0).",
        "kind": "namespace-method",
        "page": "sync-atomic.html",
        "section": "Sync"
      },
      "sync-get": {
        "name": "Sync.get",
        "sig": "Sync.get(atomic) -> int",
        "tip": "Read the counter.",
        "kind": "namespace-method",
        "page": "sync-get.html",
        "section": "Sync"
      },
      "sync-set": {
        "name": "Sync.set",
        "sig": "Sync.set(atomic, value) -> void",
        "tip": "Store a value in the counter.",
        "kind": "namespace-method",
        "page": "sync-set.html",
        "section": "Sync"
      },
      "sync-add": {
        "name": "Sync.add",
        "sig": "Sync.add(atomic, delta) -> int",
        "tip": "Add to the counter; return the new value.",
        "kind": "namespace-method",
        "page": "sync-add.html",
        "section": "Sync"
      },
      "sync-cas": {
        "name": "Sync.cas",
        "sig": "Sync.cas(atomic, expect, next) -> bool",
        "tip": "Compare-and-set the counter.",
        "kind": "namespace-method",
        "page": "sync-cas.html",
        "section": "Sync"
      },
      "sync-channel": {
        "name": "Sync.channel",
        "sig": "Sync.channel() -> int",
        "tip": "Create a bounded int FIFO channel.",
        "kind": "namespace-method",
        "page": "sync-channel.html",
        "section": "Sync"
      },
      "sync-send": {
        "name": "Sync.send",
        "sig": "Sync.send(channel, value) -> bool",
        "tip": "Enqueue a value (false if full).",
        "kind": "namespace-method",
        "page": "sync-send.html",
        "section": "Sync"
      },
      "sync-recv": {
        "name": "Sync.recv",
        "sig": "Sync.recv(channel) -> int",
        "tip": "Dequeue the oldest value.",
        "kind": "namespace-method",
        "page": "sync-recv.html",
        "section": "Sync"
      },
      "sync-can_recv": {
        "name": "Sync.can_recv",
        "sig": "Sync.can_recv(channel) -> bool",
        "tip": "Is there a value waiting?",
        "kind": "namespace-method",
        "page": "sync-can_recv.html",
        "section": "Sync"
      },
      "sync-len": {
        "name": "Sync.len",
        "sig": "Sync.len(channel) -> int",
        "tip": "How many values are queued.",
        "kind": "namespace-method",
        "page": "sync-len.html",
        "section": "Sync"
      },
      "sync-cpu_count": {
        "name": "Sync.cpu_count",
        "sig": "Sync.cpu_count() -> int",
        "tip": "The machine's logical cores (1 to 64); Job.parallel_for uses one thread per core.",
        "kind": "namespace-method",
        "page": "sync-cpu_count.html",
        "section": "Sync"
      },
      "xml-parse": {
        "name": "Xml.parse",
        "sig": "Xml.parse(text: string) -> xml",
        "tip": "Parse XML text into an element tree.",
        "kind": "namespace-method",
        "page": "xml-parse.html",
        "section": "Xml"
      },
      "xml-tag": {
        "name": "Xml.tag",
        "sig": "Xml.tag(node) -> string",
        "tip": "The element's tag name.",
        "kind": "namespace-method",
        "page": "xml-tag.html",
        "section": "Xml"
      },
      "xml-text": {
        "name": "Xml.text",
        "sig": "Xml.text(node) -> string",
        "tip": "The element's character data.",
        "kind": "namespace-method",
        "page": "xml-text.html",
        "section": "Xml"
      },
      "xml-attr": {
        "name": "Xml.attr",
        "sig": "Xml.attr(node, key: string) -> string",
        "tip": "An attribute's value by name.",
        "kind": "namespace-method",
        "page": "xml-attr.html",
        "section": "Xml"
      },
      "xml-attr_int": {
        "name": "Xml.attr_int",
        "sig": "Xml.attr_int(node, key: string, dflt: int) -> int",
        "tip": "An attribute parsed as an integer.",
        "kind": "namespace-method",
        "page": "xml-attr_int.html",
        "section": "Xml"
      },
      "xml-has": {
        "name": "Xml.has",
        "sig": "Xml.has(node, key: string) -> int",
        "tip": "Whether an attribute is present.",
        "kind": "namespace-method",
        "page": "xml-has.html",
        "section": "Xml"
      },
      "xml-attr_count": {
        "name": "Xml.attr_count",
        "sig": "Xml.attr_count(node) -> int",
        "tip": "How many attributes the element has.",
        "kind": "namespace-method",
        "page": "xml-attr_count.html",
        "section": "Xml"
      },
      "xml-child_count": {
        "name": "Xml.child_count",
        "sig": "Xml.child_count(node) -> int",
        "tip": "How many child elements.",
        "kind": "namespace-method",
        "page": "xml-child_count.html",
        "section": "Xml"
      },
      "xml-child": {
        "name": "Xml.child",
        "sig": "Xml.child(node, index: int) -> xml",
        "tip": "A child element by index.",
        "kind": "namespace-method",
        "page": "xml-child.html",
        "section": "Xml"
      },
      "xml-find": {
        "name": "Xml.find",
        "sig": "Xml.find(node, tag: string) -> xml",
        "tip": "The first child with a given tag.",
        "kind": "namespace-method",
        "page": "xml-find.html",
        "section": "Xml"
      },
      "xml-count": {
        "name": "Xml.count",
        "sig": "Xml.count(node, tag: string) -> int",
        "tip": "How many children have a given tag.",
        "kind": "namespace-method",
        "page": "xml-count.html",
        "section": "Xml"
      },
      "base64-decode": {
        "name": "Base64.decode",
        "sig": "Base64.decode(src: string) -> string",
        "tip": "Decode standard base64 text to bytes.",
        "kind": "namespace-method",
        "page": "base64-decode.html",
        "section": "Base64"
      },
      "base64-encode": {
        "name": "Base64.encode",
        "sig": "Base64.encode(src: string) -> string",
        "tip": "Encode bytes as standard base64 text.",
        "kind": "namespace-method",
        "page": "base64-encode.html",
        "section": "Base64"
      },
      "tiled-read": {
        "name": "Tiled.read",
        "sig": "Tiled.read(path: string) -> value",
        "tip": "Read a map file into the intermediate value tree.",
        "kind": "namespace-method",
        "page": "tiled-read.html",
        "section": "Tiled"
      },
      "tiled-read_tsx": {
        "name": "Tiled.read_tsx",
        "sig": "Tiled.read_tsx(path: string) -> value",
        "tip": "Read a tileset file into a value object.",
        "kind": "namespace-method",
        "page": "tiled-read_tsx.html",
        "section": "Tiled"
      },
      "tiled-load": {
        "name": "Tiled.load",
        "sig": "Tiled.load(path: string) -> map",
        "tip": "Load a map file into the runtime map model.",
        "kind": "namespace-method",
        "page": "tiled-load.html",
        "section": "Tiled"
      },
      "tiled-gid": {
        "name": "Tiled.gid",
        "sig": "Tiled.gid(map, layer: int, x: int, y: int) -> int",
        "tip": "The raw GID at a cell in a tile layer.",
        "kind": "namespace-method",
        "page": "tiled-gid.html",
        "section": "Tiled"
      },
      "tiled-resolve": {
        "name": "Tiled.resolve",
        "sig": "Tiled.resolve(map, gid: int) -> gidinfo",
        "tip": "Decode a GID into tileset, local id and flip flags.",
        "kind": "namespace-method",
        "page": "tiled-resolve.html",
        "section": "Tiled"
      },
      "tiled-width": {
        "name": "Tiled.width",
        "sig": "Tiled.width(map) -> int",
        "tip": "The map width in tiles.",
        "kind": "namespace-method",
        "page": "tiled-width.html",
        "section": "Tiled"
      },
      "tiled-height": {
        "name": "Tiled.height",
        "sig": "Tiled.height(map) -> int",
        "tip": "The map height in tiles.",
        "kind": "namespace-method",
        "page": "tiled-height.html",
        "section": "Tiled"
      },
      "tiled-layer_count": {
        "name": "Tiled.layer_count",
        "sig": "Tiled.layer_count(map) -> int",
        "tip": "How many layers the map has.",
        "kind": "namespace-method",
        "page": "tiled-layer_count.html",
        "section": "Tiled"
      },
      "tiled-layer_name": {
        "name": "Tiled.layer_name",
        "sig": "Tiled.layer_name(map, index: int) -> string",
        "tip": "A layer's name by index.",
        "kind": "namespace-method",
        "page": "tiled-layer_name.html",
        "section": "Tiled"
      },
      "tiled-draw": {
        "name": "Tiled.draw",
        "sig": "Tiled.draw(map, camx: int, camy: int) -> void",
        "tip": "Draw every visible tile layer.",
        "kind": "namespace-method",
        "page": "tiled-draw.html",
        "section": "Tiled"
      },
      "tiled-project": {
        "name": "Tiled.project",
        "sig": "Tiled.project(map, layer: int) -> void",
        "tip": "Project a collision layer to the byte tilemap.",
        "kind": "namespace-method",
        "page": "tiled-project.html",
        "section": "Tiled"
      },
      "tiled-tree": {
        "name": "Tiled.tree",
        "sig": "Tiled.tree(map) -> value",
        "tip": "The underlying intermediate value tree.",
        "kind": "namespace-method",
        "page": "tiled-tree.html",
        "section": "Tiled"
      },
      "tiled-tile_prop": {
        "name": "Tiled.tile_prop",
        "sig": "Tiled.tile_prop(map, gid: int, name: string) -> int",
        "tip": "Whether a GID's tile carries a bool property.",
        "kind": "namespace-method",
        "page": "tiled-tile_prop.html",
        "section": "Tiled"
      },
      "tiled-collide": {
        "name": "Tiled.collide",
        "sig": "Tiled.collide(map, layer: int) -> void",
        "tip": "Drive collision from per-tile metadata.",
        "kind": "namespace-method",
        "page": "tiled-collide.html",
        "section": "Tiled"
      },
      "tiled-collision_kind": {
        "name": "Tiled.collision_kind",
        "sig": "Tiled.collision_kind(map, gid: int) -> int",
        "tip": "Classify a GID's collision from its tile metadata.",
        "kind": "namespace-method",
        "page": "tiled-collision_kind.html",
        "section": "Tiled"
      },
      "tiled-tile_shapes": {
        "name": "Tiled.tile_shapes",
        "sig": "Tiled.tile_shapes(map, gid: int) -> int",
        "tip": "Whether a GID's tile has a collision shape.",
        "kind": "namespace-method",
        "page": "tiled-tile_shapes.html",
        "section": "Tiled"
      },
      "tiled-draw_anim": {
        "name": "Tiled.draw_anim",
        "sig": "Tiled.draw_anim(map, camx: int, camy: int, frame: int) -> void",
        "tip": "Draw with animated tiles advanced to a frame.",
        "kind": "namespace-method",
        "page": "tiled-draw_anim.html",
        "section": "Tiled"
      },
      "tiled-frame_gid": {
        "name": "Tiled.frame_gid",
        "sig": "Tiled.frame_gid(map, gid: int, frame: int) -> int",
        "tip": "The current GID of an animated tile at a frame.",
        "kind": "namespace-method",
        "page": "tiled-frame_gid.html",
        "section": "Tiled"
      },
      "tiled-animated": {
        "name": "Tiled.animated",
        "sig": "Tiled.animated(map, gid: int) -> int",
        "tip": "Whether a GID's tile is animated.",
        "kind": "namespace-method",
        "page": "tiled-animated.html",
        "section": "Tiled"
      },
      "tiled-object_count": {
        "name": "Tiled.object_count",
        "sig": "Tiled.object_count(map, layer: int) -> int",
        "tip": "How many objects an object layer holds.",
        "kind": "namespace-method",
        "page": "tiled-object_count.html",
        "section": "Tiled"
      },
      "tiled-object": {
        "name": "Tiled.object",
        "sig": "Tiled.object(map, layer: int, index: int) -> value",
        "tip": "An object on an object layer by index.",
        "kind": "namespace-method",
        "page": "tiled-object.html",
        "section": "Tiled"
      },
      "tiled-object_shape": {
        "name": "Tiled.object_shape",
        "sig": "Tiled.object_shape(object) -> string",
        "tip": "Classify an object's shape.",
        "kind": "namespace-method",
        "page": "tiled-object_shape.html",
        "section": "Tiled"
      },
      "tiled-prop": {
        "name": "Tiled.prop",
        "sig": "Tiled.prop(container, name: string) -> string",
        "tip": "A custom property's value, with class-default fallback.",
        "kind": "namespace-method",
        "page": "tiled-prop.html",
        "section": "Tiled"
      },
      "tiled-prop_int": {
        "name": "Tiled.prop_int",
        "sig": "Tiled.prop_int(container, name: string) -> int",
        "tip": "A custom property parsed as an integer.",
        "kind": "namespace-method",
        "page": "tiled-prop_int.html",
        "section": "Tiled"
      },
      "tiled-prop_type": {
        "name": "Tiled.prop_type",
        "sig": "Tiled.prop_type(container, name: string) -> string",
        "tip": "A custom property's declared type.",
        "kind": "namespace-method",
        "page": "tiled-prop_type.html",
        "section": "Tiled"
      },
      "tiled-load_types": {
        "name": "Tiled.load_types",
        "sig": "Tiled.load_types(path: string) -> int",
        "tip": "Load a project custom-type table.",
        "kind": "namespace-method",
        "page": "tiled-load_types.html",
        "section": "Tiled"
      },
      "tiled-template": {
        "name": "Tiled.template",
        "sig": "Tiled.template(path: string) -> value",
        "tip": "Read a template file into an object value.",
        "kind": "namespace-method",
        "page": "tiled-template.html",
        "section": "Tiled"
      },
      "tiled-spawn": {
        "name": "Tiled.spawn",
        "sig": "Tiled.spawn(map, object, model: string) -> int",
        "tip": "Spawn a Ludic entity from an object.",
        "kind": "namespace-method",
        "page": "tiled-spawn.html",
        "section": "Tiled"
      },
      "tiled-spawn_layer": {
        "name": "Tiled.spawn_layer",
        "sig": "Tiled.spawn_layer(map, layer: int, model: string) -> int",
        "tip": "Spawn every object on a layer.",
        "kind": "namespace-method",
        "page": "tiled-spawn_layer.html",
        "section": "Tiled"
      },
      "tiled-cell_x": {
        "name": "Tiled.cell_x",
        "sig": "Tiled.cell_x(map, x: int, y: int) -> int",
        "tip": "The screen x of a tile cell for the map orientation.",
        "kind": "namespace-method",
        "page": "tiled-cell_x.html",
        "section": "Tiled"
      },
      "tiled-cell_y": {
        "name": "Tiled.cell_y",
        "sig": "Tiled.cell_y(map, x: int, y: int) -> int",
        "tip": "The screen y of a tile cell for the map orientation.",
        "kind": "namespace-method",
        "page": "tiled-cell_y.html",
        "section": "Tiled"
      },
      "tiled-layer_kind": {
        "name": "Tiled.layer_kind",
        "sig": "Tiled.layer_kind(map, layer: int) -> int",
        "tip": "A layer's kind.",
        "kind": "namespace-method",
        "page": "tiled-layer_kind.html",
        "section": "Tiled"
      },
      "tiled-layer_opacity": {
        "name": "Tiled.layer_opacity",
        "sig": "Tiled.layer_opacity(map, layer: int) -> string",
        "tip": "A layer's opacity.",
        "kind": "namespace-method",
        "page": "tiled-layer_opacity.html",
        "section": "Tiled"
      },
      "tiled-layer_tint": {
        "name": "Tiled.layer_tint",
        "sig": "Tiled.layer_tint(map, layer: int) -> string",
        "tip": "A layer's tint colour.",
        "kind": "namespace-method",
        "page": "tiled-layer_tint.html",
        "section": "Tiled"
      },
      "tiled-layer_offsetx": {
        "name": "Tiled.layer_offsetx",
        "sig": "Tiled.layer_offsetx(map, layer: int) -> int",
        "tip": "A layer's horizontal offset.",
        "kind": "namespace-method",
        "page": "tiled-layer_offsetx.html",
        "section": "Tiled"
      },
      "tiled-layer_offsety": {
        "name": "Tiled.layer_offsety",
        "sig": "Tiled.layer_offsety(map, layer: int) -> int",
        "tip": "A layer's vertical offset.",
        "kind": "namespace-method",
        "page": "tiled-layer_offsety.html",
        "section": "Tiled"
      },
      "tiled-world": {
        "name": "Tiled.world",
        "sig": "Tiled.world(path: string) -> value",
        "tip": "Read a .world file.",
        "kind": "namespace-method",
        "page": "tiled-world.html",
        "section": "Tiled"
      },
      "tiled-world_count": {
        "name": "Tiled.world_count",
        "sig": "Tiled.world_count(world) -> int",
        "tip": "How many maps a world stitches.",
        "kind": "namespace-method",
        "page": "tiled-world_count.html",
        "section": "Tiled"
      },
      "tiled-world_map": {
        "name": "Tiled.world_map",
        "sig": "Tiled.world_map(world, index: int) -> value",
        "tip": "A world member map by index.",
        "kind": "namespace-method",
        "page": "tiled-world_map.html",
        "section": "Tiled"
      },
      "ui-build": {
        "name": "Ui.build",
        "sig": "Ui.build()",
        "tip": "Construct every declared ui block (loads skins, measures fonts).",
        "kind": "namespace-method",
        "page": "ui-build.html",
        "section": "Ui"
      },
      "ui-open": {
        "name": "Ui.open",
        "sig": "Ui.open(id: UI_Name)",
        "tip": "Make one menu active and focus its first button.",
        "kind": "namespace-method",
        "page": "ui-open.html",
        "section": "Ui"
      },
      "ui-close": {
        "name": "Ui.close",
        "sig": "Ui.close()",
        "tip": "Deactivate the menu: no menu is open.",
        "kind": "namespace-method",
        "page": "ui-close.html",
        "section": "Ui"
      },
      "ui-tick": {
        "name": "Ui.tick",
        "sig": "Ui.tick(key: k)",
        "tip": "Advance navigation by one key (the frame loop does this for you).",
        "kind": "namespace-method",
        "page": "ui-tick.html",
        "section": "Ui"
      },
      "ui-clicked": {
        "name": "Ui.clicked",
        "sig": "Ui.clicked(id: UI_Name) -> bool",
        "tip": "Was this control activated this frame? (polled form of UiClicked)",
        "kind": "namespace-method",
        "page": "ui-clicked.html",
        "section": "Ui"
      },
      "ui-set_text": {
        "name": "Ui.set_text",
        "sig": "Ui.set_text(id: UI_Name, text: s)",
        "tip": "Replace a label's or button's text.",
        "kind": "namespace-method",
        "page": "ui-set_text.html",
        "section": "Ui"
      },
      "ui-render": {
        "name": "Ui.render",
        "sig": "Ui.render()",
        "tip": "Draw the active menu.",
        "kind": "namespace-method",
        "page": "ui-render.html",
        "section": "Ui"
      },
      "file-open": {
        "name": "File.open",
        "sig": "File.open(path: p, mode: m) -> pointer",
        "tip": "Open a file (fopen); null when it cannot be opened.",
        "kind": "namespace-method",
        "page": "file-open.html",
        "section": "File"
      },
      "file-read": {
        "name": "File.read",
        "sig": "File.read(file: f, buffer: b, count: n) -> int",
        "tip": "Read up to n bytes into a buffer; returns the bytes read.",
        "kind": "namespace-method",
        "page": "file-read.html",
        "section": "File"
      },
      "file-write": {
        "name": "File.write",
        "sig": "File.write(file: f, buffer: b, count: n) -> int",
        "tip": "Write n bytes from a buffer; returns the bytes written.",
        "kind": "namespace-method",
        "page": "file-write.html",
        "section": "File"
      },
      "file-seek": {
        "name": "File.seek",
        "sig": "File.seek(file: f, offset: o, whence: w)",
        "tip": "Move the file cursor (0 start, 1 current, 2 end).",
        "kind": "namespace-method",
        "page": "file-seek.html",
        "section": "File"
      },
      "file-tell": {
        "name": "File.tell",
        "sig": "File.tell(file: f) -> int",
        "tip": "The cursor position in bytes.",
        "kind": "namespace-method",
        "page": "file-tell.html",
        "section": "File"
      },
      "file-close": {
        "name": "File.close",
        "sig": "File.close(file: f)",
        "tip": "Close a handle from File.open.",
        "kind": "namespace-method",
        "page": "file-close.html",
        "section": "File"
      },
      "font-load": {
        "name": "Font.load",
        "sig": "Font.load(path: p) -> int",
        "tip": "Load a TrueType font; returns a font handle.",
        "kind": "namespace-method",
        "page": "font-load.html",
        "section": "Font"
      },
      "fx-sparks": {
        "name": "Fx.sparks",
        "sig": "Fx.sparks(x: px, y: px, color: c, count: n)",
        "tip": "A burst of sparks flying out of a point.",
        "kind": "namespace-method",
        "page": "fx-sparks.html",
        "section": "Fx"
      },
      "fx-number": {
        "name": "Fx.number",
        "sig": "Fx.number(x: px, y: px, value: n, color: c)",
        "tip": "A number that floats up from a point and fades.",
        "kind": "namespace-method",
        "page": "fx-number.html",
        "section": "Fx"
      },
      "fx-clear": {
        "name": "Fx.clear",
        "sig": "Fx.clear()",
        "tip": "Drop every spark and number at once.",
        "kind": "namespace-method",
        "page": "fx-clear.html",
        "section": "Fx"
      },
      "prefab-spawn": {
        "name": "Prefab.spawn",
        "sig": "Prefab.spawn(name: s) -> entity",
        "tip": "Spawn a prefab chosen by name at runtime; -1 if none has that name.",
        "kind": "namespace-method",
        "page": "prefab-spawn.html",
        "section": "Prefab"
      },
      "prefab-spawn_at": {
        "name": "Prefab.spawn_at",
        "sig": "Prefab.spawn_at(name: s, at: IVec2) -> entity",
        "tip": "Spawn a prefab by name and place it.",
        "kind": "namespace-method",
        "page": "prefab-spawn_at.html",
        "section": "Prefab"
      },
      "app-splash_hide": {
        "name": "App.splash_hide",
        "sig": "App.splash_hide() -> void",
        "tip": "Dismiss the boot splash.",
        "kind": "namespace-method",
        "page": "app-splash_hide.html",
        "section": "App"
      },
      "app-set_icon": {
        "name": "App.set_icon",
        "sig": "App.set_icon(path) -> void",
        "tip": "Set the Dock icon from an image the game ships.",
        "kind": "namespace-method",
        "page": "app-set_icon.html",
        "section": "App"
      },
      "app-window_hide": {
        "name": "App.window_hide",
        "sig": "App.window_hide() -> void",
        "tip": "Take the game's window off the screen.",
        "kind": "namespace-method",
        "page": "app-window_hide.html",
        "section": "App"
      },
      "app-window_show": {
        "name": "App.window_show",
        "sig": "App.window_show() -> void",
        "tip": "Bring the game's window back.",
        "kind": "namespace-method",
        "page": "app-window_show.html",
        "section": "App"
      },
      "phase-start": {
        "name": "Start",
        "sig": "phase Start",
        "tip": "Runs once at boot, before the game loop — the place to set up initial state.",
        "kind": "phase",
        "page": "phase-start.html",
        "section": "Phases"
      },
      "phase-input": {
        "name": "Input",
        "sig": "phase Input",
        "tip": "The first per-frame phase — read the keyboard and record the player's intent.",
        "kind": "phase",
        "page": "phase-input.html",
        "section": "Phases"
      },
      "phase-fixedupdate": {
        "name": "FixedUpdate",
        "sig": "phase FixedUpdate",
        "tip": "The deterministic simulation step — physics and gameplay meant to be reproducible.",
        "kind": "phase",
        "page": "phase-fixedupdate.html",
        "section": "Phases"
      },
      "phase-update": {
        "name": "Update",
        "sig": "phase Update",
        "tip": "The ordinary per-frame game-logic step, run after Input and FixedUpdate.",
        "kind": "phase",
        "page": "phase-update.html",
        "section": "Phases"
      },
      "phase-lateupdate": {
        "name": "LateUpdate",
        "sig": "phase LateUpdate",
        "tip": "Runs each frame after Update and before Render.",
        "kind": "phase",
        "page": "phase-lateupdate.html",
        "section": "Phases"
      },
      "phase-render": {
        "name": "Render",
        "sig": "phase Render",
        "tip": "The last per-frame phase — draw the world, then call Screen.show() once.",
        "kind": "phase",
        "page": "phase-render.html",
        "section": "Phases"
      },
      "phase-overlay": {
        "name": "Overlay",
        "sig": "phase Overlay",
        "tip": "The HUD pass — runs after Render and after every engine-owned drawing system.",
        "kind": "phase",
        "page": "phase-overlay.html",
        "section": "Phases"
      },
      "ns-angle": {
        "name": "Angle",
        "sig": "Angle.*",
        "kind": "namespace",
        "tip": "An auto-wrapping angle in radians, so you never juggle % TAU by hand.",
        "page": "ns-angle.html",
        "section": "Namespaces"
      },
      "ns-anim": {
        "name": "Anim",
        "sig": "Anim.*",
        "kind": "namespace",
        "tip": "Spritesheet frame animation off the fixed frame clock.",
        "page": "ns-anim.html",
        "section": "Namespaces"
      },
      "ns-app": {
        "name": "App",
        "sig": "App.*",
        "kind": "namespace",
        "tip": "The running application, as distinct from its window.",
        "page": "ns-app.html",
        "section": "Namespaces"
      },
      "ns-assets": {
        "name": "Assets",
        "sig": "Assets.*",
        "kind": "namespace",
        "tip": "Loading and lookup for whole-file assets, paired with the Sprite.* atlas API.",
        "page": "ns-assets.html",
        "section": "Namespaces"
      },
      "ns-audio": {
        "name": "Audio",
        "sig": "Audio.*",
        "kind": "namespace",
        "tip": "Sound effects and music.",
        "page": "ns-audio.html",
        "section": "Namespaces"
      },
      "ns-base64": {
        "name": "Base64",
        "sig": "Base64.*",
        "kind": "namespace",
        "tip": "Standard base64 (RFC 4648) — Base64.decode reads base64 text into the bytes it stands for, and Base64.encode is the inverse.",
        "page": "ns-base64.html",
        "section": "Namespaces"
      },
      "ns-bigint": {
        "name": "BigInt",
        "sig": "BigInt.*",
        "kind": "namespace",
        "tip": "Arbitrary-precision integers with no upper bound, for idle/incremental counters, exact huge currencies, and score arithmetic that a 32- or 64-bit int would…",
        "page": "ns-bigint.html",
        "section": "Namespaces"
      },
      "ns-camera": {
        "name": "Camera",
        "sig": "Camera.*",
        "kind": "namespace",
        "tip": "A world-space camera — a draw offset threaded through the render path (the same offset Screen.camera sets).",
        "page": "ns-camera.html",
        "section": "Namespaces"
      },
      "ns-clock": {
        "name": "Clock",
        "sig": "Clock.*",
        "kind": "namespace",
        "tip": "A game-controlled simulated clock: a single seconds counter the game owns.",
        "page": "ns-clock.html",
        "section": "Namespaces"
      },
      "ns-collision": {
        "name": "Collision",
        "sig": "Collision.*",
        "kind": "namespace",
        "tip": "2D overlap tests on integer coordinates (pixels or tiles).",
        "page": "ns-collision.html",
        "section": "Namespaces"
      },
      "ns-color": {
        "name": "Color",
        "sig": "Color.*",
        "kind": "namespace",
        "tip": "The named color palette.",
        "page": "ns-color.html",
        "section": "Namespaces"
      },
      "ns-crypto": {
        "name": "Crypto",
        "sig": "Crypto.*",
        "kind": "namespace",
        "tip": "Secure, test-vector-backed hashing for the handful of security-sensitive things a game actually does: signing a save or leaderboard payload so casual tampering…",
        "page": "ns-crypto.html",
        "section": "Namespaces"
      },
      "ns-date": {
        "name": "Date",
        "sig": "Date.*",
        "kind": "namespace",
        "tip": "Calendar days on the proleptic Gregorian calendar (UTC).",
        "page": "ns-date.html",
        "section": "Namespaces"
      },
      "ns-datetime": {
        "name": "DateTime",
        "sig": "DateTime.*",
        "kind": "namespace",
        "tip": "Instants on the wall-clock timeline (UTC), stored as a plain int: the count of seconds since 1970-01-01, matching Time.now.",
        "page": "ns-datetime.html",
        "section": "Namespaces"
      },
      "ns-decimal": {
        "name": "Decimal",
        "sig": "Decimal.*",
        "kind": "namespace",
        "tip": "Exact base-10 fixed-point numbers for game economies — prices, balances and taxes on values like 0.10 that binary floating point cannot represent, so they…",
        "page": "ns-decimal.html",
        "section": "Namespaces"
      },
      "ns-dict": {
        "name": "Dict",
        "sig": "Dict.*",
        "kind": "namespace",
        "tip": "A hash map from string keys to int values — the everyday lookup a game needs, like resource counts or an id registry by name.",
        "page": "ns-dict.html",
        "section": "Namespaces"
      },
      "ns-duration": {
        "name": "Duration",
        "sig": "Duration.*",
        "kind": "namespace",
        "tip": "Spans of real time, measured in whole seconds and carried in a plain int — so a duration adds, subtracts and compares with the ordinary operators…",
        "page": "ns-duration.html",
        "section": "Namespaces"
      },
      "ns-ease": {
        "name": "Ease",
        "sig": "Ease.*",
        "kind": "namespace",
        "tip": "Tween curves — the \"juice\" layer.",
        "page": "ns-ease.html",
        "section": "Namespaces"
      },
      "ns-file": {
        "name": "File",
        "sig": "File.*",
        "kind": "namespace",
        "tip": "Raw file access over the C stdio calls, for programs that read and write their own formats.",
        "page": "ns-file.html",
        "section": "Namespaces"
      },
      "ns-font": {
        "name": "Font",
        "sig": "Font.*",
        "kind": "namespace",
        "tip": "TrueType fonts for the retained UI and for Screen.draw_text-style drawing.",
        "page": "ns-font.html",
        "section": "Namespaces"
      },
      "ns-fs": {
        "name": "Fs",
        "sig": "Fs.*",
        "kind": "namespace",
        "tip": "The filesystem, wrapped into one safe, ergonomic API — no file descriptors, no byte buffers, no half-written files.",
        "page": "ns-fs.html",
        "section": "Namespaces"
      },
      "ns-fx": {
        "name": "Fx",
        "sig": "Fx.*",
        "kind": "namespace",
        "tip": "Engine-owned transient effects.",
        "page": "ns-fx.html",
        "section": "Namespaces"
      },
      "ns-grid": {
        "name": "Grid",
        "sig": "Grid.*",
        "kind": "namespace",
        "tip": "Tile geometry and pathfinding over the Map tilemap.",
        "page": "ns-grid.html",
        "section": "Namespaces"
      },
      "ns-hash": {
        "name": "Hash",
        "sig": "Hash.*",
        "kind": "namespace",
        "tip": "Fast, non-cryptographic hashing for everyday game needs: turning string IDs into integer handles, mixing a few numbers into one deterministic seed, and…",
        "page": "ns-hash.html",
        "section": "Namespaces"
      },
      "ns-http": {
        "name": "Http",
        "sig": "Http.*",
        "kind": "namespace",
        "tip": "A poll-based HTTP / HTTPS client for out-of-band data — leaderboards, cloud saves, remote config, telemetry, downloads.",
        "page": "ns-http.html",
        "section": "Namespaces"
      },
      "ns-huge": {
        "name": "Huge",
        "sig": "Huge.*",
        "kind": "namespace",
        "tip": "Idle/incremental big numbers — magnitudes far past what a 32- or 64-bit integer can hold, for prestige currencies and exponential growth.",
        "page": "ns-huge.html",
        "section": "Namespaces"
      },
      "ns-ivec2": {
        "name": "IVec2",
        "sig": "IVec2.*",
        "kind": "namespace",
        "tip": "Integer 2D vector math for tile and grid coordinates, cell offsets, and integer sizes.",
        "page": "ns-ivec2.html",
        "section": "Namespaces"
      },
      "ns-input": {
        "name": "Input",
        "sig": "Input.*",
        "kind": "namespace",
        "tip": "Reading input.",
        "page": "ns-input.html",
        "section": "Namespaces"
      },
      "ns-job": {
        "name": "Job",
        "sig": "Job.*",
        "kind": "namespace",
        "tip": "Background work that stays out of the frame.",
        "page": "ns-job.html",
        "section": "Namespaces"
      },
      "ns-json": {
        "name": "Json",
        "sig": "Json.*",
        "kind": "namespace",
        "tip": "The text bridge over the Value tree: Json.encode turns a value tree into compact, stable JSON text and Json.parse reads it back.",
        "page": "ns-json.html",
        "section": "Namespaces"
      },
      "ns-light": {
        "name": "Light",
        "sig": "Light.*",
        "kind": "namespace",
        "tip": "A software 2D light-accumulation pass over the framebuffer, run in a render phase after drawing the scene and before Screen.show.",
        "page": "ns-light.html",
        "section": "Namespaces"
      },
      "ns-list": {
        "name": "List",
        "sig": "List.*",
        "kind": "namespace",
        "tip": "Operations over []T slices — length, ends access, push/pop, swap, search, and in-place reverse.",
        "page": "ns-list.html",
        "section": "Namespaces"
      },
      "ns-log": {
        "name": "Log",
        "sig": "Log.*",
        "kind": "namespace",
        "tip": "Levelled, structured logging — the default way to answer \"what is my game doing?\" and \"why did that break?\", and a real step up from scattering print calls…",
        "page": "ns-log.html",
        "section": "Namespaces"
      },
      "ns-map": {
        "name": "Map",
        "sig": "Map.*",
        "kind": "namespace",
        "tip": "A character grid the game paints and reads.",
        "page": "ns-map.html",
        "section": "Namespaces"
      },
      "ns-math": {
        "name": "Math",
        "sig": "Math.*",
        "kind": "namespace",
        "tip": "Deterministic fixed-point math.",
        "page": "ns-math.html",
        "section": "Namespaces"
      },
      "ns-memory": {
        "name": "Memory",
        "sig": "Memory.*",
        "kind": "namespace",
        "tip": "Raw memory — allocate byte and word buffers, copy and fill regions, and peek/poke individual bytes.",
        "page": "ns-memory.html",
        "section": "Namespaces"
      },
      "ns-mime": {
        "name": "Mime",
        "sig": "Mime.*",
        "kind": "namespace",
        "tip": "Content-type detection for assets and downloads: map a filename to its MIME type, or refine the guess by peeking at a file's leading bytes.",
        "page": "ns-mime.html",
        "section": "Namespaces"
      },
      "ns-motion": {
        "name": "Motion",
        "sig": "Motion.*",
        "kind": "namespace",
        "tip": "Ergonomic control of the engine-owned Motion component — the value tween the engine advances each tick (see the ECS engine-systems).",
        "page": "ns-motion.html",
        "section": "Namespaces"
      },
      "ns-network": {
        "name": "Network",
        "sig": "Network.*",
        "kind": "namespace",
        "tip": "The low-level networking seam — send and poll datagrams, serialize and apply entity state, and read ownership and role.",
        "page": "ns-network.html",
        "section": "Namespaces"
      },
      "ns-noise": {
        "name": "Noise",
        "sig": "Noise.*",
        "kind": "namespace",
        "tip": "Procedural noise — the primitive that terrain, caves, biomes, textures, clouds, wind, and object placement are built on.",
        "page": "ns-noise.html",
        "section": "Namespaces"
      },
      "ns-os": {
        "name": "Os",
        "sig": "Os.*",
        "kind": "namespace",
        "tip": "The operating-system interface — the environment *around* the game rather than the game itself: the command line, environment variables, the standard streams,…",
        "page": "ns-os.html",
        "section": "Namespaces"
      },
      "ns-path": {
        "name": "Path",
        "sig": "Path.*",
        "kind": "namespace",
        "tip": "Path manipulation as pure string operations — no disk access, no allocation surprises, just the joining and splitting every save system, mod loader, and asset…",
        "page": "ns-path.html",
        "section": "Namespaces"
      },
      "ns-percent": {
        "name": "Percent",
        "sig": "Percent.*",
        "kind": "namespace",
        "tip": "A value clamped to [0, 1] — health fractions, volumes, and the t of an interpolation, without stray values slipping below 0 or above 1.",
        "page": "ns-percent.html",
        "section": "Namespaces"
      },
      "ns-pool": {
        "name": "Pool",
        "sig": "Pool.*",
        "kind": "namespace",
        "tip": "Entity-pool statistics.",
        "page": "ns-pool.html",
        "section": "Namespaces"
      },
      "ns-prefab": {
        "name": "Prefab",
        "sig": "Prefab.*",
        "kind": "namespace",
        "tip": "A prefab is a model with preset component fields — prefab Grunt: Creature { Stats { hp: 30 }, Weapon { def_id: 1 } } — spawned with spawn Grunt { Position { x:…",
        "page": "ns-prefab.html",
        "section": "Namespaces"
      },
      "ns-process": {
        "name": "Process",
        "sig": "Process.*",
        "kind": "namespace",
        "tip": "Child processes, started and polled — what a launcher is made of.",
        "page": "ns-process.html",
        "section": "Namespaces"
      },
      "ns-promise": {
        "name": "Promise",
        "sig": "Promise.*",
        "kind": "namespace",
        "tip": "Combine several Job futures and resolve the group on the main thread.",
        "page": "ns-promise.html",
        "section": "Namespaces"
      },
      "ns-query": {
        "name": "Query",
        "sig": "Query.*",
        "kind": "namespace",
        "tip": "Spatial and set queries over the live entities that carry a property, built on the World reflection ABI.",
        "page": "ns-query.html",
        "section": "Namespaces"
      },
      "ns-random": {
        "name": "Random",
        "sig": "Random.*",
        "kind": "namespace",
        "tip": "A seeded, deterministic RNG — same seed, same sequence, every run and every platform.",
        "page": "ns-random.html",
        "section": "Namespaces"
      },
      "ns-rect": {
        "name": "Rect",
        "sig": "Rect.*",
        "kind": "namespace",
        "tip": "Axis-aligned rectangles for HUD layout boxes, hitboxes, and camera regions.",
        "page": "ns-rect.html",
        "section": "Namespaces"
      },
      "ns-reflect": {
        "name": "Reflect",
        "sig": "Reflect.*",
        "kind": "namespace",
        "tip": "Runtime reflection over the world schema — inspect properties, fields, and entity state by name and by index.",
        "page": "ns-reflect.html",
        "section": "Namespaces"
      },
      "ns-regex": {
        "name": "Regex",
        "sig": "Regex.*",
        "kind": "namespace",
        "tip": "Regular expressions with PCRE/PECL-compatible syntax over a **linear-time** Thompson NFA (a Pike VM), so a bad pattern from a modder can never trigger…",
        "page": "ns-regex.html",
        "section": "Namespaces"
      },
      "ns-save": {
        "name": "Save",
        "sig": "Save.*",
        "kind": "namespace",
        "tip": "Whole-world save and restore — write a binary snapshot of the ECS world and read it back.",
        "page": "ns-save.html",
        "section": "Namespaces"
      },
      "ns-screen": {
        "name": "Screen",
        "sig": "Screen.*",
        "kind": "namespace",
        "tip": "The 2D drawing surface.",
        "page": "ns-screen.html",
        "section": "Namespaces"
      },
      "ns-set": {
        "name": "Set",
        "sig": "Set.*",
        "kind": "namespace",
        "tip": "A set of string members — membership tests for tags, unlocked achievements, or visited tiles.",
        "page": "ns-set.html",
        "section": "Namespaces"
      },
      "ns-sprite": {
        "name": "Sprite",
        "sig": "Sprite.*",
        "kind": "namespace",
        "tip": "A namespaced spritesheet / atlas API.",
        "page": "ns-sprite.html",
        "section": "Namespaces"
      },
      "ns-sync": {
        "name": "Sync",
        "sig": "Sync.*",
        "kind": "namespace",
        "tip": "The advanced, opt-in tier — here be dragons.",
        "page": "ns-sync.html",
        "section": "Namespaces"
      },
      "ns-system": {
        "name": "System",
        "sig": "System.*",
        "kind": "namespace",
        "tip": "Low-level file and process access — raw file handles, reading a character, and running a shell command.",
        "page": "ns-system.html",
        "section": "Namespaces"
      },
      "ns-text": {
        "name": "Text",
        "sig": "Text.*",
        "kind": "namespace",
        "tip": "String queries and building over string values — length, character access, substrings, search, prefix/suffix tests, and int conversion.",
        "page": "ns-text.html",
        "section": "Namespaces"
      },
      "ns-tiled": {
        "name": "Tiled",
        "sig": "Tiled.*",
        "kind": "namespace",
        "tip": "Load and draw Tiled maps.",
        "page": "ns-tiled.html",
        "section": "Namespaces"
      },
      "ns-time": {
        "name": "Time",
        "sig": "Time.*",
        "kind": "namespace",
        "tip": "The frame clock.",
        "page": "ns-time.html",
        "section": "Namespaces"
      },
      "ns-tween": {
        "name": "Tween",
        "sig": "Tween.*",
        "kind": "namespace",
        "tip": "Value interpolation over a timeline, off the fixed frame clock.",
        "page": "ns-tween.html",
        "section": "Namespaces"
      },
      "ns-udp": {
        "name": "Udp",
        "sig": "Udp.*",
        "kind": "namespace",
        "tip": "Plain IPv4 datagrams, polled — the transport under a game's own netcode: peer-to-peer play, a LAN lobby, a STUN query.",
        "page": "ns-udp.html",
        "section": "Namespaces"
      },
      "ns-ui": {
        "name": "Ui",
        "sig": "Ui.*",
        "kind": "namespace",
        "tip": "The retained-mode menu API over a ui block.",
        "page": "ns-ui.html",
        "section": "Namespaces"
      },
      "ns-unicode": {
        "name": "Unicode",
        "sig": "Unicode.*",
        "kind": "namespace",
        "tip": "Correct-by-default text over UTF-8.",
        "page": "ns-unicode.html",
        "section": "Namespaces"
      },
      "ns-uuid": {
        "name": "Uuid",
        "sig": "Uuid.*",
        "kind": "namespace",
        "tip": "Universally-unique identifiers — stable IDs that don't collide, generated locally with no central authority handing out numbers.",
        "page": "ns-uuid.html",
        "section": "Namespaces"
      },
      "ns-value": {
        "name": "Value",
        "sig": "Value.*",
        "kind": "namespace",
        "tip": "A generic, self-describing value tree — the node type reflection serializes into and JSON round-trips through.",
        "page": "ns-value.html",
        "section": "Namespaces"
      },
      "ns-vector": {
        "name": "Vector",
        "sig": "Vector.*",
        "kind": "namespace",
        "tip": "2D vector math for positions, velocities, and directions.",
        "page": "ns-vector.html",
        "section": "Namespaces"
      },
      "ns-world": {
        "name": "World",
        "sig": "World.*",
        "kind": "namespace",
        "tip": "Runtime reflection over the ECS world — read and write component fields by id, spawn and inspect entities, and register components at runtime.",
        "page": "ns-world.html",
        "section": "Namespaces"
      },
      "ns-xml": {
        "name": "Xml",
        "sig": "Xml.*",
        "kind": "namespace",
        "tip": "A minimal, deterministic XML reader for the element/attribute/CDATA subset the native Tiled formats (TMX/TSX/TX) use.",
        "page": "ns-xml.html",
        "section": "Namespaces"
      }
    },
    "colors_page": "ns-color"
  }
}