Runtime codes
What a script is thrown, a query refuses with, or the log prints while a game runs or builds.
| Name | Summary |
|---|---|
| animator-clip-missing | an animator state's clip is not a clip of the asset nor of its retargeted clips (the built-ins and retarget.clips), so that state holds the rest pose; printed once per asset when the animator is built and counted in the load report |
| animator-ik-unknown | the animator declares no IK chain by that name, or the entity has no animator (AnimatorIkError) |
| animator-layer-bone-unknown | a layer's mask (include, exclude or weights) names a bone the rig does not have; printed once per asset when the animator is built, and that layer is left out while the others work |
| animator-layer-unknown | play(name, { layer }), layerWeight or stopLayer named a layer the animator component does not declare in layers, or the entity has no animator (AnimatorLayerError) |
| 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-morph-unknown | ctx.animator.setMorph or morph named a morph channel the model does not have, gave a weight that is not a number, or the entity has no animator or its model no morph targets (AnimatorMorphError) |
| 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-retarget-clips-invalid | an asset in retarget.clips has no skeleton and clips, or its skeleton lacks the canonical humanoid's required bones, so its clips were not retargeted; printed once per asset |
| animator-retarget-suspect | the retarget map is legal but probably wrong: its left and right look swapped (by the target bones' names, or the left thigh sits on the character's right for a rig facing +Z), or it leaves out the chest, neck, head or shoulders; printed once per asset |
| animator-root-motion-hips | a rootMotion state plays a clip whose root does not travel but whose hips (the canonical Hips through retarget.map, or a joint of that name) travel more than half a metre on the ground, and the animator has no rootMotionFrom, so the mesh walks away from a capsule that does not move; printed once per asset and state when the animator is built |
| animator-root-motion-joint-missing | the animator's rootMotionFrom names a joint the rig does not have (after retarget.map), so root motion is read from the rig root as if the field were absent; printed once per asset |
| 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-transition-unheard | an animator has transitions whose on nothing hands to it: the entity runs no built-in animator behaviour (the script that matches on against bus events), or runs one whose events prop leaves the name out and it is not one of the controller's moving, idle, jump, land; the transition is never taken and the state never changes; printed once per asset and set of names when the animator is built |
| 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 |
| animator-window-unreachable | a one-shot state (once, or ctx.animator.play with blendOut) plays a clip with a window event (until) that opens at or after the hand-back time (the clip's length less blendOut) or past the clip's end, so a cancel or active window authored there is never usable; printed once per asset when the animator is built (counted in the load report) and once per state and options on play |
| at_capacity | 503: a bounded resource is full, so the request was refused rather than queued |
| attach-bone-unknown | the attach component's bone is not a bone of the owner's skeleton, by the rig's own name or a canonical name in its retarget.map |
| attach-skeleton-missing | the attach owner has no animator that built (its asset has no skin or did not load), so there is no skeleton to follow |
| 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.not-own | wheels through another entity's body (other.body in a trigger): it can be pushed and its velocity set, not its wheels driven |
| 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, a texture its material file names, or an asset of a prefab a script spawns, resolved from the scene's folder) 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.font-unusable | a .ttf/.otf under the revision's ui/fonts/ does not parse as a font, has no readable family name, or maps no characters; Play skips it (ui.font.unusable) and draws with the other fonts. The warning names the file and why |
| 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, or a .js behaviour does not parse |
| 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-overlay-not-drawn | the scene has a camera with output: "overlay", which the engine does not draw yet; the screen view is drawn without it. Said once per load, naming the camera |
| camera-point-invalid | GET /camera/project or GET /camera/ray was given a missing or non-finite x, y or z, an entity the scene does not have, or entity together with x, y or z; the query server answers 400 and the message names the problem |
| 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 |
| camera-view-unknown | GET /camera/project or GET /camera/ray was given a view that is not a whole number from 1 to the layout's live views (a number, not 0, no more than the views ctx.views has set); the query server answers 400 and the message says how many views are live |
| 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 |
| face-degraded | <entity>: <what is missing>; that part is off: the model has none of the ARKit shapes for blinks, brows, cheeks or gaze, a bone named in head or eyes is not in the rig, or no head bone was found so head motion is off. Once per entity |
| 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 |
| fluid.sample-invalid | ctx.water.sample or ctx.wind.sample was given a coordinate that is NaN or infinite (RangeError); nothing is read |
| host_rejected | 403: the Host header does not name this server by a loopback name (DNS rebinding, or a client that set Host) |
| 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 context (the live one, or the one rebind named) 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-context | ctx.input.rebind or bindings named a context the scene's input map does not have |
| input-unknown-key | a keys entry, or a key:-prefixed token, is not a key name |
| instances-format-unsupported | the .instances file is a later format version or encoding than this build reads (a newer engine wrote it), so it has no instances |
| instances-source-invalid | the file is there but is not a valid instances file (wrong magic, a length or hash that does not match, an id out of order, a non-unit rotation, a scale not above zero), or carries a different number of custom floats than customData names |
| instances-source-missing | the instancedMesh component's source file is missing or unreadable, so it has no instances |
| 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 |
| lipsync-degraded | the face cannot make every viseme as written: its model lacks some viseme or ARKit mouth shapes (or has only a jaw, or no mouth shape at all, or no morph targets), or the track did not load, did not parse, or was made for another sound (the mouth follows loudness instead), or the voice streams so its loudness is not read at load. The message says which |
| 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 |
| mesh-material-name-unknown | a materials key is not the name of any material of the model (names are exact, and an unnamed glTF material has none); the mesh draws as if the entry were absent. The message lists the names the model has, once per model and name |
| mesh-uv-missing | a model has textured meshes and some meshes with no TEXCOORD_0: those meshes read every texture at UV (0, 0), so they show one texel's colour, and the model's other meshes keep their textures. Printed once per model when it loads, naming the meshes |
| 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 |
| origin_rejected | 403: the request came from a web page on another site (Origin) |
| particles-collide-unavailable | a *.vfx.json effect has a collide module, but the engine was built without the vfx-collide cargo feature, so the effect runs without collision; said once per effect |
| particles-effect-unknown | ctx.particles.play named an effect the scene did not load, so nothing played (it also counts in unwired.particles_emit); said once per name |
| particles-override-ignored | a ctx.particles.emit override key is not a particle parameter, or its value is not one that parameter takes, so that key was ignored and the others applied; said once per key |
| particles-param-unknown | an effect param was not applied: the particles component's params, a ctx.particles.play call or ctx.particles.setParam named a param the effect does not declare, or gave a value that does not fit its type (a number param takes a number; a vec3 [x, y, z]; a colour [r, g, b, a] or "#rrggbb"); said once per source and name |
| particles-texture-missing | a *.vfx.json emitter's sprite texture did not load, so that emitter draws the built-in sprite; said once per emitter |
| peer-determinism-mismatch | the peers' script configs differ (HostConfig::determinism_digest()), so their behaviours would not run the same way |
| peer-engine-mismatch | the other peer runs another engine or engine version, which does not promise the same simulation |
| peer-protocol-mismatch | the other peer's hello is in another peer protocol (proto), or its first message is not a hello this peer can read whole |
| peer-scene-mismatch | the peers loaded different scenes (the SHA-256 of the scene file's canonical JSON differs) |
| peer-seed-mismatch | the peers' world seeds differ, so every seeded draw (Math.random included) would differ |
| peer-tick-rate-mismatch | the peers step a different number of ticks a second |
| 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 |
| project-kind-2d-hd | a project with kind "2d" asks for render.profile "hd"; a 2D project draws with the standard renderer, so this one does (the validator says so too) |
| 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. Code pending coordinator confirmation (default allocation, lane plat-gfxbackend) |
| 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 HD's filmic curve (unreal-filmic), drawn as aces; on HD aces, drawn as that filmic curve (ACES-based) |
| render.hd.black_frame | an HD frame read back for --record, --out or a capture came out black (the mean of its colour channels at most 5/255), once per run; record.json counts them in blackFrames. Usually a closed mesh around the camera: its ray-traced shadows block every light outside it, and GI replaces the flat ambient with what bounces inside |
| 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.horizon_map_unavailable | the device allows fewer than 18 sampled textures per shader stage, so HD leaves out the terrain horizon map: terrain casts no shadow past the sun's shadow distance and valleys get the open sky's light |
| 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_mesh_proxied | a static mesh's geometry does not fit HD's ray-tracing vertex and index pools within the device's storage-binding limit, so it traces through an automatic simplified copy (about an eighth of its triangles, between 20,000 and 250,000, fewer only if that does not fit) in place of the full mesh; the copy is rebuilt on each load, not cached, so a mesh of millions of triangles adds simplification time to its load: shadows, reflections and GI see the simplified shape, within the measured self-hit distance; raster stays at full detail. Named once per mesh. A mesh whose simplified copy does not fit either is render.hd.rt_mesh_too_large |
| render.hd.rt_mesh_too_large | a mesh's geometry does not fit HD's ray-tracing vertex and index pools within the device's storage-binding limit (the pools are bound whole), so that mesh is drawn but not ray traced (a static mesh first gets an automatic simplified copy, render.hd.rt_mesh_proxied; this is for a mesh whose copy does not fit either, or a skinned or morph mesh): it casts no ray-traced shadow and shows in no ray-traced reflection or GI. For a skinned or morph mesh each traced instance takes its own copy, so in a crowd the instances past the limit are drawn but not traced; the skinned meshes' own rest and skin pools are held to the same limit. Named once per mesh |
| 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. A G-buffer family's meshes may be virtual geometry (its own merge draws them); a forward family's stay raster and say nothing; a family whose virtual-geometry merge did not build says so, and those pixels show the fallback |
| 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.param-dropped | a hot reload changed a param's type (a colour became a number, say), and a material's value of it no longer fits: the value is dropped and the new default draws; the line names the shader, the material and the param |
| 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 |
| render.sky.background_hd | a scene's sky.background is drawn by the standard renderer; the HD renderer draws its own sky over it (once per run) |
| render.standard.layer-mask-from-ignored | a material file's layer has maskFrom (procedural coverage from the mesh's height and facing), which only the HD renderer draws; once per material, the standard renderer blends that layer by its mask alone |
| render.uv-scroll-ignored | a material file sets uvScroll but is drawn by a renderer that has no scroll: HD, or the standard renderer's stock car and layered surfaces; once per material, the textures stay put |
| replay-bad-file | the replay file cannot be read, is not a Talos replay, is a format this engine does not read (it reads formats 1 to 4), has lines out of order, has a menu line ("ui") that is malformed or in a format 1 file, has a pointer line ("p") that is malformed or in a format 1 or 2 file, or has a seat line ("seat") that is malformed or in a format 1 to 3 file |
| 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, or a replay is played (World::start_replay_playback) into a world running another seed |
| replay-start-mismatch | the world is not at the tick the replay starts from |
| replay-web-unsupported | a replay was asked to play in the web build, which leaves out the code that re-applies a replay's live edits, so a playback there would quietly differ from the recording |
| road-material-unknown | the road file's surface.material is not a key of the scene's assets of kind material, so the road surface keeps its plain color |
| 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 |
| road.at | ctx.world.road(name).at(s) was given an s that is NaN or infinite (RangeError); nothing is answered |
| 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, sprite or children, 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) |
| selftest-bad-scenario | the scenario is not JSON, lacks "selfTest": 1, has a key the format does not know, or names a path outside the project (rooted, a drive or share, .., or a link or junction out of it) |
| selftest-crashed | the engine stopped with an internal error while playing the scenario |
| selftest-load-failed | the scene did not load (it does not validate, or a file it needs is missing), so no step ran |
| selftest-not-found | the named scenario is not selftest/<name>.json (or the project-relative .json named) in the project, or none was named and the project has no selftest/*.json |
| selftest-too-long | maxFrames is over 36,000 (ten simulated minutes), or timeout is not 1 to 300 seconds |
| sensor-shape-unsupported | the attached entity's trigger collider is not a box, sphere or capsule, which is what a sensor queries with |
| 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-prefab-cycle | prefab names a prefab that nests itself, directly or through other prefabs (prefab-cycle in engine check); it has no finite copy, so it is refused at load and every spawn of it, or of a prefab that nests it, answers this |
| 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 |
| spring-bone-unknown | a chain or collider names a bone the skeleton does not have (the message lists the bones it has), or the entity has no skeleton to swing (no animator, or its asset has no skin or did not load) |
| spring-chain-bad | a chain is not a path down the skeleton: its tip is not below its root, a joints bone is not the child of the one before, or a bone is in two chains |
| 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 |
| teleport-position-ignored | a tool's teleport (POST /entity/{id}/teleport, an editor drag during Play, a test harness) moved an entity at least 0.25 m, and two ticks later its own motion started back where it was (or more than half the jump from where it was put) while a behaviour wrote its position: that behaviour keeps the position in its own variables (a module-level let, a ctx.state copy) and wrote it over the move; said once per entity per run, with the writing behaviour as the module (native only: the web runtime does not attribute writes yet) |
| 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) |
| terrain-volume-invalid | the terrain file has an enabled volume.shape or volume.cliff op and this engine build has no volume support (the terrain-volume feature); the terrain is not built |
| 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="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.font.unusable | a font file under the project's ui/fonts/ (or named by an @font-face rule) cannot be read as a font (no faces, no family name, or no mapped characters); that one font is skipped and the rest of the chain, then the engine's fallbacks, draw. A font named with --font / the font environment variable that cannot be read is an error naming that file instead |
| ui.fx.bad-options | ctx.ui.fx's options were not { duration?, delay? } in seconds of zero or more |
| ui.fx.unknown-node | ctx.ui.fx named a node no screen on the stack holds, or a bare id that is ambiguous |
| ui.fx.unknown-preset | ctx.ui.fx named a preset that is not in the library |
| 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 |
| unsupported_media_type | 415: a POST body that is not Content-Type: application/json |
| vehicle.boost-invalid | vehicle.boost(speed, seconds) was given a speed or seconds that is NaN, infinite, zero or negative |
| vehicle.not-finite | ctx.vehicle.drive was given a throttle, brake, steer or handbrake that is NaN or infinite |
| vehicle.not-own | drive, reset or wheels through another entity's vehicle (other.vehicle in a trigger): it can be read and boosted, not driven |
| views-layout-unknown | ctx.views.setLayout was given a name that is not a layout, or ctx.views.shared a split.layout that is not a two-view split; it throws ViewsError and the layout is unchanged |
| views-out-of-range | a ctx.views member was given a view number that is not a whole number from 1 to 4; it throws ViewsError and nothing changes |
| web-export-cancelled | the web export was cancelled and the CLI stopped; the output folder is as it was |
| web-exporter-failed | the engine CLI ended with neither a report nor an error line: it crashed, or it is older than --json |
| web-exporter-missing | no Node, or no engine CLI, to run the web exporter: not named (ARGUS_ENGINE_CLI, ARGUS_NODE), not installed beside the editor, and no checkout above the project |
| 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 |