Runtime codes
What a script is thrown, a query refuses with, or the log prints while a game runs or builds.
| Name | Summary |
|---|---|
| animator-ik-unknown | the animator declares no IK chain by that name, or the entity has no animator (AnimatorIkError) |
| animator-look-at-missing | the animator component declares no lookAt, or the entity has no animator (AnimatorLookAtError) |
| animator-loop-seam | a looping state plays a clip whose last frame is far from its first (or, in a clips state, one clip that does not meet the next), so the pose jumps at every wrap; printed once per asset and state when the animator is built, listed on GET /feel → loop_seams |
| animator-param-unknown | the animator declares no parameter by that name, or the entity has no animator (AnimatorParamError) |
| animator-play-invalid | a blend or blendOut time is negative or not a number (AnimatorPlayError) |
| animator-play-unknown | play named a state, or a then, the animator does not have (AnimatorPlayError) |
| animator-stride-rate | a point of a stride-matched blend tree plays at more than 3x its clip's rate on its own at, or less than a third of it, because its clip's ground speed (measured from its feet or root, or its refSpeed) is far from where it sits; printed once per asset and point when the animator is built, listed on GET /feel → strides |
| animator-unknown | set named a state the animator does not have, so nothing changed; printed once per entity and name, every call counted on GET /feel → animator_misses |
| at_capacity | 503: a bounded resource is full, so the request was refused rather than queued |
| audio-loops-stacked | three or more loops of one sound play at once with none placed in the world (ctx.audio.play(asset, { loop: true }) without at, or looping non-spatial audio components), so they add up in the centre to one sound up to 20·log10(n) dB louder that masks the rest of the mix: usually one loop per entity, such as every car's engine; said once per asset, against the behaviour (or the audio component's entity) that started the third |
| author-failed | an authoring script (authoring/<name>.ts, run by behaviour.write with run) did not run to the end: it threw (with its line), a read it made was refused (outside the project, a dot-folder, node_modules, a link out, not text, over 16 MB), it ran past 10 s or 256 MB or made over 20,000 entities, or its default export is not a function; the scene is left as it was |
| bad_request | 400: the body or query parameters are wrong; the message quotes what was expected |
| behaviour-detached | a Behaviour instance's engine members were used on an instance the engine did not construct (new MyBehaviour() in a script) |
| behaviour-hook-unknown | a class X extends Behaviour has a method Behaviour never calls — Awake, FixedUpdate, LateUpdate, OnTriggerStay, OnCollisionStay, OnCollisionExit, or an object-form hook such as update; thrown in init |
| behaviour-prop-unknown | a class X extends Behaviour was given a script prop with no field of that name, so it would set nothing (thrown in init, which disables the behaviour); the message lists the fields |
| body.not-finite | a ctx.body force, torque, impulse or point has a NaN or infinite component |
| body.space-invalid | a ctx.body push was given a space other than "world" or "local" |
| body.velocity-not-dynamic | ctx.body.velocity was assigned on a kinematic or static body, or through a handle kept past its body; only a dynamic body has a velocity of its own to set |
| build-not-ready | the revision asked for has no Ready build |
| build-pipeline-running | a build pipeline already runs for this workspace |
| build-pipeline-stopping | the build pipeline is stopping |
| build.asset-missing | a file the scene names (an asset, or a texture its material file names) is not in this revision where it resolves; Play and export refuse the scene (content-incomplete), a bare argus run draws a placeholder. Also on a scene write (scene.patch and the other structural tools), checked on disk |
| build.asset-outside-project | an asset path leads outside the project, so no revision holds it |
| build.import | a behaviour imports something the engine does not bundle (an npm package, a Node built-in, a file outside the project, a value from @argus/api); the message opens with script-import |
| build.infrastructure | the build could not read its own inputs |
| build.material-layer-missing | a file a material file's layers need (a layer material named by path from the material's folder, or a texture that layer names from its own folder) is not in this revision; the layer is left out at run time (HD) rather than the scene refused. Also on a scene write, checked on disk |
| build.module-load | a behaviour threw while its module was evaluated |
| build.module-not-found | a scene names a script module with no .ts or .js file |
| build.module-outside-project | a script module path leads outside the project |
| build.module-unreadable | a built-in module could not be read |
| build.not-published | every check passed, but publishing the build failed |
| build.sandbox | a behaviour touches something the engine's sandbox does not provide (window, fetch, require, …) |
| build.scene-invalid | a scene breaks a contract rule; the message opens with the rule's code |
| build.scene-warning | a scene triggers a contract warning; the message opens with the rule's code |
| build.shader-hd-partial | an HD project's export packs a user shader that HD's G-buffer pass draws, with paths still on the fallback: the line names the shader and what is pending (the same words as the runtime code render.hd.user-shader-partial): per-entity floats, transmission, tonemap: off on unlit. A family HD cannot draw at all is not a warning: the export is refused (project-invalid) naming the material, the shader and why |
| build.shader-pass-not-exported | the project contains a *.shader.wgsl with //! kind: pass; nothing in a project runs pass shaders yet, so the export leaves it out of the pack |
| build.shader-scene-prewarm-heavy | a scene's predicted shader pre-warm (pipeline count times the measured cost of one) is over 400 ms on the reference machine, so its load would hitch |
| build.startup-scene-missing | the project's startupScene is not in this revision |
| build.toolchain-unavailable | the TypeScript toolchain could not be found, so behaviours were not checked |
| build.transpile | a behaviour does not compile (esbuild's error) |
| build.transpile-failed | esbuild itself did not run to its end |
| build.typecheck | a behaviour has a TypeScript type error at the line and column given |
| build.typecheck-failed | the TypeScript checker itself did not run to its end |
| camera-fov-overrides-scene | a script's ctx.camera.set(kind, { fov }) differs from the scene camera's fov, so the view is drawn at the script's number and the scene's is never seen; said once until ctx.camera.follow(null), with the scene camera as the entity |
| camera-probe-wider-than-body | ctx.camera.set's probeRadius is wider than the body the camera follows, so the arm sweeps the body's radius instead; said once per follow target, with the followed entity as the entity |
| capability_denied | 403: the session does not grant what the endpoint needs |
| component-absent | the entity has no component of that kind to read or write (ComponentWriteError) |
| component-field-type | a field was given a value of the wrong type (a colour that is not #rrggbb or [r, g, b] in 0..1, …) |
| component-field-unknown | the component has no writable field by that name |
| component-not-writable | that component cannot be written at run time; entity.set takes material, light or mesh |
| data.record | ctx.data.record(name, value) was given a name that is not 1 to 64 of A-Z, a-z, 0-9, _, -, ., or a value that is not a finite number, a boolean or a string of at most 256 characters; the call throws and nothing is recorded for that tick |
| entity-despawned | a handle kept across frames names an entity that has since been despawned (DespawnedEntityError); from a per-tick hook it ends that call only and the behaviour keeps running (disabled: false), from init it disables the behaviour |
| entity.not-finite | entity.yaw was set to NaN or an infinite number (RangeError); the rotation is unchanged |
| entity.parent-cycle | entity.setParent was given this entity or one of its descendants as the parent, which would make the hierarchy a loop (RangeError); nothing changed |
| entity.parent-despawned | entity.setParent was given a handle whose entity has been despawned (ReparentError); nothing changed |
| entity.parent-unknown | entity.setParent was given a scene id no live entity has (ReparentError); nothing changed |
| files-bad-json | readJson was given a file that is not JSON; the message has the line and column |
| files-missing | the project has no file at that path, the path names a folder, or a segment's case differs from the file's |
| files-not-text | the file is not UTF-8 text |
| files-path-refused | the path is not a file under the project's data/ folder: it is outside data/, climbs with .., is absolute, has a \ or an empty or . segment, or reaches outside the project through a symbolic link |
| files-too-large | the file is over 1 MiB, the most ctx.files reads |
| input-binding-arity | the wrong number of keys for the action's kind: a 2D axis takes four (up, left, down, right), a 1D axis two (negative, then positive), or alternate sets of them back to back |
| input-no-map | this world has no action map, so there is nothing to rebind |
| input-read-without-routing | A behaviour read ctx.input on an entity that has the handle (a controller or vehicle) but that player input is not routed to: input reaches one entity, the scene's spawn { "for": "player" } beside another component (else the first controller, else the first vehicle), so every action on this one reads false and every axis zero. Said once per entity per session, with the entity as the entity |
| input-unknown-action | the live context binds no action by that name |
| input-unknown-binding | a bare token matched no device, or a pad:/mouse: name is not one |
| input-unknown-key | a keys entry, or a key:-prefixed token, is not a key name |
| internal | 500: the engine failed while answering |
| joint.limits-invalid | ctx.joint.setLimits was given something other than [min, max] with both finite and min at most max, or null |
| joint.motor-invalid | ctx.joint.setMotor was given a target that is not finite, a maxForce, stiffness or damping that is negative or not finite, a mode other than velocity or position, or no maxForce for the joint's first motor |
| look-lut-path-empty | a colour LUT was given with no path, so it was dropped |
| look-range-inverted | a look range's minimum was above its maximum; the maximum was raised to it |
| look-value-not-finite | a camera look value was NaN or infinite and its default was used |
| look-value-out-of-range | a camera look (post-processing) value was outside its range and was clamped |
| nav-bounds-required | 400 on GET /navmesh: the navmesh has more polygons than one answer carries |
| nav-bounds-too-large | 400 on GET /navmesh: more polygons fall inside the bounds than one answer carries |
| nav-undeclared | the scene declares no navigation, so it has no navmesh to route on |
| not-newest-revision | a newer revision has been submitted, so this one is not built |
| not_found | 404: the named entity, frame or navmesh does not exist |
| null-handle | a behaviour read ctx.animator, ctx.controller, ctx.nav or ctx.input on an entity that has no such component, so the handle was null |
| physics.buoyancy.force-refused | the solver refused a buoyancy force on a body that should be dynamic (a non-finite force, or a body that stopped being dynamic); reported once per entity, and that body is not floating |
| physics.buoyancy.probe-cap | a buoyancy hull asked for more than 256 probes (an auto grid of resolution 7 or 8, or a longer authored probes list), so the engine used the largest grid under the cap or the first 256 probes |
| physics.layer-unknown | an entity's layer (or a camera's layers, hideLayers or rig.collisionLayers) names a layer the project does not declare, and the scene has no table the layer-unknown rule could check it against (no project, no meta.layers) or the entity was spawned after the check; the entity is put on default. Reported once per name, on stderr and by World::layer_problems. As the layers option of ctx.world.raycast / shapeCast it is thrown as a RangeError and the cast is not made |
| physics.water.lake-cap | the scene has more than 4 water components; only the 4 with the highest levels count (ties by priority, then scene order) and the rest are ignored |
| physics.water.river-cap | the terrain's hydrology has more than 32 rivers or 256 k centreline points under waterways; the rivers with the smallest discharge are dropped (the log lists their ids) and bodies do not float on them |
| plant-bake-missing | a recipe has no cooked meshes in the project's state folder, or its bake.json lists a mesh that is gone |
| plant-bake-stale | the cooked meshes are from an older recipe, an older template it names or an older generator, so they no longer match the recipe |
| quality-custom-defaults | a custom quality profile without basedOn left out optional knobs (it predates them), so they took their declared defaults; said once, naming them |
| quality-custom-missing | the preset is Custom and no Custom knobs were given, so High was used |
| quality-not-available-in-renderer | this renderer has no path for that value yet, so the knob fell back |
| quality-unsupported-on-device | the GPU cannot do what the knob asks, so it fell back to what it can |
| quality-value-not-a-step | a quality knob was in range but not one of its steps (a shadow size that is not a power of two); the nearest was used |
| quality-value-not-finite | a quality knob was NaN or infinite and the preset's value was used |
| quality-value-out-of-range | a quality knob was outside its range and was clamped |
| quality-value-unknown | a quality knob named a value this engine does not know (a newer engine's, or a typo), so the file still loaded and the knob took its safe value (transparency.sorting: per-instance; hair.mode: cards) |
| render-backend-forced-unavailable | the project forces a graphics backend (render.backend "vulkan" or "dx12") that cannot start on this machine (no adapter on it, or DirectX 12 off Windows); the game stops rather than fall back. |
| render-decal-range-inverted | a decal fade ended before it started; the end was moved to the start |
| render-decal-rotation-not-unit | a decal rotation was not a unit quaternion and was normalised (identity when zero) |
| render-decal-texture-unknown | a decal named a texture that was never registered, so that channel has none |
| render-decal-value-not-finite | a decal value was NaN or infinite and its default was used |
| render-decal-value-out-of-range | a decal value was outside its range and was clamped |
| render-decals-over-budget | more decals than the budget; the lowest-priority ones were dropped |
| render-decals-unsupported | the device cannot run the decal pass, so no decal is drawn |
| render-tonemap-substituted | meta.render.tonemap names a curve the renderer does not have: on the standard renderer one of HD's (agx, agx-punchy, unreal-filmic), drawn as aces; on HD aces, drawn as unreal-filmic (ACES-based) |
| render.hd.cloud_shadow_unavailable | the device allows fewer than 17 sampled textures per shader stage, so the HD cloud layer draws but casts no shadow on the ground, the fog or the particles |
| render.hd.ground-cover-no-height | reserved: the HD renderer will report this when a layer's terrain has no height raster to stand blades on, so the layer is not drawn |
| render.hd.ground-cover-over-budget | reserved: the HD renderer will report this when a frame's ground cover wants more blades than its budget, and thins them |
| render.hd.pass-point-skipped | a kind: pass escape-hatch shader at afterOpaque or beforeTonemap is not run on HD (its HDR image is inside HD's post chain); said once |
| render.hd.rt-deform-over-budget | swaying virtual-geometry instances within the ray-tracing deformation range (RtCoreDesc::deform_wind_range) are tracing their undeformed shape (sheared by the stem sway) because the per-frame deformation budget (deform_budget_instances, deform_budget_vertices) or the slot cap (deform_max_wind_slots) is spent; logged when it starts, the count is RtStats.deform.over_budget |
| render.hd.rt-proxy-invalid | a virtual-geometry mesh was given its own ray-tracing proxy (add_vg_mesh_with_rt_proxy, set_vg_rt_proxy) that is malformed, has no triangles, has more than 65,536 triangles, or names a material slot the mesh does not have; the mesh was not added |
| render.hd.rt_unavailable | the device or build has no ray tracing, so HD3 ray-traced effects are off |
| render.hd.screen-fx-views | a frame of several views (a headset's stereo pair) on HD cannot draw screen effects or user-shader particles, so it draws without them; said once |
| render.hd.shading_substituted | a material draws with vertex (Gouraud) shading (meta.render.shading or a material file's shading), which HD lights per pixel rather than per vertex: diffuse only, no specular, metal, normal or ORM map |
| render.hd.splat_format | a Gaussian splat file is not one the loader reads (not a 3DGS .ply with x y z f_dc_* opacity scale_* rot_*, a compressed PLY, a coloured point cloud, or a .splat whose size is not whole 32-byte records); nothing was loaded |
| render.hd.splat_too_large | a splat capture has more splats than one HD renderer holds (16,777,216) or bigger lists than the device can bind; nothing was loaded |
| render.hd.splat_truncated | a Gaussian splat file ends before the data its header promises; nothing was loaded |
| render.hd.unavailable | the HD renderer could not start on this device, so the standard renderer draws instead |
| render.hd.user-rt-static | HD's ray-traced paths (reflections, global illumination, ray-traced shadows through a cut-out) see a drawn user family as a bake made once when its materials register: its surface() at time 0, instanceRandom 0.5, white vertex colour, no wind and a flat card facing the viewer, 256x256 texels by default. Once per family, when its source reads one of those inputs (in.time, in.wind, in.instanceRandom, in.viewDir, in.screenUv, in.frontFacing, in.worldPos, in.objectPos, in.normal, in.tangent, its whole input passed to a helper) or the header declares per-entity floats (they bake at the header defaults); the line names them. Raster draws the live surface, so reflections of a family that animates or varies per entity show its frozen look |
| render.hd.user-shader-partial | HD draws a user shader family in some paths and not in others yet, once per family; the line names the family (shader family N (model, blend)) and what is pending. Either the family is not drawn by HD at all and its materials draw the family's flat PBR fallback (a vertex() family needs HD's vertex stage; a device without the bindless texture table; or its pipeline did not build), or it is drawn (opaque and mask lit/unlit in the G-buffer pass; stylized, blend, add and reads: depth in the forward and weighted-OIT passes) and names the paths still on the fallback: ray-traced hits when the family has no bake (reflections, global illumination, ray-traced shadows; with ray tracing on, a drawn family's materials are baked at the end of the load (when they register, after it) and that is not pending), per-entity floats (they read the header defaults), transmission. Meshes with a user material draw as raster, not virtual geometry, and say nothing |
| render.hd.vg_resident_full | a headless run, capture or --record keeps frames exact, so virtual-geometry pages never stream; a mesh whose pages no longer fit the resident pool is drawn as an ordinary mesh instead |
| render.hd.vg_streaming_auto | the virtual-geometry meshes' pages no longer fit one resident pool, so they stream within it from then on (coarser detail loads first, finer detail follows the view) |
| render.hd.water.river-flow-inconsistent | for one river the discharge its drawn geometry carries (width, depth, speed) and the terrain's flow_m3s differ by more than 4 times, once per river; speed follows the geometry |
| render.hd.water.river-id-unknown | a waterways override names a river, waterfall or lake id the terrain's hydrology does not hold (ids change when the terrain's drainage does); the override is ignored |
| render.hd.water.river-junction-gap | a tributary ends more than 5 cm above or below the river it joins, once per river; the water is built as it is |
| render.screen-effect | a screen effect listed in the scene's render settings was skipped (its shader did not build or its params were refused) or the renderer refused the set, so the frame draws without it |
| render.shader.compiled-after-load | a user shader's pipeline was first compiled after the scene loaded, so one frame hitched; the pre-warm list did not hold it. On HD the line can name a family's variant (shader family X (two-sided, skinned) in HD) first drawn after the load: it builds behind the frames and its draws show the material's fallback until it is ready |
| render.shader.downgraded | a shader effect this device or renderer cannot draw was replaced by the nearest one it can, as on web, phones and the standard renderer where HD features do not apply; the line names what changed (also named at export time for a raw screen derivative in an HD project's hit and bake variants) |
| render.shader.fallback | a user shader's pipeline failed to compile, once per shader family; its materials draw with the built-in fallback derived from the shader at t=0 (its average base colour, emission, roughness and metallic) |
| render.shader.families-many | more shader families are visible than the advised count for the target (64 on web, Android and iOS), so draws and pipelines cost more than they need |
| render.shader.reload-failed | an edited shader's new version could not replace the running one, so the last good version keeps drawing: its pipeline did not build, or HD draws the running version and cannot draw the new one (the line names why, e.g. the edit adds vertex()); the hot reload returns the same text as a shader-compile-error |
| render.shader.vg-skipped | a mesh whose shader has vertex() is drawn by HD's raster path, not virtual geometry, so it costs the raster path's price |
| replay-bad-file | the replay file cannot be read, is not a Talos replay, is a format this engine does not read, or has lines out of order |
| replay-camera-unknown | --replay-camera entity:ID names an entity the scene does not have |
| replay-engine-mismatch | the replay was recorded by another engine version, which does not promise the same simulation |
| replay-scene-mismatch | the scene that loaded is not the one the replay was recorded on (the SHA-256 of the scene file's canonical JSON differs) |
| replay-seed-mismatch | --seed names a different seed than the replay was recorded with |
| replay-start-mismatch | the world is not at the tick the replay starts from |
| road-source-invalid | the road file is there but is not a valid road (bad JSON, too few points, a width or step out of range), so it was not built |
| road-source-missing | the road component's source file is missing or unreadable, so the road, its walls and its gates were not built |
| save-bad-key | the key is not 1 to 64 characters of A-Z a-z 0-9 . _ - |
| save-full | writing the value would take the save file past its size limit |
| scene-invalid | the scene file is not a valid scene; the message lists the contract violations |
| scene-load-failed | a scene switch was refused and the current scene is still running; the event's code says why |
| scene-missing | there is no scene file at that path in this project |
| scene-no-root | this world was opened from a document, not a file, so it has no folder to resolve a scene path against |
| scene-path-refused | the scene path breaks a project-path rule (absolute, .., outside the project) |
| script-call-inapplicable | a behaviour called entity.visible = … on an entity with no mesh or sprite, or ctx.ui.set("screen:node", …) on a screen that is not on the stack; the call did nothing and the behaviour kept running; said once per entity or screen and call per session |
| script-error | a behaviour threw, ran away (work budget or hard cap) or was interrupted, and is disabled from that frame on; disabled: false marks the two that leave it running: a stale handle from a per-tick hook, and an update over its wall-clock budget (phase budget) for 10 ticks in a row, reported at once and then at most every 600 ticks |
| script-import | a behaviour imports something the engine does not bundle: an npm package, a Node built-in, a file outside the project, a value from the types-only @argus/api, or @argus/gameplay with no gameplay build to bundle it from; the load is refused, naming the file and line |
| script-unknown-hook | a behaviour's default export has a member named like another engine's hook (Update, Start, FixedUpdate, OnTriggerEnter, _process) or a Talos hook in the wrong case, which the engine never calls; said once per module version at load, and refused by behaviour.write's check when the export is not written with satisfies Behavior |
| script-warning | a behaviour did something the engine accepted but that is almost certainly a mistake; the log line and the script_warning event carry the specific code (e.g. null-handle) |
| session_mismatch | 409: the session id or nonce is another server's (a restarted game on the same port) |
| session_required | 428: this endpoint needs a session identity and the request had none |
| snapshot-modified | the revision's files changed on disk after it was recorded |
| spawn-bad-override | an overrides key does not apply to the prefab (no such entity, component or path), overrides were given with like, or the prefab with them fails the contract |
| spawn-duplicate-id | the id asked for is empty or already taken by a live entity |
| spawn-no-source | ctx.world.spawn was called with neither like nor prefab, so it names nothing to spawn (SpawnError) |
| spawn-two-sources | ctx.world.spawn was given both like and prefab; it spawns one or the other |
| spawn-unknown-prefab | prefab names no prefab file of the scene's project, or one the contract refused at load (the load log and engine check say why), or the scene is in no project |
| spawn-unknown-source | no live entity has the id like names; spawn copies an entity the scene already has |
| spawn-unsupported | this world cannot spawn entities (a headless or mock world) |
| splat-view-outside | the camera stood more than 1 m outside where a splat capture was taken (its camera trajectory, or its bounds when none is known), so the capture shows streaks and holes from there; printed once as the view leaves, and World::splat_views gives the distance every frame |
| sprite-frame-unknown | ctx.sprite.frame was set to a name no frame of the sprite has |
| sprite-image-missing | a sprite picture's asset did not load: it is not in scene.assets, not a texture asset, its file is missing or not an image the engine reads, or it is larger than the GPU's largest texture; the frames that show it draw nothing (LoadReport::sprite_images_missing counts them) |
| sprite-play-unknown | play named an animation the sprite's component does not declare, or a then that is not one of its animations; the message lists the ones it has |
| sprite-rect-outside | a view's rect reaches outside its image, so it was clamped to the image's edges |
| stale_stamp | 409: an exact read named a committed state the server no longer has |
| synth-bad-name | name is missing or is not 1 to 64 of a-z 0-9 - _ starting with a letter or digit; it becomes the asset id and the file name |
| synth-bad-param | a parameter is the wrong kind or out of its range: a frequency outside 1 to 20,000 Hz, a wave or filter type the synthesiser does not have, a note name it cannot read, a voice with no dur |
| synth-bad-sample-rate | sampleRate is not a whole number from 8,000 to 48,000, or was given with a preset (a preset is made at 44,100 Hz) |
| synth-bad-spec | the description names both preset and voices or neither, has a field that level does not take, or pairs options with voices or drive/echo with a preset |
| synth-failed | the synthesiser ran and did not write the sound (it threw, printed no answer, or ran past 60 s) |
| synth-not-found | Node, or the recipe's synth.mjs (under the SDK folder or a checkout), is not on this machine |
| synth-too-large | the WAV would be over 1 MiB (about 11.9 s at 44.1 kHz) |
| synth-too-long | the sound would be longer than 12 s, an echo's tail included |
| synth-unknown-preset | preset is not one of the recipe's: blip, whoosh, engine-loop, explosion, jingle |
| teleport-heading-ignored | a tool's POST /entity/{id}/teleport gave the character the camera films a yaw, and two ticks later the view still faces more than 0.1 rad away from it: a behaviour wrote its own old heading back over the turn (ctx.camera.set with its yaw), so shots and uses aimed along the view still go the old way; said once per teleport, with the character as the entity and teleport as the module |
| terrain-multiple | a scene has a second entity with a terrain component; only the first one gets collision, and the log says which entity was refused (report.terrains_refused) |
| tilemap-layer-unknown | ctx.tilemap.get, set or size named a layer the component does not have; the message lists the ones it has |
| tilemap-sheet-short | the tileset image is smaller than grid × tileSize (with margin and spacing) says; tiles past its edge draw nothing |
| time.after-invalid | ctx.time.after was given seconds that are negative or not finite, or was called outside a behaviour's hook or listener (RangeError); no timer is set |
| timeout | 503: the simulation did not answer in time (paused in a debugger, blocked on a load, shutting down) |
| ui.activate.blocks | the node is a blocker: it takes a click only to stop one reaching the game, and activates nothing |
| ui.activate.clipped | a clipping ancestor removes every pixel of the node, and no scroll container above it brings the node into view (activation scrolls those first) |
| ui.activate.disabled | the node is disabled, and a disabled node refuses activation |
| ui.activate.hidden | the node is under display: none, so it is not laid out or drawn |
| ui.activate.no-such-node | no screen on the stack holds that id |
| ui.activate.not-hittable | the node answers no hit test; on a click-through screen a node must say hit-test: always |
| ui.activate.not-interactive | neither the node nor any ancestor of it takes activation |
| ui.activate.not-on-top | the node's screen is not the topmost screen taking input |
| ui.activate.occluded | another node is painted over the point a click would land on |
| ui.asset.atlas-budget | the project's UI images are over the 32 MB atlas budget |
| ui.asset.image-missing | an Image or Icon names a file that is not in the project; a placeholder is drawn |
| ui.bind.unknown-node | a binding names a node the screen does not have |
| ui.bind.unknown-prop | a binding names a property that is not bindable |
| ui.bind.value-kind | the bound value is the wrong kind for the property |
| ui.css.calc | calc() is not supported |
| ui.css.combinator-depth | a selector chains more than two child or descendant combinators (one inside @size) |
| ui.css.deferred-property | a property this engine has not implemented yet |
| ui.css.duplicate-declaration | the same property twice in one rule; the last wins |
| ui.css.important | !important is not supported |
| ui.css.media-query | media queries are not supported |
| ui.css.physical-side | a physical side (left, margin-right) where a logical one mirrors for right-to-left locales |
| ui.css.reserved-token | an attempt to define a token the engine reserves |
| ui.css.syntax | the stylesheet does not parse at that point |
| ui.css.unknown-at-rule | an at-rule the engine does not support |
| ui.css.unknown-function | a CSS function the engine does not support |
| ui.css.unknown-property | a property the engine does not support |
| ui.css.unknown-selector | a selector form outside the supported subset |
| ui.css.unknown-semantic | a semantic colour or token name the theme does not define |
| ui.css.unknown-size-class | a size class the engine does not define |
| ui.css.unknown-unit | a unit the engine does not support |
| ui.css.unknown-value | a value the property does not take |
| ui.css.value-range | a value outside the range the property takes |
| ui.describe.format | the screen description is not the format the engine reads |
| ui.describe.model-view-subject.tentative | TENTATIVE (code to be numbered): a model-view names neither asset nor entity, so it draws an empty box |
| ui.describe.model-view-value.tentative | TENTATIVE: a model-view attribute is not a documented spelling (camera, yaw, spin, fov, an empty string, an unknown key) |
| ui.describe.root-id | the screen's root carries an id; it is kept as an alias of <screen>:root, which is the name reports use |
| ui.describe.too-large | the description is past the size the engine reads |
| ui.describe.unknown-prop | a prop the element does not take |
| ui.describe.unknown-role | a node's role is not one the engine knows |
| ui.describe.value | a prop's value is the wrong kind, a key repeats among siblings, or the root has an id |
| ui.diagnostics.overflow | more diagnostics than the sink holds; the count of the dropped ones is given |
| ui.draw.gradient-truncated | a gradient has more stops than the renderer draws; the rest are dropped |
| ui.draw.group-opacity | opacity on a group is applied to each child rather than the group as one |
| ui.draw.rotate-unsupported | a rotation in transform; the node is drawn unrotated |
| ui.draw.view-box-outside | an object-view-box reaches past its image; the part inside is drawn |
| ui.focus.nav-target-missing | a nav-up/nav-down/nav-left/nav-right names a node that is not there |
| ui.focus.no-focusable | a screen that takes input has nothing a pad or keyboard can focus |
| ui.focus.no-such-node | no screen on the stack holds that id |
| ui.focus.not-focusable | the node does not take focus, or is disabled |
| ui.focus.target-missing | the initial-focus target names a node that is not there |
| ui.focus.unreachable | the node takes focus and Tab never arrives at it |
| ui.font.face | an @font-face file is missing or not a font the engine reads; that family's text draws in the chain's font |
| ui.font.glyph-missing | a bitmap font has no cell for a character in the text; it is skipped |
| ui.font.unavailable | the project has screens and no font was found, so the text on them is not drawn |
| ui.get.not-a-field | the node is not a text field, so it has no value to read |
| ui.get.unknown-node | no screen on the stack holds that id, or a bare id two screens answer to |
| ui.get.unknown-prop | that property cannot be read |
| ui.input.bad-key | no key by that name |
| ui.input.no-field | text arrived and no text field holds focus, so there is nothing to type into |
| ui.layout.failed | layout could not place the tree |
| ui.layout.grid-placement-ignored | grid-column or grid-row on an item whose parent is not display: grid |
| ui.layout.grid-tracks-truncated | a track list longer than the engine's limit; only the first sixteen are used |
| ui.layout.grid-unsupported | that part of grid is not in the supported subset |
| ui.layout.image-zero-size | an image whose file loaded laid out with no width or no height, so nothing of it is drawn |
| ui.locale.file | a ui/locales/<tag>.json the engine cannot use; that one language is dropped |
| ui.locale.missing-glyphs | a locale has characters no font in the project's font chain draws; they show as squares |
| ui.locale.missing-param | a {name} slot in a string has no parameter; it draws [[key:name]] |
| ui.locale.unknown | the project ships no locale by that name; the message lists the ones it does |
| ui.model-view.count-cap.tentative | TENTATIVE: more than 4 model-view nodes are visible; the extras draw only their background |
| ui.model-view.unresolved.tentative | TENTATIVE: a model-view's asset path or entity name did not resolve to a mesh; its box draws empty |
| ui.scale.out-of-range | the UI-scale multiplier is outside the supported range |
| ui.screen.bad-json | the screen's description has an error, or its render threw at the props it was given |
| ui.screen.compile | a screen file failed to compile; it is not registered |
| ui.screen.duplicate | a push or replace named a screen already on the stack, or two screens share a name |
| ui.screen.missing | a screen names another screen that does not exist |
| ui.screen.no-exit | a screen that takes input has no way back out of it |
| ui.screen.prepared | an exported build's prepared screens are missing or unreadable |
| ui.screen.props-unbound | render reads props and the screen declares no scenario, so they were undefined when described |
| ui.screen.scenarios | a screen declares fewer than two scenarios, so the critic and the preview have little to show |
| ui.screen.stack-empty | the screen stack was left empty where a screen was expected |
| ui.screen.tools | the screen describer could not start, so no screen was registered and every push is refused |
| ui.screen.unknown | no screen answers to that name; the message lists the ones that do |
| ui.scroll.not-scrollable | scroll-top or scroll-left written to a node that is not a scroll container |
| ui.set.bad-value | the property is bindable and the value is the wrong kind for it |
| ui.set.unknown-node | no screen on the stack holds that id, or a bare id is ambiguous |
| ui.set.unknown-prop | the property is not bindable; the message carries the hint |
| ui.stack.empty | pop with nothing on the stack |
| ui.style.gradient-stops | a gradient's stops are malformed or out of order |
| ui.style.root-size-ignored | a width or height on a screen's root is ignored; the root fills the viewport |
| ui.style.token-cycle | tokens refer to one another in a loop |
| ui.style.token-kind | a token's value is the wrong kind for the property using it (a length where a colour goes) |
| ui.style.unknown-token | a var(--…) or token names no declared token |
| ui.style.unsupported-value | a value the engine cannot draw for that property |
| ui.theme.unknown | the project's stylesheets declare no theme by that name |
| ui.transition.not-animatable | a transition names a property that cannot be animated; it changes at once |
| ui.tree.duplicate-id | two nodes in one screen claim one id |
| ui.tree.invalid-id | a node id holds / or :, the id grammar's own separators; the derived id was used instead |
| ui.unavailable | this world has no UI runtime, so every ctx.ui call is refused |
| ui.viewport.no-surface | this source has no surface of its own, so there is nothing to resize |
| unavailable | 503: the command queue is full or the simulation is shutting down |
| unchecked-content | a headless worker started with --require-checked was given no --load-descriptor, so it would run the authoring tree, whose TypeScript no check has seen; it refuses to start |
| unsupported | 501: this engine or source does not implement that endpoint |
| vehicle.not-finite | ctx.vehicle.drive was given a throttle, brake, steer or handbrake that is NaN or infinite |
| web-unsupported | a behaviour running in the web runtime called a ctx member the web backend does not implement yet; it throws WebUnsupportedError naming the member |
| wheel.not-finite | ctx.wheel.setMotorTorque, setBrakeTorque or setSteer was given a NaN or infinite number |