test(geometry): pin the batched-suffix over-cut that solo_step now avoids

[BIMvoice]

Update — this PR now carries a genuine reproduction. The section below was written when only a guard test existed and is kept for the record, but it is no longer the whole story.

Commit 0731ae397 adds solo_step_batched_suffix_defect_is_active_on_a_synthetic_bowtie_cutter: a 10x10x10 box cut by a 3-cutter DIFFERENCE chain whose outermost cutter has a self-intersecting (bowtie) IfcPolyline boundary. That trips the accept gate in the top-level 3-cutter batch, and again at that node's single-cutter step once the inner 2-cutter suffix batches cleanly — reaching spine.len() == 1 && based_on_batch == true.

Verified RED/GREEN by reverting only the mod.rs / single_cutter_gate.rs hunk:

with fix:     max bounds ~ (5, 5, 10)   KeepUncut, correct
fix reverted: max bounds =  (3, 3,  2)   FallThrough over-cut

Reproduced identically under csg_manifold_gate, csg_topology_gate, and both together. A reviewer independently confirmed the decision point is genuinely reached, by instrumenting the line: spine.len()=1 based_on_batch=true solo_step=false, with an accept-gate rejection present in take_failures() — so it is not a false pass from an empty failure list.

Honest scope of that fixture. A self-intersecting boundary is synthetic and structurally malformed; no real authoring tool would emit one. Checked against the spec: IFC4X3's formal propositions for IfcPolygonalBoundedHalfSpace require only PolygonalBoundary.Dim = 2 and a curve type of IfcPolyline / IfcCompositeCurve / IfcIndexedPolyCurve — there is no machine-checked WHERE-rule demanding a simple polygon, so this input is not schema-invalid, merely degenerate. It demonstrates the defect is reachable in principle; it does not establish that a valid real-world model reaches it. On main, with the fixtures in this repo, the defect remains latent — entity #2145 hits spine.len()==1 && based_on_batch==true but never triggers a gate rejection there, and every entity that does reject has spine.len() in {2,3,4,5}.

The original guard test (solo_step_accounts_for_a_batched_suffix_not_just_spine_length) still passes but provides no RED/GREEN coverage of this defect — it never reaches the buggy branch on the real #960 fixture. It retains value as a smoke test over real production geometry; its docstring overstates its purpose relative to what it actually catches, and is worth trimming if you would rather it not mislead.

Summary

Carries the one remaining unique commit from PR #3922's diverged branch (fix-issue-3919-roof-clip-gate), which has drifted 1000+ lines from main in unrelated files. #3922's own original fix already landed separately as f7872db62; this PR isolates only the remaining change so #3922 itself can be dispositioned separately by the maintainer without touching or closing it.

solo_step in BooleanClippingProcessor::process_with_depth_inner decides, per DIFFERENCE chain, whether an accept-gate rejection on a IfcPolygonalBoundedHalfSpace cutter's subtract should KeepUncut (a sibling cutter likely covers the same material) or escalate to the riskier unbounded FallThrough clip. It was computed as spine.len() == 1 — but the chain-resolution loop retries try_union_polygonal_chain at every suffix level, so when the top-level batch fails and a shorter suffix batches cleanly, the caller's spine holds only the single outermost node even though that node's cutter has siblings already folded into the mesh by the successful suffix batch below it. spine.len() == 1 can't distinguish that from a true no-sibling shape, so it wrongly escalated to FallThrough — an over-cut in exactly the case !solo_step exists to prevent.

Fixed by tracking whether the mesh entering the sequential-apply loop already came from a successful batch (based_on_batch), and only treating a length-1 spine as truly solo when it did not: spine.len() == 1 && !based_on_batch.

Measured impact

Entering House.ifc's real chain directly at entity #2146 (issue #960 fixture, treated as a representation root): before the fix, an accept-gate rejection on #2146's own cutter over-cuts to max Z ≈ 2735.6 mm (FallThrough); after the fix, it correctly keeps the batched result un-cut at max Z ≈ 4475.3 mm (KeepUncut).

Honesty about the regression test

