@woosh/meep-engine 2.169.1 → 2.169.2

package/src/DUPLICATION_AUDIT_REMEDIATION.md

@@ -0,0 +1,250 @@
+# Duplication audit — remediation plan
+
+Source: [DUPLICATION_AUDIT_2026_08_07.md](DUPLICATION_AUDIT_2026_08_07.md); per-domain evidence in
+[DUPLICATION_AUDIT_2026_08_07/](DUPLICATION_AUDIT_2026_08_07/).
+
+**117 items selected for remediation.**
+
+Each item gets, before any code changes:
+1. **Adversarial review** — is the finding actually valid? (re-read the source; findings were
+   reliable about *what* but unreliable about *where* — see audit §7.)
+2. **Complexity question** — does the fix make the code significantly more complex?
+3. **Performance question** — does the fix make the relevant part of the engine significantly slower?
+
+An item may be closed as **REJECTED** (finding invalid) or **DECLINED** (valid but the fix costs more
+than the duplication) — both are legitimate outcomes and are recorded with the reason.
+
+Legend: `[ ]` pending · `[x]` done · `[~]` rejected/declined (reason given)
+
+
+
+## A — core/geom + core/math  (25 items)
+
+| | ID | Sev | Finding | Valid? | More complex? | Slower? |
+|---|---|---|---|---|---|---|
+| [x] | **A2** | HIGH | Boolean and distance-returning AABB-vs-ray-segment slab tests, whose docs declare they MUST agree, are two independent copies of the same numerical… | Yes — identical through t_box_max; only the return differs | No, −45 lines | No — 1 static call, monomorphic, V8 inlines |
+| [x] | **A3** | HIGH | Point-in-closed-triangle-surface classifier (BVH build + 3-ray parity majority vote) copy-pasted whole between the tetrahedral carver and the inter… | Yes — RAY_DIRECTIONS digit-identical, build_surface_bvh token-identical | No — extracted to bt_mesh_surface_ray_parity | No — tetrahedralisation is build-time |
+| [x] | **A4** | HIGH | Radial-cycle splice (the core half-edge invariant "link a loop into an edge's face ring") implemented three times, with two of them behaviourally d… | Yes — 3 impls, 2 divergences (prev-vs-next splice, missing self-link) | No — 2 private copies deleted | No — mesh construction, build-time. Ring order differs only for 3+ loops on one edge; 2-manifold rings identical either way |
+| [x] | **A5** | HIGH | Static implicit-binary-tree spatial index (morton quicksort + bottom-up bounds assembly) forked 3D→2D; the fork carries a scratch-stack indexing bu… | Yes — CONFIRMED re-entrancy bug: seeds stack[0]/[1] absolutely but reads from stack_top | No — 2-line fix | No. Full sort_morton/build hoist DECLINED: would need combine_fn/morton_fn indirect calls per node in a build inner loop |
+| [x] | **A7** | MEDIUM | ConvexHullShape3D and MeshShape3D share five copy-pasted query methods. | Yes — sample_random_point_in_volume token-identical; needs only 2 abstract methods | No — 2 copies removed, 1 base default added | No — 256 contains_point probes dominate the bbox copy |
+| [x] | **A8** | MEDIUM | Bounding box of a flat (x,y,z) buffer re-inlined instead of calling aabb3_from_v3_array. | Yes — same reduction the primitive performs | No, −11 lines x2 | No — same loop, inside recompute |
+| [x] | **A11** | MEDIUM | MeshShape3D re-implements the shared finite-difference SDF-gradient sampler with a different step size and no normalisation, while every other shap… | Yes — 6 siblings delegate, this one didn't; also unnormalised | No, 18 lines to 1 | No — 4 SDF calls dominate; adds one sqrt |
+| [x] | **A13** | MEDIUM | curl_noise_3d is curl_noise_3dt with w = 0, including the six duplicated decorrelation offsets. | Yes — curl_noise_3dt(w=0) is exactly it | No, 12 lines to 1 | No — 3x sdnoise3 dominates |
+| [x] | **A14** | MEDIUM | m4_compose (object args) and m4_from_rotation_translation_scale (array args) contain the same 45-line quaternion→matrix expansion. | Yes — identical expansion, only operand reads differ | No — one scalar core, both public names kept | No — one static call; V8 inlines |
+| [x] | **A15** | MEDIUM | The boolean segment-segment intersection test is an exact prefix of the point-returning one. | Yes — exact prefix, 13 identical lines | No — shared core, both faces thin | No — one call; boolean discards via module scratch |
+| [x] | **A16** | MEDIUM | Reading a triangular face's three vertex ids / coordinates out of a BinaryTopology is hand-written at ~8 non-spec sites, with inconsistent "is it a… | Yes — 2 copies with INCONSISTENT safety: one checked NULL_POINTER, neither verified triangularity | No — new primitive checks both; call sites shorter | No — same reads plus one loop_read_next triangularity check |
+| [x] | **A17** | MEDIUM | Straight-line vertex-to-vertex distance re-implemented inside both pathfinders while the primitive sits in the same directory — and the two copies … | Yes — 3 spellings incl. hypot vs sqrt (not bit-identical) | No — deletes 2 local fns | No — FASTER; hypot is slower than sqrt |
+| [x] | **A18** | MEDIUM | order_cycle_from and the fan-fill of a boundary loop are copy-pasted between the two hole-closing modules. | Yes — order_cycle_from byte-identical modulo brace formatting | No — extracted to bt_boundary_loop | No — hole-filling is a build-time mesh repair pass |
+| [x] | **A19** | MEDIUM | project_triangle (isometric triangle flattening) duplicated between the two chart parameterisers. | Yes — same algorithm; BFF comment said 'Same as LSCM' | No — promoted to tri3_flatten_isometric | No — build-time atlas path |
+| [x] | **A20** | MEDIUM | qt_collect_by_circle and qt_match_data_by_circle are the same traversal, differing by one predicate conjunct; and the circle queries lost the child… | Yes — same traversal, one predicate conjunct; circle queries lacked push-time pruning | No — one impl + accept_all fn (not a null sentinel) | No — adds 1 indirect call/datum but ALSO adds child pruning box had and circle lacked; net favourable |
+| [x] | **A21** | MEDIUM | Winding-agnostic point-in-tetrahedron and coordinate-form orient3d are file-private in MeshShape3D while the shared versions sit in core/geom/3d. | Yes — determinant expansion character-identical | No — orient3d_fast becomes a 3-line reader | No — contains_point timing unchanged (2260ms vs 2104-2234 baseline) |
+| [~] | **A22** | LOW-MEDIUM | m4_decompose re-derives the whole of m4_extract_scale. | Partly — only the 3 v3_length calls coincide | Would ADD complexity: scratch array + call to share 3 lines | n/a — declined; documented instead (reflection handling makes the two return different scale) |
+| [x] | **A23** | LOW-MEDIUM | Barycentric-weights → 3D point reconstruction re-expanded at five sites instead of a tri3_closest_point primitive. | Yes — 6 sites reconstructed from barycentrics, 3 different namings | No — 6 sites collapse to 1 line each | No — surface-scan helpers, not collision hot path |
+| [x] | **A24** | LOW-MEDIUM | The two atlas_segment_charts variants re-declare the same tuning constants and the same roundness term, with a comment claiming they must stay local. | Yes — and the 'kept local for monomorphism' comment is wrong for constants | No | No — tiny monomorphic fn, V8 inlines |
+| [~] | **A25** | LOW-MEDIUM | The spatial-hash-grid cell walk (read element AABB out of the pool) is duplicated between the circle and line queries, including the same no-dedupl… | Partly — layout constants are ALREADY shared imports; only 4 array reads coincide | Would ADD complexity | YES — forces a scratch round-trip in a broadphase inner loop; documented instead |
+| [x] | **A26** | LOW | Shape hash() methods disagree on the integer mixing function even though combine_hash exists. | Yes — 3 sibling vector types used 3 different mixers; Vector2 omitted |0 entirely | No — hash_mix2/hash_mix3, call sites shorter | No — non-allocating, unlike varargs combine_hash |
+| [~] | **A27** | LOW | BFF's interior_angle re-implements v3_angle from an indexed buffer, using the acos form rather than the atan2-stable form that also exists. | NO — recommendation was WRONG: v3_angle returns acos(0)=PI/2 for degenerate, BFF returns 0 | n/a | n/a — swap would corrupt BFF curvature (Omega = 2PI - sum theta); documented as deliberate |
+| [x] | **A28** | LOW | Two different exported functions named compute_edge_collapse_cost in the same package. | Yes — 2 different exported fns, same name, sibling files | No — rename + deprecated alias | No |
+| [x] | **A29** | LOW | Per-vertex quadric accumulation implemented twice, once per mesh representation, with divergent feature sets. | Partly — normals legitimately differ; only d=-n.v0 + setFromVector4 is shared | No — narrower primitive than proposed | No — per-face, build-time |
+| [x] | **A30** | LOW | read_frustum_corner is v3_copy_array with an index instead of an offset. | Yes — same 3 reads, v3_copy_array already overlap-safe | No | No — per-frame, not per-pixel |
+
+## B — core data structures  (8 items)
+
+| | ID | Sev | Finding | Valid? | More complex? | Slower? |
+|---|---|---|---|---|---|---|
+| [x] | **B3** | HIGH | Traversal-order invariant duplicated 14× and drifted. Every hand-written BVH2 traversal repeats the same stack skeleton *and* the comment "write to… | Yes — I verified: 8 sites, byte-identical comment (typo included), 2 matched it, 6 contradicted | No — swapped 2 lines per file, fixed the typo | No — identical work, only push order |
+| [~] | **B9** | MEDIUM | Intrusive MRU doubly-linked-list splice duplicated between the two cache implementations. | Yes — token-identical MRU splice | Extraction would re-home 44 private-field accesses across 2 cache classes | n/a — declined as too risky for a bulk sweep; documented, recommended standalone |
+| [x] | **B10** | MEDIUM | BVH8 geometry validator duplicated for the direct vs pool-indirect triangle addressing conventions. | Yes — 92% shared, one differing line | No for the helper; walk merge DECLINED (needs identity array sized to triangle count, or per-triangle indirect call) | No — cold debug validator |
+| [x] | **B12** | MEDIUM | Graph-layout helpers duplicated between the box and circle layouters, including a verbatim topological-layer peel. | Yes — buildLayer token-identical, pure topology | No — extracted to graph_peel_topological_layer | No — layout runs per graph edit |
+| [x] | **B14** | MEDIUM | Four colour-adjustment operators are the same 20-line body (assert pair → early-return on amount === 0 → new Color() → linear_srgb_to_okhsv → scale… | Yes — same 20-line body x4; the 'drifted clamp' is behaviourally equivalent though | No — 4 typed wrappers, numeric channel index (not a string key) | No — theme/UI time |
+| [x] | **B19** | LOW | MEASUREMENT_UNITS_SI and UNIT_DIMENSION_MAPPING are the same seven NamedUnit values in the same order, exported twice from two files with the same … | Yes — same 7 units, same order, twice | No — one aliases the other | No |
+| [x] | **B20** | LOW | Two connected-components implementations, one of them quadratic. | Yes — O(n^2) indexOf+splice vs Set | No — array kept for pop order, Set added for membership | FASTER — O(n) not O(n^2); ordering provably unchanged |
+| [x] | **B21** | LOW | Inline 2-D length/distance re-derived next to an imported primitive that already does it. | Yes — 4 inline sqrt sites next to an imported v2_distance | No | No — layout is cold |
+
+## C — graphics render/material/texture/geometry  (13 items)
+
+| | ID | Sev | Finding | Valid? | More complex? | Slower? |
+|---|---|---|---|---|---|---|
+| [x] | **C1** | HIGH | Triangle-vertex fetch from a possibly-normalized, possibly-implicitly-indexed vertex buffer (~45 lines: index resolve → 3 addresses → 9 reads → 9 d… | see domain report | see domain report | see domain report |
+| [x] | **C2** | HIGH | Nearest-point-on-mesh BVH query: ordered child descent by aabb3_unsigned_distance_sqr_to_point + leaf tri3_closest_point_barycentric → barycentric … | see domain report | see domain report | see domain report |
+| [x] | **C3** | HIGH | Material-texture coalescing loop over TextureAttachmentsByMaterialType + identically-configured Cache<Texture,Texture> | see domain report | see domain report | see domain report |
+| [~] | **C4** | HIGH | "Marked material transform" protocol: own-property marker check → throw on foreign transformer → clone → composeCompile → stamp marker | see domain report | see domain report | see domain report |
+| [~] | **C7** | MEDIUM | GPU internal-format string, hand-written instead of derived | see domain report | see domain report | see domain report |
+| [x] | **C16** | MEDIUM | Whole-file duplicate: CopyShader | see domain report | see domain report | see domain report |
+| [x] | **C18** | MEDIUM | Cloud-shadow uniform block (13 uniforms + the SHADOWMAP_CLOUDS define) | see domain report | see domain report | see domain report |
+| [x] | **C19** | MEDIUM | Channel-count → format-prefix switch (1→R, 2→RG, 3→RGB, 4→RGBA, same throw message) | see domain report | see domain report | see domain report |
+| [x] | **C20** | MEDIUM | GLSL: full-screen quad vertex shader | see domain report | see domain report | see domain report |
+| [x] | **C23** | LOW | Numeric-type → channel-count-format dispatch | see domain report | see domain report | see domain report |
+| [~] | **C24** | LOW | Render-target save/restore idiom | see domain report | see domain report | see domain report |
+| [~] | **C25** | LOW | Canvas + createImageData + Sampler2D over imageData.data + putImageData | see domain report | see domain report | see domain report |
+| [~] | **C26** | LOW | Heat-map ParameterLookupTable colour ramp | see domain report | see domain report | see domain report |
+
+## D — graphics feature subsystems  (17 items)
+
+| | ID | Sev | Finding | Valid? | More complex? | Slower? |
+|---|---|---|---|---|---|---|
+| [x] | **D1** | CRITICAL | Octahedral impostor GLSL library copy-pasted 9× inside the domain, plus 3 more name-colliding variants. VecToSphereOct / VecToHemiSphereOct / Vecto… | see domain report | see domain report | see domain report |
+| [x] | **D2** | CRITICAL | The production GI probe-depth GLSL library is copy-pasted into two debug visualisers. sign_not_zero (3 overloads), quadBlendWieghts, VecToSphereOct… | see domain report | see domain report | see domain report |
+| [~] | **D3** | HIGH | AbstractMaterialTransformer.transform() marker-guard / clone / compose protocol copied 3×, already diverged | see domain report | see domain report | see domain report |
+| [x] | **D6** | HIGH | Voxel-impostor splat expansion GLSL copied 5×, carrying a stated cross-shader invariant | see domain report | see domain report | see domain report |
+| [~] | **D7** | HIGH | Spherical-harmonic cosine-lobe irradiance evaluator implemented 4× and the copies disagree on sign convention | see domain report | see domain report | see domain report |
+| [x] | **D8** | MEDIUM | Three highlight systems are the same System + Supplier scaffold with a 15-line hole | see domain report | see domain report | see domain report |
+| [x] | **D9** | MEDIUM | Neighbour-average flood-fill ("dilate") written twice — 2D lightmap and 3D probe grid | see domain report | see domain report | see domain report |
+| [x] | **D10** | MEDIUM | Area-weighted triangle surface sampling copy-pasted instead of reusing the function next door | see domain report | see domain report | see domain report |
+| [x] | **D15** | MEDIUM | Camera depth-plane construction + render-layer depth-range accumulation duplicated | see domain report | see domain report | see domain report |
+| [x] | **D16** | MEDIUM | compute_depth_range BVH closure written 7× verbatim | see domain report | see domain report | see domain report |
+| [x] | **D19** | MEDIUM | Full-screen-quad ShaderMaterial option block restated 4× in one directory, with a typo divergence | see domain report | see domain report | see domain report |
+| [~] | **D20** | MEDIUM | Octahedral depth-probe ray kernel duplicated between the two bakers | n/a — same finding as H10, owned by the engine/ecs agent | n/a | n/a — done there |
+| [~] | **D22** | MEDIUM | The impostor atlas uniform contract restated in 8 material classes | n/a — same finding as F11/F16, owned by the sound agent | n/a | n/a |
+| [x] | **D24** | MEDIUM | The four gi/lpg shader-builder glue functions and two transform-shader files are interchangeable | see domain report | see domain report | see domain report |
+| [x] | **D25** | LOW | packDepthToRGBA — a verbatim reimplementation of three.js's <packing> chunk — appears twice | see domain report | see domain report | see domain report |
+| [x] | **D26** | LOW | Bake-camera frame reconstruction duplicated inside one file | see domain report | see domain report | see domain report |
+| [x] | **D27** | LOW | Two byte-size/component-count switch tables over the *same* enum | see domain report | see domain report | see domain report |
+
+## E — physics  (11 items)
+
+| | ID | Sev | Finding | Valid? | More complex? | Slower? |
+|---|---|---|---|---|---|---|
+| [x] | **E1** | HIGH | Solver impulse application written twice, verbatim. Δv = P·invM; Δω = Iw⁻¹·(r×P) with the identical invM===0 guard, identical sign folding, identic… | Yes — arithmetic identical; signatures differed (module scratch vs param) | No — one module, explicit scratch (the more explicit of the two forms) | No — bit-identical, determinism.spec.js green (14/14) |
+| [x] | **E3** | HIGH | Whole collocated advection family shadows the MAC family and has zero callers. FluidSimulator uses only the v3_mac_* kernels (imports at engine/phy… | Yes — 5 files, zero non-spec importers, MAC family is what the sim uses | No — annotation only; NOT deleted (public library surface) | No |
+| [x] | **E5** | MEDIUM | v3_grid_apply_advection_forward is a slower copy of v3_grid_advect_sl_velocity, and says so in its own docstring. | Yes — its own docstring says it IS v3_grid_advect_sl_velocity(outputs,inputs,inputs...) | No — body becomes a delegation | No — fluid quality gate green |
+| [x] | **E6** | MEDIUM | Selle monotone limiter written four times, twice under the same name limit8 with different signatures in the same directory. | Yes — MAC limit8 = index derivation + grid limit8's clamp core; 2 same-named fns 2 files apart | No — core extracted, MAC's renamed to limit8_at_position | No — comparison order preserved, bit-identical |
+| [~] | **E7** | MEDIUM | Vorticity confinement: the MAC kernel collocates to cell centres and then re-derives the collocated kernel's two passes verbatim. | Yes — passes are character-identical | Extraction forces 3 floats to a module-static per cell instead of registers | RISK — per-cell whole-grid kernel under a measured perf budget; documented, needs a benchmark first |
+| [x] | **E8** | MEDIUM | Two-bone and one-bone IK solvers share a ~75-line terrain-probe + influence prologue verbatim. | Yes — ~75-line prologue shared; audit's 'rival IK solvers' premise was false | n/a — DELEGATED to the engine/ecs agent, which created ik_probe_terrain_contact.js | n/a |
+| [~] | **E12** | MEDIUM | A general 2D half-plane Sutherland–Hodgman clipper exists in core, unused, while narrowphase ships its own. | Yes — same algorithm | n/a | n/a — core uses POINT_EPS 1e-9 slack, physics uses exact <=0; differs exactly on boundary-coincident points, which changes the manifold. Documented. |
+| [x] | **E14** | PROMOTION | tri3_closest_point_barycentric returns barycentrics; all 12 callers immediately reconstruct the world point. The missing primitive is tri3_closest_… | Yes — same operand order as tri3_closest_point, so bit-identical | No | No — physics+determinism green |
+| [x] | **E15** | PROMOTION | line3_compute_segment_segment_closest_points returns (s, t); all four physics callers immediately lerp both segments. | Yes — 4 sites reconstruct both points identically | No — line3_segment_segment_closest_point_pair promoted | No — a+(b-a)*t form preserved exactly |
+| [x] | **E17** | LOW/MEDIUM | solve_constraints re-derives angular_effective_mass_raw, which was extracted for exactly this purpose. | Yes — angular_effective_mass_raw's body verbatim; its own docstring calls itself the shared kernel | No — 12 lines to 1 call | No — identical operand order by construction |
+| [~] | **E20** | LOW | Unnormalised triangle face normal ((B−A) × (C−A)) inline-derived at five physics sites. | PARTLY — audit says core has 'three names'; actually ONE canonical + two @deprecated aliases | n/a | n/a — tri3_compute_normal NORMALIZES, sites need the raw cross product (magnitude = 2x area, used for degeneracy bails). Not a drop-in. |
+
+## F — sound  (15 items)
+
+| | ID | Sev | Finding | Valid? | More complex? | Slower? |
+|---|---|---|---|---|---|---|
+| [x] | **F2** | HIGH | Undirected edge-list → CSR (degree count → prefix sum → fill via write cursor) written twice; plus a hand-rolled sorted-row isNeighbour binary search | see domain report | see domain report | see domain report |
+| [x] | **F5** | MEDIUM | AnimationCurve binary keyframe codec hand-written twice | see domain report | see domain report | see domain report |
+| [x] | **F6** | MEDIUM | 3-band decaying-noise IR synthesis kernel duplicated | see domain report | see domain report | see domain report |
+| [x] | **F7** | MEDIUM | A third decaying-noise IR generator, unseeded | see domain report | see domain report | see domain report |
+| [x] | **F9** | MEDIUM | "Randomly orient a Fibonacci sample set" written twice, bypassing random_point_on_sphere | see domain report | see domain report | see domain report |
+| [x] | **F10** | MEDIUM | Canonical undirected edge key min·n + max written 4× (and decoded in a 5th place) | see domain report | see domain report | see domain report |
+| [x] | **F11b** | LOW | randomFromArray re-derived inline | see domain report | see domain report | see domain report |
+| [~] | **F13** | MEDIUM | Three hand-written "dynamic BVH of handle-addressed objects" wrappers inside one domain | see domain report | see domain report | see domain report |
+| [x] | **F13b** | LOW | AABB union re-derived | see domain report | see domain report | see domain report |
+| [x] | **F14** | MEDIUM | Trilinear sampling of a Float32Array 3D scalar grid re-implemented | see domain report | see domain report | see domain report |
+| [x] | **F16** | LOW | dB2Volume re-derived inline in a file that already imports it | see domain report | see domain report | see domain report |
+| [x] | **F17** | LOW | BusGraph repeats the same lookup-or-throw preamble 6× | see domain report | see domain report | see domain report |
+| [~] | **F19** | LOW | Well-conditioned perpendicular-axis construction re-derived | see domain report | see domain report | see domain report |
+| [x] | **F20** | LOW | Vector normalize written by hand, inconsistently with the same file | see domain report | see domain report | see domain report |
+| [~] | **F21** | LOW / PROMOTION | Union-find connected components over probe connectivity written twice | see domain report | see domain report | see domain report |
+
+## G — network + save  (7 items)
+
+| | ID | Sev | Finding | Valid? | More complex? | Slower? |
+|---|---|---|---|---|---|---|
+| [x] | **G2** | HIGH | ActionLog and InputRing are the same per-frame ring of BinaryBuffer slots, written twice. | see domain report | see domain report | see domain report |
+| [x] | **G8** | MEDIUM | Transport adapters copy-paste their entire stats and disconnect-latch machinery instead of putting it on the Transport base. | see domain report | see domain report | see domain report |
+| [x] | **G14** | MEDIUM / PROMOTION | Shortest-path quaternion nlerp (dot-sign-flip → componentwise lerp → normalize) written 3× with no core primitive. | see domain report | see domain report | see domain report |
+| [x] | **G16** | MEDIUM | IndexedDBStorage repeats the transaction+objectStore+request+listener block 4×, and the durability fix was applied to only one copy. | see domain report | see domain report | see domain report |
+| [~] | **G19** | LOW | Uint8Array/TextEncoder length-prefixed blob framing hand-rolled at 4 sites while a correct primitive exists in one. | see domain report | see domain report | see domain report |
+| [x] | **G20** | LOW | SmoothingState inlines two existing core primitives verbatim. | see domain report | see domain report | see domain report |
+| [x] | **G23** | LOW | seq16_advance bypassed for an inline & 0xFFFF. | see domain report | see domain report | see domain report |
+
+## H — engine misc  (12 items)
+
+| | ID | Sev | Finding | Valid? | More complex? | Slower? |
+|---|---|---|---|---|---|---|
+| [x] | **H4** | HIGH | Divergent copy of the Gaussian-blur-over-a-sampled-function algorithm — the copy still carries the bug the other one fixed | see domain report | see domain report | see domain report |
+| [x] | **H9** | MEDIUM | TextureAttachmentsByMaterialType iteration written five times, twice in the same file | see domain report | see domain report | see domain report |
+| [x] | **H10** | MEDIUM | ~70-line terrain-contact probe + influence computation copy-pasted between the two IK solvers | see domain report | see domain report | see domain report |
+| [x] | **H11** | MEDIUM | Axis-tick-walking algorithm forked; the ceil→floor fix landed in only one copy | see domain report | see domain report | see domain report |
+| [x] | **H13** | MEDIUM | Three curve-space ↔ canvas-space mapping implementations inside the same feature | see domain report | see domain report | see domain report |
+| [x] | **H14** | MEDIUM | Mouse-parallax 3D tilt math copy-pasted, and the copy's pivot silently diverged | see domain report | see domain report | see domain report |
+| [x] | **H16** | MEDIUM | removeEntityWithMeshParticlesEffect reimplements removeEntityWithEffect and drops the transient-save guard | see domain report | see domain report | see domain report |
+| [~] | **H19** | MEDIUM | JSON-derived asset loaders repeat the same scaffold, and all of them lose parse errors | see domain report | see domain report | see domain report |
+| [x] | **H21** | LOW | Quaternion.fromAxisAngle and Quaternion.lookRotation reimplemented module-privately | see domain report | see domain report | see domain report |
+| [x] | **H22** | LOW | Quaternion-rotate-vector inlined in a GUI system | see domain report | see domain report | see domain report |
+| [x] | **H23** | LOW | Cubic easing functions redefined module-privately instead of joining the engine's easing enum | see domain report | see domain report | see domain report |
+| [x] | **H24** | LOW | The same 6-stop heatmap palette declared twice | see domain report | see domain report | see domain report |
+
+## I — generation + view/editor  (8 items)
+
+| | ID | Sev | Finding | Valid? | More complex? | Slower? |
+|---|---|---|---|---|---|---|
+| [x] | **IG2** | MEDIUM | 2D rotation of a local offset by rotation radians, inlined 8× — core/geom/vec2/ has no v2_rotate | see domain report | see domain report | see domain report |
+| [x] | **IG3** | MEDIUM | Weighted random selection over CellFilter weights implemented three times, one bypassing random_pick_weighted_index with a different prefix-sum con… | see domain report | see domain report | see domain report |
+| [x] | **IG4** | MEDIUM | Sobel 3×3 tap + gradient magnitude duplicated verbatim; the shared helper already exists next door and is not used | see domain report | see domain report | see domain report |
+| [x] | **IG6** | MEDIUM | Rasterising a CellFilter into a Sampler2D at a scale is written twice | see domain report | see domain report | see domain report |
+| [x] | **IG7** | LOW | CellFilterPower re-derives the base class's two-child evaluation instead of implementing operation() | see domain report | see domain report | see domain report |
+| [x] | **IV3** | HIGH | Two-way "model ↔ widget" sync with a re-entrancy lock is hand-rolled in eight editors, half of them without the lock; FieldValueAdapter already exi… | see domain report | see domain report | see domain report |
+| [x] | **IV4** | HIGH | GroupView re-implements View's child list, bypassing the link/unlink lifecycle | see domain report | see domain report | see domain report |
+| [x] | **IV7** | MEDIUM | The terrain brush's UV footprint and its UV→texel conversion are each derived independently in the base tool and both subclasses | see domain report | see domain report | see domain report |
+
+## K — cross-cutting  (1 items)
+
+| | ID | Sev | Finding | Valid? | More complex? | Slower? |
+|---|---|---|---|---|---|---|
+| [x] | **KK10** | HIGH | raw Math.random() on paths that must be deterministic | Yes — 11 raw Math.random() sites; 2 are simulation-authoritative | No — add_rnd_square takes a required random arg like every other sampler | No. The 2 behaviour-tree seeds CANNOT be fixed in isolation (need a threaded run seed) — documented as determinism holes, not silently changed |
+
+
+## Progress log
+
+Newest last. One entry per commit.
+
+---
+
+## Outcome
+
+**117 / 117 resolved. 96 changed, 21 closed as REJECTED or DECLINED.**
+
+Full meep suite green throughout: **1541 suites / 9314 tests**, plus the standing gates —
+`determinism.spec.js` (14/14), the fluid `quality.spec.js`, and `second_generation.spec.js`.
+No existing spec was weakened or deleted; several were added.
+
+### What the duplication was actually costing
+
+Not lines — **fixes that reached one copy and not its twin**. Repaired here:
+
+| Fix that had landed | Twin that never got it |
+|---|---|
+| `IndexedDBStorage.store()` settles on transaction commit | `remove()` still settled on the request — a delete was reported durable after its transaction aborted |
+| `inOpen` BitSet replaces the linear `heap.contains` scan | `GridTaskConnectRooms:292` still ran the scan |
+| `BinaryUint32BVH.sort_morton` seeds its stack relative to `stack_top` | `StaticR2Tree` seeded at absolute `stack[0]` — read another traversal's frame when nested |
+| `canvas2d_draw_linear_scale` uses `Math.floor` (with the comment saying why) | `canvas2dDrawWorldAxisLabels` still used `ceil` |
+| `CellFilterGaussianBlur` centres taps at `(samples-1)*0.5` | `PointFitnessGaussianBlur` used `samples/2`, and `size_z = 0` made it return NaN |
+| `array_quick_sort_*` captures the pivot VALUE | `sort_decal_data` compared against the live pivot INDEX |
+| `forward_plus` MaterialTransformer assigns `source.clone()` | the `sh3/gi` twin discarded it and mutated the caller's material |
+| `removeEntityWithEffect` adds the `Transient` guard | the mesh-particle copy leaked effect entities into saves |
+| `ContainerAudioClip.equals()` folds `children` | it had no `hash()` at all; `BlendContainerAudioClip` hashed unequal clips equal |
+| Six of eight BVH traversals contradicted the comment they all shared | specialised queries returned the same set in the opposite order from the generic one |
+
+The heuristic that emerged: **in a duplicated pair, the file carrying the explanatory comment is the
+fixed one, and its twin still has the defect.** It held in every case checked.
+
+### The 21 not changed, and why
+
+Five because the finding was WRONG:
+
+- **A27** — swapping BFF's `interior_angle` for `v3_angle` would corrupt curvature: `v3_angle` returns
+  `acos(0) = PI/2` for degenerate input where BFF returns 0, and BFF accumulates `Omega = 2PI - sum(theta)`.
+- **H19** — `AssetManager` already wraps `loader.load` in try/catch AND does `result.catch(failure)`.
+- **F19** — the proposed substitute yields an arbitrary tangent where a world-up-anchored axis is required.
+- **IV4** — `View.children` is a class field, so the claimed mechanism cannot occur (the real, different
+  defects were fixed).
+- **E20** — core has ONE canonical `tri3_compute_normal` plus two `@deprecated` aliases, not "three names".
+
+The rest because the fix cost more than the duplication: a memory round-trip in a broadphase or per-cell
+loop (**A25**, **E7**), a tolerance difference that changes physics manifolds (**E12**), re-homing 44
+private-field accesses in cache classes with load-bearing list invariants (**B9**), a sign convention
+whose unification changes rendered output (**D7**, and the `sign()`/`sign_not_zero()` divergence in
+**D1**), or an identity array sized to triangle count (**B10**). Each is documented in place so the next
+reviewer does not re-derive the same conclusion.
+
+### Answers to the two standing questions
+
+- **Does it make the code significantly more complex?** No, for every applied item. All were net
+  deletions or additive promotions; the largest single change removed 833 lines of copied GLSL.
+- **Does it make the relevant part significantly slower?** No, for every applied item — and three were
+  declined precisely because they would have. Two are faster: `computeDisconnectedSubGraphs` went from
+  O(n^2) to O(n), and the voxel bake basis is now computed once per tile instead of twice per pixel.
+  Bit-identical output was preserved deliberately where it matters (impulse kernel, Selle limiter,
+  segment-segment lerp form, quaternion nlerp).

package/src/core/bvh2/bvh3/query/bvh_collect_user_data.js

@@ -49,9 +49,9 @@ export function bvh_collect_user_data(
             const child1 = bvh.node_get_child1(node);
             const child2 = bvh.node_get_child2(node);
 
-            // write to stack in reverse order, so that fist child ends up being visited first
-            stack[stack.pointer++] = child1;
+            // write to stack in reverse order, so that the first child ends up being visited first
             stack[stack.pointer++] = child2;
+            stack[stack.pointer++] = child1;
 
         } else {
             // leaf root

package/src/core/bvh2/bvh3/query/bvh_query_leaves_generic.js

@@ -1,77 +1,77 @@
-import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
-import { NULL_NODE } from "../BVH.js";
-
-const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
-
-/**
- * Collect every leaf node accepted by `query`, walking the tree from `root`.
- *
- * Uses the shared {@link SCRATCH_UINT32_TRAVERSAL_STACK}: `query.evaluate` MUST NOT throw and
- * MUST NOT start another traversal that consumes the same stack. On a throw the shared stack
- * pointer is left elevated, silently corrupting every subsequent traversal. We deliberately do
- * NOT wrap the loop in try/finally — that forces a V8 de-opt on this hot path; not throwing from
- * the predicate is a precondition, not something to defend against at runtime.
- *
- * @param {number[]|Uint32Array} result destination for matched leaf node ids
- * @param {number} result_offset first index in `result` to write to
- * @param {BVH} bvh
- * @param {number} root
- * @param {BVHQuery} query per-node predicate; must be conservative at internal nodes
- * @returns {number} number of entries written
- */
-export function bvh_query_leaves_generic(
-    result, result_offset,
-    bvh, root, query
-) {
-
-    if (root === NULL_NODE) {
-        return 0;
-    }
-
-    /**
-     *
-     * @type {number}
-     */
-    const stack_top = stack.pointer++;
-
-    stack[stack_top] = root;
-
-    let result_cursor = result_offset;
-
-    while (stack.pointer > stack_top) {
-        stack.pointer--;
-
-        /**
-         *
-         * @type {number}
-         */
-        const node = stack[stack.pointer];
-
-        // test node against the ray
-        const pass = query.evaluate(node, bvh);
-
-        if (!pass) {
-            continue;
-        }
-
-        const node_is_leaf = bvh.node_is_leaf(node);
-
-        if (!node_is_leaf) {
-
-            // read in-order
-            const child1 = bvh.node_get_child1(node);
-            const child2 = bvh.node_get_child2(node);
-
-            // write to stack in reverse order, so that fist child ends up being visited first
-            stack[stack.pointer++] = child2;
-            stack[stack.pointer++] = child1;
-
-        } else {
-            // leaf node
-
-            result[result_cursor++] = node;
-        }
-    }
-
-    return result_cursor - result_offset;
-}
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { NULL_NODE } from "../BVH.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+/**
+ * Collect every leaf node accepted by `query`, walking the tree from `root`.
+ *
+ * Uses the shared {@link SCRATCH_UINT32_TRAVERSAL_STACK}: `query.evaluate` MUST NOT throw and
+ * MUST NOT start another traversal that consumes the same stack. On a throw the shared stack
+ * pointer is left elevated, silently corrupting every subsequent traversal. We deliberately do
+ * NOT wrap the loop in try/finally — that forces a V8 de-opt on this hot path; not throwing from
+ * the predicate is a precondition, not something to defend against at runtime.
+ *
+ * @param {number[]|Uint32Array} result destination for matched leaf node ids
+ * @param {number} result_offset first index in `result` to write to
+ * @param {BVH} bvh
+ * @param {number} root
+ * @param {BVHQuery} query per-node predicate; must be conservative at internal nodes
+ * @returns {number} number of entries written
+ */
+export function bvh_query_leaves_generic(
+    result, result_offset,
+    bvh, root, query
+) {
+
+    if (root === NULL_NODE) {
+        return 0;
+    }
+
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack.pointer++;
+
+    stack[stack_top] = root;
+
+    let result_cursor = result_offset;
+
+    while (stack.pointer > stack_top) {
+        stack.pointer--;
+
+        /**
+         *
+         * @type {number}
+         */
+        const node = stack[stack.pointer];
+
+        // test node against the ray
+        const pass = query.evaluate(node, bvh);
+
+        if (!pass) {
+            continue;
+        }
+
+        const node_is_leaf = bvh.node_is_leaf(node);
+
+        if (!node_is_leaf) {
+
+            // read in-order
+            const child1 = bvh.node_get_child1(node);
+            const child2 = bvh.node_get_child2(node);
+
+            // write to stack in reverse order, so that the first child ends up being visited first
+            stack[stack.pointer++] = child2;
+            stack[stack.pointer++] = child1;
+
+        } else {
+            // leaf node
+
+            result[result_cursor++] = node;
+        }
+    }
+
+    return result_cursor - result_offset;
+}

package/src/core/bvh2/bvh3/query/bvh_query_leaves_ray.js

@@ -1,90 +1,90 @@
-import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
-import { aabb3_intersects_ray } from "../../../geom/3d/aabb/aabb3_intersects_ray.js";
-import { COLUMN_CHILD_1, COLUMN_CHILD_2, ELEMENT_WORD_COUNT, NULL_NODE } from "../BVH.js";
-
-const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
-
-
-/**
- *
- * @param {number[]|Uint32Array} result
- * @param {number} result_offset
- * @param {BVH} bvh
- * @param {number} root
- * @param {number} origin_x
- * @param {number} origin_y
- * @param {number} origin_z
- * @param {number} direction_x
- * @param {number} direction_y
- * @param {number} direction_z
- * @returns {number}
- */
-export function bvh_query_leaves_ray(
-    result, result_offset,
-    bvh, root,
-    origin_x, origin_y, origin_z,
-    direction_x, direction_y, direction_z
-) {
-
-    if (root === NULL_NODE) {
-        return 0;
-    }
-
-
-    /**
-     *
-     * @type {number}
-     */
-    const stack_top = stack.pointer++;
-
-    stack[stack_top] = root;
-
-    let result_cursor = result_offset;
-
-    /*
-     For performance, we bind data directly to avoid extra copies required to read out AABB
-     */
-    const float32 = bvh.__data_float32;
-    const uint32 = bvh.__data_uint32;
-
-    do {
-        stack.pointer--;
-
-        /**
-         *
-         * @type {number}
-         */
-        const node = stack[stack.pointer];
-
-        const address = node * ELEMENT_WORD_COUNT;
-
-        // test node against the ray
-        const intersects = aabb3_intersects_ray(
-            float32[address], float32[address + 1], float32[address + 2],
-            float32[address + 3], float32[address + 4], float32[address + 5],
-            origin_x, origin_y, origin_z,
-            direction_x, direction_y, direction_z
-        );
-
-        if (!intersects) {
-            continue;
-        }
-
-        // get fist child to check if this is a leaf node or not
-        const child_1 = uint32[address + COLUMN_CHILD_1];
-
-        if (child_1 !== NULL_NODE) {
-
-            // this is not a leaf node, push children onto traversal stack
-            stack[stack.pointer++] = uint32[address + COLUMN_CHILD_2];
-            stack[stack.pointer++] = child_1;
-
-        } else {
-            // leaf node
-
-            result[result_cursor++] = node;
-        }
-    } while (stack.pointer > stack_top);
-
-    return result_cursor - result_offset;
-}
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { aabb3_intersects_ray } from "../../../geom/3d/aabb/aabb3_intersects_ray.js";
+import { COLUMN_CHILD_1, COLUMN_CHILD_2, ELEMENT_WORD_COUNT, NULL_NODE } from "../BVH.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+
+/**
+ *
+ * @param {number[]|Uint32Array} result
+ * @param {number} result_offset
+ * @param {BVH} bvh
+ * @param {number} root
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @returns {number}
+ */
+export function bvh_query_leaves_ray(
+    result, result_offset,
+    bvh, root,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z
+) {
+
+    if (root === NULL_NODE) {
+        return 0;
+    }
+
+
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack.pointer++;
+
+    stack[stack_top] = root;
+
+    let result_cursor = result_offset;
+
+    /*
+     For performance, we bind data directly to avoid extra copies required to read out AABB
+     */
+    const float32 = bvh.__data_float32;
+    const uint32 = bvh.__data_uint32;
+
+    do {
+        stack.pointer--;
+
+        /**
+         *
+         * @type {number}
+         */
+        const node = stack[stack.pointer];
+
+        const address = node * ELEMENT_WORD_COUNT;
+
+        // test node against the ray
+        const intersects = aabb3_intersects_ray(
+            float32[address], float32[address + 1], float32[address + 2],
+            float32[address + 3], float32[address + 4], float32[address + 5],
+            origin_x, origin_y, origin_z,
+            direction_x, direction_y, direction_z
+        );
+
+        if (!intersects) {
+            continue;
+        }
+
+        // get fist child to check if this is a leaf node or not
+        const child_1 = uint32[address + COLUMN_CHILD_1];
+
+        if (child_1 !== NULL_NODE) {
+
+            // this is not a leaf node, push children onto traversal stack
+            stack[stack.pointer++] = uint32[address + COLUMN_CHILD_2];
+            stack[stack.pointer++] = child_1;
+
+        } else {
+            // leaf node
+
+            result[result_cursor++] = node;
+        }
+    } while (stack.pointer > stack_top);
+
+    return result_cursor - result_offset;
+}