Skip to content

armgit / 67.js

Public Imported from GitHub
0

3D engine that AI agents drive

Make scene-core validation errors name the field, the value and what is accepted (issue #653)

Nguyen Xuan An60b79f35d652
diff --git a/changes/653-scene-core.md b/changes/653-scene-core.md
new file mode 100644
index 00000000..2fc809f0
--- /dev/null
+++ b/changes/653-scene-core.md
@@ -0,0 +1 @@
+- Validation errors in the scene core now read `nodes[1].decal: got "yes"; expected true or false.`: scene operations (remove, set, inspect, checkpoints, revision), camera lens fields, geometry fields (points, holes, base, cutter), armatures, cloth and particle checks (`Cloth gravity: got [0,1]; expected three numbers, such as [0, 1, 0].`), terrain (`terrain.size: got 0; expected a number from 1 to 2000, such as 40.`) and mesh regions. Size limits and engine invariants keep their older wording (#653)
diff --git a/changes/653-scene-core.size.md b/changes/653-scene-core.size.md
new file mode 100644
index 00000000..87246b8a
--- /dev/null
+++ b/changes/653-scene-core.size.md
@@ -0,0 +1,3 @@
+- scene:agent-scene: error text grows by 388 bytes gzip in the core bundle and 595 bytes with the lazy modules (field path, value received and an example in the scene, operation, camera, geometry, cloth, particle and terrain messages); nothing new runs unless a recipe is rejected, and an agent fixes the input in one retry.
+- scene:agent-scene+lazy: the same message text, 595 bytes gzip with the shared recipe checks, terrain and mesh modules; nothing new runs unless a recipe is rejected.
+- goal:agent-scene: 388 bytes gzip of message text only, so that agent errors name the field, the value and an example; this is the issue's goal and nothing new runs unless a recipe is rejected.
diff --git a/out.tmp.txt b/out.tmp.txt
new file mode 100644
index 00000000..feaedcbc
--- /dev/null
+++ b/out.tmp.txt
@@ -0,0 +1,2690 @@
+npm notice run @codepawlhq/[email protected] test
+npm notice run node --test
+302 of 302 test files pass alone in 132.5s
+✔ scripts\test-each-file.mjs (132766.5408ms)
+✔ scripts\test-timing-reporter.mjs (1495.3748ms)
+67js preview resources closed.
+✔ error for material emissiveColor below zero names the field, the value and what is accepted (8.9681ms)
+✔ error for material opacity above one names the field, the value and what is accepted (0.971ms)
+✔ error for material metallic above one names the field, the value and what is accepted (0.4805ms)
+✔ error for material color above one names the field, the value and what is accepted (5.7692ms)
+✔ error for material roughness as text names the field, the value and what is accepted (11.508ms)
+✔ error for material alphaMode unknown names the field, the value and what is accepted (2.4615ms)
+✔ error for material emission below zero names the field, the value and what is accepted (24.6993ms)
+✔ error for node scale not positive names the field, the value and what is accepted (1.6271ms)
+✔ error for node rotation all zero names the field, the value and what is accepted (1.3555ms)
+✔ error for node translation with two numbers names the field, the value and what is accepted (0.7789ms)
+✔ error for node parent that is not text names the field, the value and what is accepted (1.421ms)
+✔ error for camera fStop out of range names the field, the value and what is accepted (1.8935ms)
+✔ error for camera fov out of range names the field, the value and what is accepted (0.599ms)
+✔ error for camera focalLength zero names the field, the value and what is accepted (0.4107ms)
+✔ error for camera eye with one number names the field, the value and what is accepted (0.3809ms)
+✔ error for point light intensity below zero names the field, the value and what is accepted (2.0357ms)
+✔ error for spot light angle too wide names the field, the value and what is accepted (1.454ms)
+✔ error for area light width zero names the field, the value and what is accepted (1.0593ms)
+✔ error for second point light position short names the field, the value and what is accepted (7.0122ms)
+✔ error for fog density too high names the field, the value and what is accepted (0.8619ms)
+✔ error for fog color above one names the field, the value and what is accepted (6.8908ms)
+✔ error for sun direction all zero names the field, the value and what is accepted (0.5457ms)
+✔ error for view transform unknown names the field, the value and what is accepted (0.6079ms)
+✔ error for bake preset unknown names the field, the value and what is accepted (3.8116ms)
+✔ error for bake gridFog as text names the field, the value and what is accepted (1.0806ms)
+✔ error for mesh edit subdivide levels too high names the field, the value and what is accepted (1.9384ms)
+✔ error for mesh edit bevel segments too high names the field, the value and what is accepted (21.7828ms)
+✔ error for mesh edit array count zero names the field, the value and what is accepted (22.9132ms)
+✔ error for mesh edit unknown op names the field, the value and what is accepted (2.7239ms)
+✔ error for mesh edit offset as text names the field, the value and what is accepted (24.9818ms)
+✔ error for motion scale keyframe not positive names the field, the value and what is accepted (0.8336ms)
+✔ error for motion keyframe time past the duration names the field, the value and what is accepted (0.6659ms)
+✔ error for motion duration too long names the field, the value and what is accepted (0.5774ms)
+✔ error for motion loop as text names the field, the value and what is accepted (0.6247ms)
+✔ error for motion interpolation unknown names the field, the value and what is accepted (0.5638ms)
+✔ error for physics body mass below range names the field, the value and what is accepted (1.0407ms)
+✔ error for physics body type unknown names the field, the value and what is accepted (0.5382ms)
+✔ error for physics velocity on a fixed body names the field, the value and what is accepted (1.0015ms)
+✔ error for physics joint to a node without a body names the field, the value and what is accepted (0.7677ms)
+✔ error for physics gravity with two numbers names the field, the value and what is accepted (0.6047ms)
+✔ error for physics duration too long names the field, the value and what is accepted (0.4499ms)
+✔ error for drive wheel node missing names the field, the value and what is accepted (21.3733ms)
+✔ error for drive speed below zero names the field, the value and what is accepted (17.1369ms)
+✔ error for drive steering unknown names the field, the value and what is accepted (14.2543ms)
+✔ error for drive path with one point names the field, the value and what is accepted (11.2369ms)
+✔ error for drive leg with a repeated point names the field, the value and what is accepted (14.9503ms)
+✔ error for drive leg with a bad point names the field, the value and what is accepted (2.5991ms)
+✔ error for drive tail light signal unknown names the field, the value and what is accepted (2.2528ms)
+✔ error for asset root scale zero names the field, the value and what is accepted (1.6465ms)
+✔ error for asset id not hexadecimal names the field, the value and what is accepted (4.2724ms)
+✔ error for asset material override unknown id names the field, the value and what is accepted (2.2701ms)
+✔ error for asset operation unknown type names the field, the value and what is accepted (10.4926ms)
+✔ error for asset set-material unknown id names the field, the value and what is accepted (4.6636ms)
+✔ error for asset inspect limit too high names the field, the value and what is accepted (5.4172ms)
+✔ error for placed asset id not hexadecimal names the field, the value and what is accepted (0.6881ms)
+✔ error for placed asset clip index below zero names the field, the value and what is accepted (0.4595ms)
+✔ error for placed asset material tag unknown names the field, the value and what is accepted (0.5698ms)
+✔ error for placed asset drive forwardAxis unknown names the field, the value and what is accepted (0.466ms)
+✔ error for shrinkwrap finds no surface names the field, the value and what is accepted (42.3329ms)
+✔ error for shrinkwrap mode unknown names the field, the value and what is accepted (3.0336ms)
+✔ error for shrinkwrap maxDistance below zero names the field, the value and what is accepted (2.0698ms)
+✔ a long received value is cut so the message stays short (0.2101ms)
+✔ withFieldPrefix puts the list position before a field path and leaves other errors alone (0.4573ms)
+✔ a schema error through the MCP layer names the field path and the value received (1063.9525ms)
+✔ src/agent-physics.js adds no raw throw that lacks a field path and an expectation (1.4096ms)
+✔ src/agent-drive-schema.js adds no raw throw that lacks a field path and an expectation (0.3601ms)
+✔ src/agent-drive.js adds no raw throw that lacks a field path and an expectation (0.4777ms)
+✔ src/agent-asset.js adds no raw throw that lacks a field path and an expectation (0.6653ms)
+✔ src/agent-asset-mesh.js adds no raw throw that lacks a field path and an expectation (0.3019ms)
+✔ src/agent-scene-assets.js adds no raw throw that lacks a field path and an expectation (0.3241ms)
+✔ src/vehicle.js adds no raw throw that lacks a field path and an expectation (0.6312ms)
+✔ src/mesh-shrinkwrap.js adds no raw throw that lacks a field path and an expectation (0.2567ms)
+✔ slow frames lower the scale one step per window and stop at the minimum (1.1359ms)
+✔ the scale rises again only after a full window well under the target (4.0445ms)
+✔ the same frame times always give the same scales (12.0453ms)
+✔ bad frame times are ignored and bad settings are refused (0.6969ms)
+✔ an export can not have adaptive resolution (0.3278ms)
+✔ the GPU timer reads finished queries in order and drops a disjoint result (0.4513ms)
+✔ a mixed batch gets one entry per operation and a diff of IDs (10.0125ms)
+✔ an operation that sets the values already there is a warning (0.4992ms)
+✔ a 20-operation batch stays under 2 KB and a larger one says how many entries were cut (0.7912ms)
+✔ the diff caps a long ID list (0.3672ms)
+✔ the preview answers a 3-operation batch with results and a diff, and flags the no-op (183.1007ms)
+✔ a 20-operation batch adds under 2 KB to the answer (51.0867ms)
+✔ catalog IDs bind self-contained GLB content and metadata stays detached without paths (245.8313ms)
+✔ changed bytes cannot silently reuse a catalog digest (113.6379ms)
+✔ catalog rejects external resources and malformed or over-budget GLBs before browser loading (1202.7887ms)
+✔ declared clip metadata stays bounded even when a GLB contains many animation declarations (1017.3479ms)
+✔ catalog rejects linked assets and requires an explicitly absolute directory (334.9937ms)
+✔ the catalog limits are the documented values and never exceed the loadGltf defaults (1.4341ms)
+✔ no MCP script writes an asset limit as a literal number (718.0407ms)
+✔ a decode limit error names the catalog limit and the value the file hit, with no code-only advice (103.0432ms)
+✔ a Radiance .hdr and a .cube file are listed as environment and look entries and read back by ID (500.1164ms)
+✔ an .hdr that is not Radiance data and a .cube that is not a 3D look are refused (128.2728ms)
+✔ an imported character reaches a point, and every part agrees with the code API (182.9943ms)
+✔ IK runs on top of the selected clip, which still drives the rest of the body (91.2486ms)
+✔ a changed clip time moves the base pose under IK, with the arm still on target (87.8737ms)
+✔ keyframed targets seek both ways, and clearing motion restores the base pose (112.9753ms)
+✔ inspecting does not disturb the published pose (61.3719ms)
+✔ an unreachable target is reported, with when it is worst (74.5501ms)
+✔ targets are in world space, under the asset root (57.5774ms)
+✔ a target can follow a node of the character, and aim takes worldForward (128.3775ms)
+✔ asset IK mistakes say what to pass (101.8801ms)
+✔ a wave layer masked to the right arm leaves every other part walking (319.4989ms)
+✔ the layered pose matches the code API for every part (87.7735ms)
+✔ seeking gives the same pose as playing: the same time twice is identical (51.0516ms)
+✔ a layer with bones retargets the clip onto other nodes by name (153.5512ms)
+✔ morph clips drive face weights as authored, and a mask can leave the face alone (85.3292ms)
+✔ the real clips load their zero morph tracks and keep the face at rest (48.8633ms)
+✔ layer input that is not bounded plain data is refused (167.1582ms)
+✔ a recipe without an imported asset refuses layers (2.4892ms)
+✔ stagePose refuses morph weights that are not bounded (16.9743ms)
+✔ cutting a hole in a rigid imported part keeps its material and passes the topology check (146.0175ms)
+✔ a boolean difference cuts a through hole in a closed imported part and an open part says how to close it (123.8648ms)
+✔ skin weights follow an edit: unmoved vertices keep theirs and new ones sum to one (102.5329ms)
+✔ morph targets follow an edit with one delta per vertex and the weights keep their identity (68.4478ms)
+✔ an edit that would turn skin or morph transfer into a guess is rejected and names the next action (37.8904ms)
+✔ a checkpoint undoes a mesh edit and replace swaps the log (70.1022ms)
+✔ an exported recipe replays the edits on a fresh decode (95.7749ms)
+✔ hostile mesh edits are rejected without changing the scene (91.7531ms)
+✔ UVs survive an edit, and faces an edit leaves without UVs read the nearest original island (49.4235ms)
+✔ imported parts report as polygon meshes with the shared lint (366.6145ms)
+✔ inspect accepts a source-node ID that holds one part and names the parts of one that holds several (24.2129ms)
+✔ imported source-node authoring reaches actual joints with stable hierarchy IDs (51.8313ms)
+✔ authored asset motion is transient and shuffled seeks preserve every retained binding (27.0865ms)
+✔ pose layers preserve imported animation while overriding selected local components (45.7597ms)
+✔ invalid authored poses roll back decoder private state and complete adapter state (50.5695ms)
+✔ material and camera tracks share authored timing while texture resources remain retained (21.9867ms)
+✔ independent imported and authored clocks stage once without an invalid intermediate pose (14.3834ms)
+✔ a walk from one humanoid file plays on another with different names, proportions and rest pose (82.8028ms)
+✔ a layer from an unavailable clip, or between rigs without humanoid bones, says what is wrong (102.7034ms)
+✔ foot lock holds a planted foot within 2 cm where the retargeted walk slides (165.817ms)
+✔ on a slope the planted sole follows the ground normal (15.1113ms)
+✔ keyed morph weights blink and open the jaw by target name, and seeking repeats (43.9247ms)
+✔ decoded resources and retained identities survive root, look, and material edits (59.4368ms)
+✔ absolute animation reverse seeks and initial-pose reset are deterministic (50.7182ms)
+✔ failed commands and Float32 root staging leave pose, recipe, materials, and revision atomic (11.2722ms)
+✔ real decoded morph weights retain identity and restore alongside animation (14.755ms)
+✔ checkpoint handles are private, bounded, revision checked, and restore identities (17.861ms)
+✔ ordinary JSON, strict schemas, numeric domains, budgets, and stale revisions reject (13.4284ms)
+✔ detached matrices and replaced pose buffers fail before publishing canonical state (6.5188ms)
+✔ nonanimated assets support root edits and detached exports while clips reject (54.607ms)
+✔ decoder animation validation failure rolls back and permits later valid seeks (8.6742ms)
+✔ decoded instances share original geometry and material wrappers (6.3736ms)
+✔ a preset on a 56 part room shrinks to the path work budget, finishes, and reports what it used (23120.6284ms)
+✔ a preset that already fits is not reduced (3230.7431ms)
+✔ a cloth sheet is skipped by the bake and still has no lightmap after a seek past t=0 (3357.76ms)
+✔ a bake places a room probe unless bake.probes is false (5428.8213ms)
+✔ a preset on a hall too large for its floor gives up bounces before it refuses, and says what it did (19.9927ms)
+✔ a preset keeps its bounces when only samples and density need to shrink, and is silent when it fits (1.7122ms)
+✔ a scene too large for one bounce at the floor is still refused, with the budget in the message (2.6326ms)
+✔ a light with affects keeps the bake on the CPU, because the GPU kernel has no light linking (0.8828ms)
+✔ a page without WebGL2 offers no GPU bake kernels, so the worker bakes on the CPU (0.2458ms)
+✔ a page kernel answers a deferred kernel when it accepts the call, and the worker answers the rest (3.9472ms)
+✔ a page kernel that fails leaves the kernel to the worker (1.0675ms)
+✔ explicit settings over the hard limit fail up front with a lower setting to try (1941.0098ms)
+✔ explicit settings far above the preset budget run when they fit the hard limit, and are never reduced (20745.7359ms)
+✔ an explicit bake that passes maxSeconds fails cleanly with a lower setting to try (3248.3036ms)
+✔ the bake kernel carries 20 s on the page thread and 90 s inside a worker (0.3286ms)
+✔ a brick wall keeps its pattern and receives bounced light through a light map (7665.0074ms)
+✔ a node that hosts a hair system bakes without an error and is reported as skipped (3440.6631ms)
+✔ a spot light that points at the floor bakes the light that bounces off it (9171.8609ms)
+✔ an area light bakes bounced light on its front side only, and a changed spot or area light bakes again (10433.1499ms)
+✔ moving a light with a motion track after a bake gives a bake-stale warning (3487.1956ms)
+✔ an unchanged scene, or one with a bake and no motion, gives no warning (6104.2951ms)
+✔ bake.rebake bakes the pose motion samples: the light map at time t equals a fresh bake of the scene posed at t (9230.7792ms)
+✔ bake.rebake keeps the bakes of the last 4 poses and traces nothing for a pose it holds (14232.0086ms)
+✔ bake presets and fields resolve to plain numbers within their ranges (1.9944ms)
+✔ bake rejects hostile and out of range fields (0.6606ms)
+✔ a recipe bake lights the room with lightmaps and reports its time and skipped parts (3094.9622ms)
+✔ the same recipe gives the same lightmap bytes (6099.7889ms)
+✔ a camera edit, a motion seek and a look edit that leaves the lights reuse the bake (3093.5091ms)
+✔ moving a part, changing a light or changing the bake runs it again, and clearing it removes the lightmaps (11426.0989ms)
+✔ a failed bake leaves the scene as it was (3671.8182ms)
+✔ the bench has 20 to 30 tasks, each known to the suite, covering every kind of work (1.4909ms)
+✔ the camera, light, look and film tasks reject plausible wrong answers (4608.7683ms)
+✔ pass@1 is the share of runs that pass, pass^k needs every run of a task to pass (0.5608ms)
+✔ a task with fewer runs than k does not count toward pass^k (0.1464ms)
+✔ the summary groups by model and kind, and the comparison flags a pass@1 drop and the tasks that moved (1.1537ms)
+✖ live MCP branches do not consume revisions or change the scene being edited (82935.6063ms)
+✔ branch names are bounded identifiers and hostile text is refused (2.5026ms)
+✔ branches with the same recipe share one snapshot and unused snapshots are pruned (1.588ms)
+✔ branch reads return copies, so a caller cannot edit stored recipes (0.7168ms)
+✔ the branch count is capped, a name can be reused at the cap, and unknown names fail clearly (1.3468ms)
+✔ label text is reduced to short printable ASCII (0.468ms)
+✔ review groups shots by branch and keeps the source shots together (1.3428ms)
+✔ review rejects hostile branch names and branch shots that sample an imported clip (1.8051ms)
+✔ a cloth seek keeps the part, makes no new batch and draws the same positions as a fresh scene (302.4679ms)
+✔ a scene without cloth has no live cloth geometry (2.7794ms)
+✔ combinedAssetBytes counts decoded bytes of every asset field in one call (1.6212ms)
+✔ a call whose assets are each under maxBytes but together over maxCombinedBytes fails naming limit and total (82.5351ms)
+✔ a call at exactly maxCombinedBytes passes (51.8967ms)
+✔ the drive finds the wheels, reports the names it rejected and sets the motion duration from the path (80.0425ms)
+✔ through a curve and a stop the rear wheels roll the distance driven, and any sampling order gives one pose (532.2922ms)
+✔ a reverse leg backs up with the wheels spinning backwards (195.9565ms)
+✔ the brake signal is on only while the car slows, and the tail lamp glows with it (189.3652ms)
+✔ a bad drive names the problem (18.4674ms)
+✔ a placed car drives its path in the placement frame, with its own decoded copy (80.6822ms)
+✔ a closed room lit by a sun gets the floor sky trace by default (1489.5584ms)
+✔ environment.floorSkyTrace false turns the trace off (17.4033ms)
+✔ environment.floorSkyTrace that is not a boolean is refused, not read as on (7.164ms)
+✔ a room with no sun and open ground are left as they were (74.3832ms)
+✔ an object with nothing under it gets a floor at its lowest height (2.0454ms)
+✔ a wide thin lowest part counts as the recipe own floor (0.3077ms)
+✔ a lone flat object, such as a gear lying down, still gets a floor (0.1608ms)
+✔ a room floor counts as a floor although its walls are as wide (0.2066ms)
+✔ a raised tabletop, a tall wall and a small plate do not count as a floor (0.2347ms)
+✔ environment.ground false removes it, and the field stays out of recipes that do not set it (0.8725ms)
+✔ the placement is deterministic and moves the floor part in place (0.4713ms)
+✔ the automatic floor is a mid-dark tone, so a pale object and its contact shadow stand out from it (0.1957ms)
+✔ a picture with a shaded disc on a plain background passes (89.1276ms)
+✔ a flat picture, a tiny picture and a file that is not a PNG fail (457.2319ms)
+✔ a missing file fails with a reason (1.3737ms)
+✔ a default look omits spot and area lights so exported recipes keep their shape (6.4238ms)
+✔ spot and area lights normalize with defaults and keep castShadow only when true (1.8546ms)
+✔ look rejects an unknown spot light field and too many shadow casters (5.5257ms)
+✔ the rasterizer covers the area a square takes in an orthographic view (4.731ms)
+✔ intersection over union is 1 for equal masks, 0 for disjoint masks and a fraction for partial overlap (1.933ms)
+✔ every scene reference scores 1 against itself (7921.4266ms)
+✔ a broken table scores lower than a correct one, and each flaw lowers it (46.7181ms)
+✔ a judge record needs four whole scores in range and keeps its criteria apart from the total (15.6397ms)
+✔ a failing image step keeps the silhouette score and records imagesError (6.2699ms)
+✔ default look is complete, detached JSON and idempotent (31.265ms)
+✔ normalization preserves author intent and publishes correct lighting radiance through existing validator (2.4727ms)
+✔ strict look schema rejects unknown keys at every object boundary (2.9971ms)
+✔ malformed JSON, getters, sparse arrays and executable values reject without executing accessors (1.3868ms)
+✔ lighting ranges include zero intensity and unlimited point range while rejecting invalid edge values (3.7218ms)
+✔ volume fog delegates defaults, domain ranges and Float32 bounds ordering (1.2094ms)
+✔ effects enforce existing ranges, independent exposure and explicit bloom disable (1.989ms)
+✔ shadow direction normalization preserves authored distance and handles vertical projectors (0.539ms)
+✔ shadow numerical combinations reject collapsed eye or clipping ranges before accepting the look (1.6047ms)
+✔ valid shadow extremes produce finite nonsingular view, projection and combined matrices (0.6638ms)
+✔ the look pick passes the golden grade and fails the dim, the pale and a moved scene (58348.3647ms)
+✔ every task has a reference solution that passes all its checks (19877.2911ms)
+✔ checks reject objects that miss the asked-for features (165.8566ms)
+✔ long tasks reject plausible wrong variants (390.4065ms)
+✔ the robot shot needs both hands on target and a side-on camera (474.0186ms)
+✔ the walk and wave check needs both clips, the legs walking and only the right arm waving (1478.9398ms)
+✔ tasks that change an existing scene carry their starting recipe in the prompt (0.716ms)
+✔ the pillar court check rejects a grid with a wrong count or spacing (13.4848ms)
+✔ an invalid recipe fails every check with the reason (1.28ms)
+✔ the tray-drop checks reject a box collider, a missing section and a body that falls through (134.1879ms)
+✔ the terrain walk needs the opening, the hills and a walk that goes around the opening (991.2326ms)
+✔ the path walk passes its reference and fails a walk through the second opening or the rock (745.1868ms)
+✔ the render pick passes the unshadowed light and fails the two shadowed places and shortcuts (26.1315ms)
+✔ the hard light pick passes the least shadowed place and fails every other place and shortcut (77.3858ms)
+✔ the overshoot lift passes with one named easing or with hand-placed keyframes, and fails without an overshoot (40.2012ms)
+✔ the plain overshoot task forbids easings in its prompt and grades the hand-placed keyframes (14.2635ms)
+✔ copy_transforms gives the owner the target world matrix (60.9626ms)
+✔ limit_distance pulls a far owner onto the sphere, keeping its direction (4.3517ms)
+✔ limit_distance inside leaves a near owner, outside pushes it out and surface does both (14.4879ms)
+✔ limit_scale clamps each ranged axis and leaves the others (3.0588ms)
+✔ stretch_to aims +y at the target and keeps volume with x and z (5.3487ms)
+✔ stretch_to takes its rest length from the rest pose, and volume none leaves x and z alone (3.6325ms)
+✔ locked_track turns only about the lock axis (2.7405ms)
+✔ transformation maps a clamped target channel range onto the owner (4.455ms)
+✔ action reads a keyed curve at the target channel position (6.4448ms)
+✔ the new constraints refuse bad fields (11.3611ms)
+✔ the newer types accept their fields in args, the shape the MCP schema uses (2.9696ms)
+✔ scene_capabilities lists every constraint type (17.4918ms)
+✔ copy_location copies chosen axes, inverts, and can offset (79.5787ms)
+✔ copy_rotation replaces chosen Euler axes in world space and adds on request (7.7764ms)
+✔ copy_scale copies and multiplies (10.1247ms)
+✔ limit_location and limit_rotation clamp, in world or local space (6.2641ms)
+✔ track_to points the track axis at the target with the up axis toward worldUp (7.6351ms)
+✔ child_of keeps the owner in place at rest and carries it with the target; influence blends (21.3084ms)
+✔ floor keeps a node above the target plane along the chosen axis (6.5007ms)
+✔ constraints run in order on the result of the one before (1.9261ms)
+✔ constraints follow a target moved by a track and a seek equals playing (22.2318ms)
+✔ drivers set a node component and a material property from time and other nodes (9.5219ms)
+✔ a seek equals play for drivers too (2.9103ms)
+✔ drivers and constraints reject anything that is not bounded data (6.753ms)
+✔ the capabilities list every constraint type (0.3192ms)
+✔ motionIk reports the poses a joint limit changed (46.8524ms)
+✔ a deliberately wrong pole produces a warning while IK still reports reached (9.1456ms)
+✔ a target at full reach warns about hyperextension (3.7821ms)
+✔ limits and bendToward are validated (4.0512ms)
+✔ constraints move parts of an imported character, and a seek equals play (219.1194ms)
+✔ a recipe arm reaches a fixed point with no rotation tracks, and bone lengths hold (48.8663ms)
+✔ a keyframed target moves through time, and seeking back gives the same pose (5.9019ms)
+✔ a target can follow another node, including one moved by a track (4.7322ms)
+✔ IK runs on top of tracks: a moving base carries the shoulder and the tip still reaches (34.9187ms)
+✔ the pole picks the side the elbow bends to (7.216ms)
+✔ keyframed weight fades IK in, with tracks showing through (4.3408ms)
+✔ aim points a node at a target and honours maxAngle (6.421ms)
+✔ scene_inspect reports where IK falls short across the clip (42.8159ms)
+✔ inspecting does not disturb the sampled pose (5.6954ms)
+✔ recipes export and reload with their ik (10.7117ms)
+✔ mistakes say what to pass (12.2865ms)
+✔ a node named like a humanoid bone is not mapped to another node (4.3208ms)
+✔ light tracks set color, intensity and position of one light and leave the rest authored (30.5211ms)
+✔ sun and environment tracks set the key light, sky, fog and volume fog (4.3355ms)
+✔ effects tracks set exposure and the focus distance of the depth of field (4.6516ms)
+✔ a scene with no look tracks reads the authored environment and effects (6.1854ms)
+✔ unknown lights, properties and ill-fitting targets name the valid ones (7.7063ms)
+✔ a sunset changes the sun and sky between two frames of a render (8421.8413ms)
+✔ normalization preserves public targets, sorts copied keys and normalizes quaternion values (4.2788ms)
+✔ all four curves use core interpolation and material roughness retains authored zero (2.367ms)
+✔ retained vectors, typed camera output and arbitrary seeks are deterministic (3.5398ms)
+✔ loop modulo and nonloop clamping agree across channels, with bounded absolute time (1.0049ms)
+✔ camera-only motion compiles an empty ordinary clip and retains the static camera lens (0.5483ms)
+✔ strict schema, final references, duplicate tracks and allocation bounds reject invalid authoring (2489.2302ms)
+✔ invalid cubic scale and material overshoot throw without clamping or partial publication (1.3738ms)
+✔ radiance overflow, camera midpose collisions and cubic lens overshoot preserve the previous sample (1.1269ms)
+✔ unlit radiance uses the authored base color when emissiveColor is absent (0.4563ms)
+✔ a native request runs native when the package and its binary are present (2.9154ms)
+✔ without the package a native job falls back to gpu, or to cpu on a cpu runtime, and says why (12.6113ms)
+✔ a package without its built binary falls back and names the build step (1.3217ms)
+✔ a trace that failed once makes later native requests fall back with that reason, without importing again (0.9417ms)
+✔ cpu and gpu requests never touch the native package (1.0421ms)
+✔ a smooth metal part gets its own reflection probe without any field (201.7289ms)
+✔ a scene with no reflective part reports nothing and keeps its parts untouched (71.8058ms)
+✔ environment.objectReflections false turns the probes off (49.461ms)
+✔ an edit that changes nothing the probe sees keeps the traced probe (128.4833ms)
+✔ a recipe physics section drops a body onto a trimesh floor and seeks deterministically (294.5929ms)
+✔ scene_inspect reports contacts, resting state and sensors as numbers (139.2124ms)
+✔ physics is recorded again only when its inputs change (132.8418ms)
+✔ masks and layers decide what a body falls through (58.3497ms)
+✔ bad physics sections fail with a message that names the fix (5.8947ms)
+✔ a node cannot have both a physics body and a motion track on its pose (3.4852ms)
+✔ a trimesh over the triangle limit is refused before it is copied (345.7111ms)
+✔ capabilities name the physics surface and the detector finds a section (0.3367ms)
+✔ every preview path that reads a recipe scene works when the on-demand scene modules start unloaded (4469.669ms)
+✔ every preview path that reads a asset scene works when the on-demand scene modules start unloaded (4426.4588ms)
+✔ HDR fallback rejects enabling or restoring volume fog before canonical publication (298.9573ms)
+✔ private review samples reset independently and camera overrides do not publish edits (123.5334ms)
+✔ source suspend and resume preserve transient motion pose and checkpoints (60.7598ms)
+✔ asset review samples imported clips and motion atomically and resets to authored clip pose (181.1366ms)
+✔ review private cameras reject Float32 overflow and preserve canonical revision after a partial grid (22.7879ms)
+✔ preview rejects a camera that overflows at a permitted aspect before committing edits (32.8403ms)
+✔ topology driver failure discloses committed recipe and retries reconciliation with the current revision (67.1433ms)
+✔ driver errors disclose committed revision and context loss preserves recipe recovery (61.9489ms)
+✔ scene_look with labels names the parts of an imported asset instead of throwing (68.8826ms)
+✔ the query-only cache asks for the file once, walks it and replaces it for another asset (76.6354ms)
+✔ a file that is not a GLB with a JSON chunk first is refused (2.5044ms)
+✔ motion job ranges use immutable recipe duration, loops and actual sample times across restart (12199.1147ms)
+✔ a scene that places a clip takes motion settings without authored motion, one that places a still asset does not (2686.6668ms)
+✔ real files publish after success with copied snapshots, hashes and restart persistence (7928.7026ms)
+✔ cancel acknowledges immediately and blocks output publication after runner writes a partial (174.2279ms)
+✔ deadline aborts a cooperative callback and close detects an uncooperative callback without releasing its lock (5275.016ms)
+✔ 1920x1080 and 1080x1920 jobs are admitted (8410.5557ms)
+✔ validation enforces range, geometry-independent storage limits and one pending frame (2792.5697ms)
+✔ runner traversal and oversized outputs fail without final artifacts (13518.8158ms)
+✔ restart marks unfinished records interrupted and rejects forged artifact paths (5485.9364ms)
+✔ incomplete admissions remain quarantined while completed jobs reopen and storage stays bounded (6487.3374ms)
+✔ a real initial status write failure publishes no job and leaves admission available (13549.2798ms)
+✔ release rejects aliases and foreign files before deleting owned entries (4317.6935ms)
+✔ record quota requires explicit release and completed artifact integrity survives reopening (116.35ms)
+✔ asset digests bind immutable bytes and still/video settings produce only their fixed artifacts (242.8295ms)
+✔ a path tracer job names its denoiser, and oidn defaults to 16 samples instead of 64 (411.2128ms)
+✔ a path tracer job draws every sample unless it passes a noise threshold, which stays within 0 to 0.1 (123.6617ms)
+✔ a path tracer job runs on the cpu unless it asks for the gpu, and film jobs may trace every frame (201.5559ms)
+✔ the deadline of a traced film covers every frame (0.2855ms)
+✔ the encoder waits 30 seconds by default and no caller sets a different value (21.3676ms)
+✔ the job deadline grows with frames and pixels and never passes its ceiling (0.4166ms)
+✔ defaults leave transparent, format and region out of the settings, so a plain job is unchanged (2576.2125ms)
+✔ transparent is kept for an image job and refused for video and the path tracer (1099.0432ms)
+✔ png16 and exr jobs name their files and MIME types, and pass files follow the format (4120.809ms)
+✔ a high-precision frame may be four times the 8-bit frame limit (3430.0813ms)
+✔ a region must lie inside the frame, and a video region keeps even sides (2435.2789ms)
+✔ a video may run at 60 fps and no faster (1564.2174ms)
+✔ options survive a restart of the job store (1707.3688ms)
+✔ encodePng16 writes 16-bit samples that decode back exactly (2.2699ms)
+✔ toHalfBits rounds to IEEE half floats and clamps to the finite range (0.2046ms)
+✔ encodeExr writes ZIP scanline blocks that decode back, in channel name order (19.4816ms)
+✔ encodeRenderOutput flips the bottom-up readback and decodes depth, object IDs and premultiplied alpha (3.048ms)
+✔ review independently defaults shot clocks and bounds its labeled grid (7.0048ms)
+✔ review rejects unknown fields, nonfinite values and unbounded inputs before allocation (4.6462ms)
+✔ review detaches caller camera and imported animation records (0.3484ms)
+✔ runtime reports real scene capabilities without launching a browser and closes idempotently (2.5181ms)
+✔ an edit of a scene with a bake, or one that adds a bake, gets the bake deadline; a plain edit keeps 30 s (202.162ms)
+✔ review deadline rejects stalled page acquisition and disposes a late page (74.1175ms)
+✔ close interrupts stalled page acquisition and late resolution cannot resurrect the runtime (27.917ms)
+✔ review queue releases private renderer before source resume, including partial and size failures (93.3679ms)
+✔ queued review detaches its request before a caller can mutate shot clocks (32.1605ms)
+✔ successful review elapsed time includes source renderer recovery (118.4518ms)
+✔ total review deadline closes private page and restores the usable source (117.4772ms)
+✔ private disposal failure still closes its page before restoring source (69.6183ms)
+✔ review stale revisions and strict runtime fields reject before leasing source (38.0988ms)
+✔ runtime close promptly aborts a pending private review and skips source resume (4.556ms)
+✔ invalid preview configuration rejects before any browser or renderer allocation (0.6081ms)
+✔ requests cannot address an absent session or enter a closing runtime (0.6496ms)
+✔ the preview server accepts only its own loopback host (0.1016ms)
+✔ ten placements of one asset share geometry, material and a draw batch (157.6233ms)
+✔ material overrides name the source material and stay shared between placements (21.4195ms)
+✔ a placed clip plays on its own time offset and a seek gives the same frame (57.5259ms)
+✔ placements are bounded and need their assets (39.3856ms)
+✔ apply can add and remove placed assets (52.0502ms)
+✔ a crowd field loads on the crowd marker and reserves one decoded copy (9.7025ms)
+✔ a crowd draws as one batch per material however many people it has, and scene_inspect reports it (2256.5676ms)
+✔ a crowd frame reached by seeking equals the one reached by playing, near and far (756.743ms)
+✔ far instances change pose only farRate times a second while near ones change every frame (248.7966ms)
+✔ crowd settings are validated and the clip must exist (372.3313ms)
+✔ a crowd keeps its baked parts across an edit that does not touch it (355.1154ms)
+✔ motion samples local joints with retained resources and exact shuffled seeks (56.6855ms)
+✔ base reset, checkpoints and authored edits rebuild motion bindings without seek revisions (9.5312ms)
+✔ final batch reference validation prevents dangling tracks and permits atomic replacement (4.7379ms)
+✔ invalid cubic mid-pose rejects a whole seek without publishing other channels (3.1414ms)
+✔ combined parent transforms and invalid camera crossings cannot publish valid sibling tracks (28.9994ms)
+✔ failed set-motion initial sampling is atomic across recipe, transforms and materials (4.5002ms)
+✔ motion loop is optional boolean and never accepts null as a hidden default (0.706ms)
+✔ a recipe with only primitives needs no on-demand module (12.8801ms)
+✔ markers name the module a recipe needs (2.9109ms)
+✔ a primitive recipe runs without loading any module (701.0559ms)
+✔ a mesh recipe says which call loads the mesh code, and runs once it is loaded (1875.5998ms)
+✔ a forest clearing grows on terrain through the recipe, keeps the clearing clear, and a seek gives the same frame (4049.6405ms)
+✔ the same scatter through the recipe and through the addon gives the same instances for a seed (3003.1837ms)
+✔ levels follow the recipe camera and are not changed by time (4129.4638ms)
+✔ season tints leaves, and bare season drops deciduous foliage but keeps conifers green (561.434ms)
+✔ one tree grows at the node transform and validation names the problem (69.48ms)
+✔ environment.wind validates and survives export (260.7371ms)
+✔ an imported tree with a foliage override gets the swaying tag and shares it between placements (35.1084ms)
+✔ the plain-data capabilities module matches the scene engine (33.5076ms)
+✔ authored look patches preserve resources and undo light, fog, exposure and projector together (15.4112ms)
+✔ invalid look in a mixed batch cannot publish transforms, material or render controls (6.7583ms)
+✔ shader arithmetic rejects cancelling product overflow and nonfinite emission atomically (15.7607ms)
+✔ recipes author liquid, foam and blended glass with batch-safe material handles (6.557ms)
+✔ trailing sparse array holes reject recipes and command batches without commit (22.1611ms)
+✔ shared resources and retained renderer identities survive apply and restore (33.6153ms)
+✔ transactions reject conflicts and invalid late commands without publishing any changes (10.8806ms)
+✔ hierarchy and actual vertex bounds agree with an independent double precision transform (20.5478ms)
+✔ depth and world overflow checks reject an entire candidate and allow recovery (6.3421ms)
+✔ checkpoints are private, bounded, session-specific and releaseable (6.6066ms)
+✔ camera supports explicit top views and rejects degenerate or collapsed projection ranges (4.6646ms)
+✔ finite matrices still reject world geometry overflow using cached local bounds (39.2504ms)
+✔ recipe boundary rejects malformed JSON, unknown keys and oversized geometry before generation (2.1414ms)
+✖ command and resource budgets, bounded inspection and missing IDs report failures (4.6314ms)
+✔ detached privileged adapter matrices cannot partially publish a transaction (21.8775ms)
+✔ all seven generators remain within conservative aggregate vertex and byte estimates (52.1699ms)
+✔ topology can grow from an empty session while sharing resources and preserving existing part identities (3.9399ms)
+✔ topology failures roll back recipes, geometry, materials, matrices and both revisions (33.5795ms)
+✔ node deletion distinguishes nonrecursive rejection from explicit subtree removal (6.7883ms)
+✔ resource removal and node rebinding resolve final references after sequential commands (5.0756ms)
+✔ unchanged definitions reuse geometry while changed definitions replace bound parts (2.9513ms)
+✔ checkpoints restore removed geometry and parts with bounded private retained identities (3.6547ms)
+✔ peak geometry budgets count checkpoint ownership and free it on release (5.1549ms)
+✔ atomic replacement budgets include old active resources until commit (1.8063ms)
+✔ new topology enforces world geometry overflow and depth before publishing (1.7977ms)
+✔ topology rejects stale revisions and detached active or checkpoint matrices atomically (10.2822ms)
+✔ a node with a geometry and no material gets an explicit default material, deterministically (4.4124ms)
+✔ an existing default material is reused and a node with only a material still names the fix (2.4209ms)
+✔ a recipe without a materials or geometries list reads them as empty, and the export lists them (2.0886ms)
+✔ recipe materials accept alphaMode 'add' and keep it when opacity is below one (18.2418ms)
+✔ totals count success rate, calls, errors, tokens and cost for each model and task (2.8473ms)
+✔ local paths are removed from recorded text (1.3589ms)
+✔ no recorded result holds a local path (1261.8709ms)
+✔ frame index is floor(time * fps), looped by default and held on the last frame without loop (1.0096ms)
+✔ a bad frame ID, frame count, fps or loop is rejected with a message that names the field (1.5395ms)
+✔ the scene shows the frame of its motion time, reports it and seeks deterministically (21.2804ms)
+✔ the scene rejects frames that are missing or differ in size, and a map with a pattern (4.0739ms)
+✔ an edit can set a sequence and the frame IDs of a recipe are collected for the host (0.4377ms)
+✔ the catalog lists PNG, JPEG and WebP images by content and rejects a mismatched extension (1049.5141ms)
+✔ the three.js grader passes the reference geometry of each sampled task and scores its look as 1 (2387.3528ms)
+✔ the three.js grader fails an open surface of the wrong size (0.711ms)
+✔ walkMap works on a procedural recipe scene and marks its box as an obstacle (91.1012ms)
+✔ walkMap on an imported asset returns a grid and reuses the cached query (1703.2635ms)
+✔ applyAnimation with checks off gives the same pose as the checked path (144.4617ms)
+✔ applyAnimation checks option must be a boolean (28.2317ms)
+✔ the checked path stays the default after an unchecked frame (23.9822ms)
+✔ frame after frame on one clip matches a fresh asset posed once, across clip switches and overrides (415.5422ms)
+✔ players and mixers retain the same isolated material across bindings (3.4643ms)
+✔ clamped spline scale poses can bind another player or mixer after Float32 rounding (0.7416ms)
+✔ overlapping walk, head and gesture clips blend per property with captured base pose (1.805ms)
+✔ weights above a total of one normalize and match installed Three PropertyMixer semantics (2.8487ms)
+✔ shortest-arc quaternion mixing handles antipodes and matches Three for two actions (1.6532ms)
+✔ crossfades retain boundary continuity and replay correctly across arbitrary seeks (0.9874ms)
+✔ interrupted fades preserve earlier history and restart continuously from the scheduled weight (0.4237ms)
+✔ play, stop and replay use explicit origins, offsets and signed time scales (0.4214ms)
+✔ material blending isolates shared frozen materials and retains identities (0.6356ms)
+✔ invalid control commands do not corrupt action timelines or partial crossfades (11.4862ms)
+✔ spline domains stay positive and zero-weight invalid curves do not run (1.6105ms)
+✔ invalid samples leave every matrix, material and last successful time unchanged (1.9671ms)
+✔ retained transform buffers survive hundreds of seeks without replacement (16.2354ms)
+✔ invalid bindings fail without publishing partially registered material copies (0.5845ms)
+✔ extrapolation constant holds ends and linear continues the end slopes (3.1798ms)
+✔ cycles repeat, offset and mirror before and after the keys, with finite counts (0.6633ms)
+✔ cycles keep going past the clip duration (0.1635ms)
+✔ stepped holds the curve for each step (0.366ms)
+✔ generator replaces or adds a polynomial of time (0.3718ms)
+✔ limits clamp and envelope remaps a value range over time (2.2391ms)
+✔ noise is seeded, bounded, smooth and independent of the order of seeks (0.6493ms)
+✔ noise differs per axis and a pinned sample stays byte stable (0.2671ms)
+✔ modifiers run time steps first, then value steps, and compose with extrapolation (0.258ms)
+✔ rotation tracks take only repeat or mirror cycles and stepped (0.9896ms)
+✔ invalid modifiers name the field and an accepted example (0.8395ms)
+✔ recipe motion tracks keep modifiers, sample them at the same times in every sampler and seek backwards (5.0536ms)
+✔ stepped lands on the new step at frame times that are inexact in binary (0.6718ms)
+✔ keyframes normalize input order, clamp endpoints and sample independently of call order (2.3677ms)
+✔ STEP and SMOOTH interpolation retain their endpoint behavior (0.2646ms)
+✔ looping wraps exact endpoints and negative times (0.18ms)
+✔ quaternion keyframes normalize and interpolate the shortest arc (0.3019ms)
+✔ bound animation preserves matrix identities and initial untracked transform components (1.3901ms)
+✔ motion sampling keeps geometry and matrix identities and frames portrait around the same focal point (68.3774ms)
+✔ invalid tracks, values and bindings fail explicitly (1.3788ms)
+✔ orbital showcase preserves speed across keyframe boundaries with fewer spline keys (51.6921ms)
+✔ CUBICSPLINE uses per-second tangents for scalar and vector Hermite curves (0.4906ms)
+✔ spline quaternion components use Hermite tangents then normalize without a shortest-arc sign flip (0.6902ms)
+✔ spline input values, tangents and sampled arrays remain isolated (0.6476ms)
+✔ malformed spline tangents and undersized spline tracks fail at compilation (1.034ms)
+✔ spline overshoot stays in positive scale and valid material domains (0.4264ms)
+✔ compiled playback isolates shared materials and seeks deterministically with stable identities (0.6833ms)
+✔ multiple players share an isolated target material without detaching earlier bindings (0.3803ms)
+✔ apply reuses the same transform inputs and composed matrix buffers (1.2296ms)
+✔ invalid sampled outputs leave all bound matrices and material properties unchanged (0.6014ms)
+✔ spline rotation playback matches public sampling for large finite tangent magnitudes (0.3865ms)
+{"individuallyExplodableParts":574,"sections":20,"minimum":[-4.207999959038421,0.25937500715255735,-2.414500024303794],"maximum":[4.207999959038421,4.075185200239399,3.1060000260843195]}
+✔ detail planning is deterministic and leaves assembled source objects untouched (2.4574ms)
+✔ all individual accessories have distinct finite movement and reversible full-explosion bounds (229.7015ms)
+✔ export displacement exactly matches the staged shader smoothstep (0.6144ms)
+✔ coincident rubber pads and steel shoes detach into visibly separate axial lanes (35.1395ms)
+✔ the fixture was recorded by Blender 5.2 and covers the required constraints (1.1095ms)
+✔ copy_rotation_xz matches Blender's world matrix (74.436ms)
+✔ copy_rotation_all_with_parent matches Blender's world matrix (9.6342ms)
+✔ limit_rotation_xy matches Blender's world matrix (2.9957ms)
+✔ track_to_negative_z_up_y matches Blender's world matrix (2.8111ms)
+✔ track_to_positive_x_up_z matches Blender's world matrix (2.3845ms)
+✔ child_of_follows_target_from_rest matches Blender's world matrix (3.9104ms)
+✔ child_of_half_influence matches Blender's world matrix (2.9096ms)
+✔ floor_z_with_offset matches Blender's world matrix (31.7353ms)
+✔ the golden file has a result for each curve and text case (2.2954ms)
+✔ bezier-pipe-open matches Blender's evaluated Bezier curve in volume, area and bounds (8.3966ms)
+✔ bezier-ring-closed matches Blender's evaluated Bezier curve in volume, area and bounds (12.2686ms)
+✔ text-B matches Blender's text object in volume, area and bounds, using the same font (56.723ms)
+✔ text-Hi matches Blender's text object in volume, area and bounds, using the same font (1.86ms)
+✔ the golden file has a result for each case and records its Blender version (3.1615ms)
+✔ every listed difference names a case and a metric (0.4351ms)
+✔ decimate-sphere-half is as close to its input as Blender's, apart from its listed differences (92.08ms)
+✔ decimate-sphere-tenth is as close to its input as Blender's, apart from its listed differences (51.7938ms)
+✔ decimate-torus-quarter is as close to its input as Blender's, apart from its listed differences (17.6124ms)
+✔ decimate-bowl-half is as close to its input as Blender's, apart from its listed differences (86.9411ms)
+✔ remesh-sphere is as close to its input as Blender's, apart from its listed differences (309.6816ms)
+✔ remesh-torus is as close to its input as Blender's, apart from its listed differences (242.2394ms)
+✔ extrude-region-cube-top matches Blender, apart from its listed differences (4.8473ms)
+✔ extrude-region-grid-block matches Blender, apart from its listed differences (1.8454ms)
+✔ extrude-region-cylinder-sides matches Blender, apart from its listed differences (1.3423ms)
+✔ extrude-individual-grid matches Blender, apart from its listed differences (1.1ms)
+✔ extrude-individual-cube-adjacent matches Blender, apart from its listed differences (0.6451ms)
+✔ inset-region-cube-top matches Blender, apart from its listed differences (0.8574ms)
+✔ inset-region-cube-top-depth matches Blender, apart from its listed differences (0.5733ms)
+✔ inset-region-grid-block matches Blender, apart from its listed differences (0.8136ms)
+✔ inset-region-grid-corner matches Blender, apart from its listed differences (0.6852ms)
+✔ inset-individual-grid matches Blender, apart from its listed differences (0.6625ms)
+✔ bevel-cube-all-chamfer matches Blender, apart from its listed differences (3.292ms)
+✔ bevel-cube-all-round matches Blender, apart from its listed differences (11.9049ms)
+✔ bevel-cube-vertical matches Blender, apart from its listed differences (1.7925ms)
+✔ bevel-cube-top-rim matches Blender, apart from its listed differences (3.0454ms)
+✔ bevel-cylinder-rim matches Blender, apart from its listed differences (1.4213ms)
+✔ bevel-cube-one-edge-profile matches Blender, apart from its listed differences (0.6402ms)
+✔ bevel-cube-clamped matches Blender, apart from its listed differences (1.0283ms)
+✔ loop-cut-cube-one matches Blender, apart from its listed differences (2.4788ms)
+✔ loop-cut-cube-three matches Blender, apart from its listed differences (0.8862ms)
+✔ loop-cut-cube-factor matches Blender, apart from its listed differences (0.445ms)
+✔ loop-cut-grid matches Blender, apart from its listed differences (0.6817ms)
+✔ loop-cut-cylinder matches Blender, apart from its listed differences (0.8232ms)
+✔ mirror-touching-plane matches Blender, apart from its listed differences (1.0878ms)
+✔ mirror-away-from-plane matches Blender, apart from its listed differences (0.4777ms)
+✔ array-relative-merged matches Blender, apart from its listed differences (1.8023ms)
+✔ array-relative-apart matches Blender, apart from its listed differences (0.49ms)
+✔ array-constant matches Blender, apart from its listed differences (0.9667ms)
+✔ solidify-open-inward matches Blender, apart from its listed differences (0.8182ms)
+✔ solidify-open-outward matches Blender, apart from its listed differences (0.3999ms)
+✔ solidify-open-uneven matches Blender, apart from its listed differences (0.5372ms)
+✔ solidify-closed-shell matches Blender, apart from its listed differences (0.3923ms)
+✔ boolean-difference-cube matches Blender, apart from its listed differences (48.9694ms)
+✔ boolean-union-cube matches Blender, apart from its listed differences (6.8087ms)
+✔ boolean-intersect-cube matches Blender, apart from its listed differences (2.3148ms)
+✔ boolean-through-hole matches Blender, apart from its listed differences (9.2853ms)
+✔ subdivide-cube-level-1 matches Blender, apart from its listed differences (7.3684ms)
+✔ subdivide-cube-level-2 matches Blender, apart from its listed differences (5.7791ms)
+✔ subdivide-cube-level-3 matches Blender, apart from its listed differences (127.9736ms)
+✔ subdivide-grid-level-1 matches Blender, apart from its listed differences (1.162ms)
+✔ subdivide-grid-level-2 matches Blender, apart from its listed differences (11.3942ms)
+✔ subdivide-grid-level-3 matches Blender, apart from its listed differences (253.7051ms)
+✔ subdivide-cylinder-level-1 matches Blender, apart from its listed differences (1.6674ms)
+✔ subdivide-cylinder-level-2 matches Blender, apart from its listed differences (42.2709ms)
+✔ subdivide-cylinder-level-3 matches Blender, apart from its listed differences (387.5392ms)
+✔ subdivide-cube-crease-all matches Blender, apart from its listed differences (5.6485ms)
+✔ subdivide-cylinder-crease-rims matches Blender, apart from its listed differences (15.7242ms)
+✔ subdivide-cube-crease-two-levels matches Blender, apart from its listed differences (143.668ms)
+✔ subdivide-cube-crease-half matches Blender, apart from its listed differences (5.8276ms)
+✔ subdivide-grid-crease-middle matches Blender, apart from its listed differences (68.356ms)
+✔ fill-holes-cube-open matches Blender, apart from its listed differences (1.3916ms)
+✔ fill-holes-cylinder-open matches Blender, apart from its listed differences (0.4085ms)
+✔ dissolve-faces-grid-block matches Blender, apart from its listed differences (0.8812ms)
+✔ dissolve-edges-grid-pair matches Blender, apart from its listed differences (2.2029ms)
+✔ dissolve-verts-grid-centre matches Blender, apart from its listed differences (0.8676ms)
+✔ dissolve-verts-square-midpoint matches Blender, apart from its listed differences (0.4386ms)
+✔ dissolve-limited-cube-cut matches Blender, apart from its listed differences (0.9463ms)
+✔ bisect-cube-clear-outer-fill matches Blender, apart from its listed differences (1.8534ms)
+✔ bisect-cube-both-sides matches Blender, apart from its listed differences (0.4677ms)
+✔ bisect-cube-diagonal-clear-inner matches Blender, apart from its listed differences (0.3291ms)
+✔ bisect-cylinder-clear-inner-fill matches Blender, apart from its listed differences (28.7875ms)
+✔ bridge-cube-pair matches Blender, apart from its listed differences (3.0665ms)
+✔ bridge-cube-pair-segments matches Blender, apart from its listed differences (3.0494ms)
+✔ subdivide-edges-cube-all matches Blender, apart from its listed differences (2.6429ms)
+✔ subdivide-edges-cube-all-two-cuts matches Blender, apart from its listed differences (2.223ms)
+✔ subdivide-edges-grid-along matches Blender, apart from its listed differences (1.372ms)
+✔ grid-fill-grid-hole matches Blender, apart from its listed differences (1.7619ms)
+✔ grid-fill-cylinder-open matches Blender, apart from its listed differences (12.2734ms)
+✔ knife-project-cube-line matches Blender, apart from its listed differences (1.9627ms)
+✔ set-position-grid-shear matches Blender, apart from its listed differences (1.9752ms)
+✔ set-position-cube-scale-sum matches Blender, apart from its listed differences (0.4568ms)
+✔ displace-cube-constant-normal matches Blender, apart from its listed differences (0.4171ms)
+✔ displace-cube-gradient-z matches Blender, apart from its listed differences (0.2529ms)
+✔ displace-grid-gradient-normal matches Blender, apart from its listed differences (1.6616ms)
+✔ weld-cube-split matches Blender, apart from its listed differences (0.6635ms)
+✔ triangulate-cube matches Blender, apart from its listed differences (0.466ms)
+✔ triangulate-cylinder matches Blender, apart from its listed differences (0.3457ms)
+✔ triangulate-cylinder-caps-only matches Blender, apart from its listed differences (0.4075ms)
+✔ triangulate-pentagon matches Blender, apart from its listed differences (0.1346ms)
+✔ edge-split-cube matches Blender, apart from its listed differences (0.6447ms)
+✔ edge-split-cylinder matches Blender, apart from its listed differences (0.8133ms)
+✔ edge-split-cylinder-wide matches Blender, apart from its listed differences (0.6181ms)
+✔ edge-split-grid matches Blender, apart from its listed differences (0.3017ms)
+✔ smooth-grid matches Blender, apart from its listed differences (0.507ms)
+✔ smooth-cube-full matches Blender, apart from its listed differences (0.1645ms)
+✔ smooth-sphere-bumpy matches Blender, apart from its listed differences (176.1694ms)
+✔ simple-deform-twist-cylinder matches Blender, apart from its listed differences (1.084ms)
+✔ simple-deform-bend-grid matches Blender, apart from its listed differences (0.2964ms)
+✔ simple-deform-bend-cylinder matches Blender, apart from its listed differences (0.2296ms)
+✔ simple-deform-taper-cylinder matches Blender, apart from its listed differences (0.232ms)
+✔ simple-deform-stretch-cylinder-x matches Blender, apart from its listed differences (0.2149ms)
+✔ cast-cube-mean matches Blender, apart from its listed differences (0.3176ms)
+✔ cast-cylinder-size matches Blender, apart from its listed differences (0.2203ms)
+✔ cast-sphere-bumpy matches Blender, apart from its listed differences (197.8601ms)
+✔ screw-quad-full-turn matches Blender, apart from its listed differences (1.2115ms)
+✔ screw-quad-lift matches Blender, apart from its listed differences (0.5795ms)
+✔ wireframe-cube matches Blender, apart from its listed differences (1.5899ms)
+✔ wireframe-cube-outside-keep matches Blender, apart from its listed differences (0.9789ms)
+✔ wireframe-quad-open matches Blender, apart from its listed differences (0.225ms)
+✔ wave-grid-ring matches Blender, apart from its listed differences (0.7015ms)
+✔ wave-grid-x-once matches Blender, apart from its listed differences (0.2777ms)
+✔ sculpt-inflate-sphere matches Blender, apart from its listed differences (263.6723ms)
+✔ sculpt-displace-smooth-grid matches Blender, apart from its listed differences (0.9684ms)
+✔ shrinkwrap-nearest-cylinder matches Blender, apart from its listed differences (23.1592ms)
+✔ shrinkwrap-project-cap-offset matches Blender, apart from its listed differences (1.9703ms)
+✔ high resolution render targets shrink before exceeding their memory budget (2.3759ms)
+✔ HDR, two half-resolution bloom targets and cached texture mipmaps fit inside the budget (2.2596ms)
+✔ presets fit their budget and device texture limits (0.3648ms)
+✔ invalid or impossible memory requests fail before allocation (0.4603ms)
+✔ a budget error names the bytes it counted and a memoryBudgetMiB that then fits (0.5696ms)
+✔ resolved depth adds exactly four bytes per pixel and participates in resolution reduction (0.3195ms)
+✔ without memoryBudgetMiB the budget fits the scene, from 256 MiB up to a device ceiling (0.4741ms)
+✔ the cabinet has 10 parts and the relations version differs from the plain one only by relations (1.8371ms)
+✔ both cabinet tasks accept their reference and reject a cabinet whose parts were left behind (2361.8266ms)
+✔ lens conversion agrees with a Three camera with a 24mm sensor height (3.3469ms)
+✔ camera follows a Hermite arc and is independent of seek order and input mutation (18.3876ms)
+✔ tracking transforms a local target offset and roll changes the up vector (3.4986ms)
+✔ retained outputs preserve identity and rejected samples leave the frame untouched (0.8359ms)
+✔ Float32 precision collapse is rejected before publishing outputs (0.4998ms)
+✔ overlapping views and readonly output components reject before any writes (0.9452ms)
+✔ looping and cubic lens overshoot obey camera domain constraints (13.8523ms)
+✔ orthographic XY size is invariant with depth and perspective size is not (1.7694ms)
+✔ axis views keep the expected screen direction, including a usable top up vector (0.4566ms)
+✔ projection preserves existing shifts for callers without explicit camera projection (0.9966ms)
+✔ orthographic fit respects both horizontal and vertical extents (0.9288ms)
+✔ perspective fit contains off-center boxes under tilted and rolled Three.js cameras (3.0267ms)
+✔ perspective fit rejects invalid bounds, lenses and impossible clipping without mutating inputs (11.0504ms)
+✔ perspective fit shares renderer clipping defaults and rejects unrepresentable camera positions (0.5998ms)
+{"parts":151,"geometries":4,"triangles":2156,"bounds":{"minimum":[-2,-2.5,0],"maximum":[2,2.5,0.06]}}
+✔ flat vector primitives have positive XY winding and no fictitious thickness (4.8388ms)
+✔ 2D poster is layered vector geometry with shared identities and deterministic reusable animation (17.6369ms)
+✔ split distances grow, end at the far plane and sit between a uniform and a logarithmic split (1.558ms)
+✔ one cascade covers the whole range (0.764ms)
+✔ a cascade matrix maps its own sphere inside the depth map (0.5887ms)
+✔ moving the slice by less than a texel leaves the matrix unchanged, so edges do not crawl (0.2969ms)
+✔ a vertical light still gets a valid view (0.1539ms)
+✔ options are checked (6.3442ms)
+✔ the cascade shader replaces the classic sun map and a plain shader has no trace of it (0.5354ms)
+✔ an update redraws only the slices whose matrix changed, and every slice when a caster changed (0.762ms)
+✔ a far slice that drifts toward the light keeps its map, because the wide fit also reaches further on the light side (0.7829ms)
+✔ a moving camera keeps a far slice's map until the slice leaves it, and a stopped camera settles on the exact fit (4.1855ms)
+✔ the changelog data holds released sections and pending fragments with issue and breaking flags (24.9518ms)
+✔ the site changelog gets an Unreleased section above the released ones (9.3292ms)
+✔ release notes are one version section with its breaking marker and the install line (0.4698ms)
+✔ a ### heading groups the entries below it, and the Breaking changes group marks them breaking (1.5461ms)
+✔ release notes fail clearly when the version is not in the changelog (0.6364ms)
+✔ fragments are read in name order, skipping the README and empty files (45.4197ms)
+✔ folding puts the notes above the newest release and keeps their text (10.3377ms)
+✔ folding refuses a repeated version, a bad version and an empty list (0.946ms)
+✔ the marketplace lists one plugin whose version matches package.json (2.2352ms)
+✔ the plugin source is the skills folder, so the install cache stays small (0.2063ms)
+✔ the plugin ships both skills that exist in the repository (1.6836ms)
+✔ the plugin starts the published MCP bin and the npm package ships its files (0.2719ms)
+✔ a closed room without a bake gets a diagnostic that names the bake (33.639ms)
+✔ a room with a bake, a room with its roof off and a lone solid get no closed room diagnostic (5.6991ms)
+✔ the ray test counts only inner faces: a room is closed, a solid around the centre is not (0.5097ms)
+✔ a room with a window opening and a garden outside still counts as closed (6.196ms)
+✔ open ground with the same garden and no walls does not count as closed (3.8146ms)
+✔ a prop heavier than the triangle budget does not stop a room from counting as closed (37.009ms)
+✔ the closed room diagnostic disappears once the recipe asks for a bake (2046.0623ms)
+✔ a hanging sheet ends where Blender hangs it, within 1 percent of the sheet height (217.0828ms)
+✔ the draped sheet stays within 10 percent of its rest edge lengths and 5 percent of its rest area (445.159ms)
+✔ with the drag matched, the sheet falls and lands like the Blender bake, then drapes more slowly in Blender (244.2303ms)
+✔ a sheet dropped on a ball stays outside it in 67js and in Blender, though the drape shapes differ (194.3722ms)
+✔ a cape pinned to a walking humanoid never enters the limb capsules in a 5 second walk (13876.107ms)
+✔ the pinned top edge stays on the chest while the walker moves (8600.1884ms)
+✔ seeking to a time gives the cloth that playing to it gives (16505.0103ms)
+✔ a ball and a capsule on nodes follow their node and push cloth aside (608.1662ms)
+✔ a soft pin pulls the particle less than a hard pin (11.9554ms)
+✔ recipe checks refuse bad moving colliders and pins (24.4809ms)
+✔ the same time gives the same cloth positions, and a seek backwards reproduces them (428.85ms)
+✔ time zero is the rest sheet, null restores it and a seek counts as a topology change (128.7029ms)
+✔ pinned particles stay put while the rest of the sheet falls and hangs below the pins (182.7549ms)
+✔ stretch stays bounded under gravity and wind (175.8505ms)
+✔ wind pushes the sheet along the wind and a calm sheet stays in its plane (424.2566ms)
+✔ a sheet dropped on a ball drapes over it and never enters it (451.8584ms)
+✔ a box collider acts as a floor the sheet stops on (1027.2681ms)
+✔ the report lists particles, pinned count and final bounds (340.0957ms)
+✔ cloth recipes need the cloth module and plain recipes do not (0.8675ms)
+✔ set-cloth edits the section, null clears it and the recipe round trips (480.2172ms)
+✔ editing a scene while the cloth is posed returns the rest sheet and tells renderers (171.2504ms)
+✔ hostile cloth sections are rejected before any solver runs (8.5068ms)
+✔ particle and frame limits reject oversized bakes with a clear error (2266.1971ms)
+✔ a cloth node cannot also carry motion or a physics body (1.767ms)
+✔ welding joins vertices at one position so a seam cannot tear (0.1695ms)
+✔ capabilities describe cloth limits that match the solver (0.2611ms)
+✔ the solver is bit-exact between runs (116.1238ms)
+✔ the same options and seed build identical clutter (422.7228ms)
+✔ stones face outward and stand on the ground they sink into (228.2687ms)
+✔ fallen leaves face the sky and litter never casts shadows (35.3754ms)
+✔ the farthest level keeps only rocks, and far tiles are culled (1382.2674ms)
+✔ a zero mask clears clutter, and update stays quiet when nothing moves (12.0915ms)
+✔ every preset builds, and bad options fail with clear errors (232.1351ms)
+✔ the KTX2 worker config follows the extensions the context exposes (4.8628ms)
+✔ a compressed image uploads each mip level into immutable storage (1.0865ms)
+✔ a linear map uploads the linear format (0.2198ms)
+✔ a context without the extension refuses the upload and names it (0.6501ms)
+✔ an sRGB DXT map needs the sRGB S3TC extension (0.3266ms)
+✔ block compressed levels must match their size and DXT must be a multiple of four (0.274ms)
+✔ compressed bytes feed the renderer texture budget and a single level drops mip filtering (0.4319ms)
+✔ createTexture uploads a compressed image without generating mips (1.4588ms)
+✔ a sign flush with a wall is reported with both parts, the area and a fix (30.3237ms)
+✔ two boxes that share a visible top face are reported (3.1748ms)
+✔ a box resting on a floor is quiet (3.3644ms)
+✔ boxes that only touch along an edge or side by side are quiet (5.6972ms)
+✔ a gap of half a millimetre still fights, a gap of five millimetres does not (3.8985ms)
+✔ decal, depthLayer and resolveCoplanar all silence the pair without moving geometry (14.6655ms)
+✔ node decal and depthLayer are validated (2.8512ms)
+✔ renderer diagnostics carry the same warning, and a decal batches apart from its wall (6.8827ms)
+✔ the polygon offset is scoped to the layer and switched off for layer 0 (25.443ms)
+✔ the check is bounded: a work budget ends the sweep and says so (1.5785ms)
+✔ a flush pair of finely tessellated parts is found, with no cap on the triangles tested (200.3797ms)
+✔ one large part against many small flush parts finds every pair within a small work budget (628.3956ms)
+✔ thousands of parts that touch no common plane cost no part-pair work (45.3971ms)
+✔ hundreds of copies parked at one spot cost two parts, not every pair among them (1.383ms)
+✔ flush parts get a layer beside the part, so the part objects and updateParts keep working (0.7022ms)
+✔ faces that share only an edge or a seam are not pairs, and a sliver under the minimum area is ignored (0.7084ms)
+✔ two parts that really share area are a pair with that area (0.2192ms)
+✔ resolveFlushParts leaves exactly flush pairs to the depth buffer; coplanarLayers still layers them (0.9016ms)
+✔ layers settle in chains and never pile up on the top layer (0.6106ms)
+✔ branch coverage may wander by run-to-run noise without failing the gate (4.7435ms)
+✔ a real drop fails each metric past its own allowance (1.2384ms)
+✔ a crowd rig keeps one geometry per material and a joint for every rigid part and skin joint (123.2334ms)
+✔ a baked palette is the same whatever order its frames are posed in, and frames blend by clip time alone (306.6143ms)
+✔ a crowd vertex at any time matches per-instance skinning and stays inside the bound (235.7514ms)
+✔ instances of one character and clip share one batch per material, whatever their number or time (263.1244ms)
+✔ lods keep the joints, shrink the triangle count and report a growing error (70.3977ms)
+✔ the renderer culls crowd instances with the bound of the whole clip, and refuses nothing for levels (172.0832ms)
+✔ a crowd reached by seeking equals the same crowd reached by playing, with a lower pose rate for far instances (172.4476ms)
+✔ a crowd rig keeps UVs through levels and packs joints and weights exactly (1.0813ms)
+✔ morph targets stay on their own crowd part when the rig asks for them (164.5539ms)
+✔ a closed Bezier ring with a round profile has the volume of a torus and faces outward (386.9224ms)
+✔ an open curve gets flat caps and is watertight (67.985ms)
+✔ taper scales the radius along the length: a cone has a third of the cylinder volume (18.0105ms)
+✔ a custom profile sweeps its own cross-section whichever way it winds (8.0065ms)
+✔ handles: automatic ones are smooth, a lone handle is mirrored and explicit ones bend the span (0.9554ms)
+✔ curve rejects hostile or malformed input (23.317ms)
+✔ the bundled font builds every printable character and keeps counters open (623.2203ms)
+✔ text sits on its baseline, reads along +X, is centred through its depth and splits lines (41.6321ms)
+✔ text rejects hostile or unsupported input (69.291ms)
+✔ registerFont validates a font table and the font becomes usable by name (23.2553ms)
+✔ contours flatten with implied points and group into outlines with holes (0.357ms)
+✔ a recipe draws a labelled sign and a piped curve (470.0051ms)
+✔ recipe geometry validation rejects unknown fields, wrong types and oversized text before generating (62.2029ms)
+✔ no bundled glyph exceeds the vertex bound the recipe estimate uses (1768.8926ms)
+✔ capabilities list the new types with their limits and details (0.3117ms)
+✔ every named setup has fields and a finite environment map (96.2572ms)
+✔ setups differ from each other (3.1447ms)
+✔ a recipe with no lighting settings gets the default setup and occlusion (4.0153ms)
+✔ a named setup supplies its fields and explicit fields win (0.7515ms)
+✔ an unknown setup is rejected with the valid names (0.6724ms)
+✔ switching setup resets setup fields, and fields in the patch still win (0.2797ms)
+✔ occlusion zero turns the pass off and the radius is bounded (0.7785ms)
+✔ the engine itself keeps occlusion off unless asked (0.1453ms)
+✔ the same inputs return the same environment map object (0.5401ms)
+✔ capabilities list the setups and the occlusion default (0.2381ms)
+✔ the desk has 12 parts and the relations version differs from the plain one only by relations (4.3684ms)
+✔ both desk tasks accept their reference and reject a desk whose parts were left behind (4078.6732ms)
+✔ each start page has one title and is in the navigation (2.3803ms)
+✔ every navigation id names a real topic (0.6936ms)
+✔ documentation links to topics and sections resolve (2.2227ms)
+✔ every poster and loop of a live example exists (4.7263ms)
+✔ the plain-text guide holds every topic once, in navigation order (79.4452ms)
+✔ links to plain-text contracts point at files the site publishes (2.2483ms)
+✔ the API reference finds the declaration of the core exports (9409.2088ms)
+✔ every easing matches Blender 5.2 at 20 sample times within 1e-4 (5.6516ms)
+✔ the golden covers every named easing except linear (0.463ms)
+✔ seeks are deterministic: the same time gives the same value in any order (1.7824ms)
+✔ segments start and end on their keyframe values (0.3317ms)
+✔ cubic-bezier follows the CSS curve and may overshoot with y outside 0..1 (0.2045ms)
+✔ easing applies to rotation, applies to the segment after its keyframe and replaces smoothstep (0.6855ms)
+✔ an unknown easing is an error that names the valid forms (0.9599ms)
+✔ Back and Elastic take bounded arguments and other easings take none (0.5437ms)
+✔ easing is rejected on STEP and CUBICSPLINE tracks (0.3138ms)
+✔ recipe motion keeps easing on node, material and camera tracks and rejects an unknown name (4.6141ms)
+✔ camera path channels take easing (2.2488ms)
+✔ GLB export bakes eased tracks to linear samples that follow the curve (46.334ms)
+✔ neutral effects preserve the existing image by default (2.3402ms)
+✔ partial bloom settings retain defaults without changing caller data (8.257ms)
+✔ nonfinite or out-of-range effects fail before GPU uniforms are changed (4.4039ms)
+✔ spherical harmonic irradiance of a constant environment is constant in every direction (5.2143ms)
+✔ spherical harmonic irradiance follows a sky above, ground below split (1.4142ms)
+✔ RGBE parsing decodes flat and run-length scanlines (1.8263ms)
+✔ RGBE parsing rejects malformed files (0.9575ms)
+✔ loadHdri fetches and wraps the parsed file in an environment map (0.6919ms)
+✔ environment map validation names the offending field (0.5511ms)
+✔ environment memory accounting counts the half-float chain and the BRDF lookup (0.5453ms)
+✔ environment specular adds the energy a rough surface scatters a second time (0.2763ms)
+✔ direct light specular takes the same multiple scatter gain once per fragment (0.2539ms)
+✔ sunFromEnvironmentMap finds a synthetic sun at a known direction with rotation applied (62.1898ms)
+✔ sunFromEnvironmentMap returns null for an overcast map (1.7096ms)
+✔ motion portrait exports derive dimensions and duration without launching a browser (1.4462ms)
+✔ square and explicit dimensions preserve their selected compositions (0.6112ms)
+✔ only film selects the original soundtrack automatically (0.3654ms)
+✔ new options retain start offsets and legacy renderer presets (0.3801ms)
+✔ invalid export options fail before starting resources (0.8865ms)
+✔ video defaults to automatic capture, JPEG 95 for screenshots and auto encoding while stills retain lossless PNG (0.3747ms)
+✔ encoder preflight probes hardware only when required and falls back only in auto mode (0.9629ms)
+✔ full trailer exports accept the authored duration within the four-minute cap (0.2185ms)
+✔ asset captures select a supplied file and avoid an automatic soundtrack (0.2334ms)
+✔ all five texture channels round trip as PNG with their pixels, samplers and factors (69.8402ms)
+✔ textures carry the flipY of their descriptor into glTF row order (12.0334ms)
+✔ a pattern material exports box projected UVs and its baked textures (446.6803ms)
+✔ RobotExpressive round trips geometry, skin, materials and every clip (266.4407ms)
+✔ an exported clip poses the copy the way it poses the original (79.314ms)
+✔ skins built without a node list export derived joints and a clip can target them (86.2611ms)
+✔ morph weight clips round trip as one SCALAR sampler per track (12.1421ms)
+✔ a clip that targets a missing node names the fix (8.6699ms)
+✔ exported GLB loads with an independent glTF loader and preserves every part (211.8642ms)
+✔ GLB export writes alpha mode, cutoff, opacity and double-sided so the loader reads them back (36.8172ms)
+✔ GLB export names the fix when textures have no UVs or exceed the size limit (27.2715ms)
+✔ GLB export rejects a skin without joints and skin attributes without a skin (35.1609ms)
+✔ GLB export rejects malformed morph pairs rather than discarding expressions (45.4831ms)
+✔ GLB morph snapshots retain relative channels, shared meshes and independent signed node weights (72.7602ms)
+✔ GLB keeps editable offset RGB/UV accessors and separate HDR emission with shared meshes (1550.64ms)
+✔ GLB defaults remain dark without extensions and active emission preserves color and scalar (50.6228ms)
+✔ GLB validates every channel and material before binary allocation without clamping (114.0189ms)
+✔ GLB rejects an invalid later part before allocating its output buffer (6.8031ms)
+✔ GLB scans shared static geometry once while preserving different instance materials (5.0149ms)
+✔ GLB rejects shear and zero scales before output allocation (50.5761ms)
+✔ GLB Float32 rotated nonuniform, reflected and tiny TRS transforms roundtrip through Three (19.9855ms)
+✔ GLB export writes an additive material as BLEND because glTF has no additive mode (92.9719ms)
+✔ both contexts give the same result for the same operator (4.776ms)
+✔ a division by zero is 0 in a field and an error in a driver (0.6196ms)
+✔ each context rejects the other context's inputs and says so (2.0156ms)
+✔ rotate turns a vector about an axis by an angle (2.8662ms)
+✔ align gives Euler angles that turn +Y onto the direction, and transform applies them (26.2428ms)
+✔ the field operator names stay in step with the language (0.2306ms)
+✔ resample places points at equal arc length with the direction of travel (0.4892ms)
+✔ fillet rounds a corner with an arc of the given radius and keeps the ends (0.528ms)
+✔ instances align along a curve (1.5669ms)
+✔ bounding_box is the axis-aligned box around the mesh (1.2697ms)
+✔ convex_hull wraps the points in outward triangles and drops inner points (1.5049ms)
+✔ bounding_box and convex_hull run as recipe edits (2.308ms)
+✔ a scene file resolves its served-root asset paths under --root and swaps them for export URLs (42.5704ms)
+✔ render options take fps from the camera keys and the memory budget from the scene file (6.3978ms)
+✔ camera keys validate and sample by time (102.2355ms)
+✔ head grid and mesher derivative probes are finite, continuous and nondegenerate (164.8627ms)
+✔ wrapped seam and bilateral facial geometry agree (18.9343ms)
+✔ nose projects beyond sockets and mouth, while jaw narrows below the cheekbones (1.1315ms)
+✔ committed film motion matches the named solver bake and physical collisions transfer energy (2277.5858ms)
+✔ film playback retains balls and suspension matrices and reproduces backward seeks (3222.4301ms)
+✔ opening shot keeps the entire moving ball envelope in wide and portrait frames (2809.5292ms)
+✔ a timeline keeps its shots, camera overrides and durations through the scene (71.6143ms)
+✔ set-timeline edits the timeline and null removes it (27.1417ms)
+✔ hostile timelines are rejected with a reason (6.2667ms)
+✔ motion must cover the shots unless it loops or the shot sets motionStart (41.2675ms)
+✔ sampling is stateless: a time gives one shot, motion clock, camera and brightness in any order (9.7327ms)
+✔ timeline settings derive the duration and reject mixed clocks and ranges past the end (891.864ms)
+✔ encoder is a bounded enum and audio is a plain file name, both video only (888.5151ms)
+✔ audio.track pcm is kept on the job for parts that will be joined (819.0187ms)
+✔ audio codec arguments: AAC by default, PCM for parts that will be joined, nothing else (0.4014ms)
+✔ the audio library resolves plain files only and refuses links, empty files and wrong names (188.46ms)
+✔ a shot sets its own focus distance and blur, and a seek gives the same answer (20.3986ms)
+✔ shot focus distance and blur are checked at the boundary (2.2922ms)
+{"apparatus":{"parts":302,"triangles":85624,"geometries":6,"estimatedMiB":83},"office":{"parts":294,"triangles":186956,"geometries":10,"estimatedMiB":89},"laboratory":{"parts":404,"triangles":329128,"geometries":9,"estimatedMiB":89},"settlement":{"parts":1227,"triangles":533508,"geometries":15,"estimatedMiB":90},"portrait":{"parts":804,"triangles":309288,"geometries":13,"estimatedMiB":90},"gadget":{"parts":596,"triangles":188116,"geometries":6,"estimatedMiB":83},"control":{"parts":411,"triangles":212052,"geometries":9,"estimatedMiB":89},"atom":{"parts":222,"triangles":68784,"geometries":2,"estimatedMiB":83},"waves":{"parts":137,"triangles":163372,"geometries":3,"estimatedMiB":83},"sparks":{"parts":480,"triangles":92160,"geometries":1,"estimatedMiB":83},"desert":{"parts":1347,"triangles":390128,"geometries":9,"estimatedMiB":84},"night":{"parts":1347,"triangles":390128,"geometries":9,"estimatedMiB":84},"ignition":{"parts":725,"triangles":189952,"geometries":5,"estimatedMiB":84}}
+{"eyelidNormalAgreement":{"open":0.9951511039395714,"partial":0.9996256682988304,"closed":0.9939133801198763,"actual":0.9981779759497278}}
+✔ 187-second study has contiguous authored cuts, a late detonation and terminal black (5.4949ms)
+✔ random-access frame samples are finite and independent of playback order (3908.7956ms)
+✔ camera motion is continuous and eases to rest within each shot (684.5499ms)
+✔ sets keep shared geometry, valid surfaces and the 384 MiB target budget (2609.7059ms)
+✔ authored motion is visible, deterministic and retains render identities across seeks (3038.538ms)
+✔ tailored figure surfaces face outward and keep a closed shoulder silhouette (3432.0678ms)
+✔ authored actor joints retain attached headwear and hands through holds and arbitrary seeks (2957.3482ms)
+✔ integrated face topology and expression targets retain identities through backward seeks (3200.5277ms)
+✔ narrow portrait shots retain face and headwear through camera moves and backward seeks (14.6803ms)
+✔ blink closes both inset eye surfaces and retains independent actor expressions (9074.3469ms)
+✔ open and closed lids retain smooth surface normals throughout the brow range (7047.7326ms)
+✔ an open floor stays at full sky visibility (87.3803ms)
+✔ a roof hides the sky under it and leaves the open side alone (189.4856ms)
+✔ strength 0.5 keeps half of what the roof hides (276.7522ms)
+✔ the cut floor keeps its UVs, normals and a shape that covers the same area (12.394ms)
+✔ the same parts give the same bytes (109.624ms)
+✔ parts that carry their own light, a cut-out or a tag are not floors (0.35ms)
+✔ onlyClosedRooms leaves an open scene as it was (0.3095ms)
+✔ a scene with no floor or nothing above it comes back unchanged (0.2869ms)
+✔ a trace that passes its time limit returns the parts as they were (1388.7387ms)
+✔ an emissive floor gives the fog above it light in its own colour, and a plain one gives none (210.8637ms)
+✔ a point light on a plain floor lights the fog, and the same scene gives the same numbers (165.8985ms)
+✔ a part with an emissive map is not a source, and a part the bake cannot read leaves no grid (92.8774ms)
+✔ a volume fog without field, flow or profile resolves to the same keys as before (6.3865ms)
+✔ a fog field is kept by reference with its flow knobs and profile (1.4593ms)
+✔ fog field validation names the problem (1.3094ms)
+✔ the post program has the field and light steps only when asked, and the default program has neither (0.4211ms)
+✔ fog lights take points then spots, premultiplied by intensity, up to the limit (5.5863ms)
+✔ the field texture allocates once per size and writes into it afterwards (0.4736ms)
+✔ a fog without detail controls resolves to the default detail and needs no detail step (0.4654ms)
+✔ detail controls are kept, bounded and typed when the fog addon resolves them (1.6449ms)
+✔ the recipe look accepts the detail controls and rejects a non-number (13.7721ms)
+✔ the detail step is compiled in only on request (0.341ms)
+✔ a small scene keeps the default fog density (1.0549ms)
+✔ a 900 m scene gets a thinner fog that leaves its far side readable (1.0943ms)
+✔ part transforms count toward the scene size (0.2621ms)
+✔ the core post shader carries no fog march, and the fog code arrives with fog-shader.js (452.6461ms)
+✔ a renderer that draws a volume fog without the addon throws and names the import (953.0091ms)
+✔ a recipe with volumeFog loads the fog code on its own, and one without does not (861.0364ms)
+✔ the film imports the fog code, so its fog scene draws without further setup (990.1374ms)
+✔ the sky grid is full under open sky, empty under a ceiling and the same on every run (47.9781ms)
+✔ a ceiling with a gap lights only the cells under the gap, and an empty scene has no grid (6.8694ms)
+✔ the grid stays small for any box (0.6562ms)
+✔ the post shader without the sky step is the same program as before and compiles the grid out (0.4113ms)
+✔ foliage transmission lights the face the viewer sees (1.1157ms)
+✔ foliage transmission keeps most of its light under a shadow (0.4897ms)
+✔ wind pushes a resting particle along its direction like constant acceleration (3.4023ms)
+✔ drag slows a moving particle along the exponential path (0.613ms)
+✔ a vortex swirls a particle around its axis and keeps it at about the same radius (1.7364ms)
+✔ a magnet pulls toward its position and a negative strength pushes away (0.413ms)
+✔ falloff shrinks a field with distance and radius cuts it off (0.3075ms)
+✔ turbulence is smooth, bounded by its strength, changes in time and depends on the seed (3.9877ms)
+✔ a particle under fields gives the same positions after any seek order (2.0722ms)
+✔ bad fields are rejected with a clear message (13.759ms)
+✔ one field list moves particles and cloth, and a recipe repeats frame for frame (197.1597ms)
+✔ fields lean hair toward the push and clamp it to the strand length (38.1563ms)
+✔ a subject in view gives no framing warning (3363.5062ms)
+✔ a scene with no parts is an empty frame and says what to add (6.818ms)
+✔ a camera that looks away from the subject names a camera.target and camera.eye that frame it (9.5113ms)
+✔ a subject far away fills so little of the frame that it is called too small (9.7385ms)
+✔ hidden parts do not count and orthographic cameras are not judged (20.1538ms)
+✔ exposure warns on a black or clipped frame and not on a normal one (0.6071ms)
+✔ an unchanged baked scene gives no stale warning at the rest pose (6997.2756ms)
+✔ moving a light after a bake gives bake-stale with the fix (3437.4121ms)
+✔ moving a part after a bake gives bake-stale (2297.4094ms)
+✔ job metrics keep one entry per warning across frames (0.3922ms)
+✔ ambient occlusion on a renderer without depth gets a named warning (5.36ms)
+✔ a shadow eye 10 degrees or more off the light direction gets a named warning (0.5258ms)
+✔ a shadow eye that follows the light, or no eye at all, is silent (0.9829ms)
+✔ ambient occlusion with depth, or switched off, is silent (0.3588ms)
+✔ parses positions, colour, opacity, scale and rotation of a synthetic PLY (3.6588ms)
+✔ accepts properties in any order and extra properties such as normals and harmonics (0.3876ms)
+✔ rejects files that are not 3DGS PLY with a clear message (1.2213ms)
+✔ enforces the byte and splat count limits before reading splats (0.6801ms)
+✔ the count limit applies to a header that claims more splats than the file holds (0.3288ms)
+✔ createGaussianSplats packs position, colour and covariance and limits the count (1.6366ms)
+✔ a rotated splat has a rotated covariance (0.5086ms)
+✔ sorts splats from the farthest to the nearest and drops those behind the camera (58.5715ms)
+✔ sort orders by view depth, not by distance to the eye (0.8341ms)
+✔ sort follows the camera: turning the view around reverses the order (0.7573ms)
+✔ sort reports no change for an unchanged view depth axis and keeps the order (0.5169ms)
+✔ sort handles splats at the same depth and a single splat (0.7006ms)
+✔ 200,000 random splats sort back to front (130.5971ms)
+✔ cone has a point, a base cap and outward slope normals (14.9815ms)
+✔ cone with two radii is a capped frustum (1.3028ms)
+✔ icoSphere has the icosahedron vertex count at each level and lies on the unit sphere (7.6012ms)
+✔ circle is a filled disc or a ring facing +Z (1.5989ms)
+✔ agent recipes accept cone, icoSphere, circle, line and plane in one record each (121.3325ms)
+✔ finishProgram on a lost context deletes the program and throws nothing (#541) (2.5023ms)
+✔ finishProgram on a live context still reports a failed compile (1.386ms)
+✔ KHR_texture_transform bakes one shared offset, rotation and scale into the UVs (60.3284ms)
+✔ KHR_texture_transform rejects different transforms and texCoord overrides on one material (52.9682ms)
+✔ a normal map may differ from the other maps by scale and offset, which the shader applies (34.8726ms)
+✔ a texture transform that only repeats the texture own texCoord changes nothing (79.5807ms)
+✔ a normal map with the same transform as its material keeps no extra transform (4.2918ms)
+✔ a normal map transform that needs a different rotation is rejected (1.6836ms)
+✔ EXT_mesh_gpu_instancing expands into parts that share one geometry (4.9851ms)
+✔ EXT_mesh_gpu_instancing handles several primitives and a bounded instance count (4.6834ms)
+✔ KHR_materials layer extensions import as material layers (101.229ms)
+✔ anisotropy and iridescence import as material layers without a warning (1.8719ms)
+✔ metadata extensions such as KHR_xmp_json_ld and the earlier KHR_xmp do not stop an import (2.1279ms)
+✔ required material extensions, bad layer values and missing decoders are rejected (3.7157ms)
+✔ EXT_meshopt_compression decodes a real encoded vertex buffer (31.518ms)
+✔ KHR_draco_mesh_compression decodes through the supplied Draco loader (1.6096ms)
+✔ KHR_texture_basisu textures arrive as RGBA8 pixels from the supplied KTX2 loader (3.5052ms)
+✔ KHR_texture_basisu keeps a GPU-compressed texture and records its format and bytes (8.2838ms)
+✔ a compressed KTX2 image counts a quarter of its RGBA8 pixels toward maxTexturePixels (5.872ms)
+✔ a KTX2 loader that transcoded to RGBA8 reports the rgba8 format (1.4089ms)
+✔ a compressed KTX2 texture with a partial mip chain keeps its first level (1.5482ms)
+✔ a compressed KTX2 format 67js does not upload fails with a clear message (15.0821ms)
+✔ a tiled base color map beside an untransformed emissive map loads, with the tiled map resampled and a warning (3.6142ms)
+✔ resampled maps stay within four times their source pixels and name the cap (3.0177ms)
+✔ maps that cannot be resampled still fail the import, naming the material (3.1323ms)
+✔ a meshopt-compressed GLB decodes without any decoder option and matches the uncompressed geometry (111.5285ms)
+✔ a fallback buffer that is absent, zero-filled in the file or an unreachable uri is never read (4.8538ms)
+✔ a compressed buffer view that cannot be decoded names the extension (4.3546ms)
+✔ a caller supplied decoder still takes the place of the built-in one (2.6947ms)
+✔ the OCTAHEDRAL filter returns unit normals (1.2036ms)
+✔ the QUATERNION filter returns a rotation equal to the source (0.6672ms)
+✔ the EXPONENTIAL filter returns floats close to the source (0.5635ms)
+✔ the INDICES mode returns the same index sequence (0.6787ms)
+✔ the public showcase and sample GLBs load without a decoder option (176.192ms)
+✔ morph targets without a base NORMAL get per-target normals that follow the morphed triangles (12.0679ms)
+✔ a NaN vertex position becomes 0 with a warning and the bounds stay finite (1.3888ms)
+✔ a non-finite inverse bind matrix is replaced with the identity and the pose stays finite (22.0483ms)
+✔ a NaN joint transform loads with a warning and a finite palette (23.2733ms)
+✔ GLB imports relative channels with missing zeros, independent node defaults and shared geometry (19.3373ms)
+✔ selected scene 0 preserves morph primitive declarations after association reduction (10.6197ms)
+✔ selected scene 0 still imports ordinary meshes without morph targets (1.0956ms)
+✔ selected scene 1 preserves morph primitive declarations after association reduction (1.2114ms)
+✔ selected scene 1 still imports ordinary meshes without morph targets (3.0726ms)
+✔ multi-scene multi-primitive mappings retain each distinct morph channel declaration, including cloned scene roots (11.9557ms)
+✔ only the selected scene is decoded (1.7761ms)
+✔ embedded glTF JSON defaults omitted node and mesh weights to retained zeros (1.0851ms)
+✔ LINEAR weights animation uses loader interpolation and repeated absolute seeks (2.2724ms)
+✔ STEP weights animation uses loader interpolation and repeated absolute seeks (1.2635ms)
+✔ CUBICSPLINE weights animation uses loader interpolation and repeated absolute seeks (1.0617ms)
+✔ morphs compose with skin palettes and invalid samples publish no matrix, palette or weights (15.8214ms)
+✔ target expansion and primitive instance budgets reject before decoding (2.7946ms)
+✔ composed world bounds and changed public identities fail before any part publishes (15.003ms)
+✔ clip switches restore untracked instance defaults before later weight seeks (1.1189ms)
+✔ exactly 64 targets import and larger counts reject explicitly (69.611ms)
+✔ malformed deltas, defaults, accessor shapes and all animation channels reject (7.0146ms)
+✔ source hierarchy metadata is detached and staged joint deformation leaves published resources unchanged (16.9242ms)
+✔ discard and failed poses restore private clip state for independent backward seeks (96.5891ms)
+✔ strict pose boundaries reject malformed fields, identifiers, scale and quaternions without changing state (2428.0718ms)
+✔ shared scene clones and grouped primitives keep source node IDs distinct from traversal mesh IDs (2.3296ms)
+✔ selected cloned scenes bind authored joint edits to their actual skin skeleton (5.4465ms)
+✔ reflected and sheared source nodes remain uneditable while decoded base poses remain usable (3.8787ms)
+✔ skin and morph candidates retain palettes and weights through authored poses (2424.9149ms)
+✔ textured rig parsing preserves texture descriptors across staged poses (18.1313ms)
+✔ a file that only lists KHR_lights_punctual, KHR_materials_unlit or EXT_texture_avif loads (10.9337ms)
+✔ an optional extension that 67js does not know is ignored and named in the warnings (1.1927ms)
+✔ an unknown extension in extensionsRequired is still refused (16.277ms)
+✔ line and point primitives are skipped with a warning that names the mesh (1.1654ms)
+✔ a file with only line primitives has nothing to draw and says so (1.4675ms)
+✔ triangle strips and fans are still refused (0.6177ms)
+✔ KHR_materials_unlit becomes the unlit tag and keeps only the base color (0.984ms)
+✔ KHR_lights_punctual lights map onto point, spot and key light options (2.1556ms)
+✔ lights beyond the renderer limits are skipped, each with a warning (2.3363ms)
+✔ a file without lights returns an empty lights object (1.0041ms)
+✔ a texture with the same shared key in two files is decoded once and both files bind one descriptor (54.6158ms)
+✔ without shared state, or with different keys, each file decodes its own texture (20.5709ms)
+✔ a skeleton-only file loads as nodes, joints and clips with zero parts (28.0552ms)
+✔ a skeleton-only asset can be posed from its own clip (48.3647ms)
+✔ the retarget addon reads a skeleton-only asset as a rig and asks for humanoid bones (2.1008ms)
+✔ a file with neither a mesh nor a skin or clip is still refused (0.943ms)
+✔ a primitive with fewer than 3 vertices is skipped with one warning and the rest loads (3.4196ms)
+✔ a primitive with a missing POSITION accessor is skipped with one warning and the rest loads (1.6357ms)
+✔ a primitive with an index count that is not a multiple of 3 is skipped with one warning and the rest loads (1.3737ms)
+✔ a primitive with an index out of range is skipped with one warning and the rest loads (1.1712ms)
+✔ a primitive with only zero-area triangles is skipped with one warning and the rest loads (1.0268ms)
+✔ an unused vertex without a generated normal does not stop a primitive that has real triangles (0.9472ms)
+✔ a file whose only primitive is unusable says why and throws (0.7538ms)
+✔ a required KHR_materials_pbrSpecularGlossiness material loads as metallic-roughness (14.1069ms)
+✔ a KHR_materials_unlit material with a base color map loads with the unlit tag and no lit maps (1.4694ms)
+✔ a normal map on a primitive without TEXCOORD_0 is dropped with a warning (1.5668ms)
+✔ an unlit material with a base color map and no UVs loads without the map (1.2899ms)
+✔ a node keyed to zero scale draws a speck at that pose instead of refusing the file (21.2296ms)
+✔ a node that starts at zero scale shows again when a clip scales it up (1.5066ms)
+✔ a morph target with normalized int16 POSITION deltas loads and is scaled into floats (1.8348ms)
+✔ a skin joint at zero scale loads with a warning and the skinned vertices collapse instead of refusing the file (14.3109ms)
+✔ authored vertex normals of zero length are rebuilt from the triangles with a warning (10.519ms)
+✔ valid normals load with no warning (1.2545ms)
+✔ a node with a zero scale is skipped with a warning and the rest of the file loads (14.3453ms)
+✔ a singular group node skips the meshes under it (2.2623ms)
+✔ morph targets without a base NORMAL load: normals are generated and the morph normal deltas are recomputed (15.5031ms)
+✔ a primitive without NORMAL falls back to a touching face normal or up when generated normals cancel out (2.186ms)
+✔ two skeletons with the same bone names each follow the clip (#565) (22.0781ms)
+✔ a real node named like a generated duplicate name does not collide (#565) (7.405ms)
+✔ nodes without names bind their own tracks (#551) (2.48ms)
+✔ scale keys of exactly zero hide a node instead of throwing (#565) (2.8233ms)
+✔ a skin joint with zero scale still gives a rig (#565) (1.8911ms)
+✔ GLB bridge preserves hierarchy, shared geometry, missing normals, UVs and linear PBR factors (11.6343ms)
+✔ 67js exported GLB roundtrip preserves transforms and repeated primitive identity (4.8352ms)
+✔ rigid animation seeks are absolute, order independent, clip selectable and clamped (4.9831ms)
+✔ mirrored static transforms keep the authored winding and the world matrix; the renderer owns the reversal (1.3032ms)
+✔ alpha mode, cutoff, base color alpha and double-sided map onto the material contract (2.4884ms)
+✔ unsupported features fail explicitly before loading resources (19.2521ms)
+✔ byte, vertex, part and input guards reject oversized or malformed assets (2.8576ms)
+✔ texture pixel budgets reject compressed images before browser decoding (1.3851ms)
+✔ forty 1024 px maps load with default options by scaling them down and naming each one (4.5579ms)
+✔ base color keeps twice the size of a data map when textures are scaled (3.48ms)
+✔ only the largest maps are scaled, and decoding requests the scaled size (2.5196ms)
+✔ the single image ceiling still rejects a hostile image whatever the combined budget (6.184ms)
+✔ one limit error names every option a file goes over, its measured value and the value that fits (2.2052ms)
+✔ the default limits take a large exported scene: a 240 MB file, 8 million vertices and a 6144 x 3072 texture (3.0695ms)
+✔ hierarchy depth guards reject long chains regardless of node ordering (2.4482ms)
+✔ relative external buffer paths normalize both fetch and decoder lookups (49.8924ms)
+✔ URL loading streams within maxBytes and cancels oversized responses (23.732ms)
+✔ linear RGB and normalized Uint8 vertex colors become shared Float32 RGB geometry (3.3328ms)
+✔ RGBA vertex colors with alpha below one keep their RGB and warn that the alpha is ignored (0.7172ms)
+✔ RGBA vertex colors that are fully opaque load without a warning (1.4759ms)
+✔ vertex colors reject invalid RGB factors explicitly (1.0774ms)
+✔ all glTF map channels preserve sampler, linear data, sRGB color, scales, sharing and image disposal (3.0216ms)
+✔ map preflight rejects unsupported UVs, sampler states, invalid scales and missing geometry UVs (10.9063ms)
+✔ GLB skin import retains inverse binds, ordered bones and deterministic visibly bent poses matching Three (25.1125ms)
+✔ skin preflight guards joints, influence shapes, raw zero weights, indices and budgets (4.4746ms)
+✔ a skeletal animation that scales a joint to zero collapses it to a point and restores with the base pose (1.2619ms)
+✔ normalized integer skin weights import correctly and skinned mesh node transforms cancel without reversed winding (1.2147ms)
+✔ EXT_texture_webp textures decode as WebP (8.1874ms)
+✔ a WebP texture falls back to its PNG source when the browser cannot decode WebP (1.5404ms)
+✔ WebP image sizes count toward the texture budgets before decoding (0.5824ms)
+✔ the same options and seed build identical blades (447.2309ms)
+✔ parts are rigid, untextured, double-sided grass with no shadow by default (193.537ms)
+✔ coarser levels keep a stable subset of the same blades (175.4867ms)
+✔ blades stand on the terrain and taper from a dark root to a light tip (111.0799ms)
+✔ a zero mask clears grass and partial masks thin it (242.5533ms)
+✔ update reports level changes, culls far tiles and stays quiet when nothing moves (242.3402ms)
+✔ every preset builds, and bad options fail with clear errors (763.3191ms)
+✔ patchiness thins and shortens parts of the field, and zero keeps it uniform (467.8861ms)
+✔ seed stalks rise above the blades but stay under 1.5 times the tallest blade (554.0467ms)
+✔ groundColor sits between the root and tip colours (108.0045ms)
+✔ grass wind bends by blade height (uv) and rolls across the field as gusts (0.5069ms)
+✔ lighting without fog gives no medium (1.2889ms)
+✔ a leg scatters with the probability a photon would and the path goes on from the point (16.621ms)
+✔ a shadowed sun adds nothing, and a leg outside the box is untouched (0.5527ms)
+✔ a forward scattering fog keeps the path closer to its direction than a backward one (26.8646ms)
+✔ the diffuse copy has albedo times the sky and sun on the ground in its lower half and the sky above (7.9003ms)
+✔ the background and the reflections keep the original sky (0.5822ms)
+✔ a sun below the horizon, black albedo or no sun leaves only the sky term (1.1676ms)
+✔ the bounce lights a wall: a sideways normal gets more irradiance from the diffuse copy (0.8837ms)
+✔ the floor is the lowest thin part that spans the scene, and its albedo is its colour (1.1025ms)
+✔ no floor, a textured, metal, water or lone part gives no ground (0.5267ms)
+✔ an open scene with a floor gets one bounced map, the same object on every call (3.6552ms)
+✔ a baked part, a closed room, no floor, no map or groundBounce false keep the environment (1.1609ms)
+✔ an automatic floor gives its albedo when no part forms one, and keyIntensity scales the sun (0.8791ms)
+✔ a point, spot or area light keeps the environment, as the term knows only the sun and the sky (0.776ms)
+✔ a textured floor gives its colour times the mean of the texture in linear space (0.4512ms)
+✔ the mean of a texture is found once per image (0.243ms)
+✔ a low sun adds a bounce colour to the map, a high sun, no sun or outdoorFill false add none (1.472ms)
+✔ sampleRasterGrid equals the cell mean of bilinear samples taken vertex by vertex (24.9063ms)
+✔ createHeightfieldGeometry matches the old per-vertex build, with dropped cells (6.4821ms)
+✔ createHeightfieldGeometry rejects a height array of the wrong length (0.4962ms)
+✔ a mesh attribute cannot be named after a prototype key (2.2741ms)
+✔ a cloth collider needs a known kind and a pin needs an existing particle (1.1542ms)
+✔ baking a pattern refuses a type that is not its own sampler (0.5692ms)
+✔ the grid trace answers a worker request with the same coefficients as the inline trace (555.5159ms)
+✔ a bake inside a worker session gives the same grid as the page thread (401.1107ms)
+✔ the page time limit is not part of the request, so a worker traces under its own limit (0.6298ms)
+✔ without workers the bake runs inline with the same result (508.7745ms)
+✔ the recipe field is true, an integer node count or off, and anything else is refused (2.4694ms)
+✔ a warm floor sends warm light to a wall the sun never reaches, and the same input gives the same bytes (948.3414ms)
+✔ the grid stores the sky a node sees: little in a closed room, a lot under open sky (228.2131ms)
+✔ nodes inside a solid are found and filled from their neighbours (32.154ms)
+✔ nodes inside walls are filled and every coefficient is finite (71.6523ms)
+✔ placing the grid wraps each material once and keeps reading the live material (13.0694ms)
+✔ the shader carries the grid code only for a renderer that asks for the feature (0.7886ms)
+✔ a recipe with bake.irradianceGrid skips lightmaps, reports the grid and gives every part the grid (1236.4126ms)
+✔ a scene with splat layers and the grid keeps the two on different texture units (11.3631ms)
+✔ bake.gridFog is a boolean that needs the grid, and is not stored when off (0.6022ms)
+✔ the grid scatters in the fog only when the lighting carries the fog (740.5207ms)
+✔ the same recipe builds to the same bytes on one thread and with kernels on a worker (8473.8753ms)
+✔ a host without workers builds inline (3307.3055ms)
+✔ a worker that cannot start leaves the work to the inline path with the same result (7290.9601ms)
+✔ a worker that dies mid-job leaves the work to the inline path with the same result (4487.9209ms)
+✔ an error a kernel raises on the worker comes back as the same class and message (5.3531ms)
+✔ an explicit bake setting over the budget fails on the worker with the message that names numbers that fit (2387.6465ms)
+✔ cancelling stops the build and ends the worker (36.2192ms)
+✔ kernel keys follow the bytes of the input and refuse data that cannot be cloned (1.9548ms)
+✔ without a session a kernel computes inline (0.9596ms)
+✔ both kettle tasks accept their reference and reject a resized body whose parts were left behind (1602.6832ms)
+✔ the unchanged kettle fails the resize task, and its relations recipe is the one the task starts from (24.6244ms)
+✔ a model from 4 to 4000 units wide draws with explicit near and far (9695.021ms)
+✔ every layer texture slot round trips through GLB with its pixels and colour space (81.8453ms)
+✔ textures that share an image in the file share one descriptor (11.7741ms)
+✔ an occlusion texture on TEXCOORD_1 round trips with the second UV set (9.6998ms)
+✔ a texture that needs a second UV set the mesh lacks is refused (23.2415ms)
+✔ the base color and normal maps stay on the first UV set (4.3566ms)
+✔ layer texture features splice their sampler once and guard shared code, whatever order they come in (0.8886ms)
+✔ a scene without layer textures gets no layer texture code (0.3786ms)
+{"diffuseGpuToCpu":1.0046194995234015}
+✔ on a room of diffuse surfaces the CPU and GPU bakes bring the same light (29927.9829ms)
+{"glossyGpuToCpu":1.0765600484420954}
+✔ a specular lobe makes the GPU bake brighter than the CPU one, which has none (30540.2395ms)
+✔ a long thin part that shares the unit box keeps square texels in the world (247.2764ms)
+✔ the same input bakes the same bytes (371.3526ms)
+✔ a bake gives each part lightmap UVs and an srgb emissive map, and leaves its input alone (222.2762ms)
+✔ light reaches a surface the lamp cannot see, and a dark scene bakes nothing (777.5977ms)
+✔ a part that sees little of the sky gets a linear occlusion map, and a part that sees all of it gets none (114.3014ms)
+✔ parts that cannot take a lightmap are skipped with a reason and still block light (139.4751ms)
+✔ a textured part keeps its map and UV channel 0 and receives light through a second UV set (773.4289ms)
+✔ an emitting part is baked through the light map slot and still lights the others (171.1899ms)
+✔ a part marked as generating its own geometry is skipped (92.5598ms)
+✔ options are validated with their bounds (1.5736ms)
+✔ hostile spot and area lights are refused before any ray is traced (0.9638ms)
+✔ hostile parts and lights are refused before any ray is traced (1.3977ms)
+✔ a bake that would trace too many rays is refused up front (2.6879ms)
+✔ a light mapped part exports its second UV set as TEXCOORD_1 and its light map as the emissive texture (181.1956ms)
+✔ a bake that runs out of time throws instead of returning a partial result (72.6581ms)
+✔ the default bounces follow most of the light that a closed room keeps, which two bounces cut off (2001.9913ms)
+✔ the backend option is cpu, gpu or webgpu, and the synchronous bake refuses the GPU ones (206.5085ms)
+✔ a GPU bake needs a page with WebGL2 and does not take light linking or a sky-only run (68.3323ms)
+✔ the GPU backend takes up to 1024 parts where the CPU bake takes 256 (10.0734ms)
+✔ a scene whose lights all reach every part keeps its parts (1.193ms)
+✔ an affects list limits a light to the named parts and leaves the others at full mask (0.3681ms)
+✔ keyAffects limits the sun (0.1814ms)
+✔ a bad affects value is named in the error (0.5523ms)
+✔ lightMaskFor treats a null list as every part (0.4102ms)
+✔ the layer state carries the mask and defaults to every light (3.4379ms)
+✔ the mask test compiles in only with the feature (1.931ms)
+✔ the default shader and a shader built from every feature keep the full picture (1.4867ms)
+✔ the light shading feature turns the macro on and needs no module (0.2683ms)
+✔ shading takes full or light (0.8916ms)
+﹣ each soft-light feature changes the picture, and the default stills keep their hashes (1.3354ms) # SKIP
+✔ a bundled profile is 1 on the axis and falls to the plane of the lamp (14.2958ms)
+✔ an inline profile is checked and normalized to its axis value (0.6892ms)
+✔ an IES file averages its horizontal planes and applies the multiplier (1.68ms)
+✔ an area light that casts a shadow takes one tile after the spot lights, and the default takes none (2.5843ms)
+✔ a lamp with an ies profile is counted so the renderer compiles the profile code (0.8821ms)
+✔ a named sun angle gives the sun at least one cascade, and an explicit count wins (0.2163ms)
+✔ a recipe look carries the sun angle, area shadows and profiles, and refuses bad values (18.234ms)
+✔ the path tracer reads the same sun disk and profile samples as the raster (4.5734ms)
+✔ a ported three.js directional light gives the same irradiance (2.6067ms)
+✔ a ported three.js point light gives intensity / d^2 at distance d (0.2202ms)
+✔ a ported three.js spot light gives intensity / d^2 on its axis (0.2001ms)
+✔ a ported three.js rect area light with nits * width * height matches far from the light (0.1946ms)
+✔ diffuse + glossy + emission match the beauty frame, and shadow, ao and mist read as light terms (49081.2078ms)
+✔ lighting preserves legacy key defaults and independently controls direct fill and ambient light (2.9028ms)
+✔ animated lights retain uniform buffers and removal clears stale lights without mutating source (1.5188ms)
+✔ malformed later lights reject atomically before replacing any retained lighting values (1.4332ms)
+✔ spot lights store a normalized direction and the Blender cone cosines (0.4912ms)
+✔ a hard-edged spot light keeps its inner cosine above the outer one (0.2693ms)
+✔ shadow tiles go to point lights first, six for a point light and one for a spot light (0.2974ms)
+✔ shadow casters beyond the 24 tile atlas are rejected before any state changes (0.311ms)
+✔ area lights store a unit normal and a width axis perpendicular to it (0.5129ms)
+✔ twelve point lights and seven area lights fill the uniform arrays (0.6197ms)
+✔ malformed spot and area lights are rejected (1.7988ms)
+✔ the width measure reads whole and fractional pixel widths of a vertical edge (5.4305ms)
+✔ the width measure skips diagonal edges (0.4138ms)
+✔ mask overlap counts a line one pixel off only after dilation (0.4794ms)
+✔ the reference scene is a valid recipe with real hard creases (1440.6721ms)
+67js preview resources closed.
+✔ an empty lines object resolves to the documented defaults (2.5594ms)
+✔ lines fields are checked with messages that name the field (1.1046ms)
+✔ polylines take defaults from the outline settings and are bounded (3.0659ms)
+✔ the recipe markers load the line art module, and the recipe keeps the resolved lines (165.1078ms)
+✔ a recipe edit with lines null removes the outlines (27.1682ms)
+✔ a material toon value is a layer field with its own range and shows in the batching state (11.8796ms)
+✔ the toon feature splices its light steps into illuminate, and no other shader mentions it (0.7471ms)
+✔ scene_capabilities names the field and the guide (0.2313ms)
+✔ installLineArt needs render passes first and leaves a frame without lines untouched (0.9002ms)
+✔ the MCP scene_create schema accepts lines (or null) and a material toon (84.938ms)
+✔ the addon finds the toon uniforms after the main program is rebuilt (0.326ms)
+✔ stepping matches bakeCloth frame for frame with the same inputs (163.6369ms)
+✔ positions is one Float32Array updated in place (3.3221ms)
+✔ pin and unpin work at runtime (16.3931ms)
+✔ a moving pin drags the cloth (17.9236ms)
+✔ pinForce grows with load and balances the weight of a hanging sheet (260.2584ms)
+✔ tearing removes constraints past the threshold and lists them (29.2011ms)
+✔ tearForce breaks the edges that carry too much tension and breakConstraint tears by hand (5.7164ms)
+✔ extra mass sags more (330.2528ms)
+67js preview resources closed.
+67js preview resources closed.
+✔ llms.txt names every registered MCP tool (226.3989ms)
+✔ llms.txt is what the generator writes from the current registry (122.9601ms)
+✔ llms.txt points agents at the server, the plugin and the changelog data (1.6555ms)
+✔ a catalog HDRI lights and reflects: the frame is lit, differs per HDRI and turns with rotation (319.1515ms)
+✔ environment strength scales the HDRI light and the map is cached per setting (1.8202ms)
+✔ a .cube look changes a frame and the shipped looks differ (22.6281ms)
+✔ recipes validate hdri and look names and never take a path or URL (2.9753ms)
+✔ catalogLookReferences finds names in recipes and set-environment operations (0.5757ms)
+✔ layer puts the top over the base where the mask passes the edge (3.0366ms)
+✔ hue shifts a colour around the wheel and curve remaps with straight segments (0.9926ms)
+✔ opacity bakes into base texture alpha, clearcoat and transmission into red channel masks (33.7526ms)
+✔ a painted-over-rust material renders from one recipe (645.3646ms)
+✔ opacity blends the material, and the tracer cuts it out and says what it ignores (39.8037ms)
+✔ scene_capabilities lists the new outputs and mixing nodes (0.1953ms)
+✔ a graph bakes the outputs it has, and only those (894.5984ms)
+✔ a baked graph is identical bytes every time (3041.8884ms)
+✔ height becomes a normal map: flat height is a flat normal, relief tilts it (87.8903ms)
+✔ a height ramp tilts the normal by bump / 32 per UV unit at any resolution, the sign pointing downhill (72.5764ms)
+✔ the slope of a sharp joint edge stays within one texel of the edge instead of spreading over three (27.2517ms)
+✔ every graph texture node tiles across the seam (36.4614ms)
+✔ the noise node returns the values of Blender 5.2 Noise Texture (2D, scale 10, detail 2, roughness 0.5, normalized) (0.398ms)
+✔ a noise tiles by default and differs from the endless one (tile false) only near the far edges (7.3515ms)
+✔ patterns with mapping uv use the geometry UVs from uv_unwrap instead of box projection (1288.4078ms)
+✔ a graph that makes emission, roughness or metallic passes it through by default (45.6111ms)
+✔ graph and preset fields do not mix (0.7363ms)
+✔ every capability operator compiles, and no other operator does (36.0169ms)
+✔ hostile graphs are rejected (1.4564ms)
+✔ hostile sizes and costs are rejected before any work (0.5624ms)
+✔ hostile strings never reach a texture, a recipe or a shader (0.4715ms)
+✔ math nodes compute the numbers they name, on numbers and on vectors (0.3617ms)
+✔ the same graph shares one baked texture set across materials (1163.0878ms)
+✔ graph errors name the valid options, and scene_capabilities lists the nodes an agent can use (1.5949ms)
+✔ the core shader sources carry no anisotropy or iridescence code (78.1332ms)
+✔ the static graph of the core shaders does not reach the layer shader module (150.3481ms)
+✔ a layer without registered code fails with the import to add (241.2609ms)
+✔ importing the layer shader module registers the code for the shader that asked for it (101.9989ms)
+✔ the normal map transform is applied only when its feature is on (0.8276ms)
+THREE.MeshPhysicalMaterial: The "iridescenceThicknessRange" property has been replaced by "iridescenceThicknessMinimum" and "iridescenceThicknessMaximum".
+✔ a plain material keeps the 4 percent dielectric reflectance and no layers (20.156ms)
+✔ ior, specular and specular colour set the dielectric reflectance (1.1578ms)
+✔ every layer value is checked at the boundary and the error names the fix (2.5737ms)
+✔ recipes accept layer fields and reject out of range values (49.8732ms)
+✔ a transmissive recipe material draws in the pass that sees the opaque scene (5.6019ms)
+✔ layers survive a GLB export and import with their extensions declared (52.1061ms)
+✔ a plain export declares no layer extension and an invalid layer is rejected (2.2704ms)
+✔ anisotropy and iridescence reach the renderer state and default to off (2.0788ms)
+✔ recipes accept anisotropy and iridescence and export them (4.4703ms)
+✔ anisotropy and iridescence survive a GLB export and import through their glTF extensions (7.1355ms)
+✔ noise is periodic over the unit square (2.7464ms)
+✔ gradient noise spreads over its range and stays bounded (3.1396ms)
+✔ every pattern tiles: the step across the seam is like any other step (2426.417ms)
+✔ patterns are deterministic and change with the seed (8191.8889ms)
+✔ bump 0 gives a flat normal map, and rust is less metallic where it has rusted (890.8996ms)
+✔ a normalized pattern normalizes to itself and bad fields say what to pass (1.4884ms)
+✔ recipe materials carry patterns as textures without needing UVs (1782.6159ms)
+✔ a material without a pattern is unchanged (3.1993ms)
+✔ patterns need the surface tag and a scene holds a bounded number (38.1921ms)
+✔ changing a pattern rebuilds the renderer resources, and changing its tint does not (639.4592ms)
+✔ a valid snippet is normalized, frozen and registered as a shader feature (45.3371ms)
+✔ the snippet follows the part 1 validation rules and names a fix (10.2651ms)
+✔ mask reads the material map and needs one (1.2457ms)
+✔ the main shader runs the hook before the render-pass output, with prefixed names (3.5016ms)
+✔ two materials with the same helper names share one shader without clashing (3.1529ms)
+✔ the shadow shaders run the same hook so a discarded fragment casts no shadow (2.2943ms)
+✔ materials with different snippets land in different batches, and a stored snippet normalizes again (88.0971ms)
+✔ probing a snippet maps the driver log to snippet lines and names the parts (1.2251ms)
+✔ a recipe sets, edits and clears the snippet and scene_capabilities reports the limits (39.3743ms)
+67js preview resources closed.
+67js preview resources closed.
+✔ every tool has a title and complete annotations, with the read-only and destructive sets fixed (197.4399ms)
+✔ structuredContent validates against the outputSchema and the text content stays (121.4965ms)
+67js preview resources closed.
+✔ a render result returns the PNG as image content and a resource link to each file (139.815ms)
+67js preview resources closed.
+67js preview resources closed.
+67js preview resources closed.
+✔ the MCP light caps are the engine light limits (68.2187ms)
+✔ scene_create accepts a full set of lights and rejects one more (98.708ms)
+✔ scene_create and set-camera take orthographic, shift, focal length and f-stop (25.8885ms)
+✔ a camera takes fov or focalLength, never both, and checks each lens field (16.6615ms)
+✔ a scene without the new fields keeps its camera exactly (13.0544ms)
+✔ orthographic orthoScale is the view height and ignores depth (4.7636ms)
+✔ lens shift moves the image by a frame fraction in both projections (28.8815ms)
+✔ focal length with a sensor width gives the matching field of view at any aspect (6.4042ms)
+✔ an f-stop gives depth of field focused on the target, and an explicit blur wins (0.3948ms)
+✔ the preview draws the lens fields and the f-stop depth of field, and set-camera reaches them (132.3796ms)
+67js preview resources closed.
+67js preview resources closed.
+67js preview resources closed.
+67js preview resources closed.
+67js internal error: runtime.activeSessionId is not a function
+67js preview resources closed.
+67js preview resources closed.
+✔ every tool lists a short environment that names the capabilities topic instead of repeating the fields (259.954ms)
+✔ the server still checks every environment field of scene_apply and scene_create_asset (28.0027ms)
+✔ the MCP environment schema lists exactly the fields the backend allows (38.8818ms)
+✔ every documented environment field is in the MCP schema (53.6492ms)
+✔ set-environment accepts every optional volume fog field on a recipe that set none (118.2508ms)
+✔ the MCP schema accepts the opt-in fog fields (39.2114ms)
+✔ set-environment accepts ground, viewTransform and resolveCoplanar (27.6076ms)
+✔ a coplanar depth layer regroups parts, and the preview sees every texture map so it rebuilds the renderer (9.1886ms)
+✔ set-environment sets every optional volumeFog field on a recipe that did not set them at creation (3.0383ms)
+✔ the MCP scene_create and scene_apply schemas accept the optional volumeFog fields (94.1567ms)
+✔ the scene_apply set-node schema accepts every node field the backend does (246.3964ms)
+67js preview resources closed.
+✔ the MCP server gives back store.lock when the client closes, so the next run starts (53320.8101ms)
+✔ a process that exits without closing the job controller still removes its lock (845.9049ms)
+67js preview resources closed.
+✔ documented MCP tool counts match the protocol listing (285.1057ms)
+67js preview resources closed.
+67js preview resources closed.
+67js preview resources closed.
+67js preview resources closed.
+67js internal error: runtime.submitJob is not a function
+67js preview resources closed.
+67js preview resources closed.
+67js preview resources closed.
+67js preview resources closed.
+67js preview resources closed.
+67js preview resources closed.
+67js preview resources closed.
+67js preview resources closed.
+✔ SDK advertises the complete strict JSON contract and truthful annotations (352.7465ms)
+✔ GLB export takes no path or code and rejects unknown or unbounded fields before dispatch (261.3441ms)
+✔ review SDK exposes one image and rejects unknown or unbounded shot fields before dispatch (139.2871ms)
+✔ branch names and labels are bounded in every tool schema and rejected before dispatch (92.9128ms)
+✔ SDK rejects unknown fields, missing revisions, invalid vectors and oversized inputs before runtime dispatch (34.2759ms)
+✔ mesh_inspect reports polygon counts, tags and lint for recipe geometries (173.79ms)
+✔ mesh_edit builds a mesh from a base and an edit log through the SDK (137.5899ms)
+✔ mesh_stack sets, changes and applies a modifier stack through the SDK (69.5325ms)
+✔ real SDK round trip authors motion, seeks without revisions and rejects unknown track fields (50.7669ms)
+67js preview resources closed.
+67js preview resources closed.
+67js preview resources closed.
+67js preview resources closed.
+67js preview resources closed.
+67js preview resources closed.
+67js preview resources closed.
+✔ real SDK calls preserve atomic revisions, checkpoints, recipe snapshots and PNG content (43.753ms)
+✔ SDK stdio EOF closes the runtime without launching a scene (7.1699ms)
+✔ branches off leaves the branch field and the variants advice out of the schemas (58.2091ms)
+✔ relations off leaves the relations field and the relations capabilities out (203.3305ms)
+✔ SDK dynamic batches create resources, reject dangling edits, and restore scene membership (49.7742ms)
+✔ a tool that takes a sessionId defaults to the active scene, and still rejects a session that is not active (60.5853ms)
+✔ scene_apply names the fix when the fields of set-node are wrapped in a node key (11.8302ms)
+✔ scene_create accepts a recipe with no materials list (10.1086ms)
+✔ a failed scene_create says the scene was not created and what to do, so the agent retries instead of inspecting (8.6843ms)
+✔ the bevel profile has the meaning it has in Blender (33.4201ms)
+✔ a beveled edge that ends at a three-faced vertex adds its points to the third face, with no fan (5.4478ms)
+✔ edge rules select rims, sharp edges, region borders and everything (2.6281ms)
+✔ chamfering one edge removes exactly the triangular prism (1.7367ms)
+✔ rounded rim keeps the box closed, keeps base tags and tags strips (2.1919ms)
+✔ beveling every edge fills the corners and clamps widths that would overlap (6.7361ms)
+✔ bevel works on curved caps and on edited meshes (43.0993ms)
+✔ bevel on an open surface keeps the opening as the only problem, and validates its fields (4.4665ms)
+✔ beveling an already beveled mesh winds its corner fills against their neighbours (2.1802ms)
+✔ random bevels on random boxes stay closed and valid (72.549ms)
+✔ recipe meshes bevel as an edit or as a stack node (52.1808ms)
+✔ a blend part mixes toward the part it cuts into, fading out over its radius (18.5483ms)
+✔ a larger radius reaches further from the seam (15.6264ms)
+✔ a part without a radius is left alone even when another part touches it (0.9744ms)
+✔ a depth jump is a silhouette, not a seam: a rock in front of a far wall is not blended (3.041ms)
+✔ two parts on one plane have no normal discontinuity, so nothing blends (3.7295ms)
+✔ pixels of one part, and the background (ID 0), never blend with themselves or the sky (19.4762ms)
+✔ the reference and the shader use the same tap pattern (0.3354ms)
+✔ blend is checked: a radius in metres and nothing else (0.9917ms)
+✔ the radius table follows the part order, with a radius map for parts that carry none (0.5545ms)
+✔ with no blend part a frame is drawn once, as given, and nothing is added to the renderer (1.305ms)
+✔ a blend part needs no extra draw: the frame asks for the ID output and the stage runs for that frame only (1.847ms)
+✔ a batch whose parts share one radius and one level keeps its culling, since any ID in its range reads that radius (0.7489ms)
+✔ a radius from the radii map opts a part in like its own blend field (0.6829ms)
+✔ passes, mirrors and benchmark frames are never blended (0.2025ms)
+✔ the ID output is a registered shader feature with a checksum and an explicit colour location (0.7795ms)
+✔ a recipe node takes blend and keeps it through export and set-node (22.8673ms)
+✔ the docs and the capability note describe the same option (18.895ms)
+✔ difference, union and intersect of two overlapping boxes have the expected volumes (84.4195ms)
+✔ drilling a hole keeps the original tags and tags the cut walls (11.8889ms)
+✔ a cutter inside the mesh leaves a cavity that lint accepts (77.5521ms)
+✔ rotation and translation place the cutter (1.6603ms)
+✔ boolean errors explain open inputs, empty results and bad fields (11.0814ms)
+✔ chained booleans with coplanar contact stay closed (104.5926ms)
+✔ recipe meshes run booleans with inline primitive cutters (119.9273ms)
+✔ MeshData derives unique edges for a cube (1.9882ms)
+✔ MeshData rejects invalid faces and attributes with actionable messages (0.9129ms)
+✔ EditMesh round trip keeps topology, order and attributes (4.1797ms)
+✔ EditMesh removal keeps every cycle valid and recycles indices (19.9129ms)
+✔ EditMesh rejects faces with repeated or missing vertices (1.0593ms)
+✔ validateTopology reports a corrupted link (0.3473ms)
+✔ random face removal and rebuilding keeps the topology valid (22.2926ms)
+✔ meshFromGeometry welds seams, joins quads, marks hard edges and tags a box (7.372ms)
+✔ meshFromGeometry keeps a sphere smooth and closed (38.67ms)
+✔ extractRender reproduces area and hard edges of generators (52.5961ms)
+✔ extractRender splits UV seams but not normals, and respects sharpAngle (2.7946ms)
+✔ triangulation handles concave n-gons in both windings (1.7262ms)
+✔ extrude with holes converts into one closed mesh (4.165ms)
+✔ lintMesh names open, non-manifold, inverted and loose problems with fixes (1.2442ms)
+✔ gatherRenderPositions follows a deform-only edit (2.122ms)
+✔ fill_holes caps an open boundary and tags the cap (101.8603ms)
+✔ fill_holes skips loops with more sides than allowed and refuses a closed mesh (10.8064ms)
+✔ the lint message for an open boundary points at fill_holes (2.1609ms)
+✔ dissolve_edges, dissolve_verts and dissolve_limited undo a loop cut (14.8575ms)
+✔ dissolve_faces merges a connected selection into one polygon (3.0841ms)
+✔ bisect_plane cuts, clears one side and fills the cut (5.8565ms)
+✔ bisect_plane with fill and both sides kept makes two closed shells (25.7979ms)
+✔ bridge_edge_loops joins two holes with a strip (5.2458ms)
+✔ subdivide_edges grids quads whose edges are all split (28.1471ms)
+✔ subdivide_edges refuses to grow past the limits before allocating (2.4142ms)
+✔ grid_fill fills an even loop with quads (3.6295ms)
+✔ knife_project cuts every face a projected line crosses (5.552ms)
+✔ knife_project follows a bend and adds points on the face (5.9447ms)
+✔ the cutting edits validate their fields (0.7646ms)
+✔ decimate reaches its ratio, keeps the surface close and the mesh valid (215.1217ms)
+✔ decimate keeps the open boundary where it was (106.0538ms)
+✔ decimate keeps tags and the border between them (53.3575ms)
+✔ decimate rejects a bad ratio and stops at four triangles (11.9922ms)
+✔ decimate and remesh run as edits and as stack nodes with a budget (278.8329ms)
+✔ remesh makes a closed quad surface with positive volume near the input (505.591ms)
+✔ remesh refuses an open surface and a mesh smaller than a voxel (6.6812ms)
+✔ generated levels shrink, report a growing error and share the input as level 0 (48.4349ms)
+✔ geometry and asset levels return renderer geometry, and refuse skinned parts (108.992ms)
+✔ lattice moves a control point fully at its vertex and by the blend elsewhere, and keeps the topology (33.538ms)
+✔ lattice refuses bad grids and moves with the limit in the message (1.1401ms)
+✔ curve leaves a beam alone on a straight path along its axis and bends it along an arc (7.0789ms)
+✔ curve names its limits (0.6535ms)
+✔ hook pulls the vertices inside the radius by the falloff weight and none outside (5.0427ms)
+✔ wave lifts vertices inside its ring along z, moves with time and can follow the normal (1.0931ms)
+✔ the deforming modifiers run as stack nodes (0.9413ms)
+✔ selection rules combine tags, normals, regions and growth (21.3841ms)
+✔ extrude_face_region on a closed box keeps it closed and moves the cap along the normal (27.9377ms)
+✔ extruding a plane gives an open box with outward sides (2.4755ms)
+✔ extrude_face_region extrudes separate groups separately and refuses cancelling regions (13.1305ms)
+✔ extrude_individual and inset_individual handle every face on its own (12.349ms)
+✔ inset_region keeps an even rim and depth moves the inner face (2.3446ms)
+✔ delete, flip_normals and merge_by_distance report what they changed (19.0728ms)
+✔ translate with connected falloff moves nearby vertices less (21.2997ms)
+✔ edit validation names the op, field and allowed values (69.2682ms)
+✔ random edit sequences keep a valid topology (65.8681ms)
+✔ recipe mesh geometry renders, reports edits and rejects bad edits atomically (83.8051ms)
+✔ scatter on terrain avoids a path mesh and follows the terrain height (45.6605ms)
+✔ results repeat for the same seed and change with another (10.6766ms)
+✔ a raycast keeps a box scatter that has terrain below it and drops the rest (5.1374ms)
+✔ a mesh edit snaps a flat grid to terrain height and stores proximity as a named group (18.9472ms)
+✔ surface inputs are validated without a surface and reject bad records (2.9706ms)
+✔ hostile expressions are rejected at the boundary and nothing runs (89.0791ms)
+✔ limits on elements and work are checked before any element is evaluated (3.3572ms)
+✔ the language has no way to run code (1.8874ms)
+✔ the operator list in the plain-data module matches the language (1.0848ms)
+✔ expressions compute attributes, math, comparison, logic and vectors (7.0042ms)
+✔ the field selection rule picks faces from attributes (37.506ms)
+✔ set_position moves vertices by a field and leaves the rest alone (2.4397ms)
+✔ displace moves a sphere along its normals by (field - midlevel) * strength (51.1918ms)
+✔ noise is smooth, stays in 0 to 1 and changes with the seed (42.6165ms)
+✔ the same expression gives identical bytes on every run (54.1974ms)
+✔ field nodes in a stack reuse earlier nodes from the cache (11.4271ms)
+✔ instances on a grid, a scatter and a surface are seeded, bounded and filterable (6.6791ms)
+✔ hostile instance records are rejected before any point is made (36.7246ms)
+✔ a recipe with an instanced node creates one instanced batch of ordinary nodes (142.9154ms)
+✔ screw closes a full turn into a ring and keeps the last copy open for a partial turn (5.8147ms)
+✔ screw turns about the chosen axis and a negative angle turns the other way (0.457ms)
+✔ screw names the limit and what to change when it would make too many vertices (1.8487ms)
+✔ wireframe makes two quads per face edge, stays closed and puts the strut either side of the surface (9.7688ms)
+✔ wireframe refuses a result over the limits and bad fields (3.825ms)
+✔ skin puts a closed square tube on every edge and takes a radius per vertex from a field (17.627ms)
+✔ the generating modifiers run as stack nodes (3.5759ms)
+✔ a single cube and a cylinder raise no spatial warnings (63.0104ms)
+✔ two boxes that cross are reported as intersecting parts with the pair in the sample (10.7323ms)
+✔ a part that touches nothing floats, and a part resting on another does not (12.4104ms)
+✔ a plate under half a percent of the mesh size is a thin wall, and a slab is not (5.1665ms)
+✔ a mesh that is mirror-symmetric except for one moved vertex names the axis and the vertex (120.1227ms)
+✔ plain lintMesh stays free of spatial checks and a clean mesh skips none (3.7046ms)
+✔ one cut around a cube makes one closed ring and two tagged bands (123.7974ms)
+✔ several cuts space evenly and one cut honours factor from the low side (75.2499ms)
+✔ faces beside an open ring get the new points, so no T-junctions appear (11.7406ms)
+✔ corner UVs are interpolated at the new points (2.7711ms)
+✔ cutting then extruding a band makes a closed belt (104.8985ms)
+✔ a band around a cylinder extrudes along normals as one joined hoop (57.4527ms)
+✔ loop cut validation and errors are explicit (1.8416ms)
+✔ random loop cuts on stretched boxes and cylinders stay closed (86.7988ms)
+✔ recipe meshes loop cut through mesh_edit-style edits (307.5679ms)
+✔ every modifier is in the edit list, the stack list and the capability notes (2.9685ms)
+✔ weld merges the vertices an edge split pulled apart and keeps the surface closed (16.7476ms)
+✔ triangulate turns every quad and cap into triangles and keeps tags (3.8741ms)
+✔ triangulate with a larger minVertices leaves the smaller faces alone (0.9596ms)
+✔ edge_split separates faces along edges sharper than the angle and leaves flat joins alone (9.4799ms)
+✔ smooth pulls vertices toward their neighbours and factor 0 changes nothing (1.9947ms)
+✔ simple_deform twist keeps the axis coordinate and rotates the cross-section in proportion to it (2.9936ms)
+✔ simple_deform taper, stretch and bend run and a flat mesh along the axis is left as it is (7.7151ms)
+✔ cast moves vertices toward a sphere (1.4832ms)
+✔ modifier fields are validated and unknown fields are refused (45.1797ms)
+✔ hostile input: output past the vertex or face limit is refused before it is built (3.802ms)
+✔ hostile input: a huge n-gon is refused when its triangles would pass the face limit (9.8665ms)
+✔ modifiers run as stack nodes, reuse the cache and report their counts (3.9261ms)
+✔ smooth_by_angle marks bends over the angle sharp and the rest smooth, over the angle the render would use (12.1104ms)
+✔ smooth_by_angle keeps hand-marked sharp edges unless told to ignore them (1.4964ms)
+✔ weighted_normal tilts a shared vertex toward the larger face and the render uses the stored normals (1.5179ms)
+✔ a higher weight leans further toward the large face and sharp bends stay split (0.899ms)
+✔ the normal modifiers name their limits and run as stack nodes (2.425ms)
+✔ closed boxes distinguish containment in both directions, crossings, contact, and separation (66.0856ms)
+✔ surface mode supports open triangles, including coplanar contact, without a containment claim (1.89ms)
+✔ ray hits retain original triangle IDs and barycentric coordinates across affine transforms (3.1913ms)
+✔ closed queries accept reflected, rotated, nonuniform, and sheared affine transforms (5.9468ms)
+✔ exact position welding handles UV seams and leaves source arrays untouched and uncoupled (2.3935ms)
+✔ solid preflight rejects open, unoriented, nonmanifold, disconnected and self-crossing boundaries (3.9038ms)
+✔ budget failures unwind BVH callbacks and leave subsequent queries usable (17.0669ms)
+✔ closed built-in curved primitives retain seams and distinguish the torus hole from its solid interior (134.991ms)
+✔ closed topology rejects a pinched vertex even when all welded edges remain manifold (1.8854ms)
+✔ input and allocation limits reject before building, including malformed deformation and triangles (1.405ms)
+✔ numeric domains normalize tiny and huge meshes but reject singular, overflow and collapsed poses (6.5885ms)
+✔ sculpt inflate moves only the vertices of the selected faces and keeps the topology valid (28.7899ms)
+✔ sculpt displace and smooth strokes change the surface, and smooth lowers the bump (17.9341ms)
+✔ sculpt gives the same bytes every time (14.7266ms)
+✔ the shared stroke maths still serves sculptGeometry (1.8698ms)
+✔ sculpt refuses hostile strokes before running them (1.2165ms)
+✔ sculpt stops when the vertex visits would be too many (839.5798ms)
+✔ shrinkwrap nearest puts a flat sheet on the target with an offset (27.4512ms)
+✔ shrinkwrap project follows a direction and honours placement and select (43.2016ms)
+✔ shrinkwrap misses are an error or kept in place, and maxDistance bounds the search (9.2832ms)
+✔ shrinkwrap gives the same bytes every time (12.7553ms)
+✔ shrinkwrap refuses hostile fields before running them (1.3953ms)
+✔ both edits are in the vocabulary agents read (0.1693ms)
+✔ a recipe mesh carries named shape keys as morph targets with offsets only where the key moves vertices (54.955ms)
+✔ morph tracks blend two shape keys of a recipe mesh (4.027ms)
+✔ shape keys that change the vertex count, repeat a name or sit on a missing track are refused (5.6328ms)
+✔ the starting value of a key is the weight without motion, and a GLB export writes the morph targets (45.1222ms)
+✔ mirroring a closed half that touches the plane gives one closed whole with swapped side tags (128.9782ms)
+✔ mirror across y and z keeps parts separate when they do not touch the plane (34.6331ms)
+✔ array repeats with relative and constant offsets and merges touching copies (5.6903ms)
+✔ solidify turns an open surface into a closed wall and a closed surface into a hollow shell (98.1486ms)
+✔ even thickness keeps flat walls at the full thickness at corners (3.3855ms)
+✔ removeCoincidentFaces drops back-to-back faces and keeps one of duplicates (1.3515ms)
+✔ stack validation names allowed nodes and defaults names per position (0.6341ms)
+✔ stack evaluation caches each prefix and recomputes only changed nodes (3.2567ms)
+✔ recipe meshes evaluate stacks, reuse cached prefixes and apply nodes into the edit log (216.1449ms)
+✔ an array over the budget fails before it allocates, and names the fix (2.1869ms)
+✔ a cube keeps Euler characteristic 2 and multiplies its faces by four each level (17.9312ms)
+✔ the size is known from counts before anything is built (9.8739ms)
+✔ an n-gon with open boundary edges splits into quads and its boundary stays on the straight edges (1.3203ms)
+✔ faces keep their tags through each level (4.5255ms)
+✔ corner uv values blend linearly and stay inside their island (0.5739ms)
+✔ full creases on every edge keep a cube a cube, and a half crease only partly rounds it (15.529ms)
+✔ a crease of sharpness 1 holds for one level only (9.6209ms)
+✔ the budget is checked before the mesh grows (2.8104ms)
+✔ the recipe rejects levels out of range and a sharpness without a crease (1.5504ms)
+✔ subdivide runs as a stack node after the edits (2.0427ms)
+✔ a cube unwraps into six equal undistorted squares cut along its twelve edges (62.4946ms)
+✔ unwrapping keeps the topology and leaves the input untouched (35.6543ms)
+✔ a cylinder gets caps and one side strip, cut once to lie flat, with no stretch (13.6529ms)
+✔ closed smooth shapes split into axis charts without folds (529.5103ms)
+✔ seams follow an edge rule and margin widens the border (1.6844ms)
+✔ the edited crate unwraps into flat panels and renders with uvs (75.4435ms)
+✔ uv_unwrap validates its fields and works as an unnamed stack node (296.3501ms)
+✔ a vertex group limits a displace edit to the vertices it weighs (12.8665ms)
+✔ a gradient writes partial weights that scale the displacement (21.4023ms)
+✔ a field sets weights and an unknown group names the groups that exist (5.8508ms)
+✔ vertex_color writes corner colors for the selected faces only (2.501ms)
+✔ vertex colors of a recipe mesh reach the part and export as COLOR_0 in a GLB (75.199ms)
+✔ cloth holds the vertices of a pin group (40.5601ms)
+✔ a matrix is mirrored when the determinant of its upper 3x3 is negative (1.1425ms)
+✔ parts that share a geometry and material batch apart by the sign of their determinant (2.4961ms)
+✔ a mirrored batch draws with clockwise front faces and restores the default winding (0.6328ms)
+✔ updateParts regroups once when a part crosses a mirror instead of throwing (8.0332ms)
+{"parts":574,"geometries":7,"triangleCount":860380,"meshBytes":499176,"sections":20,"bounds":{"minimum":[-1.24099999400478,0.051500000059604645,-0.7603544635956833],"maximum":[1.24099999400478,2.8755852189314153,0.9336800542815968]},"expandedBounds":{"minimum":[-3.0100000530481337,0.051500000059604645,-2.008500024303794],"maximum":[3.0100000530481337,3.695585218931415,2.3375000160187485]}}
+✔ closed primitives have exact Float32 seams and oppositely oriented paired edges (34.3791ms)
+✔ primitive validation rejects unsafe allocations and invalid shapes before sampling (1.1283ms)
+✔ sphere UVs preserve separate seam coordinates and cover every vertex (3.0123ms)
+✔ closed primitive surfaces have finite unit normals and outward winding (149.0507ms)
+✔ partial armor arc keeps its winding (84.575ms)
+✔ rounded box fillets are sampled locally with closed smooth patch joins (101.7451ms)
+✔ cylinder rim fillets join flat caps and walls without gaps or normal discontinuities (20.0661ms)
+✔ model respects the renderer contract, instancing and authored bounds (241.0543ms)
+✔ assembled WALL-E geometry and instance snapshot stays stable after exact seam closure (28.3335ms)
+✔ modeling output matches the former generator: lathe-cylinder (7.1312ms)
+✔ modeling output matches the former generator: lathe-half-sweep (0.5272ms)
+✔ modeling output matches the former generator: lathe-quarter-offset (0.5394ms)
+✔ modeling output matches the former generator: lathe-pipe (3.4876ms)
+✔ modeling output matches the former generator: lathe-vase (0.5468ms)
+✔ modeling output matches the former generator: lathe-large-angle (0.3528ms)
+✔ modeling output matches the former generator: lathe-cone-tip (0.2594ms)
+✔ modeling output matches the former generator: lathe-tilted-profile (0.42ms)
+✔ modeling output matches the former generator: extrude-square (2.7646ms)
+✔ modeling output matches the former generator: extrude-concave (1.0585ms)
+✔ modeling output matches the former generator: extrude-comb (0.9241ms)
+✔ modeling output matches the former generator: extrude-arrow (5.2542ms)
+✔ modeling output matches the former generator: extrude-hollow (1.7709ms)
+✔ modeling output matches the former generator: extrude-hollow-reversed (0.5363ms)
+✔ modeling output matches the former generator: extrude-bevel (1.7383ms)
+✔ modeling output matches the former generator: extrude-bevel-thickness (3.0171ms)
+✔ modeling output matches the former generator: extrude-bevel-holes (7.1346ms)
+✔ modeling output matches the former generator: extrude-window (2.5879ms)
+✔ modeling output matches the former generator: extrude-window-steps (6.0898ms)
+✔ modeling output matches the former generator: extrude-hexagon (0.9902ms)
+✔ modeling output matches the former generator: extrude-gear (4.8074ms)
+✔ modeling output matches the former generator: extrude-bracket (7.1682ms)
+✔ modeling output matches the former generator: extrude-two-holes-bevel (6.9613ms)
+✔ modeling output matches the former generator: tube-straight (4.6019ms)
+✔ modeling output matches the former generator: tube-closed (6.1061ms)
+✔ modeling output matches the former generator: tube-cable (5.5634ms)
+✔ modeling output matches the former generator: tube-bend (1.1286ms)
+✔ modeling output matches the former generator: tube-helix (5.402ms)
+✔ modeling output matches the former generator: tube-uneven-spacing (1.4977ms)
+✔ modeling output matches the former generator: tube-closed-loop-plane (1.2822ms)
+✔ lathe produces shared indexed geometry with normalized normals and UV seam (20.2088ms)
+✔ concave extrusion and holes retain literal area, depth and outward winding (6.6919ms)
+✔ beveled extrusion has finite geometry and extends its end caps by the requested thickness (2.3097ms)
+✔ tube follows straight and closed paths with retained topology and finite seam data (8.3086ms)
+✔ invalid topology and allocation requests fail before generating a mesh (1.6053ms)
+✔ Float32 collapse is rejected and large lathe angles retain drawable geometry (1.7444ms)
+✔ torus maps cover both surface seams and partial arc caps (5.1045ms)
+✔ extrude stays closed when hole edges line up with each other (60.5644ms)
+✔ morph pose identity partitions batches while shared geometry and pose retain instancing (15.4529ms)
+✔ shared morph consumers outside update list reject unsafe weights before any committed changes (23.5196ms)
+✔ main and shadow draws upload the retained morph weights and disable morphs for rigid batches (0.8604ms)
+✔ world scale overflow and shared unsent consumer transforms reject before publishing morph weights (5.4232ms)
+✔ morph world bounds use the same Float32 coefficients as instance upload (4.0629ms)
+✔ signed relative target blends match literal positions and the installed Three.js Mesh implementation (6.9624ms)
+✔ target-major two-texel packing preserves channels, missing zeros and texture padding (0.8573ms)
+✔ one static metadata object accepts independent retained poses and validates without changing their weights (0.8515ms)
+✔ cheap pose validation pins static channel identities and leaves content rescans to full preflight (0.4106ms)
+✔ zero and cancelled normal blends remain valid for shader fallback, while overflow bounds reject atomically (0.359ms)
+✔ Float32 accumulation guards aggregate overflow even when every target product is finite (0.2449ms)
+✔ malformed channels, poses, target counts and unsafe base normals reject before packing (0.8314ms)
+✔ all 64 targets pack within explicit texture capacity and invalid layouts fail before allocation (13.6591ms)
+✔ the light bake accepts the native backend and hands its texels to the texel tracer (73.5514ms)
+✔ a native bake without a texel tracer says what it needs instead of running the WebGL kernel (43.0668ms)
+✔ the texel parameter block carries the texel count, the sample count and the bounces after the first leg (1.9403ms)
+✔ the host decodes the page request, runs the native texel trace and encodes the answer (2.4788ms)
+✔ only the native time limit error is a clean failure (0.5463ms)
+✔ a host that offers the native tracer gives the page bake kernels even without WebGL2 (0.3503ms)
+✔ a native job without the native tracer runs the cpu backend with the same image and report fields (148028.6203ms)
+✔ a plain scene packs no fog and no subsurface table, so the kernel compiles without either (5.9109ms)
+✔ fog packs its box, medium and density where the kernel reads them (1.8109ms)
+✔ subsurface appends its table after the materials and points the kernel at it (0.9207ms)
+✔ noiseThreshold lands in the parameter block and defaults to drawing every sample (0.5206ms)
+✔ the kernel declares the two constants the host rewrites and reads the vectors the packer writes (58.8073ms)
+{"detail":"low","parts":1670,"sharedMeshes":20,"triangles":275533}
+{"detail":"balanced","parts":2817,"sharedMeshes":20,"triangles":608766}
+{"detail":"high","parts":3738,"sharedMeshes":20,"triangles":981490}
+✔ nature generation is repeatable and seeds change terrain and tree placement (305.0426ms)
+✔ all detail presets produce finite geometry with consistent winding (1786.4553ms)
+✔ scene parts meet the renderer contract and stay within declared bounds (130.8614ms)
+✔ detail presets scale vegetation and real geometry inside the instancing budget (67.9069ms)
+✔ water is a continuous horizontal surface and navigation has usable view directions (0.5537ms)
+✔ unsupported options fail with explicit errors (0.4948ms)
+✔ a path goes around a hole, keeps the agent radius and is deterministic (103.384ms)
+✔ string pulling leaves a straight line where nothing is in the way (83.5304ms)
+✔ a start inside a hole, outside the ground or beside an obstacle is refused with a reason (10.1102ms)
+✔ a wall of holes that cuts the ground in two has no path (83.7026ms)
+✔ the cell and search budgets give clear errors (72.9877ms)
+✔ ground that climbs faster than the slope limit blocks the way (170.5431ms)
+✔ scene_inspect path returns translation keyframes around the hole of a recipe terrain (8326.4288ms)
+✔ the object stage uploads the part deltas and the ID texture, then frees them (29.2229ms)
+✔ installing object blur without render passes is refused (0.9386ms)
+✔ object blur is absent from resolved effects until it is set above zero (47.6631ms)
+✔ only a non-zero objects value loads the object blur module (0.8338ms)
+✔ each part gets the transform back to where it was, and a part that did not move gets the identity (2.4365ms)
+✔ the object stage replaces camera blur on a frame that carries object motion (0.7037ms)
+67js preview resources closed.
+✔ every tool passes the rules all clients enforce (1.5863ms)
+✔ tool names use only the characters and length that OpenAI, Gemini and Anthropic accept (2.5539ms)
+✔ every input schema compiles under a strict JSON Schema 2020-12 validator (1795.8782ms)
+✔ every tool accepts an empty-argument call only when it has no required fields (1300.4164ms)
+✔ strict-mode and subset gaps are the known ones, so a new kind of gap is noticed (1.3068ms)
+✔ every page that llms.txt and the README link to exists in the package or on the site (74.8589ms)
+(node:47152) [DEP0190] DeprecationWarning: Passing args to a child process with shell option true can lead to security vulnerabilities, as the arguments are not escaped, only concatenated.
+(Use `node --trace-deprecation ...` to show where the warning was created)
+✔ the built MCP server reads shipped HDRIs and .cube looks from assets/looks (48414.4838ms)
+✔ the npm archive ships every bundled HDRI and .cube look (7551.5754ms)
+✔ every page in the Blender manual has a ledger row (17.9201ms)
+✔ every ledger row names a real manual path, once (0.5664ms)
+✔ every status is known, and every row says why (0.3722ms)
+✔ a done row links to evidence that exists (0.1702ms)
+✔ every evidence link resolves to a file (95.3122ms)
+✔ an out of scope row has no issue, because nothing is planned (0.3782ms)
+✔ every issue under the goal maps to a ledger row (0.2686ms)
+✔ coverage counts rows by section, and only Blender evidence counts as compared (0.4294ms)
+✔ a row covers its subtree only (0.455ms)
+✔ a section with finer rows needs no row, and its other pages still do (0.3222ms)
+✔ a resized body keeps its attached handle against it (398.0291ms)
+✔ gap, flush, align and centered place parts on their own axes (99.1917ms)
+✔ relations under a rotated and scaled parent still solve in world space (58.5726ms)
+✔ a chain of relations solves in dependency order whatever the node order (104.0288ms)
+✔ a tagged region of the target is the reference, not the whole part (429.4671ms)
+✔ relations solve the same every time and again after an edit moves a referenced region (202.0845ms)
+✔ set-node with an empty list removes relations and the part stays where it is (106.5906ms)
+✔ cycles, unknown parts and self references are rejected with the next action (1.6028ms)
+✔ a part cannot be placed against its own child, which would move with it (0.6624ms)
+✔ group nodes, group targets and two relations on one axis are rejected (57.3654ms)
+✔ hostile relation input is rejected without leaking or hanging (5.9522ms)
+✔ relation nodes are bounded (13.3582ms)
+✔ a long chain of relations solves with work in proportion to its length (5105.3985ms)
+✔ relations on a rejected edit leave the scene unchanged (6.3089ms)
+✔ particles bounce off a box: they never pass through it and rise again after the hit (324.9311ms)
+✔ a bounce keeps its energy ratio: the first apex is about the bounce squared of the drop height (167.2687ms)
+✔ without bounce a particle sticks where it lands, on the top face (94.6885ms)
+✔ a fast particle does not tunnel through a thin collider (82.5884ms)
+✔ friction slows the particle along the surface, and a slow bounce comes to rest (86.6633ms)
+✔ the same seed gives the same frames, forward, after seeking back and in a second scene (233.1954ms)
+✔ spin turns each particle in place and never changes where it flies (6.7062ms)
+✔ color and alpha follow the life: start, middle, end (35.5329ms)
+✔ a system without color or alpha writes no vertex colors (5.185ms)
+✔ collision input is validated and the capabilities describe it (6.9225ms)
+✔ a collider system node of another system and too many triangles are refused (303.1169ms)
+✔ the collision surface reports the nearest face and skips meshes the path cannot reach (0.6083ms)
+✔ a floor bounce needs no collider, and the closed form still serves a free fall (50.6854ms)
+✔ stepping from birth every frame stays cheap enough for long lives, and playback continues from the last frame (1147.3202ms)
+✔ Coulomb friction stops a slider after about v squared over two mu g, and a settled particle stops turning (0.971ms)
+✔ the default bounce with colliders reads as debris (117.0528ms)
+✔ a seek gives the same particles: back and forth, from the end, and in a second scene (262.7789ms)
+✔ a seeded emitter gives identical bytes and another seed gives different particles (270.0086ms)
+✔ raising the count keeps the particles that were already there (1.6244ms)
+✔ drag, wind and gravity follow the closed form, checked against small time steps (4.526ms)
+✔ particles land on the floor and stay there, and never fall below it (75.9282ms)
+✔ rate spreads births in time and size can shrink to nothing at death (26.1399ms)
+✔ the node transform does not move or scale particles (66.7026ms)
+✔ a seek replaces the part, so a renderer sees a topology change (6.7537ms)
+✔ the report counts particles and vertices, and a scene without particles has none (73.0296ms)
+✔ set-particles adds, changes and clears the section, and restores through a checkpoint (119.6178ms)
+✔ the capabilities describe the limits that the validator enforces (0.5445ms)
+✔ hostile input is rejected with the limit in the message (97.4134ms)
+✔ total particles and total vertices are bounded across systems (64.4366ms)
+✔ a particle node cannot carry motion or physics, or be a cloth sheet (4.5343ms)
+✔ a large burst seeks statelessly in fixed buffers, and a huge time is only a dead system (1346.7254ms)
+✔ the particle code stays unloaded for a scene without particles (3197.6464ms)
+✔ hair grows from the surface, outward, and seeks deterministically (174.2281ms)
+✔ hair droops toward gravity and sways with time only when asked (104.5165ms)
+✔ hair triangles face outward and the report counts strands (68.7507ms)
+✔ hostile hair input is rejected (21.0646ms)
+✔ hair limits the vertices it draws, and an empty surface is refused (32.7333ms)
+✔ denoise takes a boolean or a name and keeps the boolean the tracer reports (4.7425ms)
+✔ denoise "oidn" leaves the colour as traced and returns the feature images for the caller (73.88ms)
+✔ a job that asks for oidn without the binary runs the wavelet filter and says why (4.4354ms)
+✔ PFM files keep the pixels and store rows bottom to top (0.4717ms)
+﹣ the installed OIDN removes noise from a flat image and gives the same bytes twice (0.103ms) # the oidnDenoise binary is not fetched
+✔ an emissive map colours the emission and the strength scales it (70.462ms)
+✔ an emissive map no longer appears among the ignored features (0.2702ms)
+✔ an absorbing fog slab removes light by exp(-density * thickness) (1686.4473ms)
+✔ a lit fog slab scatters sunlight toward the camera over a black floor (155.6461ms)
+✔ fog is the same in a repeat render (50.3073ms)
+✔ fog with no density, or none at all, builds no medium (0.4457ms)
+✔ the fog box clips a ray to where it is inside (0.2132ms)
+✔ Henyey-Greenstein draws follow their density (10.9303ms)
+✔ the report says the fog is traced as a uniform medium only when noise or ambient were asked for (0.4245ms)
+✔ triangles are packed in leaf order with their corner, edges and material (3.8918ms)
+✔ nodes mark a leaf with a negative triangle count and an inner node with its right child (0.5498ms)
+✔ materials carry values, the light mask in two halves and an atlas rectangle with its flags (1.5459ms)
+✔ the backend option is cpu unless asked, and refuses other names (992.2987ms)
+✔ lights are packed as points, then spots, then areas (0.6303ms)
+✔ the subsurface block is packed as two texels per material, with -1 for the base colour (1.0699ms)
+✔ weight 0 and no block both leave the kernel without the random walk (1.7572ms)
+✔ the texel kernel starts paths at lightmap texels, and the camera kernel does not carry its samplers (0.525ms)
+✔ a scene without links keeps the pixels it had before linking was traced (136.2078ms)
+✔ a mask that lets every light through gives the pixels of no mask (213.4501ms)
+✔ the sun adds nothing at a part whose mask skips it (84.1952ms)
+✔ a point light adds nothing at a part whose mask skips it, and the other light still does (74.8808ms)
+✔ a spot light and an area light honour their bits too (52.9106ms)
+✔ the path tracer no longer names light linking as ignored (0.6529ms)
+✔ the tree has one leaf per light and boxes and energy that cover the children (5.5142ms)
+✔ merging cones keeps both inside the result (0.4033ms)
+✔ a node is worth more when it is near, bright and turned toward the point, and its minimum measure never reaches zero (0.4449ms)
+✔ the left chance mixes the two measures and falls back to the minimum measure (0.1404ms)
+✔ the walk reports the chance it took: frequencies match and the chances add up to one (100.4983ms)
+✔ the light tree packs into a float table and the kernel has the walk only when asked (1.5715ms)
+✔ the CPU tracer with the light tree keeps the mean radiance of the uniform draw (838.6234ms)
+✔ the surface area orientation split keeps two far apart clusters of lights in separate subtrees (0.5777ms)
+✔ the WebGPU kernels carry the tree walk (223.5514ms)
+✔ the blue noise tile is the same bytes for the same seed and differs for another (1519.4574ms)
+✔ every channel of the tile holds each value equally often, and its blurred variance is far below white noise (524.2296ms)
+✔ the options choose the sampling pattern and the light choice, and the CPU reference keeps its defaults (1.9817ms)
+✔ the kernel compiles the new paths only when asked, so the default kernel keeps its pixels (0.3449ms)
+✔ a point and a nearby point of the same cell share a slot, and the slot is stable (1.1596ms)
+✔ cells far apart and surfaces facing opposite ways get different slots (0.2064ms)
+✔ a normal that wobbles around an axis stays in one cell (0.1668ms)
+✔ cells grow with the distance from the eye, one level each time the distance doubles (0.1824ms)
+✔ the hash spreads cells evenly over the slots (101.2992ms)
+✔ few cells collide at the size a room needs (5.462ms)
+✔ a cell averages the records it receives, quickly while it is new and slowly once it has history (1.4815ms)
+✔ the kernel gets the cache only when it is asked for (0.3811ms)
+✔ a page without a WebGPU adapter does not get the WebGPU tracer (2.0395ms)
+✔ an unknown real-time backend is rejected before any GPU work (0.4373ms)
+✔ the WebGPU real-time tracer encodes a frame per call and ping-pongs its history (90.049ms)
+✔ an update that only moves a part keeps the history and sends the part motion with the next frame (4.377ms)
+✔ the default megakernel does not carry the real-time pieces (2.1936ms)
+✔ the real-time megakernel ends paths in the cache, records the hit before, and has its own entry point (0.3589ms)
+✔ the WGSL cache hash uses the constants of the JavaScript reference (0.2321ms)
+✔ the real-time pieces stay out of the other kernel variants (0.7878ms)
+✔ the output rows of the texture copy are whole 256 byte multiples (0.9245ms)
+✔ the real-time options default to WebGL2 and name the backends they know (0.9399ms)
+✔ the cache cell size follows the scene unless it is given (1.1351ms)
+✔ two cameras that look the same way match (0.2809ms)
+✔ a part that slid is followed, a part that changed shape is not (3.0053ms)
+✔ a part that turned and moved maps its points back through the previous matrix (0.3509ms)
+✔ invertAffine undoes a matrix and refuses a singular one (0.1762ms)
+✔ a point seen through a pixel projects back to that pixel with its eye distance (0.5261ms)
+✔ the picture centre is where the camera looks, and up is toward row 0 (0.2096ms)
+✔ a resting camera gives a zero motion vector (0.1839ms)
+✔ a camera that moves right sees a near surface move left (vector toward this frame), more than a far one (0.1717ms)
+✔ a camera that turns moves every surface by the same amount whatever its distance (0.2637ms)
+✔ a point behind the previous camera has no history (0.2058ms)
+✔ bilinear taps add up to one and fall on the pixel centres around the position (0.4117ms)
+✔ history is rejected across a depth jump or a turned surface and accepted along a slope (0.7567ms)
+✔ a weight of 0 or no block at all draws exactly the same pixels (1076.214ms)
+✔ a walk that never reaches a surface stops after the step cap (1.5859ms)
+✔ a card with nothing of its own behind the point is walked as thin (0.2726ms)
+✔ the single scattering albedo maps 0 to 0 and 1 to 1 and grows between (0.2585ms)
+✔ a white part under a uniform sky never returns more light than arrives (1550.4445ms)
+✔ a thin slab lit from behind glows with subsurface and stays dark without (340.685ms)
+✔ the capability list names subsurface as traced (0.2996ms)
+✔ an image with RGBA data is used as it is (1.5049ms)
+✔ a decoded bitmap without data is read back through a canvas, once per image (0.5171ms)
+✔ compressed images, images without a size and runtimes without a canvas give no pixels (0.2631ms)
+✔ the webgpu backend is a valid path tracer option, the default stays cpu (1.6723ms)
+✔ without navigator.gpu the webgpu backend throws a clear error naming the fallbacks (5.9714ms)
+✔ an unknown kernel name is rejected before any GPU work (1.6496ms)
+✔ fog and the subsurface walk are compiled in only for the megakernel of a scene that uses them (2.85ms)
+✔ the texel kernel replaces the camera entry point and reads the texels from the two spare bindings (0.6206ms)
+✔ the wavefront kernel refuses a scene with fog or subsurface scattering before it asks for an adapter (1.3776ms)
+✔ both kernels share the scene bindings and the wavefront adds its path state (0.8171ms)
+✔ the job limits listed for agents match the limits the tracer enforces (3.1814ms)
+✔ options are validated with their bounds (5.9226ms)
+✔ hostile cameras and scenes are refused before any ray is traced (64.964ms)
+✔ the same scene and seed give the same bytes, and another seed does not (647.6137ms)
+✔ a floor lit by an overhead sun matches the diffuse closed form (84.8377ms)
+✔ a rough floor keeps its diffuse light when seen at a grazing angle (219.0603ms)
+✔ a block between the sun and the floor leaves a shadow (105.0059ms)
+✔ a render that runs out of time throws and returns nothing (355.6887ms)
+✔ denoising keeps the mean of a noisy image and removes some of its noise (210.8564ms)
+✔ the display transform matches the rasterizer post pass at known values (0.4297ms)
+✔ what the tracer does not draw is named in the report (0.3619ms)
+✔ a normal map tilts the surface toward or away from the light (198.6873ms)
+✔ a metallic-roughness map scales the metallic and roughness of the material (180.5432ms)
+✔ normal and roughness maps on box-projected materials are drawn through the projection UVs (278.8195ms)
+✔ drawing one light at random past the first hit keeps the average (650.5508ms)
+✔ bands drawn in any order and split anywhere give the pixels of the whole image (293.2174ms)
+✔ a scene sent to a worker gets its ray query back from the arrays (9.2765ms)
+✔ a threshold of zero draws every sample, and a threshold stops the pixels that have converged (1143.2871ms)
+✔ adaptive bands split anywhere give the pixels of the whole image (519.554ms)
+✔ the noise threshold is validated (0.4126ms)
+✔ a camera ray and a shadow ray pass through a deep stack of transparent cutouts (220.7689ms)
+✔ a ball comes to rest on a trimesh floor (811.9755ms)
+✔ a convex hull body rests on a trimesh floor (86.7993ms)
+✔ trimesh and hull counts are rejected before anything is allocated (2.3572ms)
+✔ a sensor reports enter and leave without pushing the body (9.4918ms)
+✔ collision masks let a ball pass through a floor it does not collide with (6.5369ms)
+✔ a seek back reproduces the same poses (4.8215ms)
+✔ memory plan bounds counts and rejects the bake before allocating Rapier or timeline (5.2493ms)
+✔ actual Rapier contact stops a falling box and supports a stable stack (1038.7295ms)
+✔ ball and capsule contacts use real collider dimensions (78.7314ms)
+✔ compound collider mass and density both contribute to real impulse response (4.2427ms)
+✔ spherical ragdoll constraint retains anchors while bodies collide with the floor (79.1608ms)
+✔ revolute ragdoll constraint retains anchors while bodies collide with the floor (16.844ms)
+✔ fixed ragdoll constraint retains anchors while bodies collide with the floor (83.0834ms)
+✔ impulses, off-center impulses, and torque impulses are applied at declared ticks (3.5928ms)
+✔ recording repeats bit exactly, and backward seeks do not change later samples (136.9666ms)
+✔ kinematic targets push a dynamic body and samples interpolate translation and unit quaternions (3.9417ms)
+✔ part binding keeps matrix identity and scales, and updates all bindings atomically (1.994ms)
+✔ malformed bodies, colliders, constraints, and events fail at the boundary (1.7863ms)
+✔ binding rejects distinct overlapping matrix views before changing either target (0.756ms)
+✔ Float32 validation rejects rounded zero, overflow, and unsafe geometry inertia (1.3473ms)
+✔ solver preflight rejects normal-looking inputs that freeze or overflow Rapier motion (1.1792ms)
+✔ small normal mass still responds to gravity instead of silently freezing (0.4835ms)
+✔ inputs are copied before awaiting WASM initialization, and event/joint limits are enforced (0.7101ms)
+✔ invalid samples and bindings cannot mutate matrices, and disposed scenes reject calls (0.7176ms)
+✔ prismatic limits constrain a real motor in both directions (7.8579ms)
+✔ prismatic position motors respond to tick target changes and wake sleeping bodies (47.2725ms)
+✔ revolute limits constrain a real motor in both directions (28.3125ms)
+✔ revolute position motors respond to tick target changes and wake sleeping bodies (143.2696ms)
+✔ rotated prismatic endpoints use Float32 coordinate membership and still reject outside positions (20.1436ms)
+✔ exact half-turn antipodes share limit membership and real solver trajectories (27.7527ms)
+✔ maxForce limits real motor response, and disabling leaves momentum instead of holding a pose (7.0014ms)
+✔ motor snapshots repeat bit exactly, respect same-tick order and permit arbitrary seeks (52.1428ms)
+✔ motor controls and limits are copied before asynchronous initialization, including nested event snapshots (4.6286ms)
+✔ joint controls reject unknown fields, unsupported joints, out-of-limit targets and Float32 collapse (3.5834ms)
+✔ initial controlled joint coordinates, orientations and axes must match their authored limits (0.7755ms)
+✔ motor preflight rejects huge, weak, collapsed and motor-induced unsafe Float32 states (3.0315ms)
+✔ explicit initial and tick motor disable can be no-ops without changing the recorded pose (2.2579ms)
+✔ a look that names no step resolves exactly as before (8.8251ms)
+✔ each named step resolves with defaults and refuses bad input (1.3137ms)
+✔ a recipe that names a step loads the module, validates it and keeps the group in the look (1.7717ms)
+✔ an edit adds a step to a scene that has none (6.3973ms)
+✔ each stage draws only for a frame that sets its step, and frees its target (4.2761ms)
+✔ the shaders keep their fixed sample patterns and read no history (0.3729ms)
+﹣ each named step changes the picture and the default still keeps its hash (0.2023ms) # SKIP
+✔ a docs-only change runs the link check and skips the code gates (1.7597ms)
+✔ a source change without a change note fails the note check (0.6004ms)
+✔ a size note alone does not count as a change note (0.3053ms)
+✔ editing a protected file fails with the alternative (0.2564ms)
+✔ MCP tool code runs the schema and tool cost checks (0.2074ms)
+✔ --skip-tests skips the build, the tests and the coverage gate (0.2393ms)
+✔ manual GPU checks are pointed out by the files they cover (2.1518ms)
+✔ assembly approaches arbitrary targets smoothly without overshooting (1.1127ms)
+✔ transition timing is independent of display refresh and reaches fully assembled (2.147ms)
+✔ a ragdoll on a preset armature falls, lies on the floor and reports numbers (1097.3176ms)
+✔ a seek to the same time gives the same bytes in any order (755.9016ms)
+✔ the ragdoll bake is reused until the rig changes (342.9533ms)
+✔ a scene without physics never loads the ragdoll code path (0.638ms)
+✔ bad ragdoll sections fail with a message that names the fix (36.2486ms)
+✔ a bone cannot have both a ragdoll and a pose track (5.2505ms)
+✔ an armature larger than the bone limit is refused before the solver runs (10.6683ms)
+✔ a bone with no length is refused (1.0741ms)
+✔ an imported robot ragdolls onto the floor and seeks to the same pose (419.1269ms)
+✔ asset physics refuses unknown fields and a missing ragdoll (220.5336ms)
+✔ a recipe that names no links or cascades loads neither module (3.2291ms)
+✔ affects and keyAffects limit lights to the named nodes and keep their shape through export (174.5183ms)
+✔ a scene without links keeps plain parts and a recipe shape without the new fields (7.481ms)
+✔ an unknown node in affects fails and names the next action (54.5681ms)
+✔ set-environment carries links, and removing a linked node is refused until the list changes (16.9806ms)
+✔ an edit that leaves the links alone keeps the same part objects (8.0283ms)
+✔ cascade counts and affects lists are validated (1.9534ms)
+✔ cascades turn on by themselves only where one map is coarse, and an explicit count always wins (0.3214ms)
+✔ scene_capabilities says recipes reach linking and cascades (0.308ms)
+✔ the path tracer traces linking, so its report does not list it (5.1035ms)
+✔ the bake adds no light from a lamp onto parts it skips, even as a bounce (1008.759ms)
+✔ the stored bake scores hold every baked room, with no local paths (3.9757ms)
+✔ a score that gets worse by more than the margin is a regression, and noise inside it is not (1.136ms)
+✔ a better score, and a scene the fresh run did not draw, are not regressions (0.2381ms)
+﹣ a fresh bake.json from a run has no score worse than the stored one by the margin (0.0986ms) # no fresh run in artifacts/reference
+✔ the render baseline scores every scene with every renderer pair (3.71ms)
+✔ every baseline scene has its side by side image (2.0401ms)
+✔ the baseline records real hardware and a software renderer, and no local paths (0.3627ms)
+✔ the water of the megacity scenes stands above the ground box, not in the same plane (5.6632ms)
+✔ score.py rounds the EEVEE array to what an 8-bit PNG holds (8770.6819ms)
+✔ every scoring path loads EEVEE through the quantising loader (0.3594ms)
+✔ an enclosed room gets one automatic probe at its centre (1055.2148ms)
+✔ an open scene gets no automatic probe and says why (94.3939ms)
+✔ a probe sees the coloured wall it faces and is lit by the lamp (115.6807ms)
+✔ the same input traces the same bytes (384.4808ms)
+✔ a part takes the nearest probe in range, else none (0.2901ms)
+✔ explicit probes with a radius leave distant parts without one (74.1158ms)
+✔ probe lists are validated (0.8818ms)
+✔ bake.probes defaults to room, and false opts out (0.4627ms)
+✔ the probe shader code compiles in only when asked for (0.4703ms)
+✔ a probe on a light-mapped part keeps its light map fields and still reads live colour (1405.866ms)
+✔ a reflective part gets a probe of its own, and no other part is probed (10.8501ms)
+✔ the probe of a part never hits the part itself and sees the floor and the block (20.4948ms)
+✔ an object probe records the level floor under it so the lookup can follow the ray to the floor (8.3489ms)
+✔ a room probe keeps the plain lookup (96.5497ms)
+✔ a scene with no reflective part, or too many, traces nothing (0.5981ms)
+✔ rough metal and plain surfaces are not reflective (0.2033ms)
+✔ a bounce in the probe trace adds light to a lit surface and never takes direct light away (12.2143ms)
+✔ a bounding sphere is centred on the box of the vertices and reaches the farthest one (2.9904ms)
+✔ instances behind, beside and beyond the camera are culled and the rest stay in order (86.979ms)
+✔ a sphere that only touches the frustum edge is kept, and scale grows its reach (0.5311ms)
+✔ an instance that is everywhere in view reports that the full buffer can be used (0.4958ms)
+✔ a level is chosen by the pixels of error it would show, coarsest first allowed (0.1954ms)
+✔ farther copies of one model use coarser levels, and each copy lands in exactly one level (0.511ms)
+✔ selection depends only on its inputs, so any frame picks the same instances (4.2856ms)
+✔ the renderer draws only the visible instances, each level from its own geometry (581.964ms)
+✔ culling is off for deforming, skinned and alpha-blended batches, and lods are refused there (1.4406ms)
+✔ the shadow pass skips instances outside the light and picks the shadow level from the texel size (3.9974ms)
+✔ a batch without shadow levels uses its camera levels in the shadow pass, and shadow levels are refused on deforming parts (0.6857ms)
+✔ swaying foliage is culled and given shadow levels, with a bound that grows with the wind (1.8913ms)
+✔ an instance wholly under belowHeight is culled and one that reaches above it stays (0.6812ms)
+✔ an instance smaller than minimumPixelRadius on screen is culled, and a near one stays (0.5104ms)
+✔ the renderer lets the water mirror widen the level error, and a normal frame is unchanged (43.9404ms)
+✔ a visible track hides a node and its children from the keyed time, with the same parts (52.2319ms)
+✔ a static visible:false node is hidden and a track can show it again (27.5008ms)
+✔ scenes that never use visibility add no part fields (2.5487ms)
+✔ shadow and composite flags reach the part and split batches (5.044ms)
+✔ flags must be booleans on mesh nodes and a node is not both holdout and catcher (2.5903ms)
+✔ visible, castShadow, receiveShadow, holdout and shadowCatcher draw as documented (19384.5029ms)
+✔ capabilities and the renderer list the same passes in the same order (1.7131ms)
+✔ the pass branch of the main shader is compiled out unless a pass is requested (0.4363ms)
+✔ camera effects default off, validate ranges and survive look normalization (4.5791ms)
+✔ installing camera effects adds two stages once and costs nothing until a frame uses them (0.7549ms)
+✔ render passes need the addon, reject unknown names and touch no GL until asked (1.7786ms)
+✔ artifact names list the lit image and each pass per frame (0.8701ms)
+✔ a job with passes publishes every pass file and rejects bad pass requests (5962.9939ms)
+✔ the render skill reference has submissions to check (1.6973ms)
+✔ render skill submission 1 uses declared settings (0.3241ms)
+✔ render skill submission 2 uses declared settings (0.1661ms)
+✔ render skill submission 3 uses declared settings (0.1183ms)
+✔ render skill submission 4 uses declared settings (0.1141ms)
+✔ render skill submission 5 uses declared settings (0.0959ms)
+✔ render skill submission 6 uses declared settings (0.0961ms)
+✔ render skill submission 7 uses declared settings (0.0812ms)
+✔ the ledger sizes a target by pixels, layers, samples and format and lists the largest first (2.8378ms)
+✔ the ledger forgets released targets (0.3219ms)
+✔ a scene with nothing to cast keeps a one texel shadow map and a casting scene keeps the full one (1.1707ms)
+✔ the local shadow atlas holds one row of tiles per four shadow tiles and regrows when more are needed (0.4934ms)
+✔ the multisampled depth uses 16 bits unless a depth texture needs the same format as its resolve (60.367ms)
+✔ the single shadow map follows the casters: it grows when casters arrive and shrinks when they leave (0.5035ms)
+✔ with cascades the single shadow map stays one texel unless volume fog or subsurface reads it (0.3875ms)
+✔ without the compact colour addon the frame and multisample colour stay RGBA16F (2.1224ms)
+✔ compact colour halves the frame and multisample colour and keeps the other targets (1.5389ms)
+✔ compact colour needs HDR, an opaque canvas and a sample count the format supports (1.0084ms)
+✔ topology reconciliation reuses geometry uploads and unchanged batches, and releases removed geometry (146.7057ms)
+✔ invalid geometry and peak staging budgets reject before allocation and preserve the previous scene (56.4034ms)
+✔ driver errors and throwing uploads clean staged resources without retiring the working renderer (6.127ms)
+✔ retained textured batches survive while streamed rigid parts change around them (14.0215ms)
+✔ committed uploaded resource ownership rejects replacement even when callers mutate live handles (4.7898ms)
+✔ replaceParts adds a textured part and uploads its texture once (26.9511ms)
+✔ replaceParts removes a textured part and deletes its batch, buffers and texture (6.0236ms)
+✔ a texture shared by two parts survives removing one of them (5.0511ms)
+✔ replaceParts no longer rejects textured parts (9.4309ms)
+✔ sample reporting uses the negotiated allocation count and cannot diverge through assignment (1.7209ms)
+✔ batching shares geometry only when texture descriptor identities also match (2.0394ms)
+✔ liquid and foam parts form their own batches and validate their optics (2.728ms)
+✔ shadowless parts form separate render batches and cannot change casting after upload (0.6836ms)
+✔ alpha mode, cutoff and double-sided state partition batches, while blend and add opacity does not (0.868ms)
+✔ alpha material fields are validated with clear errors (0.6906ms)
+✔ blend batches skip shadows by default and alpha state cannot change after upload (0.9082ms)
+✔ updateParts changes the opacity of blend and add parts without a new batch (0.8844ms)
+✔ opaque and mask parts keep an instance opacity of one (0.4575ms)
+✔ blend instances upload back to front by distance to the eye (0.6222ms)
+✔ instance animation reuses retained buffers, updates inverse-transpose normals and RGB emission (1.1239ms)
+✔ mixed invalid updates fail atomically before CPU or GPU instance data changes (1.03ms)
+✔ repeated instance updates retain normal buffers without allocating matrices per frame (1.92ms)
+✔ texture descriptor preflight validates dimensions, channel, samplers and mipmap bytes (51.5299ms)
+✔ all material map identities and fixed scale values partition instance batches (6.8349ms)
+✔ map and scale changes reject atomically before retained data uploads (2.861ms)
+✔ texture budgets count every channel and charge shared descriptors once before GPU allocation (8.5929ms)
+✔ GPU uploads use descriptor color spaces, filter anisotropically, cache shared maps, and dispose every cached texture (0.8345ms)
+✔ draw batches bind all channels with their flags and scalar uniforms (0.9627ms)
+✔ pose identity partitions batches while shared poses retain instancing and all material maps (13.5379ms)
+✔ GPU skin preflight checks capabilities, texture capacity and retained texture budgets (9.4428ms)
+✔ skin updates retain palette upload data, deduplicate shared poses and reject mixed invalid updates atomically (1.205ms)
+✔ skin palette and influence textures cache by pose and geometry identity and dispose fully (1.3724ms)
+✔ a shared palette validates consumers outside the submitted update list before any upload (1.1055ms)
+✔ color, benchmark and shadow passes bind the same skin textures and disable skinning for rigid batches (0.3537ms)
+✔ the shadow depth pass draws both faces of a single-sided batch, so the sun cannot pass through an open surface seen from behind (1.4357ms)
+✔ blend batches draw their opaque texels with depth writes before the blended pass (2.6494ms)
+✔ resize keeps the projection centered at 699 px and 1440 px (1.1174ms)
+✔ adding a textured part without the addon names the import to add (39.1226ms)
+✔ name mapping recognises the mixamo rig family (3.6111ms)
+✔ name mapping recognises the mixamo with numbered namespace rig family (0.3229ms)
+✔ name mapping recognises the vrm rig family (0.2233ms)
+✔ name mapping recognises the vrm 0 bip names rig family (0.3089ms)
+✔ name mapping recognises the unreal rig family (0.4364ms)
+✔ name mapping recognises the rigify rig family (0.2184ms)
+✔ name mapping recognises the quaternius rig family (0.2004ms)
+✔ name mapping reports missing required bones and accepts overrides (0.9611ms)
+✔ a source joint rotation moves the target bone by the same world-space rotation across T-pose and A-pose rests (90.2079ms)
+✔ a source with differently oriented bone axes produces the same world pose on the target (6.6365ms)
+✔ hips translation scales with the ratio of leg lengths and respects root motion and scale options (16.7475ms)
+✔ retargeting is deterministic and honours the bones option (69.3174ms)
+✔ non-humanoid input is rejected with the missing bones listed (28.4276ms)
+✔ a rig recovered from a skin and played with its rest clip keeps the identity palette (7.3647ms)
+✔ crowd placement and timing are deterministic per seed (1.3445ms)
+✔ crowd grid layout is centred and scatter layout keeps instances apart (0.992ms)
+✔ a reversed perspective projection maps the near plane to 1 and the far plane to 0 (1.8565ms)
+✔ the reversed depth is one minus the standard depth mapped to 0..1, so a pass can turn it back (0.3492ms)
+✔ an orthographic projection reverses too, and x, y and w are untouched (0.2962ms)
+✔ the far to near rule: a lens over 10,000 to 1 asks for reversed depth, the default lens does not (0.1761ms)
+✔ auto mode stays off until a frame or a request asks, true forces it and false never switches it on (0.7733ms)
+✔ without the extension, or in benchmark mode, the standard path stays (0.2209ms)
+✔ a flush pair far from the eye asks for reversed depth, a near one does not (0.3924ms)
+✔ the main vertex shader is compiled camera-relative only through the addon, and only that program (48.5468ms)
+✔ the renderer loads reversed depth itself for a stretched lens, once, and not when the mode is false (435.1046ms)
+✔ a rig with a missing leg bone, an unskinned arm or a backward elbow fails its own check (2000.9258ms)
+✔ the walker reference passes every check (349.5224ms)
+✔ automatic weights give four influences that sum to one, and seams share weights (160.8325ms)
+✔ scene_inspect reports unweighted vertices, bones with no vertices and joint axis problems (23.8495ms)
+✔ a straight-legged humanoid and a backward knee are both flagged (82.6224ms)
+✔ armature bones are recipe nodes, and an exported recipe loads back unchanged (212.079ms)
+✔ a preset armature maps to humanoid bones without overrides (94.3888ms)
+✔ a quadruped preset fits the bounds of a mesh node (7.9314ms)
+✔ weights depend on position only and unweighted vertices still bind to a bone (2.2745ms)
+✔ the walker exports to a GLB that three.js loads with its skeleton and walk clip (266.6758ms)
+✔ set-armatures replaces the rig and refuses to leave a skin without one (322.5714ms)
+✔ a closed room lit by a lamp gets flux * rho / (pi * area * (1 - rho)) as its bounce, scaled by the fitted gain (46.7877ms)
+✔ the bounce takes the colour of the walls (9.6744ms)
+✔ the map keeps its data, so a lamp that changes every frame never rebuilds the environment textures (3.6853ms)
+✔ no bounce is added with a sun, with roomBounce off, in an open room or from a lamp outside the room (4.7557ms)
+✔ a scene without a map or without lamps is left alone (3.1174ms)
+✔ scene_inspect names the bake for a closed room lit by lamps only (3.7665ms)
+✔ the runtime report covers every scene in both engines on both backends (2.8449ms)
+✔ each picture difference is recorded, and the three.js version matches the package (0.3423ms)
+✔ each 67js result lists its render targets, and they fit in the GPU memory the counter saw (0.3106ms)
+✔ the report names real hardware and a software renderer, and no local paths (0.5717ms)
+✔ child-first definitions propagate nested rotations and nonuniform scales like Three Object3D (3.3374ms)
+✔ pivot conjugation places the pivot correctly under parent translation, rotation and scale (0.4735ms)
+✔ roots, empty graphs and multiple render meshes keep a stable Renderer67 part shape (14.9829ms)
+✔ definition matrices and pivots copy serializable inputs while geometry and material remain shared (0.8685ms)
+✔ nonsingular affine shear and reflected transforms remain valid graph transforms (16.662ms)
+✔ local mixer and parent animation propagate independently for arbitrary seek order (3.2804ms)
+✔ animation target material assignment forwards retained isolation to render parts and preserves map identity (0.7611ms)
+✔ all published world matrices remain unchanged when any local, pivot or composed world is invalid (0.8946ms)
+✔ keepWorld reparent preserves pivoted subtrees under rotated nonuniform scales without changing identities (0.9921ms)
+✔ reparent without keepWorld preserves local pose and keepWorld includes unpublished local edits (0.6108ms)
+✔ reparent rejects cycles, excessive depth and invalid candidate worlds atomically (1.0767ms)
+✔ hierarchy guards bound node count and depth without recursive traversal (7.2987ms)
+✔ malformed matrices, pivots and mesh definitions fail before graph publication (1.0221ms)
+✔ update reuses parent matrices and effective-local buffers across repeated evaluation (4.0367ms)
+✔ obstacles marks things over 0.3 m and keeps a kerb walkable (34.6164ms)
+✔ the street level defaults to the lowest sampled surface (15.1708ms)
+✔ keepOut clears cells near an obstacle and a wall, and leaves the open street (40.2162ms)
+✔ a closing step fills a one-cell seam before keepOut is applied (0.6081ms)
+✔ walkMap rejects unknown obstacles options (0.8327ms)
+✔ raycast returns the nearest hit over every part with its world matrix (5.4158ms)
+✔ normals face the ray, also from below (0.6797ms)
+✔ indexes are built lazily and kept (0.7056ms)
+✔ slivers do not stop a part from being queried (0.5194ms)
+✔ walkMap samples ground and headroom and finds the ground under a roof (1.6034ms)
+✔ walkMap refuses a region above maxCells and unknown options (0.677ms)
+✔ directional sculpt uses literal quintic falloff and preserves independent channels (4.3862ms)
+✔ inflate and deflate use original normals and leave vertices outside brush unchanged (8.3909ms)
+✔ exact coincident position seams move together while authored normal splits stay separate (37.72ms)
+✔ Laplacian smoothing uses one immutable neighborhood snapshot for each stroke (1.5179ms)
+✔ invalid sculpt data, unsupported deformation and work budgets fail without source mutation (1.562ms)
+✔ sculpt rejects collapsed output triangles and retains source when the operation fails (0.4432ms)
+✔ normal reconstruction remains accurate for very small and large finite meshes (0.4009ms)
+✔ UV seam duplication does not change area-weighted sculpt normals (0.3808ms)
+✔ stages and bloom never read a texture left on a mipmapped filter by the previous frame (#578) (2.2153ms)
+✔ the default fragment shader keeps every feature (1.3453ms)
+✔ a mapped normal takes the sky light below the surface plane out of the ambient term (0.2468ms)
+✔ a feature that a scene does not use becomes a constant false (1.8524ms)
+✔ the two fill lights compile in only for a renderer whose fill intensity is above 0 (0.2972ms)
+✔ every feature condition is a macro that the shader body uses (0.5365ms)
+✔ anisotropy and iridescence compile in only when a material asks for them (0.5365ms)
+✔ the validator refuses each forbidden pattern and says where (7.9379ms)
+✔ loops nest and call helpers within the work limit (1.3021ms)
+✔ comments are blanked and never hide a rule (0.3317ms)
+✔ an entry function can be required (0.318ms)
+✔ uniforms: names, types, values and counts (1.3494ms)
+✔ info log lines map to the snippet (1.0346ms)
+✔ the documented limits match the validator (0.248ms)
+✔ passes: count, names, fields, scale and the entry function (0.9428ms)
+✔ the documented example passes the validator and builds a scene (56.2174ms)
+✔ shadow-depth.py passes its self test on a synthetic lit and shadowed image (14551.9539ms)
+✔ the sun shadow is one hardware comparison fetch for each filter tap (2.7085ms)
+✔ the fog volume reads the same shadow texture through a comparison sampler (0.2683ms)
+✔ the default shadow eye sits along the sun direction (2.2335ms)
+✔ an explicit shadow eye wins and a custom target moves the derived eye (20.2824ms)
+✔ a missing or zero sun falls back to the default direction (0.2978ms)
+✔ the shadow bias is the same distance in metres for two depth ranges (0.2636ms)
+✔ the shadow bias in metres follows the texel size (0.1783ms)
+✔ timed files are dealt longest first to the lightest shard (1.9423ms)
+✔ a file without a timing lands in one shard and moves no other file (0.7833ms)
+✔ the port showcase loads in two meshopt-compressed parts, the first small enough to draw quickly (86.6633ms)
+✔ the port showcase parts hold meshes and keep every skinned part in the first (41.1893ms)
+✔ the port showcase has a small preview sky that parses (18.6116ms)
+✔ the airport showcase loads in two meshopt-compressed parts, the first small enough to draw quickly (18.6809ms)
+✔ the airport showcase parts hold meshes and keep every skinned part in the first (28.4522ms)
+✔ the airport showcase has a small preview sky that parses (24.0439ms)
+✔ the datacenter showcase loads in two meshopt-compressed parts, the first small enough to draw quickly (41.3514ms)
+✔ the datacenter showcase parts hold meshes and keep every skinned part in the first (18.0915ms)
+✔ the datacenter showcase has a small preview sky that parses (17.1856ms)
+✔ the showcase page leaves meshopt decoding to the glTF loader (1.998ms)
+✔ the port showcase files load through loadGltf without a decoder option (1902.0765ms)
+✔ the airport showcase files load through loadGltf without a decoder option (2958.5096ms)
+✔ the datacenter showcase files load through loadGltf without a decoder option (2211.2717ms)
+✔ the showcase page draws the first part before it streams the rest (34.3001ms)
+✔ projected queries keep inside-bound hits and prune distant stacked surfaces (5.9152ms)
+✔ nearest and directional projection wrap to a literal plane with physical clearance (6.4723ms)
+✔ target-local nearest and project queries return original triangle coordinates and count misses (2.526ms)
+✔ sphere projection follows actual triangle planes rather than an analytic sphere (31.1578ms)
+✔ misses throw atomically by default and keep only the transformed source when requested (1.1003ms)
+✔ partial keep misses preserve transformed vertices and rebuild normals for the resulting slope (0.506ms)
+✔ total callback and unique-position budgets fail without poisoning subsequent operations (1.04ms)
+✔ source affine transforms use target-local coordinates and retain UVs and color byte offsets (1.339ms)
+✔ coincident position seams move together while authored hard-normal groups remain separate (3.1267ms)
+✔ invalid geometry, options, precision collapse, backfaces and clearance failure reject (2.4258ms)
+✔ normalized queries and Double normal sums support small and large finite local meshes (0.7059ms)
+✔ shared normal extraction preserves sculpt literal falloff and no-op behavior (1.3492ms)
+✔ a bundle over its budget is a problem that names the bundle and the fix (1.59ms)
+✔ a bundle at its budget passes (0.8651ms)
+✔ a new bundle needs a budget, and a budget needs a bundle (0.501ms)
+✔ rows report the change from the baseline (0.4314ms)
+✔ a budget leaves 2% of room, rounded up to 100 bytes (0.1652ms)
+✔ every package entry has a source file (9.0778ms)
+✔ the baseline records the three.js version and its scene sizes (0.1873ms)
+✔ the initial total follows static imports into shared chunks and skips lazy modules (916.6768ms)
+✔ core and the scenes get a small fixed allowance, other entries a percentage (1.7909ms)
+✔ a pull request that grows core past the allowance fails with the accept instruction (0.5343ms)
+✔ growth inside the allowance, a shrink and a new bundle all pass (1.5821ms)
+✔ a size note accepts only the bundles it names (0.5542ms)
+✔ the archive gets 2% of the base archive, and a note accepts more (0.3069ms)
+✔ two pull requests that each grow the archive within the allowance both pass against their own base (0.1483ms)
+✔ the release ceiling is a report that names the number a release refreshes (0.355ms)
+✔ two pull requests that grow different entries merge in sequence without touching each other (15781.2999ms)
+✔ the base measurement of the bundles prints one JSON document and no archive size (29956.6038ms)
+✔ a pull request behind the base branch is compared with the base it was merged into, not the newest tip (3110.8428ms)
+✔ a goal scene that crosses its goal fails, unless a goal line accepts it (0.425ms)
+✔ a bundle note for the scene does not accept crossing its goal (0.1442ms)
+✔ a goal scene over its goal on the base may shrink or stay, and one under its goal may grow inside it (0.2244ms)
+✔ a goal scene over its goal on the base fails when it grows, unless a goal line accepts it (0.1736ms)
+✔ a real exported file loads even though some weights are one unit of rounding above 1 (100.9568ms)
+✔ a GLB clip through createAssetPose matches the decoder playing it, on rigid parts and skins (109.3222ms)
+✔ rigid parts follow the pose, and seeking back gives the same matrices (68.6555ms)
+✔ a mask limits a clip to one arm of a walking character (104.7365ms)
+✔ arm IK reaches a world point through the armature scale and rotation (54.7029ms)
+✔ worldForward aims by the way the character faces, whatever the bone axes are (58.2304ms)
+✔ a foot that is not a child of the lower leg gets a clear error (21.8846ms)
+✔ clip conversion keeps node tracks and skips morph weights (126.2916ms)
+✔ euler conversion round trips in Blender XYZ order (1.3595ms)
+✔ a joint limit clamps the solved pose and the change is reported (6.6466ms)
+✔ limits that the pose already respects change nothing (12.4327ms)
+✔ limits are checked when the pose is built (9.316ms)
+✔ a wrong pole bends the knee backward and warns; the right pole stays quiet (2.3ms)
+✔ a limb that rests bent warns when it is solved the other way, without bendToward (1.163ms)
+✔ a limb stretched to its reach warns about hyperextension (2.2913ms)
+✔ seeking gives the same limited pose as playing to that time (4.191ms)
+✔ with no layers the pose is the rest pose (5.9684ms)
+✔ one full-weight layer matches the existing skin clip player (14.6967ms)
+✔ a mask limits a layer to a joint and its descendants, minus exclusions (2.6427ms)
+✔ a masked layer overrides only its joints on top of a base layer (1.0255ms)
+✔ layer weight blends, and can be a function of time (37.7384ms)
+✔ an additive layer adds its change from the reference onto the pose below (6.4428ms)
+✔ additive translation adds the offset from the reference (0.7031ms)
+✔ seeking gives the same pose as playing forward (4.3292ms)
+✔ two-bone IK reaches a target, keeps bone lengths and keeps the foot rotation (2.9811ms)
+✔ two-bone IK bends toward the pole on either side (0.9448ms)
+✔ two-bone IK reports an unreachable target and reaches toward it (0.5127ms)
+✔ a target function can plant a foot from the animated position (0.651ms)
+✔ IK weight fades the solve in, and zero leaves the pose alone (1.3284ms)
+✔ aim IK points the forward axis at the target (0.4227ms)
+✔ aim IK respects maxAngle and shares the turn along a chain (1.0414ms)
+✔ solvers run in order on the pose the previous one left (0.6673ms)
+✔ joints resolve by name or humanoid bone, and mistakes say what to pass (2.4114ms)
+✔ on a skin with real bind matrices, rest is the identity palette and IK moves a bound vertex to the target (4.2141ms)
+✔ skill reference look has scene_apply examples to check (1.0937ms)
+✔ skill reference look, example 1 applies to a fresh scene (220.0706ms)
+✔ skill reference look, example 2 applies to a fresh scene (11.826ms)
+✔ skill reference look, example 3 applies to a fresh scene (15.5886ms)
+✔ skill reference look, example 4 applies to a fresh scene (11.2472ms)
+✔ skill reference look, example 5 applies to a fresh scene (46.3208ms)
+✔ skill reference look, example 6 applies to a fresh scene (6.3578ms)
+✔ skill reference light has scene_apply examples to check (1.2149ms)
+✔ skill reference light, example 1 applies to a fresh scene (37.9039ms)
+✔ skill reference light, example 2 applies to a fresh scene (8.5268ms)
+✔ skill reference light, example 3 applies to a fresh scene (2053.2242ms)
+✔ skill reference light, example 4 applies to a fresh scene (2008.0715ms)
+✔ skill reference light, example 5 applies to a fresh scene (65.7355ms)
+✔ skill reference camera has scene_apply examples to check (0.5406ms)
+✔ skill reference camera, example 1 applies to a fresh scene (46.3487ms)
+✔ skill reference camera, example 2 applies to a fresh scene (5.568ms)
+✔ skill reference camera, example 3 applies to a fresh scene (7.5625ms)
+✔ skill reference film-and-animation has scene_apply examples to check (0.2795ms)
+✔ skill reference film-and-animation, example 1 applies to a fresh scene (29.6131ms)
+✔ skill reference film-and-animation, example 2 applies to a fresh scene (25.2817ms)
+✔ skill reference film-and-animation, example 3 applies to a fresh scene (11.9557ms)
+✔ the skill reference has mesh recipes to check (1.7371ms)
+✔ skill recipe "crate" builds a clean mesh (213.1608ms)
+✔ skill recipe "mailbox" builds a clean mesh (99.0959ms)
+✔ skill recipe "pillar" builds a clean mesh (59.9097ms)
+✔ skill recipe "drum" builds a clean mesh (177.9396ms)
+✔ skill recipe "bracket" builds a clean mesh (346.2118ms)
+✔ skill recipe "bench" builds a clean mesh (61.0154ms)
+✔ skill recipe "barrel" builds a clean mesh (370.0335ms)
+✔ skill recipe "planter" builds a clean mesh (5.6739ms)
+✔ skill recipe "soap" builds a clean mesh (55.8667ms)
+✔ skill recipe "pebble" builds a clean mesh (254.9853ms)
+✔ skill recipe "button" builds a clean mesh (557.9321ms)
+✔ skill recipe "boulder" builds a clean mesh (256.0735ms)
+✔ skill recipe "twisted-column" builds a clean mesh (4.6677ms)
+✔ skill recipe "boulder" builds a clean mesh (208.764ms)
+✔ skill recipe "tower" builds a clean mesh (57.5279ms)
+✔ skill recipe "halved-crate" builds a clean mesh (12.7232ms)
+✔ skill recipe "badge" builds a clean mesh (397.7555ms)
+✔ mesh-local palette produces the same bent position as Three.js with inverse binds and mesh transforms (26.2021ms)
+✔ pose update retains buffers and rejects invalid input atomically (3.3857ms)
+✔ influences normalize explicitly without modifying inputs and guard malformed skin data (1.0003ms)
+✔ singular weighted transforms and texture capacity limits fail explicitly (0.4289ms)
+✔ Float64 influences that round to a singular GPU blend are rejected (0.3518ms)
+✔ near-affine singular mesh input cannot reuse a stale inverse or mutate the palette (0.311ms)
+✔ matrix preflight rejects singular Float32 rounding for every pose input atomically (0.4376ms)
+✔ failed matrix inversion leaves the retained palette unchanged (0.4708ms)
+✔ pose calculations use Float32 mesh and bind matrices before inversion and multiplication (0.4171ms)
+✔ validateSkinPose checks each distinct influence set once and still finds a singular one (0.5283ms)
+✔ skinInfluenceSets rebuilds when the index array is replaced (0.3266ms)
+✔ a mirrored weighted vertex draws pinched and is reported instead of failing the pose (issue #581) (0.6982ms)
+✔ a palette of many joints equals the four-matrix Float32 product with and without identity bind and mesh matrices (issue #572) (1.3913ms)
+✔ flat terrain sees the whole sky (5.3387ms)
+✔ a bowl hides part of the sky on its floor and none on its rim (161.362ms)
+✔ terrain sky visibility is the same on every build (40.9814ms)
+✔ crown vertices inside the leaves see less sky than the outermost ones, at every level (222.1967ms)
+✔ bark and other parts carry no sky visibility (40.1476ms)
+✔ specular anti-aliasing is on by default and a lighting update sets or clears it (1.2968ms)
+✔ specular anti-aliasing outside zero to the maximum is refused (0.6252ms)
+✔ a look keeps specularAntiAliasing only when it is set, and bounds it (23.2479ms)
+✔ accepts one to four layers and rejects everything else (37.0008ms)
+✔ a weight texture needs bounds and a linear descriptor (0.7978ms)
+✔ packs per-layer rules for the shader (2.9664ms)
+✔ variation and edge noise default on, can be switched off and are bounded (1.5793ms)
+✔ the splat shader drifts colour at several scales and jitters rule edges (84.7638ms)
+✔ resizes layers to a common size and counts the texture bytes (2.4174ms)
+✔ missing channels fall back to neutral texels (0.4697ms)
+✔ parts batch together only with the same layers and splat rules (2.1353ms)
+✔ procedural material tags reject layers (0.4464ms)
+✔ decodes Spume frames back to metres within one int16 step (3.1123ms)
+✔ rejects frames that are not Spume binary glTF (0.544ms)
+✔ float16 decoding covers normal, subnormal and signed values (0.4636ms)
+✔ loads a cache through a read function and plays frames by time (3.0964ms)
+✔ whitewater becomes octahedra filtered by kind and capped evenly (0.9363ms)
+✔ the studio floor stays at 0.019 under a scene a metre or more tall, or a large scene that dips below y 0 (13.1275ms)
+✔ the studio floor drops under small objects and scenes below y 0 instead of burying them (issue #468) (40.0029ms)
+✔ the subsurface block is checked against bounded ranges and names the field that is wrong (1.9934ms)
+✔ a recipe material takes the subsurface block and rejects values out of range (112.7222ms)
+✔ a material without subsurface keeps its batching state and its shader exactly (1.2572ms)
+✔ the subsurface code loads on demand: the recipe marker finds it, and a renderer without it says which import to add (776.6877ms)
+✔ a sun-lit closed room gets point lights at its sunlit patches, above the floor (944.2962ms)
+✔ a room lit through a window gets lights that grow with sunBounce, though a garden lies outside it (1604.9285ms)
+✔ environment.sunBounce scales the lights, and 0 returns the environment unchanged (374.7495ms)
+✔ the lights fit in the point light limit beside the scene lamps (582.6745ms)
+✔ open ground and a room with no sun get no lights (53.973ms)
+✔ environment.sunBounce that is not a number of 0 or more is refused (52.7395ms)
+✔ literal static binding is retained, rigid and compatible with original mesh-query hits (18.5503ms)
+✔ world affine transforms give rigid axes, geometric reflected winding, and constant world clearance (0.9427ms)
+✔ relative morph runs before normalized four-influence skin and mesh world transformation (2.0382ms)
+✔ homogeneous normalized Float32 weights follow the post-divide geometric triangle (2.0193ms)
+✔ different influences at each selected vertex change the geometric frame rather than a shared rigid skin pose (0.5675ms)
+✔ arbitrary pose order returns the same matrices and makes no per-update matrix allocation (5.8542ms)
+✔ static channel contents use immutable-upload snapshots while replacements require rebinding (4.6661ms)
+✔ option snapshots and restored target identities recover without changing the retained output (2.8486ms)
+✔ invalid mutable poses and triangle collapse fail atomically and permit later recovery (1.1098ms)
+✔ updates validate only referenced palette entries and selected vertices (0.8984ms)
+✔ binding rejects malformed coordinates, work budgets, unsupported tags and deformation contracts (3.2605ms)
+✔ world clearance must remain outward and nonzero after Float32 rounding (0.5178ms)
+✔ a very narrow angle includes a perfectly aligned face (7.5459ms)
+✔ surface patch conforms to actual curved triangles, projects bounded UVs and adds local normal clearance (92.995ms)
+✔ projector rotation maps plane coordinates to UVs and filters reversed target faces (2.2682ms)
+✔ thick projector on a closed mesh only emits the outward-facing side and maxAngle narrows the patch (31.3222ms)
+✔ local patch shares affine target transforms across arbitrary backward and forward animation seeks (8.0374ms)
+✔ surface creation leaves offset source arrays and projector inputs untouched, including the sphere seam (6.2793ms)
+✔ surface geometry and options reject malformed data, unsupported deformation and unsafe clearance (44.31ms)
+✔ surface reservations reject before clipping while bounded local projection accepts a full detailed sphere (39.2878ms)
+✔ surface budget and invalid-input failures precede source and DecalGeometry buffer construction (3.0931ms)
+✔ clearance rejects smooth-normal movement that rounds entirely tangent to a high-coordinate face (0.5731ms)
+✔ large smooth-normal clearance cannot publish a reversed or collapsed patch triangle (0.5449ms)
+✔ seeded terrain is byte-identical while holes are absent, undefined or empty (196.8453ms)
+✔ a hole leaves no surface inside it, keeps the rest and reports isHole (80.4943ms)
+✔ a hole covering the whole ground gives empty geometry instead of throwing (1.546ms)
+✔ hostile hole lists are rejected with a clear error (0.843ms)
+✔ a recipe terrain has hills, a hole and a stable seed (141.7848ms)
+✔ recipe terrain rejects out-of-range, hostile and unknown fields before building (6.1251ms)
+✔ the capabilities list the terrain geometry and its limits (0.4136ms)
+✔ the same seed gives the same terrain and another seed differs (201.3592ms)
+✔ mirrorLevels gives every chunk coarser mirrorOnly meshes with growing errors, and none without the option (505.6139ms)
+✔ a mirror mesh keeps every finest-grid vertex on the chunk edge, so it meets its neighbours without a crack (577.9921ms)
+✔ heightAt returns the vertex height at mesh vertices of the finest level (220.9898ms)
+✔ heightAt matches the interpolated triangles of the finest mesh (6.1126ms)
+✔ triangles face up and normals are unit length and smooth (75.9296ms)
+✔ chunk edges stay watertight between different levels of detail (45.0617ms)
+✔ update reports only chunks that changed and keeps triangle budgets per level (22.3333ms)
+✔ heightmap arrays and functions drive the surface, and bad options throw (4.1881ms)
+✔ loads every channel with the right color spaces (5.0256ms)
+✔ skips channels that do not exist unless they were requested by name (0.9547ms)
+✔ rejects unknown channels, empty lists and sets with nothing (0.4782ms)
+✔ a color space override applies to its channel (0.2915ms)
+✔ leaf textures load color, normal and crown per species, clamped at the card edges (1.0219ms)
+✔ region validation names the problem (2.8248ms)
+✔ region rows follow the flipY of the first upload (0.9049ms)
+✔ a region upload binds, sets unpack state, restores it and regenerates mipmaps (0.9132ms)
+✔ a texture without mipmaps is not regenerated (0.3303ms)
+✔ a whole image upload takes update.image or the descriptor image again (0.6199ms)
+✔ unusable updates fail with a clear message and leave the unpack state alone (0.4717ms)
+✔ compressed textures reject updates (0.1994ms)
+✔ costs are named tool:<name>, tool-total and result:<name> (1.9178ms)
+✔ a tool gets 64 bytes, a result and the total 128 (0.2194ms)
+✔ a tool that grows past the allowance fails with the move advice and the accept instruction (0.3745ms)
+✔ growth inside the allowance, a shrink and a new cost pass (0.2039ms)
+✔ a note accepts only the costs it names (0.2574ms)
+✔ release ceilings are listed as problems, and a release resets them (0.4175ms)
+✔ absolute ceilings fail the total, a large tool, any other tool and the default capabilities answer (0.3252ms)
+✔ two pull requests that grow different tools merge in sequence and neither touches the shared budget file (15964.372ms)
+67js preview resources closed.
+67js preview resources closed.
+✔ every typical result has a release ceiling, and the budget file holds no history string (0.9447ms)
+✔ the release ceilings come back as a list of problems (0.3231ms)
+✔ a small mesh change as a mesh_edit call is smaller than rewriting the recipe (0.1337ms)
+✔ error for unknown geometry type names what failed and what to do next (100.2761ms)
+✔ error for unknown geometry field names what failed and what to do next (1.7167ms)
+✔ error for node refers to a missing geometry names what failed and what to do next (0.409ms)
+✔ error for node refers to a missing material names what failed and what to do next (0.2618ms)
+✔ error for node with a material and no geometry names what failed and what to do next (0.2474ms)
+✔ error for node parent that does not exist names what failed and what to do next (0.4292ms)
+✔ error for duplicate node id names what failed and what to do next (0.2854ms)
+✔ error for opacity above one names what failed and what to do next (0.3148ms)
+✔ error for unknown alpha mode names what failed and what to do next (41.2437ms)
+✔ error for pattern with one colour names what failed and what to do next (0.6945ms)
+✔ error for transmission on an unlit material names what failed and what to do next (0.295ms)
+✔ error for mesh edit with an unknown op names what failed and what to do next (0.2191ms)
+✔ error for mesh edit that selects nothing names what failed and what to do next (0.2435ms)
+✔ error for mesh edit on a primitive geometry names what failed and what to do next (0.174ms)
+✔ error for mesh edit on a missing geometry names what failed and what to do next (0.1487ms)
+✔ error for stale revision names what failed and what to do next (0.1473ms)
+✔ error for unknown operation type names what failed and what to do next (0.1198ms)
+✔ error for set-node on a missing node names what failed and what to do next (0.7241ms)
+✔ error for set-node with an unknown field names what failed and what to do next (0.207ms)
+✔ error for remove a geometry that a node uses names what failed and what to do next (0.1638ms)
+✔ error for remove a node that has children names what failed and what to do next (0.1577ms)
+✔ error for inspect a missing node names what failed and what to do next (0.1827ms)
+✔ error for inspect with an unknown option names what failed and what to do next (1.6286ms)
+✔ error for mesh inspect of a missing geometry names what failed and what to do next (0.2781ms)
+✔ error for rotation that is not a unit quaternion names what failed and what to do next (36.5688ms)
+✔ error for scale that is not positive names what failed and what to do next (0.3929ms)
+✔ error for motion with an unknown field names what failed and what to do next (0.2132ms)
+✔ a session error names the active session or says how to create one (0.1844ms)
+✔ page errors lose the evaluate prefix and the bundle stack (0.2452ms)
+✔ engine fault "Cannot read properties of undefined (rea" reaches an agent as advice with a next action (0.2486ms)
+✔ engine fault "page.evaluate: TypeError: scene.inspect " reaches an agent as advice with a next action (1.1162ms)
+✔ engine fault "undefined is not iterable (cannot read p" reaches an agent as advice with a next action (0.4811ms)
+✔ engine fault "sessionProblem is not defined" reaches an agent as advice with a next action (0.0669ms)
+✔ engine fault "Cannot destructure property 'id' of 'und" reaches an agent as advice with a next action (0.0791ms)
+✔ the validation errors we write ourselves are not mistaken for engine faults (0.1601ms)
+✔ every level of a broadleaf sees about as much sky as level 0, weighted by the leaf it stands for (181.0729ms)
+✔ every level of a birch sees about as much sky as level 0, weighted by the leaf it stands for (191.7494ms)
+✔ every level of a conifer sees about as much sky as level 0, weighted by the leaf it stands for (150.9497ms)
+✔ every level of a palm sees about as much sky as level 0, weighted by the leaf it stands for (80.2678ms)
+✔ every level of a bush sees about as much sky as level 0, weighted by the leaf it stands for (169.4912ms)
+✔ the level match weights each vertex by its share of the leaf area (0.345ms)
+✔ a tree whose far level carries more leaf area than its species usually does gets a larger colour gain (148.3179ms)
+✔ the standing clump cards of a far level face every way, so the crown is as bright from every side (197.6419ms)
+✔ level 0 keeps the sky visibility it measures from its own leaves (56.8746ms)
+✔ the fitted gains only touch levels 1 to 3 and stay in a sane range (0.7332ms)
+✔ ear clipping covers star contours with several holes exactly once (26.6309ms)
+✔ ear clipping accepts clockwise contours and counter-clockwise holes (0.7746ms)
+✔ updatePartVertices rewrites the drawn buffers without a new batch or geometry (3.5096ms)
+✔ updatePartVertices leaves normals alone when none are given (0.3492ms)
+✔ updatePartVertices refuses a changed vertex count, an unknown part and a skinned part (0.632ms)
+✔ the snapshot lists cover every material map and layer field the batch compares (0.9317ms)
+✔ a snapshot matches only a material whose compared fields are unchanged (0.9427ms)
+✔ matrix, colour, emission and roughness changes update through the fast path (3.1368ms)
+✔ rejections still throw after the fast path has been taken (2.7945ms)
+✔ geometry changes and bad numbers still throw after the fast path has been taken (0.5633ms)
+✔ bark u spans each ring by its own circumference, so texel density matches from trunk to twig (2.7192ms)
+✔ bark v advances at the same texel density as u, so texels stay square and do not stretch (0.642ms)
+✔ bark v is constant around a ring and never decreases along the tube (0.3735ms)
+✔ the bark seam of a thin horizontal branch sits on its underside (0.3121ms)
+✔ procedural bark keeps its whole-number repeats and 0.6 m tile by default (265.3271ms)
+✔ scanned bark textures reach the bark material as map, normalMap and metallicRoughnessMap (230.7272ms)
+✔ barkTextures accepts one set or one set per species and rejects malformed sets (36.8971ms)
+✔ scatterVegetation passes per-species bark textures to its variants (359.5301ms)
+✔ textured bark is deterministic for the same seed (75.0427ms)
+✔ leaf cards are single-sided: one copy of each face, half the old triangles (14.4477ms)
+✔ cards use the swaying foliage tag with a base map, alpha mask and double-sided drawing (40.9527ms)
+✔ colour and shadow vertex shaders apply the same wind displacement (0.3174ms)
+✔ scanned leaf cards reach the foliage and crown materials with the normal map (69.115ms)
+✔ leafTextures resolves per species, ignores mesh leaves and rejects malformed sets (648.2178ms)
+✔ the renderer accepts a normal map on foliage and grass but not on other procedural tags (11.0004ms)
+trees 5223, triangles plain 2684078, cards from level 3 524870, from level 2 358790
+✔ every atlas cell is picked from the direction it was baked from (2.6559ms)
+✔ the card basis is orthonormal and falls back straight above the tree (0.5653ms)
+✔ an atlas bake covers the tree, repeats exactly and keeps unit normals (589.7959ms)
+✔ the impostor card holds the tree and carries the impostor tag (396.5978ms)
+✔ a distance gives the same blend whatever came before, with eighths between two levels (0.7732ms)
+✔ a fade draws both levels with complementary coverage and repeats for a camera (762.7457ms)
+✔ selectLevels keeps its hysteresis path unless fade or impostors are asked for (388.9967ms)
+✔ impostors replace the last level only beyond its fade band (2400.7322ms)
+✔ a 5,000 tree forest draws far fewer triangles with impostors (1481.2413ms)
+✔ the impostor code is added to the three shaders it hooks into and to nothing else (1.7038ms)
+✔ a pixel error moves the switch distances with the view and the tree size (1273.9135ms)
+{"withFade":0.06804259713144517,"hardSwitch":0.24484109477124183}
+✔ a slow dolly across the impostor boundary shows no pop in a frame difference (39729.2779ms)
+✔ trees are deterministic by seed and differ between seeds (398.4027ms)
+✔ every species and leaf mode yields valid geometry on all levels (2264.957ms)
+✔ bark faces outward and leaf cards carry the alpha-mask material contract (48.1782ms)
+✔ invalid inputs are rejected (0.9546ms)
+✔ triangle budgets fall with each level of detail (694.1848ms)
+✔ foliage carries thinner shadow layers, and the far conifer level costs under half the level before it (84.1624ms)
+✔ wind sway comes from leaves on the foliage tag while bark stays static (280.1583ms)
+✔ grass and flowers produce valid geometry (10.0189ms)
+✔ textures have alpha leaves and opaque bark (46.2789ms)
+✔ scatter keeps spacing, honors exclusion and slope, and is deterministic (900.9124ms)
+✔ scattered instances share geometry per variant and a species mix is respected (218.9229ms)
+✔ level selection follows distance with hysteresis and culling (41.5749ms)
+✔ selectLevels reports changes and triangle totals, and parts keep geometry identity (219.1465ms)
+✔ grass fields scatter clumps and flowers (66.8272ms)
+✔ full lock turns the inner front wheel by the Ackermann angle for the measured wheelbase and track (35.6816ms)
+✔ a reverse leg backs the car along its path with the heading kept and the wheels spinning backwards (10.7306ms)
+✔ a reversing car steers the opposite way for the same path curvature (4.2014ms)
+✔ wheel spin times radius equals the distance driven, forwards and backwards (3.8496ms)
+✔ the brake signal is on exactly while the car slows down (41.4499ms)
+✔ headlights follow the body position and heading (5.9204ms)
+✔ tail-light emission follows the brake and reverse signals and can be applied to parts (4.0323ms)
+✔ legs and lights sample the same pose whatever order they are read in (7.3423ms)
+✔ bad steering, light and leg input produces specific errors (3.7133ms)
+✔ wheel spin equals distance over radius and rolls the top of the tire forward (68.2013ms)
+✔ spinSign flips a wheel whose model axis is mirrored (6.3038ms)
+✔ inner wheels turn slower than outer wheels in a corner (4.367ms)
+✔ steering turns the front wheels toward the turn and leaves the rear straight (6.3048ms)
+✔ front wheel matrices yaw toward the turn relative to the body (2.5027ms)
+✔ body leans outward in a turn and stays level on a straight path (58.2684ms)
+✔ braking pitches the nose down and accelerating pitches it up (8.5881ms)
+✔ a lateral acceleration limit slows the vehicle in corners (5.3161ms)
+✔ sampling is deterministic regardless of order (4.547ms)
+✔ wheels stay on uneven ground (4.0835ms)
+✔ name detection finds wheels, groups corners and rejects look-alikes (0.7101ms)
+✔ automatic rigs group tire, hub and bolts per corner and ignore the steering wheel (2.4224ms)
+✔ forwardAxis lets a vehicle modelled along +x drive forward (1.7426ms)
+✔ a camera path object can serve as the drive path (29.6813ms)
+✔ scene-graph nodes receive the same world poses as parts (6.1524ms)
+✔ imported glTF nodes get local overrides that reproduce the world pose (3.9854ms)
+✔ bad input produces specific errors (11.3341ms)
+✔ VERSION matches the version in package.json (5.1693ms)
+✔ agx matches Blender 5.2.2 LTS on the colour ramp within 0.026 (31.4502ms)
+✔ neutral matches Blender 5.2.2 LTS on the colour ramp within 0.01 (0.4137ms)
+✔ agx maps 0.18 mid grey to what Blender does (0.4546ms)
+✔ the ramp covers greys from black to 16 and saturated colours (0.6882ms)
+✔ the rasterizer shaders and the path tracer apply the same default curve (0.6826ms)
+✔ the GLSL of agx and neutral prints the constants the path tracer uses (1.3309ms)
+✔ the display curve is replaced in all four programs, and the look only in the post pass (0.7857ms)
+✔ neutral leaves base colours below the compression start as authored, minus the 0.04 shadow offset (0.1942ms)
+✔ recipes take a view transform and a named look, and refuse anything else (3.3803ms)
+✔ a .cube look parses, samples as the identity, and reaches the path tracer image (2.8414ms)
+✔ cube text is bounded and 1D looks are refused (0.3141ms)
+✔ every named look is a 17-point cube that changes a mid grey (11.0648ms)
+✔ bounded volume controls default disabled and preserve ordinary input data (2.1279ms)
+✔ volume preflight rejects malformed controls and Float32 collapsed bounds (2.9779ms)
+✔ volume shadow ambient stays unset until the renderer derives it, and accepts the full range (0.3355ms)
+✔ an unset volume shadow ambient follows how open the sky is above the fog (1.1908ms)
+✔ height falloff in metres keeps its metres, and a flat volume keeps zero (0.2357ms)
+✔ preview preserves the assembled model, all instance identities and assembly data (317.7518ms)
+✔ absolute sampling and gaze are deterministic and reject invalid input (48.0479ms)
+✔ both caterpillars circulate with coherent shoe/pad pairs and stationary ground contact (19.5838ms)
+✔ wheel bolts orbit their own sprockets and retain their radius and x coordinate (104.6851ms)
+✔ forward travel never reverses or resets and articulation stays continuous at period boundaries (476.4829ms)
+✔ head, neck, arm and finger joints move attached groups and repeat relative to forward root (86.6486ms)
+✔ pointer gaze changes the attached head without changing the drive or arms (113.0354ms)
+✔ a large flat smooth box qualifies and its top is the plane (3.3148ms)
+✔ a scene with no such surface gets no surface and keeps its parts (0.5387ms)
+✔ a surface that is small, tall, rough, liquid or transmissive does not qualify (0.4364ms)
+✔ smooth metal qualifies the same way as water (0.3299ms)
+✔ a ball is not flat (1.2036ms)
+✔ marked parts keep reading the live material and carry the flag (0.4529ms)
+✔ attaching to nothing changes nothing (0.2684ms)
+✔ the shader of a scene without the feature is the shader it was (0.582ms)
+✔ the mirror image is drawn at three quarters of the canvas in each direction (0.9963ms)
+✔ a mirrorOnly level is hidden from every draw but the mirror, and detaching puts the renderer back (0.7611ms)
+✔ a render pass frame skips the mirror image and the next lit frame draws it again (0.4024ms)
+✔ the mirror draw leaves out spot and area lights and the lit frame sends them again (27.4851ms)
+✔ the mirror image is kept while the frame holds the same values, even when its arrays are changed in place (0.8038ms)
+✔ a part update, a lower camera and a changed canvas size each draw the mirror image again (0.4635ms)
+✔ updateEvery 2 keeps the picture for one lit frame after each draw, and detaching puts updateParts back (0.3234ms)
+✔ rougher water keeps the mirror pass and blurs it instead of dropping it (0.9366ms)
+✔ the mirror level is 0 up to roughness 0.1 and rises continuously to the limit (0.2916ms)
+✔ the mirror weight is 1 until the fade starts and 0 at the limit (0.1883ms)
+✔ the shader samples a mip level taken from roughness (0.4402ms)
+✔ canReuseMirrorImage needs a drawn picture, the same frame and parts, or an updateEvery window that is still open (0.2225ms)
+✔ canReuseMirrorImage compares small typed arrays by value and a large one, a sky payload, by identity (0.3063ms)
+✔ only the mirror draw carries the mirror culling: parts under the plane, coarser levels and small far parts (0.8373ms)
+✔ a terrain with no mirrorLevels builds no coarse mirror meshes until the scene gets water (105.2895ms)
+✔ a scene with no water surface leaves the terrain without coarse mirror meshes (153.5215ms)
+✔ an explicit mirrorLevels wins over the lazy default, 0 included (384.2821ms)
+✔ the lazy levels follow later terrain updates and are built once, and a resolution that allows fewer halvings takes fewer (81.0658ms)
+✔ worldBounds equals the per-axis formula it replaced, under a rotated and moved matrix (2.575ms)
+﹣ bed shadow contrast follows the eye and refracted sun legs within 10% (or 0.05) for clear water, never goes negative, and the surface shadow stays faint (0.8579ms) # SKIP
+✔ the capabilities list the same water presets as the shader addon (3.7786ms)
+✔ water fields resolve as explicit value, then preset, then the default lake (1.5363ms)
+✔ the largest flat water part sets the level and optics; a ribbon that is not flat sets none (0.6917ms)
+✔ a recipe water material carries resolved optics and other tags refuse them (22.1595ms)
+✔ the shader keeps the sun shadow off the reflection and applies the column only below the level (0.719ms)
+✔ the refraction blur averages only the taps that saw the bed, so the bed edge does not fade into a haze (1.2855ms)
+✔ the sun leg is absorbed over the refracted path and the murky scatter only adds light to the lit side (0.3531ms)
+✔ nature.js alone loads the shader code its world parts need (1938.3189ms)
+✔ terrain.js alone loads the shader code its world parts need (479.1065ms)
+✔ grass.js alone loads the shader code its world parts need (839.2345ms)
+✔ vegetation.js alone loads the shader code its world parts need (1402.3733ms)
+ℹ tests 2556
+ℹ suites 0
+ℹ pass 2549
+ℹ fail 2
+ℹ cancelled 0
+ℹ skipped 5
+ℹ todo 0
+ℹ duration_ms 193211.2734
+
+✖ failing tests:
+
+test at tests\agent-branches-live.test.js:13:1
+✖ live MCP branches do not consume revisions or change the scene being edited (82935.6063ms)
+ AssertionError [ERR_ASSERTION]:
+ file:///C:/Users/nxan2/Documents/67js/.claude/worktrees/wf_89db4c2b-abd-2/node_modules/@modelcontextprotocol/client/dist/src-CeKsbNLO.mjs:6254
+ const timeoutHandler = () => cancel(new SdkError(SdkErrorCode.RequestTimeout, "Request timed out", { timeout }));
+ ^
+
+ SdkError: Request timed out
+ at Timeout.timeoutHandler (file:///C:/Users/nxan2/Documents/67js/.claude/worktrees/wf_89db4c2b-abd-2/node_modules/@modelcontextprotocol/client/dist/src-CeKsbNLO.mjs:6254:40)
+ at listOnTimeout (node:internal/timers:635:17)
+ at process.processTimers (node:internal/timers:571:7) {
+ code: 'REQUEST_TIMEOUT',
+ data: { timeout: 60000 }
+ }
+
+ Node.js v24.19.0
+
+
+ 1 !== 0
+
+ at TestContext.<anonymous> (file:///C:/Users/nxan2/Documents/67js/.claude/worktrees/wf_89db4c2b-abd-2/tests/agent-branches-live.test.js:18:10)
+ at Test.runInAsyncScope (node:async_hooks:227:14)
+ at Test.run (node:internal/test_runner/test:1382:25)
+ at Test.start (node:internal/test_runner/test:1242:17)
+ at startSubtestAfterBootstrap (node:internal/test_runner/harness:387:17) {
+ generatedMessage: false,
+ code: 'ERR_ASSERTION',
+ actual: 1,
+ expected: 0,
+ operator: 'strictEqual',
+ diff: 'simple'
+ }
+
+test at tests\agent-scene.test.js:304:1
+✖ command and resource budgets, bounded inspection and missing IDs report failures (4.6314ms)
+ AssertionError [ERR_ASSERTION]: The input did not match the regular expression /operations: got \[\]; expected a list of 1 to 1 operations/. Input:
+
+ 'RangeError: operations: got "0 operations"; expected a list of 1 to 1 operations, such as [{ "type": "set-camera", "fov": 50 }].'
+
+ at TestContext.<anonymous> (file:///C:/Users/nxan2/Documents/67js/.claude/worktrees/wf_89db4c2b-abd-2/tests/agent-scene.test.js:314:10)
+ at Test.runInAsyncScope (node:async_hooks:227:14)
+ at Test.run (node:internal/test_runner/test:1382:25)
+ at Test.processPendingSubtests (node:internal/test_runner/test:960:18)
+ at Test.postRun (node:internal/test_runner/test:1522:19)
+ at Test.run (node:internal/test_runner/test:1447:12)
+ at async Test.processPendingSubtests (node:internal/test_runner/test:960:7) {
+ generatedMessage: true,
+ code: 'ERR_ASSERTION',
+ actual: RangeError: operations: got "0 operations"; expected a list of 1 to 1 operations, such as [{ "type": "set-camera", "fov": 50 }].
+ at invalidField (file:///C:/Users/nxan2/Documents/67js/.claude/worktrees/wf_89db4c2b-abd-2/src/field-error.js:25:17)
+ at Object.apply (file:///C:/Users/nxan2/Documents/67js/.claude/worktrees/wf_89db4c2b-abd-2/src/agent-scene.js:1600:15)
+ at file:///C:/Users/nxan2/Documents/67js/.claude/worktrees/wf_89db4c2b-abd-2/tests/agent-scene.test.js:314:31
+ at getActual (node:assert:611:5)
+ at strict.throws (node:assert:759:24)
+ at TestContext.<anonymous> (file:///C:/Users/nxan2/Documents/67js/.claude/worktrees/wf_89db4c2b-abd-2/tests/agent-scene.test.js:314:10)
+ at Test.runInAsyncScope (node:async_hooks:227:14)
+ at Test.run (node:internal/test_runner/test:1382:25)
+ at Test.processPendingSubtests (node:internal/test_runner/test:960:18)
+ at Test.postRun (node:internal/test_runner/test:1522:19),
+ expected: /operations: got \[\]; expected a list of 1 to 1 operations/,
+ operator: 'throws',
+ diff: 'simple'
+ }
diff --git a/src/agent-mesh.js b/src/agent-mesh.js
index 274d51bd..b1f46a47 100644
--- a/src/agent-mesh.js
+++ b/src/agent-mesh.js
@@ -1,5 +1,6 @@
import { meshFromGeometry } from './mesh-convert.js';
import { facesWithTag } from './mesh-data.js';
+import { invalidField } from './field-error.js';
import { lintMesh } from './mesh-lint.js';
import { applyMeshEdits, evaluateMeshStack } from './mesh-recipe.js';
import { extractRender } from './mesh-render.js';
@@ -100,7 +101,7 @@ export function generateMeshGeometry(baseGeometry, edits, {
const evaluated = evaluateMeshStack(edited.mesh, stack, { maxVertices, maxFaces: maxVertices, cache: evaluationCache, cacheKey: editsKey });
const { geometry, renderVertexSource } = extractRender(evaluated.mesh, { sharpAngle: smoothAngle * Math.PI / 180 });
if (geometry.positions.length / 3 > maxVertices) {
- throw new RangeError(`The edited mesh needs ${geometry.positions.length / 3} render vertices, over maxVertices ${maxVertices}.`);
+ throw invalidField('edits', geometry.positions.length / 3, `an edited mesh of at most ${maxVertices} render vertices (maxVertices); use fewer subdivisions or segments`);
}
const keys = normalizeShapeKeys(shapeKeys);
if (keys.length) {
@@ -124,7 +125,7 @@ export function registerEditedMesh(geometry, mesh, results) {
export function taggedFacePositions(geometry, tag) {
const polygon = polygonMeshes.get(geometry);
if (!polygon) {
- throw new RangeError('this part is a plain shape with no tagged faces. Use a mesh geometry and tag faces with a mesh_edit tag op, or drop region.');
+ throw invalidField('region', tag, 'a tag on a mesh geometry; tag faces with a mesh_edit tag op, or drop region');
}
const { mesh } = polygon;
const positions = [];
@@ -135,7 +136,7 @@ export function taggedFacePositions(geometry, tag) {
}
}
if (positions.length === 0) {
- throw new RangeError(`tag ${tag} is on no faces. Tag some faces, or use another region.`);
+ throw invalidField('region', tag, 'a tag that is on some faces; tag faces with a mesh_edit tag op, or use another region');
}
return { positions: Float32Array.from(positions) };
}
diff --git a/src/agent-recipe-checks.js b/src/agent-recipe-checks.js
index 59a17758..b643af1d 100644
--- a/src/agent-recipe-checks.js
+++ b/src/agent-recipe-checks.js
@@ -1,33 +1,34 @@
// Checks shared by the recipe sections that bake geometry (cloth, particles, hair).
+import { invalidField } from './field-error.js';
export function knownKeys(value, fields, label) {
if (!value || Object.getPrototypeOf(value) !== Object.prototype) {
- throw new TypeError(`${label} must be a plain object.`);
+ throw invalidField(label, value, 'an object, such as {}', TypeError);
}
for (const key of Object.keys(value)) {
if (!fields.includes(key)) {
- throw new TypeError(`Unknown or unsupported ${label} field: ${key}. Allowed fields: ${fields.join(', ')}.`);
+ throw invalidField(`${label}.${key}`, value[key], `one of the fields ${fields.join(', ')}; remove ${key}`, TypeError);
}
}
}
export function finiteNumber(value, label, minimum, maximum) {
if (typeof value !== 'number' || !Number.isFinite(value) || !Number.isFinite(Math.fround(value)) || value < minimum || value > maximum) {
- throw new RangeError(`${label} must be a finite number within ${minimum} and ${maximum}.`);
+ throw invalidField(label, value, `a finite number from ${minimum} to ${maximum}, such as ${Math.min(Math.max(1, minimum), maximum)}`);
}
return value;
}
export function vectorOfThree(value, label, limit) {
if (!Array.isArray(value) || value.length !== 3) {
- throw new TypeError(`${label} needs 3 numbers.`);
+ throw invalidField(label, value, 'three numbers, such as [0, 1, 0]', TypeError);
}
return value.map(component => finiteNumber(component, label, -limit, limit));
}
export function boundedArray(value, maximum, label) {
if (!Array.isArray(value) || value.length > maximum) {
- throw new TypeError(`${label} must be an array of at most ${maximum} entries.`);
+ throw invalidField(label, value, `an array of at most ${maximum} entries, such as []`, TypeError);
}
return value;
}
@@ -35,19 +36,19 @@ export function boundedArray(value, maximum, label) {
export function rootNodeWithGeometry(nodeId, recipeNodes, claimedNodes, motionNodeIds, physicsNodeIds, label, system = 'cloth') {
const node = typeof nodeId === 'string' ? recipeNodes.get(nodeId) : undefined;
if (!node) {
- throw new RangeError(`${label} node was not found: ${String(nodeId).slice(0, 64)}.`);
+ throw invalidField(`${label} node`, nodeId, 'the ID of a node in nodes, such as one scene_inspect lists');
}
if (node.geometry === undefined) {
- throw new RangeError(`${label} node ${nodeId} has no geometry.`);
+ throw invalidField(`${label} node`, nodeId, 'a node with a geometry; give it geometry and material');
}
if (node.parent !== null) {
- throw new RangeError(`${label} node ${nodeId} must be a root node; reparent it first.`);
+ throw invalidField(`${label} node`, nodeId, 'a root node without a parent; reparent it first');
}
if (claimedNodes.has(nodeId)) {
- throw new RangeError(`Node ${nodeId} is used twice in ${system}.`);
+ throw invalidField(`${label} node`, nodeId, `a node used once in ${system}; pick another node`);
}
if (motionNodeIds.has(nodeId) || physicsNodeIds.has(nodeId)) {
- throw new RangeError(`Node ${nodeId} has a motion translation or rotation track or a physics body. ${label} needs a node that stays where it is.`);
+ throw invalidField(`${label} node`, nodeId, 'a node that stays where it is, with no motion translation or rotation track and no physics body');
}
claimedNodes.add(nodeId);
}
diff --git a/src/agent-scene.js b/src/agent-scene.js
index 0570bdf8..1712fff5 100644
--- a/src/agent-scene.js
+++ b/src/agent-scene.js
@@ -56,11 +56,11 @@ const REMOVAL_FIELDS = Object.freeze({
function knownKeys(value, allowed, label) {
if (!value || typeof value !== 'object' || Array.isArray(value)) {
- throw new TypeError(`${label} must be an object.`);
+ throw invalidField(label, value, 'an object, such as {}', TypeError);
}
for (const key of Object.keys(value)) {
if (!allowed.includes(key)) {
- throw new TypeError(`Unknown ${label} field: ${key}. Allowed fields: ${allowed.join(", ")}.`);
+ throw invalidField(`${label}.${key}`, value[key], `one of the fields ${allowed.join(', ')}; remove ${key}`, TypeError);
}
}
}
@@ -70,7 +70,7 @@ function resolveLimits(input) {
const result = { ...DEFAULT_LIMITS, ...input };
for (const [key, value] of Object.entries(result)) {
if (!Number.isSafeInteger(value) || value <= 0) {
- throw new RangeError(`${key} must be a positive safe integer.`);
+ throw invalidField(`limits.${key}`, value, 'a positive whole number, such as 1024');
}
}
if (result.maxNodes > 4096) {
@@ -186,13 +186,13 @@ function identifier(value, label = 'id') {
function resources(values, maximum, label, validate) {
if (!Array.isArray(values) || values.length > maximum) {
- throw new RangeError(`${label} exceeds its resource limit of ${maximum} or is not an array. Pass "${label}": [] for none, or remove some.`);
+ throw invalidField(label, Array.isArray(values) ? `${values.length} entries` : values, `an array of at most ${maximum} entries, such as []`);
}
const seen = new Set();
return values.map((value, index) => withFieldPrefix(`${label}[${index}]`, () => {
identifier(value?.id);
if (seen.has(value.id)) {
- throw new RangeError(`Duplicate ${label} ID: ${value.id}. IDs must be unique: rename one, or remove the other.`);
+ throw invalidField('id', value.id, `an ID no other ${label} entry uses; rename one, or remove the other`);
}
seen.add(value.id);
return validate(value);
@@ -222,11 +222,11 @@ function materialFrom(value) {
...(graphFactor('clearcoat', 0) && { clearcoat: 1 }), ...(graphFactor('transmission', 0) && { transmission: 1 }),
metallic: defaultValue(value.metallic, graphFactor('metallic', 0)), roughness: defaultValue(value.roughness, graphFactor('roughness', 0.5)), emission: defaultValue(value.emission, graphFactor('emission', 0)) };
if (!AGENT_SCENE_CAPABILITIES.materialTags.includes(result.tag)) {
- throw new RangeError(`Material tag must be one of ${AGENT_SCENE_CAPABILITIES.materialTags.join(', ')}.`);
+ throw invalidField('tag', result.tag, `one of ${AGENT_SCENE_CAPABILITIES.materialTags.join(', ')}`);
}
if (value.map !== undefined) agentSceneModule('assets').applyMapSequence(value, result);
if (value.pattern !== undefined) {
- if (result.tag !== 'surface') throw new RangeError('Material pattern needs the surface tag.');
+ if (result.tag !== 'surface') throw invalidField('pattern', value.pattern?.type, 'a material with the surface tag; remove pattern or set tag to surface');
result.pattern = agentSceneModule('patterns').normalizeMaterialPattern(value.pattern);
}
result.opacity = defaultValue(value.opacity, 1);
@@ -272,10 +272,10 @@ function materialFrom(value) {
for (const component of emissiveColor) {
const radiance = Math.fround(component) * Math.fround(result.emission);
if (!Number.isFinite(Math.fround(radiance))) {
- throw new RangeError('Emissive radiance exceeds Float32 range.');
+ throw invalidField('emission', result.emission, 'an emission that keeps color times emission within Float32 range, such as 2');
}
if (result.tag === 'unlit' && radiance > 65500) {
- throw new RangeError('Unlit emissive radiance exceeds the half-float HDR target range.');
+ throw invalidField('emission', result.emission, 'an unlit emission that keeps color times emission at or below 65500, such as 2');
}
}
return result;
@@ -302,7 +302,7 @@ function nodeFrom(value) {
}
result.rotation = result.rotation.map(component => component / length);
if ((value.geometry !== undefined) !== (value.material !== undefined)) {
- throw new TypeError(`Node ${value.id}: set both geometry and material, or neither for a group node. Name a geometry to draw it, or drop material to make it a group.`);
+ throw invalidField(value.geometry === undefined ? 'geometry' : 'material', value.geometry ?? value.material, `set together with ${value.geometry === undefined ? 'material' : 'geometry'} to draw a mesh, or drop both for a group node`, TypeError);
}
if (value.geometry !== undefined) {
identifier(value.geometry);
@@ -310,25 +310,25 @@ function nodeFrom(value) {
}
if (value.asset !== undefined) {
if (value.geometry !== undefined || value.skin !== undefined) {
- throw new TypeError(`Node ${value.id}: an asset node is a group; drop geometry, material and skin.`);
+ throw invalidField('asset', value.geometry ?? value.skin, 'an asset node without geometry, material and skin; an asset node is a group', TypeError);
}
result.asset = agentSceneModule('assets').normalizeAssetPlacement(value.asset);
}
if (value.vegetation !== undefined) result.vegetation = agentSceneModule('vegetation').normalizeVegetation(value.vegetation, value);
if (value.decal !== undefined && typeof value.decal !== 'boolean') {
- throw new TypeError('decal must be boolean.');
+ throw invalidField('decal', value.decal, 'true or false', TypeError);
}
if (value.depthLayer !== undefined) {
integer(value.depthLayer, 0, MAXIMUM_DEPTH_LAYER, 'depthLayer');
}
for (const flag of RENDER_FLAG_FIELDS) {
- if (value[flag] !== undefined && typeof value[flag] !== 'boolean') throw new TypeError(`${flag} must be boolean.`);
- if (flag !== 'visible' && value[flag] !== undefined && value.geometry === undefined) throw new TypeError(`Node ${value.id}: ${flag} belongs on a mesh node.`);
+ if (value[flag] !== undefined && typeof value[flag] !== 'boolean') throw invalidField(flag, value[flag], 'true or false', TypeError);
+ if (flag !== 'visible' && value[flag] !== undefined && value.geometry === undefined) throw invalidField(flag, value[flag], 'a flag on a mesh node with geometry and material; remove it from group nodes', TypeError);
}
- if (value.holdout === true && value.shadowCatcher === true) throw new TypeError(`Node ${value.id}: a node is a holdout or a shadow catcher, not both.`);
+ if (value.holdout === true && value.shadowCatcher === true) throw invalidField('shadowCatcher', value.shadowCatcher, 'false when holdout is true; a node is a holdout or a shadow catcher, not both', TypeError);
if (value.skin !== undefined) {
if (value.geometry === undefined) {
- throw new TypeError('Only mesh nodes can have a skin.');
+ throw invalidField('skin', value.skin, 'a skin on a mesh node with geometry and material; remove skin from group nodes', TypeError);
}
knownKeys(value.skin, ['armature', 'maxInfluences', 'maxDistance'], 'skin');
identifier(value.skin.armature);
@@ -336,7 +336,7 @@ function nodeFrom(value) {
integer(value.skin.maxInfluences, 1, 4, 'skin maxInfluences');
}
if (value.skin.maxDistance !== undefined && !(Number.isFinite(value.skin.maxDistance) && value.skin.maxDistance > 0)) {
- throw new RangeError('skin maxDistance must be a positive number of metres.');
+ throw invalidField('skin.maxDistance', value.skin.maxDistance, 'a positive number of metres, such as 0.5');
}
}
return result;
@@ -360,7 +360,7 @@ export function applyCameraFields(camera, fields) {
function rejectFovWithFocalLength(fields) {
if (fields.fov !== undefined && fields.focalLength !== undefined) {
- throw new RangeError('Give a camera fov or a focalLength, not both. Use focalLength (with sensorWidth) for a lens in millimetres, fov for degrees.');
+ throw invalidField('camera.focalLength', fields.focalLength, 'only one of fov (degrees) or focalLength (millimetres with sensorWidth), such as fov 45; remove the other');
}
}
@@ -370,12 +370,12 @@ function checkCameraLens(camera) {
}
const orthographic = camera.projection === 'orthographic';
if (camera.orthoScale !== undefined) {
- if (!orthographic) throw new RangeError('Camera orthoScale needs projection orthographic.');
+ if (!orthographic) throw invalidField('camera.orthoScale', camera.orthoScale, 'a field of an orthographic camera; set projection to orthographic, or remove orthoScale');
if (!Number.isFinite(camera.orthoScale) || camera.orthoScale <= 0) throw invalidField('camera.orthoScale', camera.orthoScale, 'a positive view height in metres, such as 10');
}
- if (camera.sensorWidth !== undefined && camera.focalLength === undefined) throw new RangeError('Camera sensorWidth needs focalLength.');
+ if (camera.sensorWidth !== undefined && camera.focalLength === undefined) throw invalidField('camera.sensorWidth', camera.sensorWidth, 'a field used with focalLength, such as focalLength 35; add focalLength or remove sensorWidth');
if (camera.focalLength !== undefined) {
- if (orthographic) throw new RangeError('Camera focalLength needs a perspective projection; an orthographic camera is sized by orthoScale.');
+ if (orthographic) throw invalidField('camera.focalLength', camera.focalLength, 'a field of a perspective camera; an orthographic camera is sized by orthoScale, so remove focalLength');
if (!Number.isFinite(camera.focalLength) || camera.focalLength <= 0 || camera.focalLength > 10000) throw invalidField('camera.focalLength', camera.focalLength, 'a lens length above 0 and up to 10000 millimetres, such as 35');
if (camera.sensorWidth !== undefined && !(Number.isFinite(camera.sensorWidth) && camera.sensorWidth > 0 && camera.sensorWidth <= 1000)) throw invalidField('camera.sensorWidth', camera.sensorWidth, 'a width above 0 and up to 1000 millimetres, such as 36');
}
@@ -418,7 +418,7 @@ function cameraFrom(value = {}) {
const crossLength = Math.hypot(unitDirection[1] * result.up[2] - unitDirection[2] * result.up[1],
unitDirection[2] * result.up[0] - unitDirection[0] * result.up[2], unitDirection[0] * result.up[1] - unitDirection[1] * result.up[0]);
if (Math.fround(crossLength) === 0) {
- throw new RangeError('Camera up must not be collinear with the view direction.');
+ throw invalidField('camera.up', result.up, `a direction not parallel to the view from eye to target, such as [0, 1, 0]`);
}
const view = mat4.lookAt(mat4.create(), result.eye, result.target, result.up);
const projection = applyProjection(mat4.create(), result, 1);
@@ -450,22 +450,22 @@ function lineEnds(value) {
const ends = [value.from, value.to];
for (const end of ends) vector(end, 3, 'line end');
if (ends[0].every((component, axis) => component === ends[1][axis])) {
- throw new RangeError('A line needs two distinct end points.');
+ throw invalidField('to', value.to, `a point different from from ${JSON.stringify(value.from)}, such as [0, 1, 0]`);
}
return ends;
}
function geometryEstimate(value) {
if (!Object.hasOwn(GEOMETRY_FIELDS, value.type)) {
- throw new TypeError(`Unsupported geometry type: ${value.type}. Use one of ${Object.keys(GEOMETRY_FIELDS).join(', ')}.`);
+ throw invalidField('type', value.type, `one of ${Object.keys(GEOMETRY_FIELDS).join(', ')}`, TypeError);
}
knownKeys(value, ['id', 'type', ...GEOMETRY_FIELDS[value.type]], 'geometry');
function detail(field, fallback, minimum, maximum) {
return integer(value[field] ?? fallback, minimum, maximum, field);
}
- function points(input, size, minimum) {
+ function points(input, size, minimum, field = 'points') {
if (!Array.isArray(input) || input.length < minimum || input.length > 4096) {
- throw new RangeError('Geometry point count exceeds its limit.');
+ throw invalidField(field, Array.isArray(input) ? `${input.length} points` : input, `a list of ${minimum} to 4096 points of ${size} numbers, such as ${JSON.stringify(Array.from({ length: minimum }, (_, index) => Array.from({ length: size }, () => index)))}`);
}
for (const point of input) {
vector(point, size, 'geometry point');
@@ -501,24 +501,24 @@ function geometryEstimate(value) {
case 'torus':
return (detail('segments', 96, 3, 2048) + 1) * (detail('sides', 24, 3, 128) + 1) + 2 * ((value.sides ?? 24) + 2);
case 'lathe':
- return (detail('segments', 64, 3, 2048) + 1) * points(value.profile, 2, 2);
+ return (detail('segments', 64, 3, 2048) + 1) * points(value.profile, 2, 2, 'profile');
case 'tube':
- points(value.path, 3, value.closed ? 3 : 2);
+ points(value.path, 3, value.closed ? 3 : 2, 'path');
if (value.closed !== undefined && typeof value.closed !== 'boolean') {
- throw new TypeError('closed must be boolean.');
+ throw invalidField('closed', value.closed, 'true or false', TypeError);
}
return (detail('segments', 64, 3, 2048) + 1) * (detail('radialSegments', 12, 3, 128) + 1);
case 'curve': {
const knots = value.points;
if (!Array.isArray(knots) || knots.length < 2 || knots.length > CURVE_TEXT_LIMITS.maxCurvePoints) {
- throw new RangeError('Geometry point count exceeds its limit.');
+ throw invalidField('points', Array.isArray(knots) ? `${knots.length} points` : knots, `a list of 2 to ${CURVE_TEXT_LIMITS.maxCurvePoints} points, such as [[0, 0, 0], [0, 1, 0]]`);
}
- const sides = value.profile === undefined ? detail('radialSegments', 8, 3, 128) : points(value.profile, 2, 3);
+ const sides = value.profile === undefined ? detail('radialSegments', 8, 3, 128) : points(value.profile, 2, 3, 'profile');
const rings = (value.closed ? knots.length : knots.length - 1) * detail('resolution', 12, 1, 64) + 1;
return rings * sides * 2 + 2 * (sides + 1);
}
case 'text': {
- if (typeof value.text !== 'string') throw new TypeError('text must be a string.');
+ if (typeof value.text !== 'string') throw invalidField('text', value.text, 'a string, such as "Hello"', TypeError);
const visible = [...value.text].filter(character => !/\s/.test(character)).length;
const isDefaultFont = value.font === undefined || value.font === 'default';
const perSegment = isDefaultFont ? CURVE_TEXT_LIMITS.verticesPerCharacterSegment : CURVE_TEXT_LIMITS.verticesPerCustomCharacterSegment;
@@ -529,11 +529,11 @@ function geometryEstimate(value) {
case 'extrude': {
const holes = value.holes ?? [];
if (!Array.isArray(holes) || holes.length > 128) {
- throw new RangeError('holes must contain at most 128 rings.');
+ throw invalidField('holes', Array.isArray(holes) ? `${holes.length} rings` : holes, 'a list of at most 128 rings of points, such as []');
}
- const count = points(value.contour, 2, 3) + holes.reduce((total, hole) => total + points(hole, 2, 3), 0);
+ const count = points(value.contour, 2, 3, 'contour') + holes.reduce((total, hole) => total + points(hole, 2, 3, 'holes'), 0);
if (count > 4096) {
- throw new RangeError('Extrude exceeds 4096 input points.');
+ throw invalidField('contour', `${count} points`, 'a contour and holes with at most 4096 points in total; simplify them');
}
const beveled = (value.bevel ?? 0) > 0 || (value.bevelThickness ?? value.bevel ?? 0) > 0;
return 6 * (count + holes.length * 2 - 2) + 6 * count * (detail('steps', 1, 1, 256) + (beveled ? detail('bevelSegments', 3, 1, 32) * 2 : 0));
@@ -541,7 +541,7 @@ function geometryEstimate(value) {
case 'mesh': {
const base = value.base;
if (!base || typeof base !== 'object' || Array.isArray(base) || base.type === 'mesh' || Object.hasOwn(base, 'id')) {
- throw new TypeError('mesh base must be a primitive or profile geometry record without an id (box, cylinder, sphere, torus, lathe, extrude or tube).');
+ throw invalidField('base', base, 'a primitive or profile record without an id, such as { "type": "box" } (box, cylinder, sphere, torus, lathe, extrude or tube)', TypeError);
}
let estimate = geometryEstimate({ id: 'base', ...base });
for (const edit of agentSceneModule('mesh').normalizeMeshEdits(value.edits ?? [])) {
@@ -551,7 +551,7 @@ function geometryEstimate(value) {
for (const node of agentSceneModule('mesh').normalizeMeshStack(value.stack ?? [])) estimate *= node.op === 'array' ? node.count : 2;
if (value.shapeKeys !== undefined) agentSceneModule('mesh').normalizeShapeKeys(value.shapeKeys);
if (value.smoothAngle !== undefined && (value.smoothAngle < 0 || value.smoothAngle > 180)) {
- throw new RangeError('smoothAngle is degrees from 0 to 180.');
+ throw invalidField('smoothAngle', value.smoothAngle, 'degrees from 0 to 180, such as 30');
}
// Edits can grow the mesh; the real size is checked against maxVertices after generation.
return estimate * 2;
@@ -565,7 +565,7 @@ function hasInstancedNodes(nodes) {
function cutterEstimate(cutter) {
if (cutter.type === 'mesh' || Object.hasOwn(cutter, 'id')) {
- throw new TypeError('A boolean cutter must be a primitive or profile record without an id (box, cylinder, sphere, torus, lathe, extrude or tube).');
+ throw invalidField('cutter', cutter, 'a primitive or profile record without an id, such as { "type": "box" } (box, cylinder, sphere, torus, lathe, extrude or tube)', TypeError);
}
return geometryEstimate({ id: 'cutter', ...cutter });
}
@@ -625,7 +625,8 @@ function compile(recipe, geometries, localBounds, limits) {
const materials = new Map(recipe.materials.map(material => [material.id, material]));
const graph = createSceneGraph(recipe.nodes.map(node => {
if (node.geometry !== undefined && (!geometries.has(node.geometry) || !materials.has(node.material))) {
- throw new RangeError(`Node ${node.id} uses ${geometries.has(node.geometry) ? `material ${node.material}` : `geometry ${node.geometry}`}, which does not exist. Use one of: ${(geometries.has(node.geometry) ? [...materials.keys()] : [...geometries.keys()]).join(', ')}.`);
+ const missingField = geometries.has(node.geometry) ? 'material' : 'geometry';
+ throw invalidField(`nodes.${node.id}.${missingField}`, node[missingField], `one of ${(geometries.has(node.geometry) ? [...materials.keys()] : [...geometries.keys()]).join(', ')}`);
}
return { name: node.id, parent: node.parent,
matrix: node.assetPart ? mat4.clone(node.assetPart.matrix) : mat4.fromRotationTranslationScale(mat4.create(), node.rotation, node.translation, node.scale),
@@ -678,7 +679,7 @@ function addArmatures(recipe, limits) {
if (!Object.hasOwn(recipe, 'armatures')) {
for (const node of recipe.nodes) {
if (node.skin) {
- throw new RangeError(`Node ${node.id} has a skin but the recipe has no armatures.`);
+ throw invalidField(`nodes.${node.id}.skin`, node.skin, 'a skin only when the recipe has armatures; add an armatures list or remove skin');
}
}
return;
@@ -687,7 +688,7 @@ function addArmatures(recipe, limits) {
const resolveBounds = (armature, nodeId) => {
const node = userNodes.get(nodeId);
if (!node?.geometry) {
- throw new RangeError(`Armature ${armature.id} fit node ${JSON.stringify(String(nodeId).slice(0, 48))} must be a mesh node.`);
+ throw invalidField(`armatures.${armature.id}.fit`, nodeId, 'the ID of a mesh node with a geometry, such as one scene_inspect lists');
}
const definition = recipe.geometries.find(geometry => geometry.id === node.geometry);
const bounds = boundsFor(generateGeometry(definition, Math.min(limits.maxVertices, 1_000_000)), mat4.create());
@@ -699,15 +700,15 @@ function addArmatures(recipe, limits) {
const derived = recipe.armatures.flatMap(armatureNodes);
for (const node of derived) {
if (userNodes.has(node.id)) {
- throw new RangeError(`Armature node ${node.id} collides with a node of the same ID. Give the armature a prefix.`);
+ throw invalidField(`armatures.${node.id}`, node.id, 'a bone node ID no other node uses; give the armature a prefix, such as "rig-"');
}
}
if (new Set(derived.map(node => node.id)).size !== derived.length) {
- throw new RangeError('Two armatures generate the same node ID. Give one a prefix.');
+ throw invalidField('armatures', recipe.armatures.map(armature => armature.id), 'armatures that generate different node IDs; give one a prefix, such as "rig-"');
}
for (const node of recipe.nodes) {
if (node.skin && !recipe.armatures.some(armature => armature.id === node.skin.armature)) {
- throw new RangeError(`Node ${node.id} skin names armature ${node.skin.armature}, which is not in armatures.`);
+ throw invalidField(`nodes.${node.id}.skin.armature`, node.skin.armature, `one of ${recipe.armatures.map(armature => armature.id).join(', ')}`);
}
}
recipe.nodes = [...derived, ...recipe.nodes];
@@ -740,7 +741,7 @@ function checkLightLinkNames(recipe) {
}
const unknown = agentSceneModule('lightLinking').unknownLightLinkNames(recipe.environment, recipe.nodes);
if (unknown.length > 0) {
- throw new RangeError(`Light links name nodes that do not exist (${unknown.slice(0, 4).join('; ')}). scene_inspect lists node IDs.`);
+ throw invalidField('environment.keyAffects', unknown.slice(0, 4), 'node IDs that exist in nodes in every affects list; scene_inspect lists them');
}
}
@@ -770,7 +771,7 @@ function normalizeRecipe(input, limits) {
let recipe = copiedJson(input, limits.maxRecipeBytes);
knownKeys(recipe, ['format', 'schemaVersion', 'geometries', 'materials', 'nodes', 'armatures', 'camera', 'environment', 'effects', 'shadow', 'motion', 'physics', 'cloth', 'timeline', 'particles', 'bake', 'postPasses'], 'recipe');
if (recipe.format !== '67js.scene' || recipe.schemaVersion !== 1) {
- throw new RangeError('Expected 67js.scene schemaVersion 1.');
+ throw invalidField(recipe.format !== '67js.scene' ? 'format' : 'schemaVersion', recipe.format !== '67js.scene' ? recipe.format : recipe.schemaVersion, recipe.format !== '67js.scene' ? '"67js.scene"' : '1');
}
// A scene with no mesh, or whose nodes all take the default material, has nothing to list: absent means empty.
// Placed assets generate their own geometries, materials and part nodes each time; an exported or checkpointed recipe may still carry them.
@@ -792,14 +793,14 @@ function normalizeRecipe(input, limits) {
recipe.materials = resources(withDefaultMaterial(recipe), limits.maxMaterials, 'materials', materialFrom);
const distinctPatterns = new Set(recipe.materials.filter(material => material.pattern).map(material => JSON.stringify(material.pattern)));
if (distinctPatterns.size > MAX_MATERIAL_PATTERNS) {
- throw new RangeError(`A scene holds at most ${MAX_MATERIAL_PATTERNS} different material patterns; it has ${distinctPatterns.size}. Reuse one; tint with color.`);
+ throw invalidField('materials', `${distinctPatterns.size} different patterns`, `at most ${MAX_MATERIAL_PATTERNS} different material patterns; reuse one and tint it with color`);
}
recipe.nodes = withoutArmatureNodes(recipe.nodes);
if (hasInstancedNodes(recipe.nodes)) recipe.nodes = agentSceneModule('mesh').expandInstancedNodes(recipe.nodes, {
maxNodes: limits.maxNodes,
resolveSurface: id => {
const definition = recipe.geometries.find(geometry => geometry.id === id);
- if (!definition) throw new RangeError(`Instances surface geometry ${JSON.stringify(id.slice(0, 48))} is not in geometries.`);
+ if (!definition) throw invalidField('instances.surface', id, `the ID of a geometry in geometries, such as ${recipe.geometries[0]?.id ?? 'ground'}`);
return generateGeometry(definition, Math.min(limits.maxVertices, 1_000_000));
},
});
@@ -817,7 +818,7 @@ function normalizeRecipe(input, limits) {
}
Object.assign(recipe, normalizeAgentLook(look));
if (recipe.camera.fStop !== undefined && recipe.effects?.depthOfField.blur > 0) {
- throw new RangeError('Camera fStop drives depth of field; set effects.depthOfField.blur to 0 or remove fStop.');
+ throw invalidField('camera.fStop', recipe.camera.fStop, 'a camera without effects.depthOfField.blur above 0; set blur to 0 or remove fStop');
}
checkLightLinkNames(recipe);
if (Object.hasOwn(recipe, 'motion')) {
@@ -1097,10 +1098,10 @@ function meshGeometryTarget(candidate, operation, remedy) {
identifier(operation.geometry);
const target = candidate.geometries.find(geometry => geometry.id === operation.geometry);
if (!target) {
- throw new RangeError(`Geometry ID was not found: ${operation.geometry}. Known geometry IDs: ${[...candidate.geometries.map(known => known.id)].join(', ')}.`);
+ throw invalidField('geometry', operation.geometry, `one of ${[...candidate.geometries.map(known => known.id)].join(', ')}`);
}
if (target.type !== 'mesh') {
- throw new TypeError(`Geometry ${operation.geometry} is a ${target.type}. ${remedy(target.type)}`);
+ throw invalidField('geometry', operation.geometry, `the ID of a mesh geometry, but it is a ${target.type}. ${remedy(target.type)}`, TypeError);
}
return target;
}
@@ -1110,10 +1111,10 @@ function removeNode(candidate, operation) {
identifier(operation.id);
const recursive = operation.recursive === undefined ? false : operation.recursive;
if (typeof recursive !== 'boolean') {
- throw new TypeError('recursive must be boolean.');
+ throw invalidField('recursive', recursive, 'true or false', TypeError);
}
if (!candidate.nodes.some(node => node.id === operation.id)) {
- throw new RangeError(`${operation.type} target was not found: ${operation.id}. scene_inspect lists the IDs.`);
+ throw invalidField('id', operation.id, 'the ID of a node in nodes; scene_inspect lists them');
}
const children = new Map();
for (const node of candidate.nodes) {
@@ -1122,7 +1123,7 @@ function removeNode(candidate, operation) {
children.set(node.parent, siblings);
}
if (!recursive && (children.get(operation.id)?.length ?? 0) > 0) {
- throw new RangeError('Nonrecursive removal cannot remove a node with children. Remove children first or use recursive.');
+ throw invalidField('recursive', recursive, 'true for a node with children, such as true; or remove the children first');
}
const removed = new Set([operation.id]);
const pending = [operation.id];
@@ -1160,7 +1161,7 @@ export function createAgentScene(input, inputLimits = {}, options = {}) {
identifier(id);
const node = state.recipe.nodes.find(value => value.id === id);
const geometry = node && state.geometries.get(node.geometry);
- if (!geometry) throw new RangeError(`path ${label} ${id} is not a node with a drawn geometry. List node IDs with scene_inspect.`);
+ if (!geometry) throw invalidField(`path.${label}`, id, 'the ID of a node with a drawn geometry; scene_inspect lists node IDs');
return { geometry, worldMatrix: state.graph.getNode(id).worldMatrix };
}
@@ -1507,7 +1508,7 @@ export function createAgentScene(input, inputLimits = {}, options = {}) {
function expected(options) {
knownKeys(options, ['expectedRevision'], 'transaction options');
if (!Number.isSafeInteger(options.expectedRevision) || options.expectedRevision !== revision) {
- throw new RangeError('expectedRevision must match the current revision.');
+ throw invalidField('expectedRevision', options.expectedRevision, `the current revision, ${revision}; scene_inspect returns it`);
}
}
@@ -1535,10 +1536,10 @@ export function createAgentScene(input, inputLimits = {}, options = {}) {
},
sampleMotion(time) {
if (time !== null && (!Number.isFinite(time) || time < 0 || time > 3600)) {
- throw new RangeError('Motion time must be null or within zero and 3600 seconds.');
+ throw invalidField('time', time, 'null or a number of seconds from 0 to 3600, such as 0.5');
}
if (time !== null && !state.motionSampler && !state.physicsSampler && !state.clothSampler && !state.particleSampler && !state.assetRuntime.animators.length && !state.sequences.length) {
- throw new RangeError('This procedural recipe has no motion, physics, cloth or particles, and no placed asset clip.');
+ throw invalidField('time', time, 'null, because this recipe has no motion, physics, cloth, particles or placed asset clip to sample; add motion first');
}
const pose = stagePose(state, time);
rebakeAtPose(pose);
@@ -1596,7 +1597,7 @@ export function createAgentScene(input, inputLimits = {}, options = {}) {
apply(inputOperations, options = {}) {
expected(options);
if (!Array.isArray(inputOperations) || inputOperations.length === 0 || inputOperations.length > limits.maxOperations) {
- throw new RangeError('operations must contain 1 to maxOperations commands.');
+ throw invalidField('operations', Array.isArray(inputOperations) ? `${inputOperations.length} operations` : inputOperations, `a list of 1 to ${limits.maxOperations} operations, such as [{ "type": "set-camera", "fov": 50 }]`);
}
const operations = copiedJson(inputOperations, limits.maxRecipeBytes);
const candidate = authoredRecipe(state.recipe);
@@ -1607,7 +1608,7 @@ export function createAgentScene(input, inputLimits = {}, options = {}) {
if (section) {
knownKeys(operation, ['type', section], 'operation');
if (!Object.hasOwn(operation, section)) {
- throw new TypeError(`${operation.type} requires ${section}; use null to clear it.`);
+ throw invalidField(section, undefined, `a ${section} value, or null to clear it, in a ${operation.type} operation`, TypeError);
}
candidate[section] = operation[section];
if (candidate.armatures === null) delete candidate.armatures;
@@ -1644,7 +1645,7 @@ export function createAgentScene(input, inputLimits = {}, options = {}) {
nodeFrom(record);
}
if (candidate[collection].some(existing => existing.id === record.id)) {
- throw new RangeError(`Duplicate ${collection} ID: ${record.id}. IDs must be unique: pick a new ID, or remove the existing one first.`);
+ throw invalidField(`${field}.id`, record.id, `an ID no ${collection} entry uses yet; pick a new ID, or remove the existing one first`);
}
candidate[collection].push(record);
continue;
@@ -1653,10 +1654,10 @@ export function createAgentScene(input, inputLimits = {}, options = {}) {
knownKeys(operation, ['type', 'geometry', 'edits', 'replace'], 'operation');
const target = meshGeometryTarget(candidate, operation, type => `Add a mesh geometry with base: { type: '${type}', ... } to edit it.`);
if (operation.replace !== undefined && typeof operation.replace !== 'boolean') {
- throw new TypeError('replace must be boolean.');
+ throw invalidField('replace', operation.replace, 'true or false', TypeError);
}
if (!Array.isArray(operation.edits)) {
- throw new TypeError('edit-mesh needs an edits array.');
+ throw invalidField('edits', operation.edits, 'an array of mesh edits, such as [{ "op": "extrude" }]', TypeError);
}
target.edits = operation.replace ? operation.edits : [...(target.edits ?? []), ...operation.edits];
agentSceneModule('mesh').normalizeMeshEdits(target.edits);
@@ -1669,7 +1670,7 @@ export function createAgentScene(input, inputLimits = {}, options = {}) {
agentSceneModule('mesh').normalizeMeshStack(stack);
const applied = operation.apply ?? 0;
if (!Number.isInteger(applied) || applied < 0 || applied > stack.length) {
- throw new RangeError(`apply must be an integer from 0 to the stack length ${stack.length}.`);
+ throw invalidField('apply', applied, `a whole number from 0 to the stack length ${stack.length}, such as 0`);
}
// Applying moves the first nodes into the edit log, as Blender's Apply modifier does.
target.edits = [...(target.edits ?? []), ...stack.slice(0, applied)];
@@ -1689,7 +1690,7 @@ export function createAgentScene(input, inputLimits = {}, options = {}) {
identifier(operation.id);
const index = candidate[removal].findIndex(record => record.id === operation.id);
if (index < 0) {
- throw new RangeError(`${operation.type} target was not found: ${operation.id}. scene_inspect lists the IDs; add it first with an add operation.`);
+ throw invalidField('id', operation.id, `the ID of an existing ${removal} entry; scene_inspect lists them`);
}
candidate[removal].splice(index, 1);
if (operation.type === 'remove-material') {
@@ -1709,11 +1710,11 @@ export function createAgentScene(input, inputLimits = {}, options = {}) {
fields = CAMERA_FIELDS;
target = candidate.camera;
} else {
- throw new TypeError(`Unsupported operation type: ${operation.type}. Use one of ${AGENT_SCENE_CAPABILITIES.operations.join(', ')}.`);
+ throw invalidField('type', operation.type, `one of ${AGENT_SCENE_CAPABILITIES.operations.join(', ')}`, TypeError);
}
knownKeys(operation, ['type', ...(operation.type === 'set-camera' ? [] : ['id']), ...fields], 'operation');
if (!target) {
- throw new RangeError(`${operation.type} target was not found: ${operation.id}. scene_inspect lists the IDs; add it first with an add operation.`);
+ throw invalidField('id', operation.id, `the ID of an existing ${operation.type === 'set-node' ? 'node' : 'material'}; scene_inspect lists them, or add it first with an add operation`);
}
if (operation.type === 'set-camera') {
applyCameraFields(target, operation);
@@ -1731,16 +1732,16 @@ export function createAgentScene(input, inputLimits = {}, options = {}) {
knownKeys(options, ['ids', 'limit', 'includeBounds', 'path'], 'inspection');
const maximum = integer(options.limit ?? Math.min(64, limits.maxNodes), 1, limits.maxNodes, 'inspection limit');
if (options.includeBounds !== undefined && typeof options.includeBounds !== 'boolean') {
- throw new TypeError('includeBounds must be boolean.');
+ throw invalidField('includeBounds', options.includeBounds, 'true or false', TypeError);
}
if (options.ids !== undefined && (!Array.isArray(options.ids) || options.ids.length > limits.maxNodes)) {
- throw new RangeError('Inspection IDs exceed maxNodes.');
+ throw invalidField('ids', Array.isArray(options.ids) ? `${options.ids.length} IDs` : options.ids, `a list of at most ${limits.maxNodes} node IDs, such as ["body"]`);
}
const selected = options.ids === undefined ? state.recipe.nodes.filter(node => !node.assetPart) : options.ids.map(id => {
identifier(id);
const node = state.recipe.nodes.find(value => value.id === id);
if (!node) {
- throw new RangeError(`Inspection ID was not found: ${id}. Call scene_inspect without ids to list node IDs.`);
+ throw invalidField('ids', id, 'IDs of existing nodes; call scene_inspect without ids to list them');
}
return node;
});
@@ -1801,14 +1802,14 @@ export function createAgentScene(input, inputLimits = {}, options = {}) {
knownKeys(options, ['geometries'], 'mesh inspection');
const requested = options.geometries ?? [...state.geometries.keys()];
if (!Array.isArray(requested) || (options.geometries !== undefined && requested.length > MAX_MESH_REPORTS)) {
- throw new RangeError(`Inspect at most ${MAX_MESH_REPORTS} geometry IDs per call.`);
+ throw invalidField('geometries', Array.isArray(requested) ? `${requested.length} IDs` : requested, `a list of at most ${MAX_MESH_REPORTS} geometry IDs, such as ["block"]`);
}
const selected = requested.slice(0, MAX_MESH_REPORTS);
const meshes = selected.map(id => {
identifier(id);
const geometry = state.geometries.get(id);
if (!geometry) {
- throw new RangeError(`Geometry ID was not found: ${id}. Known IDs: ${[...state.geometries.keys()].join(', ')}.`);
+ throw invalidField('geometries', id, `one of ${[...state.geometries.keys()].join(', ')}`);
}
return { geometry: id, ...agentSceneModule('mesh').meshReport(geometry) };
});
@@ -1816,7 +1817,7 @@ export function createAgentScene(input, inputLimits = {}, options = {}) {
},
checkpoint() {
if (checkpoints.size >= limits.maxCheckpoints) {
- throw new RangeError('Checkpoint budget exhausted. Release a checkpoint.');
+ throw invalidField('checkpoints', `${checkpoints.size} saved`, `at most ${limits.maxCheckpoints} saved checkpoints; release one with scene_release_checkpoint first`);
}
const handle = Object.freeze({});
checkpoints.set(handle, {
@@ -1832,13 +1833,13 @@ export function createAgentScene(input, inputLimits = {}, options = {}) {
expected(options);
const checkpoint = checkpoints.get(handle);
if (!checkpoint) {
- throw new RangeError('Unknown or released checkpoint. Save one with scene_checkpoint, or use a checkpointId that scene_checkpoint returned and you have not released.');
+ throw invalidField('checkpointId', handle, 'a checkpointId that scene_checkpoint returned and you have not released');
}
return commit(stage(checkpoint.recipe, checkpoint), true);
},
releaseCheckpoint(handle) {
if (!checkpoints.delete(handle)) {
- throw new RangeError('Unknown or released checkpoint. Save one with scene_checkpoint, or use a checkpointId that scene_checkpoint returned and you have not released.');
+ throw invalidField('checkpointId', handle, 'a checkpointId that scene_checkpoint returned and you have not released');
}
},
});
diff --git a/src/agent-terrain.js b/src/agent-terrain.js
index 57f38bc8..5856e470 100644
--- a/src/agent-terrain.js
+++ b/src/agent-terrain.js
@@ -2,6 +2,7 @@
// It loads on demand with the recipes that contain a terrain geometry, so the scene entry does not carry it.
import './world-material-shader.js';
import { createTerrain } from './terrain.js';
+import { invalidField } from './field-error.js';
export const TERRAIN_LIMITS = Object.freeze({
size: [1, 2000],
@@ -16,14 +17,14 @@ export const TERRAIN_LIMITS = Object.freeze({
function numberWithin(value, fallback, [minimum, maximum], label) {
const resolved = value ?? fallback;
if (!Number.isFinite(resolved) || resolved < minimum || resolved > maximum) {
- throw new RangeError(`terrain ${label} must be a number within ${minimum} and ${maximum}.`);
+ throw invalidField(`terrain.${label}`, resolved, `a number from ${minimum} to ${maximum}, such as ${fallback}`);
}
return resolved;
}
function integerWithin(value, fallback, [minimum, maximum], label) {
const resolved = numberWithin(value, fallback, [minimum, maximum], label);
- if (!Number.isInteger(resolved)) throw new RangeError(`terrain ${label} must be a whole number.`);
+ if (!Number.isInteger(resolved)) throw invalidField(`terrain.${label}`, resolved, `a whole number, such as ${fallback}`);
return resolved;
}
@@ -33,7 +34,7 @@ export function terrainVertexEstimate(value) {
numberWithin(value.size, TERRAIN_LIMITS.defaultSize, TERRAIN_LIMITS.size, 'size');
numberWithin(value.amplitude, TERRAIN_LIMITS.defaultAmplitude, TERRAIN_LIMITS.amplitude, 'amplitude');
if (value.holes !== undefined && (!Array.isArray(value.holes) || value.holes.length > TERRAIN_LIMITS.maximumHoles)) {
- throw new RangeError(`terrain holes must be a list of at most ${TERRAIN_LIMITS.maximumHoles} circles.`);
+ throw invalidField('terrain.holes', value.holes, `a list of at most ${TERRAIN_LIMITS.maximumHoles} circles, such as [{ "center": [0, 0], "radius": 2 }]`);
}
return (resolution + 1) * (resolution + 1);
}
@@ -61,6 +62,6 @@ export function createRecipeTerrain(value) {
/** Render geometry of a terrain record: ground from -size / 2 to size / 2 on X and Z, hills of the given amplitude, holes cut out. */
export function generateTerrainGeometry(value, maxVertices) {
const vertices = terrainVertexEstimate(value);
- if (vertices > maxVertices) throw new RangeError(`Terrain needs ${vertices} vertices, exceeding maxVertices ${maxVertices}. Lower resolution.`);
+ if (vertices > maxVertices) throw invalidField('terrain.resolution', value.resolution ?? TERRAIN_LIMITS.defaultResolution, `a resolution whose ${vertices} vertices fit maxVertices ${maxVertices}; lower it`);
return createRecipeTerrain(value).parts[0].geometry;
}
diff --git a/tests/actionable-errors-scene-core.test.js b/tests/actionable-errors-scene-core.test.js
new file mode 100644
index 00000000..c5648381
--- /dev/null
+++ b/tests/actionable-errors-scene-core.test.js
@@ -0,0 +1,142 @@
+import './support/load-agent-scene-modules.mjs';
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { createAgentScene } from '../src/agent-scene.js';
+import { taggedFacePositions } from '../src/agent-mesh.js';
+import { generateTerrainGeometry } from '../src/agent-terrain.js';
+import { loadAgentSceneModules } from '../src/agent-scene-modules.js';
+
+function baseRecipe() {
+ return {
+ format: '67js.scene', schemaVersion: 1,
+ geometries: [{ id: 'cube', type: 'box', bevel: 0 }, { id: 'sheet', type: 'grid', segments: 4 }],
+ materials: [{ id: 'plain', color: [0.5, 0.5, 0.5] }],
+ nodes: [{ id: 'body', geometry: 'cube', material: 'plain' }, { id: 'flag', geometry: 'sheet', material: 'plain' }],
+ };
+}
+
+async function recipeError(change, limits) {
+ const recipe = baseRecipe();
+ change(recipe);
+ await loadAgentSceneModules(recipe);
+ try {
+ createAgentScene(recipe, limits);
+ } catch (error) {
+ return error;
+ }
+ assert.fail('the recipe was accepted');
+}
+
+// Each case names the full path, the value received and what is accepted with an example or a range.
+const RECIPE_CASES = [
+ // src/agent-scene.js
+ ['a node flag names its full path', recipe => { recipe.nodes[0].decal = 'yes'; }, TypeError, /^nodes\[0\]\.decal: got "yes"; expected true or false\.$/],
+ ['an unknown node field names the field to remove', recipe => { recipe.nodes[0].colour = 'red'; }, TypeError, /^nodes\[0\]\.node\.colour: got "red"; expected one of the fields id, geometry, material.*; remove colour\.$/],
+ ['a camera takes fov or focalLength, never both', recipe => { recipe.camera = { fov: 40, focalLength: 50 }; }, RangeError, /^camera\.focalLength: got 50; expected only one of fov \(degrees\) or focalLength \(millimetres with sensorWidth\), such as fov 45; remove the other\.$/],
+ ['a missing material names the choices', recipe => { recipe.nodes[0].material = 'ghost'; }, RangeError, /^nodes\.body\.material: got "ghost"; expected one of plain\.$/],
+ ['a duplicate ID names the collection', recipe => { recipe.nodes[1].id = 'body'; }, RangeError, /^nodes\[1\]\.id: got "body"; expected an ID no other nodes entry uses; rename one, or remove the other\.$/],
+ ['a geometry type outside the list names the list', recipe => { recipe.geometries[0].type = 'blob'; }, TypeError, /^geometries\[0\]\.type: got "blob"; expected one of box, cylinder.*terrain\.$/],
+ ['a point list gives the range and an example', recipe => { recipe.geometries.push({ id: 'ring', type: 'lathe', profile: [[1, 0]] }); }, RangeError, /^geometries\[2\]\.profile: got "1 points"; expected a list of 2 to 4096 points of 2 numbers, such as \[\[0,0\],\[1,1\]\]\.$/],
+ ['a wrong schema version gives the expected value', recipe => { recipe.schemaVersion = 2; }, RangeError, /^schemaVersion: got 2; expected 1\.$/],
+ // src/agent-recipe-checks.js (cloth sections use its shared checks)
+ ['a cloth node that does not exist', recipe => { recipe.cloth = { duration: 2, sheets: [{ node: 'ghost' }] }; }, RangeError, /^Cloth sheet node: got "ghost"; expected the ID of a node in nodes, such as one scene_inspect lists\.$/],
+ ['a cloth number outside its range', recipe => { recipe.cloth = { duration: 0, sheets: [{ node: 'flag' }] }; }, RangeError, /^Cloth duration: got 0; expected a finite number from 0\.1 to \d+, such as 1\.$/],
+ ['a cloth vector of the wrong length', recipe => { recipe.cloth = { duration: 2, gravity: [0, 1], sheets: [{ node: 'flag' }] }; }, TypeError, /^Cloth gravity: got \[0,1\]; expected three numbers, such as \[0, 1, 0\]\.$/],
+ ['a cloth list that is not a list', recipe => { recipe.cloth = { duration: 2, sheets: 'flag' }; }, TypeError, /^Cloth sheets: got "flag"; expected an array of at most \d+ entries, such as \[\]\.$/],
+ ['an unknown cloth field names the field to remove', recipe => { recipe.cloth = { duration: 2, surprise: 1, sheets: [{ node: 'flag' }] }; }, TypeError, /^cloth\.surprise: got 1; expected one of the fields duration.*; remove surprise\.$/],
+ // src/agent-terrain.js
+ ['a terrain size outside its range', recipe => { recipe.geometries.push({ id: 'ground', type: 'terrain', size: 0 }); }, RangeError, /^geometries\[2\]\.terrain\.size: got 0; expected a number from 1 to 2000, such as 40\.$/],
+ ['a terrain resolution that is not whole', recipe => { recipe.geometries.push({ id: 'ground', type: 'terrain', resolution: 8.5 }); }, RangeError, /^geometries\[2\]\.terrain\.resolution: got 8\.5; expected a whole number, such as 64\.$/],
+ ['terrain holes that are not a list', recipe => { recipe.geometries.push({ id: 'ground', type: 'terrain', holes: 'many' }); }, RangeError, /^geometries\[2\]\.terrain\.holes: got "many"; expected a list of at most 16 circles, such as \[\{ "center": \[0, 0\], "radius": 2 \}\]\.$/],
+ ['a terrain amplitude outside its range', recipe => { recipe.geometries.push({ id: 'ground', type: 'terrain', amplitude: 500 }); }, RangeError, /^geometries\[2\]\.terrain\.amplitude: got 500; expected a number from 0 to 200, such as 1\.$/],
+ // src/agent-mesh.js
+];
+
+for (const [name, change, ErrorType, pattern, limits] of RECIPE_CASES) {
+ test(`recipe error: ${name}`, async () => {
+ const error = await recipeError(change, limits);
+ assert.ok(error instanceof ErrorType, `${error.name}: ${error.message}`);
+ assert.match(error.message, pattern);
+ });
+}
+
+test('scene operations report the field, the value and what is accepted', () => {
+ const scene = createAgentScene(baseRecipe(), { maxCheckpoints: 1 });
+ const expectError = (run, ErrorType, pattern) => assert.throws(run, error => error instanceof ErrorType && pattern.test(error.message), `${pattern}`);
+ expectError(() => scene.apply([{ type: 'remove-node', id: 'ghost' }], { expectedRevision: 0 }), RangeError, /^id: got "ghost"; expected the ID of a node in nodes; scene_inspect lists them\.$/);
+ expectError(() => scene.apply([{ type: 'set-node', id: 'ghost' }], { expectedRevision: 0 }), RangeError, /^id: got "ghost"; expected the ID of an existing node;/);
+ expectError(() => scene.apply([{ type: 'launch' }], { expectedRevision: 0 }), TypeError, /^type: got "launch"; expected one of set-node, set-material/);
+ expectError(() => scene.apply([], { expectedRevision: 0 }), RangeError, /^operations: got "0 operations"; expected a list of 1 to \d+ operations, such as \[\{ "type": "set-camera", "fov": 50 \}\]\.$/);
+ expectError(() => scene.apply([{ type: 'set-camera', fov: 50 }], { expectedRevision: 7 }), RangeError, /^expectedRevision: got 7; expected the current revision, 0; scene_inspect returns it\.$/);
+ expectError(() => scene.apply([{ type: 'remove-node', id: 'body', recursive: 'yes' }], { expectedRevision: 0 }), TypeError, /^recursive: got "yes"; expected true or false\.$/);
+ expectError(() => scene.inspect({ ids: ['ghost'] }), RangeError, /^ids: got "ghost"; expected IDs of existing nodes; call scene_inspect without ids to list them\.$/);
+ expectError(() => scene.inspect({ includeBounds: 'yes' }), TypeError, /^includeBounds: got "yes"; expected true or false\.$/);
+ expectError(() => scene.inspect({ path: { ground: 'ghost', from: [0, 0], to: [1, 1] } }), RangeError, /^path\.ground: got "ghost"; expected the ID of a node with a drawn geometry;/);
+ expectError(() => scene.inspectMeshes({ geometries: ['ghost'] }), RangeError, /^geometries: got "ghost"; expected one of cube, sheet\.$/);
+ expectError(() => scene.sampleMotion(1), RangeError, /^time: got 1; expected null, because this recipe has no motion/);
+ expectError(() => scene.sampleMotion(4000), RangeError, /^time: got 4000; expected null or a number of seconds from 0 to 3600, such as 0\.5\.$/);
+ const checkpoint = scene.checkpoint();
+ expectError(() => scene.checkpoint(), RangeError, /^checkpoints: got "1 saved"; expected at most 1 saved checkpoints;/);
+ scene.releaseCheckpoint(checkpoint);
+ expectError(() => scene.releaseCheckpoint(checkpoint), RangeError, /^checkpointId: got \{\}; expected a checkpointId that scene_checkpoint returned and you have not released\.$/);
+});
+
+test('a mesh region on a plain shape names the tag and the next step', () => {
+ const recipe = baseRecipe();
+ recipe.nodes[1] = { id: 'lid', geometry: 'cube', material: 'plain', relations: [{ kind: 'gap', to: 'body', region: 'top', side: '+y' }] };
+ assert.throws(() => createAgentScene(recipe), error => error instanceof RangeError
+ && /region: got "top"; expected a tag on a mesh geometry; tag faces with a mesh_edit tag op, or drop region/.test(error.message));
+});
+
+test('direct mesh and terrain builders name the field and the next step', () => {
+ const scene = createAgentScene(baseRecipe());
+ assert.throws(() => taggedFacePositions(scene.parts[0].geometry, 'lid'), error => error instanceof RangeError
+ && /^region: got "lid"; expected a tag on a mesh geometry; tag faces with a mesh_edit tag op, or drop region\.$/.test(error.message));
+ assert.throws(() => generateTerrainGeometry({ resolution: 200 }, 5000), error => error instanceof RangeError
+ && /^terrain\.resolution: got 200; expected a resolution whose 40401 vertices fit maxVertices 5000; lower it\.$/.test(error.message));
+ assert.throws(() => generateTerrainGeometry({ resolution: 8.5 }, 5000), error => error instanceof RangeError
+ && /^terrain\.resolution: got 8.5; expected a whole number, such as 64\.$/.test(error.message));
+});
+
+// The guard: these files hold the validators an agent reaches through recipes and operations. A throw in them reports
+// through invalidField, which names the path, the value and what is accepted. The throws listed here stay raw on
+// purpose: whole-input size limits, JSON copy checks that run before any field has a path, and engine invariants no
+// recipe field can fix. A new raw throw fails this test until it uses invalidField or is listed.
+const RAW_THROWS_LEFT = {
+ 'src/agent-scene.js': [
+ "'maxNodes cannot exceed 4096.');",
+ "'JSON exceeds maxRecipeBytes. Reduce the",
+ "'JSON nesting exceeds 64 levels.');",
+ "'JSON exceeds maxRecipeBytes.');",
+ "'Recipe must contain finite, acyclic JSO",
+ "'JSON exceeds maxRecipeBytes.');",
+ "'Recipe objects must be plain JSON objec",
+ "'Invalid JSON key.');",
+ "'JSON accessors and hidden fields are un",
+ "'JSON arrays must be dense without extra",
+ "'JSON arrays must be dense without trail",
+ "'JSON exceeds maxRecipeBytes.');",
+ "'Camera matrices must remain finite and ",
+ "`Node ${node.name} normal transform exce",
+ "`Node ${node.name} world geometry bounds",
+ "'Retained render matrices must not be de",
+ "'Motion camera matrices exceed the suppo",
+ "'Motion scale must remain positive at Fl",
+ "'Geometry preflight exceeds peak maxVert",
+ "`Mesh ${plan.definition.id} has ${vertic",
+ "'Generated geometry exceeds its conserva",
+ ],
+ 'src/agent-recipe-checks.js': [],
+ 'src/agent-mesh.js': [],
+ 'src/agent-terrain.js': [],
+};
+const THROW_PATTERN = /throw new (?:Range|Type)?Error\((.{0,40})/;
+
+for (const [file, listed] of Object.entries(RAW_THROWS_LEFT)) {
+ test(`${file} adds no raw throw that lacks a field path and an expectation`, () => {
+ const lines = readFileSync(new URL(`../${file}`, import.meta.url), 'utf8').split(/\r?\n/);
+ const found = lines.map(line => line.match(THROW_PATTERN)?.[1]).filter(Boolean);
+ assert.deepEqual(found, listed, `${file}: report agent input mistakes with invalidField(path, value, expected) from src/field-error.js; list a throw here only when no input field can cause it`);
+ });
+}
diff --git a/tests/agent-scene-motion.test.js b/tests/agent-scene-motion.test.js
index ff876e39..05bdce36 100644
--- a/tests/agent-scene-motion.test.js
+++ b/tests/agent-scene-motion.test.js
@@ -99,7 +99,7 @@ test('final batch reference validation prevents dangling tracks and permits atom
assert.throws(() => scene.apply([{ type: 'remove-node', id: 'hinge', recursive: true }], { expectedRevision: 0 }), /target/);
assert.deepEqual(pose(scene), before);
assert.deepEqual(scene.exportRecipe(), canonical);
- assert.throws(() => scene.apply([{ type: 'set-motion' }], { expectedRevision: 0 }), /requires motion/);
+ assert.throws(() => scene.apply([{ type: 'set-motion' }], { expectedRevision: 0 }), /motion: got undefined; expected a motion value, or null to clear it/);
scene.apply([
{ type: 'remove-node', id: 'hinge', recursive: true },
{ type: 'remove-material', id: 'finish' },
diff --git a/tests/agent-scene.test.js b/tests/agent-scene.test.js
index e7c22bf3..680e9b89 100644
--- a/tests/agent-scene.test.js
+++ b/tests/agent-scene.test.js
@@ -82,14 +82,14 @@ test('shader arithmetic rejects cancelling product overflow and nonfinite emissi
const before = session.exportRecipe();
const matrix = Array.from(session.parts[0].matrix);
assert.throws(() => session.apply([{ type: 'set-node', id: 'root', scale: [1e20, 1e-20, 1] }], { expectedRevision: 0 }), /world geometry bounds/);
- assert.throws(() => session.apply([{ type: 'set-material', id: 'finish', emission: 1e30, emissiveColor: [1e30, 0, 0] }], { expectedRevision: 0 }), /Emissive radiance/);
+ assert.throws(() => session.apply([{ type: 'set-material', id: 'finish', emission: 1e30, emissiveColor: [1e30, 0, 0] }], { expectedRevision: 0 }), /materials\[0\]\.emission: got 1e\+30; expected an emission that keeps color times emission within Float32 range/);
assert.deepEqual(session.exportRecipe(), before);
assert.deepEqual(Array.from(session.parts[0].matrix), matrix);
assert.equal(session.revision, 0);
input.materials[0].tag = 'unlit';
input.materials[0].emission = 70000;
input.materials[0].emissiveColor = [1, 0, 0];
- assert.throws(() => createAgentScene(input), /half-float HDR/);
+ assert.throws(() => createAgentScene(input), /materials\[0\]\.emission: got 70000; expected an unlit emission that keeps color times emission at or below 65500/);
});
test('recipes author liquid, foam and blended glass with batch-safe material handles', () => {
@@ -243,16 +243,16 @@ test('checkpoints are private, bounded, session-specific and releaseable', () =>
const session = createAgentScene(recipe(), { maxCheckpoints: 1 });
const checkpoint = session.checkpoint();
assert.ok(Object.isFrozen(checkpoint));
- assert.throws(() => session.checkpoint(), /budget/);
+ assert.throws(() => session.checkpoint(), /checkpoints: got "1 saved"; expected at most 1 saved checkpoints/);
const foreign = createAgentScene(recipe()).checkpoint();
- assert.throws(() => session.restore(foreign, { expectedRevision: 0 }), /Unknown/);
- assert.throws(() => session.releaseCheckpoint(foreign), /Unknown/);
+ assert.throws(() => session.restore(foreign, { expectedRevision: 0 }), /checkpointId: got \{\}; expected a checkpointId that scene_checkpoint returned/);
+ assert.throws(() => session.releaseCheckpoint(foreign), /checkpointId: got \{\}; expected a checkpointId that scene_checkpoint returned/);
session.apply([{ type: 'set-node', id: 'root', translation: [8, 0, 0] }], { expectedRevision: 0 });
assert.throws(() => session.restore(checkpoint, { expectedRevision: 0 }), /expectedRevision/);
session.restore(checkpoint, { expectedRevision: 1 });
session.releaseCheckpoint(checkpoint);
- assert.throws(() => session.restore(checkpoint, { expectedRevision: 2 }), /released/);
- assert.throws(() => session.releaseCheckpoint(checkpoint), /released/);
+ assert.throws(() => session.restore(checkpoint, { expectedRevision: 2 }), /checkpointId: got \{\}; .*you have not released/);
+ assert.throws(() => session.releaseCheckpoint(checkpoint), /checkpointId: got \{\}; .*you have not released/);
assert.ok(session.checkpoint());
});
@@ -278,7 +278,7 @@ test('finite matrices still reject world geometry overflow using cached local bo
});
test('recipe boundary rejects malformed JSON, unknown keys and oversized geometry before generation', () => {
- assert.throws(() => createAgentScene({ ...recipe(), eval: 'code' }), /Unknown/);
+ assert.throws(() => createAgentScene({ ...recipe(), eval: 'code' }), /recipe\.eval: got "code"; expected one of the fields format/);
assert.throws(() => createAgentScene(recipe(), { maxNodes: 4097 }), /4096/);
assert.throws(() => createAgentScene(recipe(), { maxRecipeBytes: 100 }), /maxRecipeBytes/);
assert.throws(() => createAgentScene(recipe(), { maxGeometryBytes: 100 }), /preflight/);
@@ -302,22 +302,22 @@ test('recipe boundary rejects malformed JSON, unknown keys and oversized geometr
});
test('command and resource budgets, bounded inspection and missing IDs report failures', () => {
- assert.throws(() => createAgentScene(recipe(), { maxNodes: 2 }), /resource limit/);
+ assert.throws(() => createAgentScene(recipe(), { maxNodes: 2 }), /nodes: got "3 entries"; expected an array of at most 2 entries/);
const extra = recipe();
extra.geometries.push({ id: 'sphere', type: 'sphere', segments: 8, rings: 4 });
- assert.throws(() => createAgentScene(extra, { maxGeometries: 1 }), /resource limit/);
+ assert.throws(() => createAgentScene(extra, { maxGeometries: 1 }), /geometries: got "2 entries"; expected an array of at most 1 entries/);
const duplicate = recipe();
duplicate.nodes[2].id = 'root';
- assert.throws(() => createAgentScene(duplicate), /Duplicate/);
+ assert.throws(() => createAgentScene(duplicate), /nodes\[2\]\.id: got "root"; expected an ID no other nodes entry uses/);
const session = createAgentScene(recipe(), { maxOperations: 1 });
- assert.throws(() => session.apply([{ type: 'set-camera', fov: 60 }, { type: 'set-camera', fov: 70 }], { expectedRevision: 0 }), /maxOperations/);
- assert.throws(() => session.apply([], { expectedRevision: 0 }), /commands/);
+ assert.throws(() => session.apply([{ type: 'set-camera', fov: 60 }, { type: 'set-camera', fov: 70 }], { expectedRevision: 0 }), /operations: got "2 operations"; expected a list of 1 to 1 operations/);
+ assert.throws(() => session.apply([], { expectedRevision: 0 }), /operations: got \[\]; expected a list of 1 to 1 operations/);
const inspection = session.inspect({ limit: 1 });
assert.equal(inspection.nodes.length, 1);
assert.equal(inspection.truncated, true);
assert.equal(inspection.counts.nodes, 3);
- assert.throws(() => session.inspect({ ids: ['missing'] }), /not found/);
- assert.throws(() => session.inspect({ includeBounds: 'yes' }), /boolean/);
+ assert.throws(() => session.inspect({ ids: ['missing'] }), /ids: got "missing"; expected IDs of existing nodes/);
+ assert.throws(() => session.inspect({ includeBounds: 'yes' }), /includeBounds: got "yes"; expected true or false/);
assert.equal(session.revision, 0);
});
@@ -358,7 +358,7 @@ test('all seven generators remain within conservative aggregate vertex and byte
assert.notEqual(session.parts[0], originalBox);
assert.equal(session.parts[0].geometry, session.parts[2].geometry);
assert.equal(session.topologyRevision, 1);
- assert.throws(() => session.apply([{ type: 'set-material', id: 'material', tag: 'unlit' }], { expectedRevision: 1 }), /Unknown/);
+ assert.throws(() => session.apply([{ type: 'set-material', id: 'material', tag: 'unlit' }], { expectedRevision: 1 }), /operation\.tag: got "unlit"; expected one of the fields type, id/);
});
function emptyRecipe() {
@@ -449,7 +449,7 @@ test('node deletion distinguishes nonrecursive rejection from explicit subtree r
const session = createAgentScene(input);
assert.throws(() => session.apply([
{ type: 'remove-node', id: 'root' }, { type: 'remove-node', id: 'child', recursive: true },
- ], { expectedRevision: 0 }), /Nonrecursive/);
+ ], { expectedRevision: 0 }), /recursive: got false; expected true for a node with children/);
session.apply([{ type: 'remove-node', id: 'root', recursive: true }], { expectedRevision: 0 });
assert.deepEqual(session.exportRecipe().nodes.map(node => node.id), ['other']);
assert.deepEqual(session.parts.map(part => part.name), ['other']);
@@ -624,7 +624,7 @@ test('an existing default material is reused and a node with only a material sti
const orphan = recipe();
delete orphan.nodes[1].geometry;
orphan.nodes[1].material = 'finish';
- assert.throws(() => createAgentScene(orphan), /Name a geometry to draw it, or drop material/);
+ assert.throws(() => createAgentScene(orphan), /nodes\[1\]\.geometry: got "finish"; expected set together with material/);
});
test('a recipe without a materials or geometries list reads them as empty, and the export lists them', () => {
diff --git a/tests/cloth.test.js b/tests/cloth.test.js
index e8d8ccb1..6122e8e0 100644
--- a/tests/cloth.test.js
+++ b/tests/cloth.test.js
@@ -174,7 +174,7 @@ test('cloth recipes need the cloth module and plain recipes do not', () => {
test('set-cloth edits the section, null clears it and the recipe round trips', () => {
const scene = createAgentScene(flagRecipe(null));
- assert.throws(() => scene.sampleMotion(1), /no motion, physics, cloth or particles/);
+ assert.throws(() => scene.sampleMotion(1), /time: got 1; expected null, because this recipe has no motion, physics, cloth, particles or placed asset clip/);
scene.apply([{ type: 'set-cloth', cloth: hangingFlag }], { expectedRevision: scene.revision });
scene.sampleMotion(1);
const exported = scene.exportRecipe();
@@ -201,22 +201,22 @@ test('hostile cloth sections are rejected before any solver runs', () => {
bad({ duration: 2, sheets: [] }, /at least one sheet/);
bad({ duration: 0, sheets: [{ node: 'flag' }] }, /duration/);
bad({ duration: 11, sheets: [{ node: 'flag' }] }, /duration/);
- bad({ duration: 2, sheets: [{ node: 'missing' }] }, /not found/);
- bad({ duration: 2, sheets: [{ node: 'flag' }, { node: 'flag' }] }, /twice/);
+ bad({ duration: 2, sheets: [{ node: 'missing' }] }, /Cloth sheet node: got "missing"; expected the ID of a node in nodes/);
+ bad({ duration: 2, sheets: [{ node: 'flag' }, { node: 'flag' }] }, /Cloth sheet node: got "flag"; expected a node used once in cloth/);
bad({ duration: 2, sheets: [{ node: 'flag', stiffness: 2 }] }, /stiffness/);
bad({ duration: 2, sheets: [{ node: 'flag', density: 0 }] }, /density/);
bad({ duration: 2, sheets: [{ node: 'flag', pin: ['middle'] }] }, /pin/);
- bad({ duration: 2, sheets: [{ node: 'flag', surprise: 1 }] }, /Unknown/);
- bad({ duration: 2, surprise: 1, sheets: [{ node: 'flag' }] }, /Unknown/);
+ bad({ duration: 2, sheets: [{ node: 'flag', surprise: 1 }] }, /cloth sheet\.surprise: got 1; expected one of the fields/);
+ bad({ duration: 2, surprise: 1, sheets: [{ node: 'flag' }] }, /cloth\.surprise: got 1; expected one of the fields/);
bad({ duration: 2, wind: [0, 0, NaN], sheets: [{ node: 'flag' }] }, /finite/);
bad({ duration: 2, wind: [0, 0, 1e9], sheets: [{ node: 'flag' }] }, /wind/);
bad({ duration: 2, gravity: [0, -Infinity, 0], sheets: [{ node: 'flag' }] }, /finite/);
bad({ duration: 2, sheets: Array.from({ length: 9 }, () => ({ node: 'flag' })) }, /at most 8/);
bad({ duration: 2, sheets: [{ node: 'flag' }], colliders: Array.from({ length: 17 }, () => ({ node: 'flag' })) }, /at most 16/);
- bad({ duration: 2, sheets: [{ node: 'flag' }], colliders: [{ node: 'flag' }] }, /twice/);
+ bad({ duration: 2, sheets: [{ node: 'flag' }], colliders: [{ node: 'flag' }] }, /Cloth collider node: got "flag"; expected a node used once in cloth/);
bad({ duration: 2, sheets: [{ node: 'flag' }], colliders: [{ node: 'stone', shape: 'cone' }] }, /shape/, [{ id: 'stone', geometry: 'ball', material: 'stone' }]);
bad({ duration: 2, sheets: [{ node: 'flag' }], colliders: [{ node: 'child' }] }, /root node/, [{ id: 'child', parent: 'flag', geometry: 'ball', material: 'stone' }]);
- bad('cloth', /plain object/);
+ bad('cloth', /expected an object/);
bad({ duration: 2, sheets: 'flag' }, /array/);
});
diff --git a/tests/coplanar-overlap.test.js b/tests/coplanar-overlap.test.js
index 53ba2817..69e05a9a 100644
--- a/tests/coplanar-overlap.test.js
+++ b/tests/coplanar-overlap.test.js
@@ -77,7 +77,7 @@ test('decal, depthLayer and resolveCoplanar all silence the pair without moving
});
test('node decal and depthLayer are validated', () => {
- assert.throws(() => createAgentScene(recipe([wall, { ...sign, decal: 'yes' }])), /decal must be boolean/);
+ assert.throws(() => createAgentScene(recipe([wall, { ...sign, decal: 'yes' }])), /nodes\[1\]\.decal: got "yes"; expected true or false/);
assert.throws(() => createAgentScene(recipe([wall, { ...sign, depthLayer: 9 }])), /depthLayer: got 9; expected a whole number from 0 to 4/);
assert.throws(() => createAgentScene(recipe([wall], { resolveCoplanar: true })), /resolveCoplanar/);
});
diff --git a/tests/film-timeline.test.js b/tests/film-timeline.test.js
index 10cf2262..9bf68064 100644
--- a/tests/film-timeline.test.js
+++ b/tests/film-timeline.test.js
@@ -45,7 +45,7 @@ test('set-timeline edits the timeline and null removes it', () => {
assert.equal(scene.exportRecipe().timeline.shots.length, 3);
scene.apply([{ type: 'set-timeline', timeline: null }], { expectedRevision: scene.revision });
assert.equal(Object.hasOwn(scene.exportRecipe(), 'timeline'), false);
- assert.throws(() => scene.apply([{ type: 'set-timeline' }], { expectedRevision: scene.revision }), /requires timeline/);
+ assert.throws(() => scene.apply([{ type: 'set-timeline' }], { expectedRevision: scene.revision }), /timeline: got undefined; expected a timeline value, or null to clear it/);
});
test('hostile timelines are rejected with a reason', () => {
diff --git a/tests/geometry-cone-icosphere-circle.test.js b/tests/geometry-cone-icosphere-circle.test.js
index 9435580b..665f2876 100644
--- a/tests/geometry-cone-icosphere-circle.test.js
+++ b/tests/geometry-cone-icosphere-circle.test.js
@@ -116,5 +116,5 @@ test('agent recipes accept cone, icoSphere, circle, line and plane in one record
assert.ok(Math.abs(nodeBounds('sheet').max[0] - 0.5) < 1e-6);
assert.deepEqual(createAgentScene(session.exportRecipe()).inspect(), session.inspect());
assert.equal(session.exportRecipe().geometries.find(geometry => geometry.id === 'sheet').type, 'grid');
- assert.throws(() => sceneWith([{ id: 'same', type: 'line', from: [1, 1, 1], to: [1, 1, 1] }]), /distinct/);
+ assert.throws(() => sceneWith([{ id: 'same', type: 'line', from: [1, 1, 1], to: [1, 1, 1] }]), /geometries\[0\]\.to: got \[1,1,1\]; expected a point different from from \[1,1,1\]/);
});
diff --git a/tests/material-patterns.test.js b/tests/material-patterns.test.js
index f77324b0..6b0de5b9 100644
--- a/tests/material-patterns.test.js
+++ b/tests/material-patterns.test.js
@@ -139,7 +139,7 @@ test('a material without a pattern is unchanged', () => {
});
test('patterns need the surface tag and a scene holds a bounded number', () => {
- assert.throws(() => createAgentScene(baseScene([{ id: 'glow', tag: 'unlit', pattern: { type: 'wood' } }])), /needs the surface tag/);
+ assert.throws(() => createAgentScene(baseScene([{ id: 'glow', tag: 'unlit', pattern: { type: 'wood' } }])), /materials\[0\]\.pattern: got "wood"; expected a material with the surface tag/);
const tooMany = Array.from({ length: MAX_MATERIAL_PATTERNS + 1 }, (_, index) => ({ id: `material-${index}`, pattern: { type: 'wood', seed: index } }));
assert.throws(() => createAgentScene(baseScene(tooMany)), /at most 16 different material patterns/);
const shared = Array.from({ length: MAX_MATERIAL_PATTERNS + 1 }, (_, index) => ({ id: `material-${index}`, pattern: { type: 'wood' }, color: [index / 17, 1, 1] }));
diff --git a/tests/mcp-camera-lights.test.js b/tests/mcp-camera-lights.test.js
index 3707c185..1b154dba 100644
--- a/tests/mcp-camera-lights.test.js
+++ b/tests/mcp-camera-lights.test.js
@@ -94,17 +94,17 @@ test('scene_create and set-camera take orthographic, shift, focal length and f-s
test('a camera takes fov or focalLength, never both, and checks each lens field', () => {
const make = camera => createAgentScene(baseRecipe({ camera }));
- assert.throws(() => make({ fov: 40, focalLength: 50 }), /fov or a focalLength, not both/);
- assert.throws(() => make({ sensorWidth: 36 }), /sensorWidth needs focalLength/);
- assert.throws(() => make({ projection: 'orthographic', focalLength: 50 }), /perspective projection/);
- assert.throws(() => make({ orthoScale: 4 }), /needs projection orthographic/);
+ assert.throws(() => make({ fov: 40, focalLength: 50 }), /camera\.focalLength: got 50; expected only one of fov \(degrees\) or focalLength/);
+ assert.throws(() => make({ sensorWidth: 36 }), /camera\.sensorWidth: got 36; expected a field used with focalLength/);
+ assert.throws(() => make({ projection: 'orthographic', focalLength: 50 }), /camera\.focalLength: got 50; expected a field of a perspective camera/);
+ assert.throws(() => make({ orthoScale: 4 }), /camera\.orthoScale: got 4; expected a field of an orthographic camera/);
assert.throws(() => make({ projection: 'orthographic', orthoScale: 0 }), /camera\.orthoScale: got 0; expected a positive view height/);
assert.throws(() => make({ projection: 'fisheye' }), /perspective or orthographic/);
assert.throws(() => make({ shift: [2, 0] }), /shift/);
assert.throws(() => make({ fStop: 0.1 }), /fStop/);
- assert.throws(() => createAgentScene(baseRecipe({ camera: { fStop: 2 }, effects: { depthOfField: { blur: 0.5 } } })), /fStop drives depth of field/);
+ assert.throws(() => createAgentScene(baseRecipe({ camera: { fStop: 2 }, effects: { depthOfField: { blur: 0.5 } } })), /camera\.fStop: got 2; expected a camera without effects\.depthOfField\.blur above 0/);
const scene = createAgentScene(baseRecipe({ camera: { fov: 40 } }));
- assert.throws(() => scene.apply([{ type: 'set-camera', fov: 40, focalLength: 50 }], { expectedRevision: 0 }), /not both/);
+ assert.throws(() => scene.apply([{ type: 'set-camera', fov: 40, focalLength: 50 }], { expectedRevision: 0 }), /camera\.focalLength: got 50; expected only one of fov/);
scene.apply([{ type: 'set-camera', focalLength: 85 }], { expectedRevision: 0 });
assert.equal(scene.camera.fov, undefined);
scene.apply([{ type: 'set-camera', fov: 30 }], { expectedRevision: 1 });
diff --git a/tests/mcp-tools.test.js b/tests/mcp-tools.test.js
index ca4b80c8..23c7e0e3 100644
--- a/tests/mcp-tools.test.js
+++ b/tests/mcp-tools.test.js
@@ -290,7 +290,7 @@ test('mesh_inspect reports polygon counts, tags and lint for recipe geometries',
assert.deepEqual(singular.structuredContent.meshes.map(mesh => mesh.geometry), ['cube']);
const missing = await client.callTool({ name: 'mesh_inspect', arguments: { sessionId, geometries: ['nope'] } });
assert.equal(missing.isError, true);
- assert.match(missing.content[0].text, /Known IDs: cube, cable/);
+ assert.match(missing.content[0].text, /geometries: got "nope"; expected one of cube, cable/);
await rejected(client, 'mesh_inspect', { sessionId, geometries: [] });
await rejected(client, 'mesh_inspect', { sessionId, geometries: Array.from({ length: 17 }, (_, index) => `g${index}`) });
await rejected(client, 'mesh_inspect', { sessionId, path: '../file' });
@@ -402,7 +402,7 @@ test('real SDK calls preserve atomic revisions, checkpoints, recipe snapshots an
assert.equal((await call('scene_release_checkpoint', { sessionId, checkpointId: checkpoint.checkpointId })).structuredContent.released, true);
const released = await call('scene_restore', { sessionId, checkpointId: checkpoint.checkpointId, expectedRevision: revision + 2 });
assert.equal(released.isError, true);
- assert.match(released.content[0].text, /released checkpoint/);
+ assert.match(released.content[0].text, /checkpointId: got .*expected a checkpointId that scene_checkpoint returned and you have not released/);
assert.equal((await call('scene_dispose', { sessionId })).structuredContent.disposed, true);
await boundary.server.close();
await new Promise(resolve => setImmediate(resolve));
diff --git a/tests/mesh-boolean.test.js b/tests/mesh-boolean.test.js
index 10fcc072..29b23a56 100644
--- a/tests/mesh-boolean.test.js
+++ b/tests/mesh-boolean.test.js
@@ -130,5 +130,5 @@ test('recipe meshes run booleans with inline primitive cutters', () => {
format: '67js.scene', schemaVersion: 1,
geometries: [{ id: 'bad', type: 'mesh', base: { type: 'box' }, edits: [{ op: 'boolean', operation: 'union', cutter: { type: 'box', id: 'x' } }] }],
materials: [], nodes: [],
- }), /cutter must be a primitive/);
+ }), /geometries\[0\]\.cutter: got \{"type":"box","id":"x"\}; expected a primitive or profile record without an id/);
});
diff --git a/tests/mesh-edit.test.js b/tests/mesh-edit.test.js
index 9c4b6897..25e82bd7 100644
--- a/tests/mesh-edit.test.js
+++ b/tests/mesh-edit.test.js
@@ -204,7 +204,7 @@ test('recipe mesh geometry renders, reports edits and rejects bad edits atomical
format: '67js.scene', schemaVersion: 1,
geometries: [{ id: 'plain', type: 'box', bevel: 0 }, { id: 'nested', type: 'mesh', base: { type: 'mesh', base: { type: 'box' } } }],
materials: [], nodes: [],
- }), /mesh base must be a primitive/);
+ }), /geometries\[1\]\.base: got .*expected a primitive or profile record without an id/);
const plain = createAgentScene({ format: '67js.scene', schemaVersion: 1, geometries: [{ id: 'plain', type: 'box', bevel: 0 }], materials: [], nodes: [] });
- assert.throws(() => plain.apply([{ type: 'edit-mesh', geometry: 'plain', edits: [] }], { expectedRevision: 0 }), /Add a mesh geometry with base/);
+ assert.throws(() => plain.apply([{ type: 'edit-mesh', geometry: 'plain', edits: [] }], { expectedRevision: 0 }), /geometry: got "plain"; expected the ID of a mesh geometry, but it is a box\. Add a mesh geometry with base/);
});
diff --git a/tests/mesh-fields.test.js b/tests/mesh-fields.test.js
index a2ce8218..f910ab80 100644
--- a/tests/mesh-fields.test.js
+++ b/tests/mesh-fields.test.js
@@ -253,5 +253,5 @@ test('a recipe with an instanced node creates one instanced batch of ordinary no
assert.equal(session.parts.length, 1 + 30);
assert.equal(new Set(session.parts.map(part => part.geometry)).size, 2);
assert.throws(() => createAgentScene({ ...recipe, nodes: [{ ...recipe.nodes[1], instances: { scatter: { count: 10_000_000, min: [0, 0, 0], max: [1, 1, 1] } } }] }), /scatter count/);
- assert.throws(() => createAgentScene({ ...recipe, nodes: [{ ...recipe.nodes[1], instances: { surface: { geometry: 'missing', count: 3 } } }] }), /not in geometries/);
+ assert.throws(() => createAgentScene({ ...recipe, nodes: [{ ...recipe.nodes[1], instances: { surface: { geometry: 'missing', count: 3 } } }] }), /instances\.surface: got "missing"; expected the ID of a geometry in geometries/);
});
diff --git a/tests/mesh-stack.test.js b/tests/mesh-stack.test.js
index 2839212b..d2f98085 100644
--- a/tests/mesh-stack.test.js
+++ b/tests/mesh-stack.test.js
@@ -135,7 +135,7 @@ test('recipe meshes evaluate stacks, reuse cached prefixes and apply nodes into
assert.deepEqual(exported.stack.map(node => node.op), ['array']);
const [applied] = scene.inspectMeshes().meshes;
assert.equal(applied.counts.faces, changed.counts.faces, 'applying a node does not change the result');
- assert.throws(() => scene.apply([{ type: 'set-mesh-stack', geometry: 'wing', apply: 5 }], { expectedRevision: 2 }), /apply must be an integer from 0 to the stack length 1/);
+ assert.throws(() => scene.apply([{ type: 'set-mesh-stack', geometry: 'wing', apply: 5 }], { expectedRevision: 2 }), /apply: got 5; expected a whole number from 0 to the stack length 1/);
assert.throws(() => scene.apply([{ type: 'set-mesh-stack', geometry: 'wing', stack: [{ op: 'translate', offset: [0, 1, 0] }] }], { expectedRevision: 2 }), /op must be one of mirror/);
assert.equal(scene.revision, 2);
});
diff --git a/tests/navmesh.test.js b/tests/navmesh.test.js
index 9b3c41be..741c56b8 100644
--- a/tests/navmesh.test.js
+++ b/tests/navmesh.test.js
@@ -81,6 +81,6 @@ test('scene_inspect path returns translation keyframes around the hole of a reci
assert.ok(!(value[0] > -8.8 && value[0] < -5.2 && value[2] > -8.8 && value[2] < -5.2), `${value} is inside the rock`);
}
assert.throws(() => scene.inspect({ path: { ground: 'ground', from: [0, 0], to: [15, 15] } }), /a hole/);
- assert.throws(() => scene.inspect({ path: { ground: 'nowhere', from: [0, 0], to: [15, 15] } }), /not a node/);
+ assert.throws(() => scene.inspect({ path: { ground: 'nowhere', from: [0, 0], to: [15, 15] } }), /path\.ground: got "nowhere"; expected the ID of a node with a drawn geometry/);
assert.throws(() => scene.inspect({ path: { ground: 'ground', from: [-15, -15], to: [15, 15], seconds: 2, speed: 1 } }), /seconds or speed/);
});
diff --git a/tests/part-relations.test.js b/tests/part-relations.test.js
index 8d93b926..70568d98 100644
--- a/tests/part-relations.test.js
+++ b/tests/part-relations.test.js
@@ -99,7 +99,7 @@ test('a tagged region of the target is the reference, not the whole part', () =>
], [body]);
assert.throws(() => createAgentScene(bad), /cannot be satisfied.*Unknown tag lid.*Known tags: .*top/s);
const plain = recipeWith([{ id: 'a' }, { id: 'b', relations: [{ kind: 'gap', to: 'a', region: 'top', side: '+y' }] }]);
- assert.throws(() => createAgentScene(plain), /plain shape.*tag faces with a mesh_edit tag op/s);
+ assert.throws(() => createAgentScene(plain), /region: got "top"; expected a tag on a mesh geometry.*tag faces with a mesh_edit tag op/s);
});
test('relations solve the same every time and again after an edit moves a referenced region', () => {
diff --git a/tests/particle-collision.test.js b/tests/particle-collision.test.js
index 456428e1..5f10a2e4 100644
--- a/tests/particle-collision.test.js
+++ b/tests/particle-collision.test.js
@@ -142,7 +142,7 @@ test('collision input is validated and the capabilities describe it', () => {
const rejects = (system, pattern) => assert.throws(() => createAgentScene(dropRecipe(system)), pattern);
rejects({ bounce: 1.5 }, /bounce/);
rejects({ friction: -1 }, /friction/);
- rejects({ colliders: ['ghost'] }, /not found/);
+ rejects({ colliders: ['ghost'] }, /Particle collider node: got "ghost"; expected the ID of a node in nodes/);
rejects({ colliders: ['sparks'] }, /own collider/);
rejects({ colliders: 'slab' }, /colliders/);
rejects({ alpha: [0, 2] }, /alpha/);
diff --git a/tests/particles.test.js b/tests/particles.test.js
index cc53186c..6108e684 100644
--- a/tests/particles.test.js
+++ b/tests/particles.test.js
@@ -145,7 +145,7 @@ test('set-particles adds, changes and clears the section, and restores through a
assert.equal(scene.inspect().particles.systems[0].particles, 5);
scene.apply([{ type: 'set-particles', particles: null }], { expectedRevision: scene.revision });
assert.equal(scene.inspect().particles, undefined);
- assert.throws(() => scene.apply([{ type: 'set-particles' }], { expectedRevision: scene.revision }), /requires particles/);
+ assert.throws(() => scene.apply([{ type: 'set-particles' }], { expectedRevision: scene.revision }), /particles: got undefined; expected a particles value, or null to clear it/);
});
test('the capabilities describe the limits that the validator enforces', () => {
@@ -166,40 +166,40 @@ test('hostile input is rejected with the limit in the message', () => {
bad(system({ seed: -1 }), /seed must be an integer/);
bad(system({ seed: 2 ** 32 }), /seed must be an integer/);
bad(system({ seed: 1.5 }), /seed must be an integer/);
- bad(system({ lifetime: 0 }), /lifetime must be a finite number/);
- bad(system({ lifetime: 1e9 }), /lifetime must be a finite number/);
+ bad(system({ lifetime: 0 }), /Particle lifetime: got (0|1e\+9); expected a finite number from 0\.01 to 60/);
+ bad(system({ lifetime: 1e9 }), /lifetime: got .*expected a finite number/);
bad(system({ lifetime: [2, 1] }), /minimum must not exceed/);
bad(system({ lifetime: [1, 2, 3] }), /lifetime must be a number or/);
bad(system({ speed: NaN }), /finite|count|speed|direction|rate/);
- bad(system({ speed: -1 }), /speed must be a finite number/);
- bad(system({ size: 0 }), /size must be a finite number/);
- bad(system({ size: 1e30 }), /size must be a finite number/);
- bad(system({ rate: 0 }), /rate must be a finite number/);
+ bad(system({ speed: -1 }), /speed: got .*expected a finite number/);
+ bad(system({ size: 0 }), /size: got .*expected a finite number/);
+ bad(system({ size: 1e30 }), /size: got .*expected a finite number/);
+ bad(system({ rate: 0 }), /rate: got .*expected a finite number/);
bad(system({ rate: Infinity }), /finite|count|speed|direction|rate/);
- bad(system({ spread: 181 }), /spread must be a finite number/);
- bad(system({ drag: -1 }), /drag must be a finite number/);
- bad(system({ drag: 1e9 }), /drag must be a finite number/);
- bad(system({ floor: 1e9 }), /floor must be a finite number/);
+ bad(system({ spread: 181 }), /spread: got .*expected a finite number/);
+ bad(system({ drag: -1 }), /drag: got .*expected a finite number/);
+ bad(system({ drag: 1e9 }), /drag: got .*expected a finite number/);
+ bad(system({ floor: 1e9 }), /floor: got .*expected a finite number/);
bad(system({ direction: [0, 0, 0] }), /zero vector/);
- bad(system({ direction: [1, 2] }), /needs 3 numbers/);
+ bad(system({ direction: [1, 2] }), /expected three numbers/);
bad(system({ direction: [1, 2, NaN] }), /finite|count|speed|direction|rate/);
bad(system({ scale: 'huge' }), /scale must be one of/);
bad(system({ emitter: { shape: 'cone' } }), /emitter shape must be one of/);
- bad(system({ emitter: { radius: -1 } }), /radius must be a finite number/);
- bad(system({ emitter: { position: [1e9, 0, 0] } }), /position must be a finite number/);
- bad(system({ emitter: { jet: true } }), /Unknown or unsupported particle emitter field/);
- bad(system({ colour: 'red' }), /Unknown or unsupported particle system field/);
- bad({ systems: [{ node: 'sparks' }], extra: 1 }, /Unknown or unsupported particles field/);
+ bad(system({ emitter: { radius: -1 } }), /radius: got .*expected a finite number/);
+ bad(system({ emitter: { position: [1e9, 0, 0] } }), /position: got .*expected a finite number/);
+ bad(system({ emitter: { jet: true } }), /particle emitter\.\w+: got .*expected one of the fields/);
+ bad(system({ colour: 'red' }), /particle system\.\w+: got .*expected one of the fields/);
+ bad({ systems: [{ node: 'sparks' }], extra: 1 }, /particles\.\w+: got .*expected one of the fields/);
bad({ systems: [] }, /at least one system/);
- bad({ systems: 'many' }, /must be an array/);
+ bad({ systems: 'many' }, /expected an array/);
bad({ systems: Array.from({ length: 5 }, () => ({ node: 'sparks' })) }, /at most 4/);
- bad({ systems: [{ node: 'sparks' }, { node: 'sparks' }] }, /used twice in particles/);
- bad({ gravity: [0, -1e9, 0], systems: [{ node: 'sparks' }] }, /gravity must be a finite number/);
- bad({ wind: [1000, 0, 0], systems: [{ node: 'sparks' }] }, /wind must be a finite number/);
- bad(system({ node: 'missing' }), /node was not found/);
- bad(system({ node: '__proto__' }), /node was not found/);
+ bad({ systems: [{ node: 'sparks' }, { node: 'sparks' }] }, /expected a node used once in particles/);
+ bad({ gravity: [0, -1e9, 0], systems: [{ node: 'sparks' }] }, /gravity: got .*expected a finite number/);
+ bad({ wind: [1000, 0, 0], systems: [{ node: 'sparks' }] }, /wind: got .*expected a finite number/);
+ bad(system({ node: 'missing' }), /node: got .*expected the ID of a node in nodes/);
+ bad(system({ node: '__proto__' }), /node: got .*expected the ID of a node in nodes/);
bad(null === 0 ? null : JSON.parse('{"systems":[{"node":"sparks","__proto__":{"count":5}}]}'), /Invalid JSON key|Unknown or unsupported/);
- bad('systems', /must be a plain object/);
+ bad('systems', /expected an object/);
});
test('total particles and total vertices are bounded across systems', () => {
@@ -218,7 +218,7 @@ test('a particle node cannot carry motion or physics, or be a cloth sheet', () =
assert.throws(() => createAgentScene(withMotion), /motion/);
const withCloth = sparkRecipe(burst);
withCloth.cloth = { duration: 1, sheets: [{ node: 'sparks' }] };
- assert.throws(() => createAgentScene(withCloth), /used twice|cloth/i);
+ assert.throws(() => createAgentScene(withCloth), /Particle system node: got "sparks"; expected a node used once in particles/);
const child = sparkRecipe(burst, [{ id: 'kid', geometry: 'speck', material: 'glow', parent: 'sparks' }]);
child.particles.systems[0].node = 'kid';
assert.throws(() => createAgentScene(child), /root node/);
@@ -245,7 +245,7 @@ test('a large burst seeks statelessly in fixed buffers, and a huge time is only
assert.equal(bufferSizes.size, 1, 'the particle buffers keep one size across seeks');
scene.sampleMotion(3600);
assert.ok(particlePositions(scene).every(Number.isFinite));
- assert.throws(() => scene.sampleMotion(3601), /Motion time/);
+ assert.throws(() => scene.sampleMotion(3601), /time: got 3601; expected null or a number of seconds from 0 to 3600/);
});
test('the particle code stays unloaded for a scene without particles', async () => {
@@ -343,16 +343,16 @@ test('hair triangles face outward and the report counts strands', () => {
test('hostile hair input is rejected', () => {
const bad = (system, pattern) => assert.throws(() => createAgentScene(hairRecipe(system)), pattern);
- bad({ surface: 'missing' }, /Hair surface node was not found/);
+ bad({ surface: 'missing' }, /Hair surface node: got "missing"; expected the ID of a node in nodes/);
bad({ surface: 'fur' }, /different nodes/);
bad({ segments: 9 }, /segments must be an integer from 1 to 8/);
bad({ segments: 0 }, /segments must be an integer/);
bad({ count: 2001 }, /count must be an integer/);
- bad({ length: 0 }, /length must be a finite number/);
+ bad({ length: 0 }, /length: got .*expected a finite number/);
bad({ length: [3, 1] }, /minimum must not exceed/);
- bad({ width: 100 }, /width must be a finite number/);
- bad({ droop: -1 }, /droop must be a finite number/);
- bad({ sway: 11 }, /sway must be a finite number/);
+ bad({ width: 100 }, /width: got .*expected a finite number/);
+ bad({ droop: -1 }, /droop: got .*expected a finite number/);
+ bad({ sway: 11 }, /sway: got .*expected a finite number/);
});
test('hair limits the vertices it draws, and an empty surface is refused', () => {
diff --git a/tests/render-flags-scene.test.js b/tests/render-flags-scene.test.js
index dbed9ffe..7b3a8520 100644
--- a/tests/render-flags-scene.test.js
+++ b/tests/render-flags-scene.test.js
@@ -84,9 +84,9 @@ test('shadow and composite flags reach the part and split batches', () => {
test('flags must be booleans on mesh nodes and a node is not both holdout and catcher', () => {
const node = fields => recipe({ nodes: [{ id: 'one', geometry: 'box', material: 'finish', ...fields }] });
- assert.throws(() => createAgentScene(node({ castShadow: 'no' })), /castShadow must be boolean/);
- assert.throws(() => createAgentScene(node({ visible: 0 })), /visible must be boolean/);
- assert.throws(() => createAgentScene(node({ holdout: true, shadowCatcher: true })), /not both/);
- assert.throws(() => createAgentScene(recipe({ nodes: [{ id: 'g', holdout: true }] })), /belongs on a mesh node/);
+ assert.throws(() => createAgentScene(node({ castShadow: 'no' })), /nodes\[0\]\.castShadow: got "no"; expected true or false/);
+ assert.throws(() => createAgentScene(node({ visible: 0 })), /nodes\[0\]\.visible: got 0; expected true or false/);
+ assert.throws(() => createAgentScene(node({ holdout: true, shadowCatcher: true })), /nodes\[0\]\.shadowCatcher: got true; expected false when holdout is true/);
+ assert.throws(() => createAgentScene(recipe({ nodes: [{ id: 'g', holdout: true }] })), /nodes\[0\]\.holdout: got true; expected a flag on a mesh node/);
assert.throws(() => createAgentScene(recipe({ motion: { duration: 1, tracks: [{ kind: 'node', id: 'first', property: 'visible', keyframes: [{ time: 0, value: 0.5 }] }] } })), /1 \(shown\) or 0/);
});
diff --git a/tests/shader-snippet-validator.test.js b/tests/shader-snippet-validator.test.js
index 92455e71..28b97076 100644
--- a/tests/shader-snippet-validator.test.js
+++ b/tests/shader-snippet-validator.test.js
@@ -144,6 +144,6 @@ test('the documented example passes the validator and builds a scene', async ()
assert.equal(scene.postPasses.length, 1);
assert.throws(() => scene.apply([{ type: 'set-post-passes', postPasses: [{ ...postPasses[0], fragment: '#define A 1\n' + postPasses[0].fragment }] }], { expectedRevision: scene.revision }), /Preprocessor lines/);
assert.equal(scene.postPasses.length, 1);
- assert.throws(() => scene.apply([{ type: 'set-post-passes' }], { expectedRevision: scene.revision }), /requires postPasses; use null to clear it/);
+ assert.throws(() => scene.apply([{ type: 'set-post-passes' }], { expectedRevision: scene.revision }), /postPasses: got undefined; expected a postPasses value, or null to clear it/);
assert.deepEqual(scene.exportRecipe().postPasses, scene.postPasses);
});