This defect is latent on main today, not active. Entering the #960 fixture at #2146 currently produces spine.len() == 2, not 1, so the buggy formula isn't reached by that fixture as-is. I scanned every DIFFERENCE-chain root across all five chains (~50 nodes) in the only in-repo fixture with this shape and found none that simultaneously hits spine.len() == 1, based_on_batch == true, AND an actual accept-gate rejection at that node. So the new regression test, solo_step_accounts_for_a_batched_suffix_not_just_spine_length, passes both before and after this fix on main — it is a guard against a real, structurally-possible defect (proven via direct instrumentation of spine.len()/based_on_batch, and via the code-path analysis above), not a live reproduction. It exists to catch a regression once an in-repo fixture reaches that branch, not to demonstrate one exists today.

Controls (run individually, targeted binaries)

• cargo test -p ifc-lite-geometry --test issue_960_segmented_roof_clip — pass
• cargo test -p ifc-lite-geometry --test issue_1007_real_opening_no_bridge — pass (real numbers printed: worst_rim_incident_aspect=7.74 worst_aspect=25.90 open_boundary_edges=0 out_tris=98)
• cargo test -p ifc-lite-geometry --test issue_3353_near_coplanar_rotated_overlap — pass (4/4)
• cargo test -p ifc-lite-geometry --lib a_three_operand_near_coplanar_union_stays_closed — pass

Other gates

• cargo clippy -p ifc-lite-geometry -- -D warnings — clean
• cargo clippy -p ifc-lite-core -- -D warnings — clean (no pre-existing failures reproduced in this checkout)
• cargo test -p ifc-lite-processing --test module_size_ratchet — pass (6/6)
• node scripts/check-module-size.mjs — OK
• node scripts/check-test-wiring.mjs — OK
• node scripts/check-source-text-assertions.mjs — OK

Closes #4023

[coderabbitai]

Warning

Review limit reached

• Run on-demand review

_{This review includes 1 billable file and costs up to $0.25.}

Or wait 59 minutes for your next included review.

Check out review usage here.

View limit details

Limit details: You’ve used all 2 included reviews currently available.

Learn how review limits work.

Review configuration:

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Team

Run ID: 4213709d-05df-4879-877f-c7defe352997

📥 Commits

Reviewing files that changed from the base of the PR and between 4f341b6 and 9145a1d.

📒 Files selected for processing (1)

• rust/geometry/src/processors/boolean/chain_cycle_tests.rs

---

_{Comment @coderabbitai help to get the list of available commands.}

[github-actions]

Claude review - no findings for 55c037ca0

Reviewed this diff and found nothing to flag.

[github-actions]

Viewer benchmark

✅ No threshold regressions detected.

01_Snowdon_Towers_Sample_Structural(1).ifc

Baseline recorded 2026-07-01T20:31:05.538Z on github-actions ubuntu-latest, viewer-benchmark-ci (headless Chrome, SwiftShader ANGLE), production build.

Metric	Current	Baseline	Delta	Threshold	Status
firstBatchWaitMs	1121ms	2905ms	-61.4%	+50%	✅
firstVisibleGeometryMs	1877ms	3652ms	-48.6%	+50%	✅
streamCompleteMs	1881ms	3598ms	-47.7%	+50%	✅
spatialReadyMs	969ms	1032ms	-6.1%	+50%	✅
metadataCompleteMs	1189ms	3063ms	-61.2%	+50%	✅
totalWallClockMs	2000ms	3700ms	-45.9%	+50%	✅

AC20-FZK-Haus.ifc

Baseline recorded 2026-07-01T20:30:59.972Z on github-actions ubuntu-latest, viewer-benchmark-ci (headless Chrome, SwiftShader ANGLE), production build.

Metric	Current	Baseline	Delta	Threshold	Status
firstBatchWaitMs	178ms	1075ms	-83.4%	+50%	✅
firstVisibleGeometryMs	733ms	1572ms	-53.4%	+50%	✅
streamCompleteMs	744ms	1980ms	-62.4%	+50%	✅
spatialReadyMs	772ms	915ms	-15.6%	+50%	✅
metadataCompleteMs	866ms	1392ms	-37.8%	+50%	✅
totalWallClockMs	1000ms	3300ms	-69.7%	+50%	✅

Refresh the baseline from a CI run: dispatch the Benchmark workflow with record_baseline, download the benchmark-baseline artifact, and commit baseline.json (see tests/benchmark/README.md).

[louistrue]

Merge-readiness nudge: this PR remains blocked by the changed-test revert oracle and aggregate Build + WASM + Rust + Node gate. The production change needs a discriminating regression test that fails when the fix is reverted; then refresh onto current main and rerun all gates.

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

2 Skipped Deployments

Project	Deployment	Actions	Updated
ifc-lite-dev	Ignored		Sep 7, 2026 4:01pm UTC
ifc-lite-viewer-embed	Ignored		Sep 7, 2026 4:01pm UTC

[BIMvoice]

Update: constructed a synthetic fixture that makes the defect active (option 1 from the review), so the revert oracle should now observe a real regression instead of reporting UNOBSERVED.

Added solo_step_batched_suffix_defect_is_active_on_a_synthetic_bowtie_cutter (rust/geometry/src/processors/boolean/chain_cycle_tests.rs, feature-gated same as the existing guard): a hand-written 10x10x10-box fixture cut by a 3-cutter DIFFERENCE chain whose outermost cutter (cutterE) has a self-intersecting (bowtie) IfcPolyline boundary. That trips the accept gate (OpenTopologyRejected under csg_topology_gate, NonManifoldRejected under csg_manifold_gate) both in the outer 3-cutter batch attempt at the top node (deferring it) and again at that node's own single-cutter step once the inner 2-cutter suffix has batched cleanly — exactly the spine.len() == 1 && based_on_batch == true shape this PR's fix targets.

Verified by hand (reverting just the mod.rs/single_cutter_gate.rs fix and re-running):

• With the fix: max bounds ≈ (5, 5, 10) — KeepUncut, cutterE dropped, the batched suffix returned un-cut.
• With the fix reverted: max bounds = (3, 3, 2) — a real assertion failure, the FallThrough over-cut.

Confirmed under csg_manifold_gate, csg_topology_gate, and both features together. The original real-fixture guard (solo_step_accounts_for_a_batched_suffix_not_just_spine_length) is left in place as a regression pin for #960's own geometry; this new test is the one that should satisfy the revert oracle.

Also re-ran the required controls on top of this change: issue_960_segmented_roof_clip (pass), issue_1007_real_opening_no_bridge (pass — worst_rim_incident_aspect=7.74 worst_aspect=25.90 open_boundary_edges=0 out_tris=98, unchanged), issue_3353_near_coplanar_rotated_overlap (4/4 pass), a_three_operand_near_coplanar_union_stays_closed (pass). cargo clippy -p ifc-lite-geometry -- -D warnings (plus with each gate feature) and cargo test -p ifc-lite-processing --test module_size_ratchet are clean.

Pushed to this branch.

[github-actions]

Claude review - no findings for 0731ae397

Reviewed this diff and found nothing to flag.

[BIMvoice]

Changed tests observe production reports UNOBSERVED on this PR, and after investigating it is a structural blind spot in the oracle, not a gap in this PR's testing. Escalating rather than working around it.

What the oracle sees

baseline:  pass — 1273 passed / 1273 collected
reverted:  pass — 1273 passed, 0 failed / 1273 collected
✘ UNOBSERVED

Identical collection counts, because the reproducing test is not in the 1273. solo_step_batched_suffix_defect_is_active_on_a_synthetic_bowtie_cutter is gated #[cfg(any(feature = "csg_manifold_gate", feature = "csg_topology_gate"))], rust/geometry/Cargo.toml:19 sets default = [], and cargoRunner() in scripts/lib/revert-oracle.mjs:187-190 hardcodes ['test', '--no-fail-fast', '-p', crate] with no --features mechanism anywhere in the oracle. Confirmed locally: cargo test -p ifc-lite-geometry --lib chain_cycle_tests under default features collects 18 tests in that module, and the gated one is not among them.

Why neither obvious fix applies

Running it under default features is a known regression. Cargo.toml:56-70 documents exactly why those gates are opt-in — enabling them takes issue_098_reveal_wall from 42 to 380 unpaired edges, issue_098_v5c from 108 to 416, and regrows issue_960_segmented_roof_clip's full-height seam sliver. The accept-gate rejection this fixture depends on is only reachable behind the gates.

Teaching the oracle the features is not possible today — there is no per-crate feature config in check-test-revert-oracle.mjs or revert-oracle-cargo.mjs.

The test does work, and CI does run it

Reverting only the solo_step line in mod.rs:

RED:   max bounds = [3.0, 3.0, 2.0]   (panic, --features csg_manifold_gate)
GREEN: test ... ok

And .github/workflows/test.yml already runs cargo test -p ifc-lite-geometry --features csg_manifold_gate (line 1496) and --features csg_topology_gate,csg_manifold_gate (lines 1668-1682) as their own jobs — so a genuine regression here would be caught by the suite. It is only the oracle's own invocation that cannot see it.

Controls all pass individually: issue_960_segmented_roof_clip ok; issue_1007_real_opening_no_bridge ok (open_boundary_edges=0 out_tris=98); issue_3353_near_coplanar_rotated_overlap 4/4; a_three_operand_near_coplanar_union_stays_closed ok. Clippy clean, module-size ratchet 6/6.

Your call

1. Apply the maintainer-only revert-oracle-exempt label here.
2. Give the oracle a per-crate feature list so feature-gated Rust tests are visible to it.

This is the same shape as #4050, where the oracle cannot see Python tests: in both cases it reports UNOBSERVED for work it simply did not run, which is indistinguishable from work that genuinely observes nothing. That is the failure direction that erodes the check.

We did not delete the feature gate, weaken the oracle, or add a token production edit to satisfy it — it caught a real false all-clear in #3982 this morning and is worth more intact than this PR is worth merged today.

[BIMvoice]

Perf verdict — #4024 (base-vs-branch, interleaved)

Method: base = merge-base with upstream/main (f2a9f5daf0), branch = PR head (0731ae397b). Built cargo build --profile profiling -p ifc-lite-processing --example perf_probe at each commit, copied the two binaries out, restored the worktree, then ran perf_probe <fixture> --iters 5 --json interleaved base→branch, 3 rounds, on both required fixtures.

tests/models/ara3d/AC20-FZK-Haus.ifc (default fixture)

round	base total (best-of-5)	branch total (best-of-5)
1	9 ms	8 ms
2	9 ms	9 ms
3	9 ms	8 ms

Base spread 0 ms, branch spread 1 ms, mean delta ≈ −0.7 ms. Noise floor ≥ delta — not a measurable difference. Mesh/vert/tri counts identical on every run (285 meshes / 35 940 verts / 19 456 tris). No CSG accept-gate rejection occurs on this fixture at all (perf_probe only prints a csg failures line when the count is >0; it never appeared for this fixture in any of the 6 runs) — the KeepUncut/FallThrough fallback this PR changes is structurally unreachable here, independent of timing.

tests/models/ara3d/ISSUE_129_N1540_17_EXE_MOD_448200_02_09_11SMC_IGC_V17.ifc (CSG-heavy)

round	base total (best-of-5)	branch total (best-of-5)
1	645 ms	646 ms
2	661 ms	651 ms
3	658 ms	665 ms

Base mean 654.7 ms, spread 16 ms (645–661). Branch mean 654.0 ms, spread 19 ms (646–665). Mean delta ≈ −0.7 ms, i.e. well inside the base-side run-to-run spread (16–19 ms) — this is noise, not signal.

This fixture does hit the accept gate: csg failures 43 across 6 products (plus degenerate dropped 6), identically on base and branch, in all 6 runs. Mesh/vert/tri output is byte-identical on every run (1402 meshes / 218 326 verts / 132 674 tris). Given the PR's own reported effect size for an actual KeepUncut vs FallThrough divergence (max Z 2735.6 mm vs 4475.3 mm on the #960/entity-#2146 case — a large geometric change), an identical mesh/vertex/triangle count on every one of the 43 rejections rules out any of them landing on a node where spine.len() == 1 && based_on_batch differs from spine.len() == 1 alone. So the changed branch is not reached differently on this fixture either.

Interpretation

#4024 changes which fallback (KeepUncut vs the unbounded FallThrough clip) runs when an accept gate rejects an IfcPolygonalBoundedHalfSpace cutter subtract, for the specific case spine.len() == 1 && based_on_batch == true. On both required fixtures:

• AC20-FZK-Haus.ifc never triggers an accept-gate rejection at all — the changed code is not executed.
• ISSUE_129 triggers 43 rejections, but byte-identical mesh/vertex/triangle counts base vs branch show none of them land on the specific based_on_batch case this PR changes.

Verdict: no measurable perf difference, and none is expected — the changed branch is not reached on either required fixture. This is consistent with the PR's own honesty note that the defect is latent on main's in-repo real-world fixtures (only the synthetic bowtie unit test added in this PR reaches it). The observed ~0.7 ms deltas on both fixtures are noise (smaller than the base-side spread), not a regression or a win.

Byte-identity: mesh/vertex/triangle counts (and CSG-failure counts on ISSUE_129) match exactly between base and branch on every one of the 6 runs per fixture.

[BIMvoice]

Reviewed adversarially — the PR is sound; its blocker is elsewhere

Traced based_on_batch end to end. Set in process_with_depth_inner (initialised false, flipped true only when try_union_polygonal_chain returns Some), read once at solo_step = spine.len() == 1 && !based_on_batch. The if cutters.len() < 2 { return Ok(None); } guard rules out the failure mode I was most concerned about — a trivial one-cutter "batch" setting the bit and masking a genuine solo cutter. Not dropped at any layer; single read site.

Behaviour changes in exactly one case (spine.len()==1 && based_on_batch), and single_cutter_gate.rs's diff is doc-comment-only. On diagnostics it removes a spurious PolygonalBoundedHalfSpaceFallback record in the corrected case rather than adding one — relevant given the live double-count work in #4067/#4083/#4089. Operand ordering (promote_operands_mutually, plane_weld.rs) is untouched.

RED/GREEN verified by real reverse-patch, not by trusting the PR body — reverting the mod.rs/single_cutter_gate.rs hunks flips solo_step_batched_suffix_defect_is_active_on_a_synthetic_bowtie_cutter RED under both gates independently:

[baseline] csg_manifold_gate -> pass 1260, fail 0
[reverted] csg_manifold_gate -> pass 1259, fail 1
[baseline] csg_topology_gate -> pass 1258, fail 1   (pre-existing, unrelated)
[reverted] csg_topology_gate -> pass 1257, fail 2

chain_cycle_tests.rs calls real production types, no mocking.

On the oracle failure: I had been saying #4090 would clear it. That is wrong — I verified it by running #4090's own oracle code against this PR's head and got BASELINE-BROKEN, not OBSERVED. Enabling --features csg_topology_gate compiles a pre-existing fixture-dependent census test that panics with "no fixtures on disk", because the revert-oracle job checks out lfs: false and never fetches fixtures. Details and a suggested fix are on #4090.

So this PR's own logic is clean and its test is load-bearing; what stands between it and a green gate is the oracle job's environment, not anything in this diff.

[louistrue]

Triage: same shape as #4089, and the revert-oracle is correct rather than broken.

production reverted: rust/geometry/src/processors/boolean/mod.rs
                     rust/geometry/src/processors/boolean/single_cutter_gate.rs
test:                rust/geometry/src/processors/boolean/chain_cycle_tests.rs
baseline: pass 1273/1273
reverted: pass 1273/1273, failed 0

With the batched-sibling bit reverted, chain_cycle_tests.rs still passes 1273 of 1273. So the test does not observe the production change.

The issue (#4023) describes a latent over-cut, which is exactly the hard case: if the current code never reaches the over-cut on the fixture, a test written against that fixture passes either way. The fix needs a fixture that actually produces a batched suffix with already-folded siblings, and an assertion on the resulting geometry rather than on the mechanism you changed.

Local check before pushing: git stash the production hunk, run chain_cycle_tests, confirm it FAILS. That is the whole contract the oracle is enforcing.

[louistrue]

Heads-up on the module-size budget, from reviewing the hotfix for main.

main is currently red on rust/processing/tests/module_size_ratchet.rs: #3922 merged from a base 88 commits stale and took rust/geometry/src/processors/boolean/mod.rs to 948 lines against its 936 budget. #4101 fixes that by splitting the trait wiring into a sibling router_impl.rs, leaving mod.rs at 920.

What that means for this PR. Your mod.rs hunk is net +14 (comments plus the based_on_batch flag). On top of #4101 you land at 934 against a budget of 936. It passes, with two lines to spare.

So: after you rebase, do not add lines to boolean/mod.rs while resolving conflicts. Two lines is not much room, and the conflict will land right where #4101 moved code out. Your other files are fine (single_cutter_gate.rs is 96 lines, and chain_cycle_tests.rs is a test file, which the rule exempts).

This PR is currently CONFLICTING and based on f2a9f5d, 44 commits behind main, which predates #3922 entirely. It needs a rebase before it can merge regardless.

Separately, the revert-oracle finding on this PR still stands and is the more important one: with your production hunk reverted, chain_cycle_tests.rs still passes 1273 of 1273. The test does not yet observe the fix.

[github-actions]

Claude review - no findings for 3ebc832c4

Reviewed this diff and found nothing to flag.

[BIMvoice]

Rebased to 3ebc832c4 (MERGEABLE again) — but its core fix is now redundant, and only the test is unique.

#3922 merged at 13:31 today carrying the identical based_on_batch/solo_step change. After merging main in here, boolean/mod.rs is byte-identical to upstream/main (git hash-object matches, 2a797dcab…), and diffing this branch's own tip against main on that file shows comment-text changes only — a doc rewrite from #3980, zero non-comment line differences.

So the logic this PR was opened for is already on main. What remains unique is the new synthetic test in chain_cycle_tests.rs: solo_step_batched_suffix_defect_is_active_on_a_synthetic_bowtie_cutter.

That test is worth keeping on its own merits — it is a genuine guard for a fix that currently has one, and I verified earlier by reverse-patching that reverting the mod.rs hunks flips it RED under both gates independently. But this PR is now effectively a test-only contribution, which may change how you want to handle it.

Conflict: trivial add/add at end-of-file in chain_cycle_tests.rs, exactly as predicted. mod.rs auto-merged with zero conflict — the three-way impl GeometryProcessor extraction collision between #4101 and #4089 did not materialise here.

Both-parents diff: 1 file, 165 insertions, 0 deletions vs main — pure addition, no silent revert.

Verification, -p ifc-lite-geometry --lib, all three feature combinations, new test included each time:

csg_manifold_gate                    20 passed
csg_topology_gate                    20 passed
csg_manifold_gate,csg_topology_gate  20 passed

On the failing gates, neither is caused by this branch:

• module_size_ratchet fails identically on main — boolean/mod.rs is 948 lines against a 936 budget. fix(geometry): split boolean/mod.rs back under its module-size ratchet #4101 fixes it (948 → 920).
• The revert-oracle failure is the missing fixture fetch in that CI job, described on fix(review): let the revert-oracle see feature-gated Rust tests #4090's thread. fix(ci): install Python toolchain for revert-oracle's pytest lane #4102 fixes the sibling Python case; the fixture case is still open.

[louistrue]

Correction: my earlier triage on this PR was wrong twice over.

I said the revert-oracle showed the test does not observe the production change, and warned you about a 2-line margin on boolean/mod.rs. Both were stale.

1. This PR no longer contains a production change at all. git diff --name-only origin/main...origin/fix-solo-step-batched-suffix returns exactly one file: rust/geometry/src/processors/boolean/chain_cycle_tests.rs. The based_on_batch fix reached main through #3922 (9dbe8c429, merged today). So the oracle's correct verdict on the current head is NOT APPLICABLE: this branch changes no production files, and it exits green. There is nothing for it to revert. My margin warning is moot for the same reason: you do not touch that file any more.

2. The observing test is real, and the oracle structurally cannot see it. solo_step_batched_suffix_defect_is_active_on_a_synthetic_bowtie_cutter sits under #[cfg(any(feature = "csg_manifold_gate", feature = "csg_topology_gate"))]. Both are default = [] opt-ins, and the oracle's runner is fixed to cargo test -p <crate> with no features, so cargo test -p ifc-lite-geometry --lib solo_step reports 0 passed; 860 filtered out.

That gate is correct and should stay. On a default build the fix is behaviourally inert: the only consumer of solo_step is resolve_single_cutter_subtract's gate_rejected && !solo_step branch, and gate_rejected needs OpenTopologyRejected | NonManifoldRejected, which only the feature-gated rejections record. No default-build test can observe this fix, so removing the cfg would produce a test that passes for the wrong reason.

Under the feature it discriminates properly. Reverting the one line to let solo_step = spine.len() == 1;:

panicked at chain_cycle_tests.rs:1119
max bounds = [3.0, 3.0, 2.0], expected ~(5, 5, 10)

(5,5,10) is the batched extent of the centred 10x10x10 extrusion, derivable from the STEP text without running the code; (3,3,2) is the FallThrough plane clip. The gate firing is asserted separately via take_failures(), so a fixture that stopped tearing would fail loudly rather than pass on a bounds coincidence.

What is actually left here, none of it code:

• Rewrite the PR description: the fix is on main via fix(geometry): defer to sequential path when an accept gate rejects the roof-clip union subtract #3922; this PR is the feature-build reproduction only; the oracle verdict is NOT APPLICABLE by design, not by evasion.
• Paste the two RED lines above into the body. That is the evidence the oracle cannot produce for a feature-gated test.
• Trim the docstring on solo_step_accounts_for_a_batched_suffix_not_just_spine_length to what it does: a smoke test over the real IfcWallStandardCase geometry anomalies or missing #960 geometry that does not reach the gate-rejection branch (spine.len() is 2 there), so it passes with the formula reverted too.
• Your Rust tests lane was red on main's 948-line boolean/mod.rs, not on anything of yours. fix(geometry): split boolean/mod.rs back under its module-size ratchet #4101 landed and took it to 920. Merge main in and re-run.

Worth saying plainly: do not add a --features mode to the oracle to make it judge this test, and do not add an exemption label. The gate already passes for the right reason. If we want the oracle to cover feature-gated tests, that is a change to scripts/lib/revert-oracle*.mjs and its own issue.

[github-actions]

Claude review - no findings for 9145a1dad

Reviewed this diff and found nothing to flag.

[louistrue]

Reopened deliberately, and retitled to say what it now is.

Why it should land even though it carries no production change. The based_on_batch fix reached main through #3922 (9dbe8c429). Closing this PR would have left main with the fix and no test observing it — nothing to catch the regression coming back. That is the shape this repo pays for most often, so the reproduction is worth keeping on its own.

The test is real in the only build where the behaviour exists. Reverting the one line on main to let solo_step = spine.len() == 1; gives:

panicked at chain_cycle_tests.rs
max bounds = [3.0, 3.0, 2.0], expected ~(5, 5, 10)

(5,5,10) is the batched extent of the centred 10x10x10 extrusion, derivable from the STEP text without running the code; (3,3,2) is the FallThrough plane clip. The gate firing is asserted separately via take_failures(), so a fixture that stopped tearing would fail loudly rather than pass on a bounds coincidence.

The oracle's NOT APPLICABLE here is correct, not an evasion. The branch changes no production files, so there is nothing to revert. And the test stays #[cfg(any(feature = "csg_manifold_gate", feature = "csg_topology_gate"))] on purpose: on a default build the fix is behaviourally inert, because gate_rejected is only ever set by the feature-gated rejections. Removing the cfg would produce a test that passes for the wrong reason. The lane that actually compiles it is "CSG accept gates (feature builds)".

Two things worth doing before this merges, neither of them code:

1. Update the PR description to match the retitle: the fix is on main via fix(geometry): defer to sequential path when an accept gate rejects the roof-clip union subtract #3922, this is the feature-build reproduction, and paste the RED output above as the evidence the oracle structurally cannot produce for a feature-gated test.
2. Trim the docstring on solo_step_accounts_for_a_batched_suffix_not_just_spine_length to what it actually does. It is a smoke test over the real IfcWallStandardCase geometry anomalies or missing #960 geometry that never reaches the gate-rejection branch (spine.len() is 2 there), so it passes with the formula reverted too. Leaving a docstring that implies otherwise is how the next reader concludes the fix is guarded when it is not.

And to close the loop: #4023 stays open until this lands, because until then the fix on main is genuinely unguarded.

[louistrue]

Your Node tests red is not yours. Re-running it.

FAIL packages/parser/src/compact-entity-index-cache.test.ts
     > entity cache eviction after long scans (#3983)
Error: Test timed out in 5000ms.
Test Files  1 failed | 110 passed (111)

A TypeScript parser test, on a PR whose entire diff is rust/geometry/src/processors/boolean/chain_cycle_tests.rs. There is no path from your change to that code.

The cause is a flaky test rather than a real regression: the loop makes ~40,000 expect() calls (20,000 iterations, half of them a deep toEqual against a fresh object literal) against a fixed 5000ms vitest timeout, so the assertion machinery dominates the runtime and loses the race under CI load. Filed as #4110 with the fix, which is to collect mismatches and assert once rather than to raise the timeout.

So on this PR the remaining state is:

• Node tests: flake, re-running, not yours.
• Changed tests observe production: NOT APPLICABLE, correct, because the branch changes no production files.
• The two prose items from my earlier comment still stand: update the description to say the fix is on main via fix(geometry): defer to sequential path when an accept gate rejects the roof-clip union subtract #3922 and this is the feature-build reproduction, and trim the docstring on solo_step_accounts_for_a_batched_suffix_not_just_spine_length since it never reaches the gate-rejection branch.