Record lane tradeoffs, verification and runtime concern

crates/oa-core/src/routing.rs

@@ -759,6 +759,64 @@ impl<'a> RoutingSpace<'a> {
             ys: sorted_coordinates(obstacles.iter().flat_map(|r| [r.top, r.bottom]).collect()),
         }
     }
+
+    /// Experimental bounded lanes around settled other-edge segments. Preserve
+    /// every obstacle coordinate; only new lane coordinates count toward the cap.
+    fn with_lanes(&self, start: Position, end: Position, previous: &[Segment]) -> Self {
+        const EXTRA_LIMIT: usize = 64;
+        let add = |base: &[f32], candidates: Vec<f32>, a: f32, b: f32| {
+            let lo = a.min(b);
+            let hi = a.max(b);
+            let midpoint = f64::from(a) / 2.0 + f64::from(b) / 2.0;
+            let mut extra = sorted_coordinates(
+                candidates
+                    .into_iter()
+                    .filter(|v| {
+                        v.is_finite() && base.binary_search_by(|base| base.total_cmp(v)).is_err()
+                    })
+                    .collect(),
+            );
+            let distance = |v: f32| {
+                if v < lo {
+                    f64::from(lo) - f64::from(v)
+                } else if v > hi {
+                    f64::from(v) - f64::from(hi)
+                } else {
+                    0.0
+                }
+            };
+            extra.sort_by(|a, b| {
+                distance(*a)
+                    .total_cmp(&distance(*b))
+                    .then_with(|| {
+                        (f64::from(*a) - midpoint)
+                            .abs()
+                            .total_cmp(&(f64::from(*b) - midpoint).abs())
+                    })
+                    .then_with(|| a.total_cmp(b))
+            });
+            extra.truncate(EXTRA_LIMIT);
+            sorted_coordinates(base.iter().copied().chain(extra).collect())
+        };
+        let mut xs = Vec::new();
+        let mut ys = Vec::new();
+        for segment in previous {
+            if segment.a == segment.b {
+                continue;
+            }
+            if segment.a.x == segment.b.x {
+                xs.extend([segment.a.x - CLEARANCE, segment.a.x + CLEARANCE]);
+            }
+            if segment.a.y == segment.b.y {
+                ys.extend([segment.a.y - CLEARANCE, segment.a.y + CLEARANCE]);
+            }
+        }
+        Self {
+            obstacles: self.obstacles,
+            xs: add(&self.xs, xs, start.x, end.x),
+            ys: add(&self.ys, ys, start.y, end.y),
+        }
+    }
 }
 
 #[allow(clippy::too_many_arguments)]
@@ -849,13 +907,17 @@ fn route_edge(
                 // Only the final leg has a known continuation. Intermediate
                 // authored pins must not inherit the target's terminal direction.
                 let outgoing = (index == pins.len()).then_some(b.point);
-                let path =
-                    fast_path(start, end, &space, &occupied, incoming, outgoing).or_else(|| {
+                // Both searches see identical lanes. Earlier legs/current
+                // source stubs affect cost as before, but do not generate lanes.
+                let leg_space = space.with_lanes(start, end, previous);
+                let path = fast_path(start, end, &leg_space, &occupied, incoming, outgoing)
+                    .or_else(|| {
                         if !search {
                             return None;
                         }
-                        let (path, hit_limit) =
-                            grid_path(start, end, &space, &occupied, incoming, outgoing, budget);
+                        let (path, hit_limit) = grid_path(
+                            start, end, &leg_space, &occupied, incoming, outgoing, budget,
+                        );
                         exhausted |= hit_limit;
                         path
                     });
@@ -1610,6 +1672,97 @@ impl BoundsBuilder {
 mod terminal_join_tests {
     use super::*;
 
+    #[test]
+    fn lanes_preserve_base_coordinates_and_bound_unique_extras_deterministically() {
+        let base: Vec<_> = (0..80).map(|i| 10_000.0 + i as f32).collect();
+        let space = RoutingSpace {
+            obstacles: &[],
+            xs: base.clone(),
+            ys: base.clone(),
+        };
+        let mut previous = Vec::new();
+        for i in 0..100 {
+            let coordinate = i as f32 * 40.0;
+            previous.push(Segment {
+                a: pos(coordinate, 0.0),
+                b: pos(coordinate, 100.0),
+                count: 1,
+            });
+            previous.push(Segment {
+                a: pos(0.0, coordinate),
+                b: pos(100.0, coordinate),
+                count: 1,
+            });
+        }
+        let lanes = space.with_lanes(pos(0.0, 0.0), pos(100.0, 100.0), &previous);
+        previous.reverse();
+        previous.extend(previous.clone());
+        let reordered = space.with_lanes(pos(0.0, 0.0), pos(100.0, 100.0), &previous);
+        assert_eq!(lanes.xs, reordered.xs);
+        assert_eq!(lanes.ys, reordered.ys);
+        for coordinates in [&lanes.xs, &lanes.ys] {
+            assert_eq!(coordinates.len(), 80 + 64);
+            assert!(base.iter().all(|v| coordinates.contains(v)));
+            assert!(coordinates.windows(2).all(|v| v[0] < v[1]));
+            assert!(coordinates.contains(&12.0));
+            assert!(coordinates.contains(&92.0));
+            assert!(!coordinates.contains(&3972.0));
+        }
+    }
+
+    #[test]
+    fn lanes_rank_interval_then_midpoint_and_skip_nonfinite_values() {
+        let space = RoutingSpace::new(&[]);
+        let previous: Vec<_> = (0..100)
+            .map(|i| Segment {
+                a: pos(i as f32 * 40.0, 0.0),
+                b: pos(i as f32 * 40.0, 100.0),
+                count: 1,
+            })
+            .chain(std::iter::once(Segment {
+                a: pos(f32::INFINITY, 0.0),
+                b: pos(f32::INFINITY, 100.0),
+                count: 1,
+            }))
+            .collect();
+        let lanes = space.with_lanes(pos(0.0, 0.0), pos(4000.0, 0.0), &previous);
+        assert_eq!(lanes.xs.len(), 64);
+        assert!(lanes.xs.contains(&1988.0));
+        assert!(lanes.xs.contains(&2012.0));
+        assert!(!lanes.xs.contains(&12.0));
+        assert!(lanes.xs.iter().all(|v| v.is_finite()));
+        assert!(lanes.ys.is_empty());
+    }
+
+    #[test]
+    fn shared_lane_space_offers_clear_parallel_path_to_fast_and_grid() {
+        let start = pos(0.0, 0.0);
+        let end = pos(200.0, 0.0);
+        let previous = vec![Segment {
+            a: start,
+            b: end,
+            count: 1,
+        }];
+        let base = RoutingSpace::new(&[]);
+        let lanes = base.with_lanes(start, end, &previous);
+        assert_eq!(lanes.ys, vec![-12.0, 12.0]);
+        let fast = fast_path(start, end, &lanes, &previous, None, None).unwrap();
+        assert_eq!(fast.first(), Some(&start));
+        assert_eq!(fast.last(), Some(&end));
+        // Under experimental P=3, direct cost280 loses to length224 + turns48.
+        // No terminal direction is fixed in this private leg-level witness.
+        // Keep the witness valid when parent compares the baseline coefficient.
+        let expected = path_cost(&[start, end], &previous).min(272.0);
+        assert!((path_cost(&fast, &previous) - expected).abs() < EPSILON);
+        let mut budget = VIEW_SEARCH_BUDGET;
+        let (grid, exhausted) = grid_path(start, end, &lanes, &previous, None, None, &mut budget);
+        assert!(!exhausted);
+        let grid = grid.unwrap();
+        assert_eq!(grid.first(), Some(&start));
+        assert_eq!(grid.last(), Some(&end));
+        assert!((path_cost(&grid, &previous) - expected).abs() < EPSILON);
+    }
+
     fn complete_cost(
         path: &[Position],
         before: Position,

harness/auto-layout-investigation-20260925.md

@@ -16,6 +16,11 @@ isolates a routing score correction with fixed Projects/nodes/ports/endpoints.
 Its 185 regression checks pass, but an original-scene overlap regression and
 additional bipartite T contacts prevent a general readability acceptance.
 
+The [completed scoring/lane comparison](experiments/auto-layout-20260925/results-lanes.md)
+records J/P/PL/L and closes this fixture-tuning experiment. L passes 188 selected
+checks and strict core Clippy, but residual ambiguity and a runtime cost signal
+require broader, independently selected evidence before production adoption.
+
 ## Question and existing evidence
 
 Can explicit Auto-layout produce a readable arrangement that accounts for

harness/experiments/auto-layout-20260925/lanes-results-audit.md

@@ -0,0 +1,46 @@
+# L results and four-way routing experiment audit
+
+Recommendation: stop tuning these fixtures. L is a useful experimental witness that route alternatives affect sharing, but its small layered benefit and material runtime signal do not presently justify its per-leg preprocessing as a production default. Keep J as the simpler independently motivated scoring correction candidate; decide L only against frozen independent scenes and route-only timing. No production/native acceptance claimed.
+
+## Verified final L result
+
+Primary J06 pin `08656b18bf8934cf264469cf68fc6dea97c15cbb`; L11 pin `e8ec6dbb3160f62476a5557f14605f68959f65fe`. Both recorded offline dev/gnullvm probe commands exit0, source unchanged, failure null. Verified receipt log hashes. Separate raw-output traversal confirms all37 Projects, projected nodes/ports and per-edge endpoint records exactly equal. All nine candidate supported/repeat-input/idempotence/ten-call/JSON-and-single-source-roundtrip results remain true, with unchanged conservation and baseline history checks. Candidate Command/Undo integration remains absent.
+
+J→L changed scalar rows only:
+
+- Original bipartite raw sharing872→724, nonterminal800→652.
+- Layered bipartite raw187→176, nonterminal115→104; drawing area175960→165360.
+- Original two-container raw/nonterminal54→12.
+- Two-container baseline and reset raw/nonterminal18→12 each.
+
+The other32 rows are unchanged in recorded scalar quality metrics. No changed point-contact, proper-crossing, length, bend, warning or collision counts in J→L. Independently comparing full candidate metric objects confirms all nine L layered metrics exactly equal PL, not merely the headline totals. Remaining layered bipartite104 nonterminal shared units still prohibit a solved-traceability claim.
+
+Test10 receipts record135+7+13+18+2+13=188 passed,0 failed/ignored, exit0, unchanged source. J02 and L10 command argv and entire recorded environment dictionaries compare equal. Their routing_geometry test summary elapsed4.30s versus16.43s (~3.82 times, +12.13s); parent reports no concurrent agent compiler. This is a material cost signal, not a controlled routing benchmark: suite runtime includes varied tests and scheduling effects, with no repeated route-only timing. It must not be dismissed by quoting cargo compilation time or presented as an established scaling law.
+
+Verified37 L schematic image hashes/lengths and manifest input hash. Native/glyph rendering was not exercised. Strict Clippy12 was active when assigned and is outside this audit; no outcome inferred.
+
+## Four-way conclusion
+
+All numbers below are raw pairwise shared length; inspect the preceding audits for contacts/area/turn tradeoffs.
+
+| Scene/variant | J | P | P+L | L |
+|---|---:|---:|---:|---:|
+| Layered bipartite |187|187|176|176|
+| Original bipartite |872|730|724|724|
+| Baseline/reset bipartite |276|276|72|276|
+| Original two-container |54|6|12|12|
+| Baseline/reset two-container |18|18|12|12|
+
+P has no layered benefit. P+L's baseline bipartite72 means only common terminal sharing remains, but proper crossings rise0→1, length+24 and area+19392; L alone does not produce that tradeoff. The strongest ordinary two-container sharing result is P6, at an extra bend,12 length units and one T contact. Neither the coefficient nor lanes dominates all vectors. J diamond's isolated improvement remains valid but does not erase its original bipartite regression.
+
+Next scope should be finite and specified before inspecting outcomes: one realistic nested/folded scene, one mixed fan-in/out with a fixed edge-ID permutation, and one modest sparse scene measured by route-only timing and warning/budget counts. Preserve endpoint/model constraints and evaluate traceability, collisions, bends/length/area jointly. Do not silently extend unsupported layered folded behavior into an acceptance claim. Set practical timing and readability criteria before repeating improvement. If L does not show proportionate independent benefit, omit it; avoid adding configuration/architecture solely to retain every experiment. The explicit Layout reset policy and ordinary input/Undo/Save lifecycle are still separate implementation work.
+
+## Evidence identities
+
+J06 output `f9ac7c1320b1cf026259bfcaf13a39e968ae317463712d8dc793375d9a4a541f`.
+L11 output `64232f580600b7a874a6f4ceb128a6188fd5ff72655bc6b93d824ebed27ffb7d`.
+L11 result.json `feee84c2fde115c22ea865033ff2d136da2aace1f1c8a7423c8add11358366a8`.
+L comparison JSON `e1e23e6c2a50cd384457bb061d5b70a740f586f42767164fad9703ecbb4096a8`.
+L contact audit JSON `6f6cc674c27d3f43001fe1751ef3b09332caa9ddca396759f5525f811cbe1aaf`.
+
+Read-only audit of completed records; no build/probe/helper rerun, source edit or publication. Earlier independent J/P/PL source/results notes retain grid-axis, subdivision-score, capped retained coordinates versus unbounded preprocessing, stable-edge-order and approximate-label limitations.

harness/experiments/auto-layout-20260925/lanes-source-review.md

@@ -0,0 +1,20 @@
+# Bounded L lane-candidate source review
+
+Reviewed routing.rs SHA256 `af5995af10c8e3b30c5c6fb776a2ac2678eeef59dd58eb0cdb3d5c62cd153f1b` before parent formatting. Static inspection only; no builds or source edits. No blocking implementation finding for the finite nine-fixture P+L / J+L probe comparison.
+
+The code retains all sorted base obstacle coordinates and adds at most64 unique extras EACH axis (128 total), filters nonfinite generated values, deduplicates before ranking, then ranks distance from the start/end axis interval, distance from its midpoint, and numeric value. Final lists return to coordinate order. It derives perpendicular offsets only from nondegenerate settled other-edge segments. The current edge's earlier legs/source stub still contribute occupied scoring but do not generate lanes. Fast/grid receive the identical per-leg RoutingSpace; obstacles, endpoints, authored pins, terminal joins and fallback remain unchanged.
+
+Three new tests cover80 retained base coordinates plus64 extras per axis, previous-segment reorder/duplication invariance, nearest-interval/midpoint selection and nonfinite rejection, and direct calls to fast/grid sharing the same parallel-lane witness. The latter expects min(direct cost,272) and supports both coefficients. No test success is inferred before execution.
+
+Test-scope caveat sent to parent: the existing `unspecified_continuation_keeps_intermediate_leg_choice` test deliberately hardcodes baseline coefficient0.12, path choice and cost255.52. At P3, the shared penalty caps80 and the alternative is cheaper; a whole private suite at P3 can fail that baseline-policy assertion. Preserve the result honestly; restore0.12 for baseline-suite claims or explicitly distinguish experimental tests. This does not block a diagnostic P+L probe.
+
+Limits relevant to interpreting results:
+
+-64 bounds retained coordinates, not scan/sort work. Every endpoint-pair/leg constructs candidates from all previous segments; this preprocessing is outside the search-step budget. No large-scene performance guarantee.
+- Added coordinates can make the grid exceed65536 cells even when its original grid fit. Existing exhaustion warning/fallback is the evidence to inspect, not something to suppress.
+- Grid scoring is coordinate-subdivision-sensitive: strict-interior crossing tests can miss contacts at inserted grid vertices, and per-segment capped overlap charges can change with subdivision. Therefore a grid result can change due to scoring partition as well as newly offered parallel lanes. Keep independent contact/shared-interval metrics authoritative for quality observations.
+- Rank uses one axis and does not filter segment extent on the other; remote lanes can consume the cap. This deterministic heuristic is not proof of optimal lane coverage. The router still uses a feasible fast path before grid, two-axis rather than signed-direction search state, stable sequential edge order, and local hard-pin legs.
+
+Required experiment interpretation: compare P+L to P and J+L to J with exact Project/node/port/endpoints, all quality metrics and warning counts. Retain label collisions, T/bend contacts, length/turn/area regressions; fewer shared units alone is not acceptance. No broad production or native readability conclusion follows from this finite source review.
+
+Current formatted routing SHA256: 3a8af7a44f8f32bd9fb94dddd9184fafcf64c93c510025169c62958566bbaedf. Reread formatted lane construction: filtering/ranking/cap semantics agree with reviewed candidate. No mechanical original-byte whitespace comparison claimed. Parent plans exactly the three lane-filtered private tests for P+L, then restores0.12 for the full baseline suite; that appropriately separates the baseline-policy assertion noted above.

harness/experiments/auto-layout-20260925/penalty-lanes-audit.md

@@ -0,0 +1,35 @@
+# P+L results independent audit
+
+P+L demonstrates that additional lanes can remove one scene's nonterminal overlap, but adds a proper crossing and gives only a small layered improvement. It does not yet justify adopting the extra heuristic as a general production default. Static record audit only; no reruns, builds or source edits.
+
+Compared P07 `3d7adff923dee5bed54dfdccc119dbee0c7c2773` with PL09 `d0be9ff0674373fcf9623daf62bbf50dad02c4df`. Both probe receipts exit0, failure null, unchanged source; all logged hashes independently checked. Separate raw-output traversal confirms all37 Projects, projected nodes/ports and route endpoint records exact. All nine candidate support/repeat/idempotence/ten-call/roundtrip results remain true; conservation and baseline Command::Layout history checks match P. Candidate Undo integration remains untested.
+
+Test08 actually ran `cargo test --locked --offline -p oa-core --lib lane`: five passed,130 filtered, zero failed/ignored. This is three new routing lane tests plus two existing scenario-layout tests, not a whole core-suite pass.
+
+All changed numeric-vector rows, P→PL:
+
+| Scene/variant | Sharing raw / nonterminal | Other changes |
+|---|---|---|
+| bipartite before |730→724 /658→652|contacts10→9; bends5→4; length2076→2064|
+| bipartite baseline |276→72 /204→0|proper crossings0→1; contacts6→5; length3284→3308; area300576→319968|
+| bipartite reset |276→72 /204→0|same changes as baseline|
+| bipartite layered |187→176 /115→104|area175960→165360; contacts9 unchanged|
+| two-container before |6→12 /6→12|contacts3→2; bends5→4; length1524→1512|
+| two-container baseline |18→12 /18→12|no other scalar change|
+| two-container reset |18→12 /18→12|no other scalar change|
+
+Remaining30 rows unchanged; eight other layered vectors unchanged. No new label-collision or warning-count changes appear. The baseline/reset proper crossing is a real quality tradeoff, not an automatic failure: a visible isolated crossing may be easier to trace than coincident routes. Conversely, zero proper crossings in the layered scene still accompanies104 nonterminal shared units. Two-container original sharing doubles6→12 despite fewer contacts/turns. No single scalar orders all these results.
+
+Viewed the baseline and layered bipartite PNGs. Baseline channels separate except for the isolated crossing; layered channels retain shared horizontals. Verified all37 offline image hashes/lengths and manifest input binding. These are schematic core geometry, not actual font/native rendering or a user traceability test.
+
+Performance/complexity: probe command elapsed approximately67.1s(P) and69.7s(PL), but these cargo invocations include compilation; they are not comparable routing benchmarks and establish no overhead bound. The new code scans/sorts all prior segments for each endpoint-pair/leg;64-per-axis limits retained coordinates, not preparation work. It can expand the grid past its existing cell cap. Grid crossing/overlap scoring also changes under coordinate subdivision. None of these limitations is resolved by the tiny fixture set.
+
+Recommendation: finish the already-declared J/P/PL/L grid and stop coefficient/lane-spacing tuning on these fixtures. Retain L as an experimental option unless the final comparison supplies stronger value. The next useful acceptance scope is a frozen, modest set of independent scenes chosen before results: one realistic authored diagram with nested/folded content, one mixed-direction fan-in/out, and one moderately sized sparse diagram for routing time/budget behavior, including a fixed edge-order permutation. Choose a preferred traceability tradeoff explicitly; do not add architectural hooks merely to preserve this heuristic. Prioritize the explicit Layout command/reset contract and production integration lifecycle once a maintainable geometry choice is selected. No #32 closure or native readability acceptance follows here.
+
+Bindings:
+
+- P output SHA256 `13111fe89e4e637d1af572a8a45b8bdd763e94b58a2ec5ec6ca83e40ffa209c7`.
+- PL output `04bb9ba4ab551a965cea130510cca6b96d9c1012911f191b14a7aa7efbf563dd`.
+- PL result.json `538aa79bcedd4cf646c63d5309ec738be4676e2045715db1035a4f334a536117`.
+- PL comparison JSON `81f57e651a8840aaaeacc085df2eb90174b2e494182f6cd40ccd6d50e7bb531e`.
+- PL contact audit JSON `60ce7e9735ceef50a92d29a0414aafe3d8fb6174dab99eff6397e2abc88e0afa` (inspected as independent worker evidence, not rerun here).

harness/experiments/auto-layout-20260925/penalty-results-audit.md

@@ -0,0 +1,26 @@
+# P overlap-penalty experiment independent audit
+
+Confirmed the reported finite result. Static read-only audit; no build, probe rerun, source edit or GUI action. P does not improve any of the nine layered candidate metric vectors and is not a demonstrated solution to their remaining shared routes.
+
+Primary comparison: J06 `08656b18bf8934cf264469cf68fc6dea97c15cbb` versus P07 `3d7adff923dee5bed54dfdccc119dbee0c7c2773`. Inspected the latter commit: only routing.rs changes, overlap coefficient0.12→3.0 plus an experiment comment; cap80 remains unchanged. Both recorded `cargo run --locked --offline -p oa-core --example auto_layout_probe` receipts are Windows gnullvm/dev, exit0, inputs unchanged, failure null. Independently verified every log hash in both receipts.
+
+Independent traversal of the raw outputs confirmed all37 variant Projects, projected nodes, projected ports and emitted route endpoint records match exactly. All nine layered candidates retain supported=true, repeat-input exactness, idempotence, passes2–10 equal first/previous, exact JSON/single-source roundtrips and identical conservation results. The authored-detour route-reset exception remains intentional. Baseline Command::Layout history/Undo checks remain identical; this is still not candidate-command Undo evidence.
+
+Only two variant rows change numeric metrics:
+
+| Original/before scene | Raw sharing J→P | Nonterminal sharing J→P | Bends | Length | Point contacts |
+|---|---:|---:|---:|---:|---:|
+| crossed_bipartite |872→730|800→658|4→5|2064→2076|9→10|
+| two_containers_reversed_children |54→6|54→6|4→5|1512→1524|2→3|
+
+Each extra contact is classified as a T contact in the separately generated independent interval audit: bipartite T3→4 and two-container T1→2; proper crossings remain0. Lower shared length therefore comes with one additional bend,12 length units and one additional point contact in each scene. Bipartite returns to the pre-J shared-length total; this does not establish trace readability. All baseline/reset rows, manual witness and nine layered scalar vectors are unchanged. Exact model/endpoint invariants do not imply identical polylines.
+
+Evidence identities:
+
+- J06 raw output `f9ac7c1320b1cf026259bfcaf13a39e968ae317463712d8dc793375d9a4a541f` (also identical to J03 output).
+- P07 raw output `13111fe89e4e637d1af572a8a45b8bdd763e94b58a2ec5ec6ca83e40ffa209c7`.
+- P07 result.json `6149122d05d77e02b463edb3dd359b06786bc4468c27d8cd625cbc1bc80c9894`.
+- P comparison JSON `9f228fbe78e1888c5d93e87dddd8d2effc01bab723929a87423c61e23f5cad66`.
+- P independent contact audit JSON `6f4add5c81f6d16c45efabbefd9e36c9beb637b6823993f0d51adc3e20485ad9`. Its recorded definitions and counts were inspected; this reviewer did not execute that helper again.
+
+Recommendation: archive P as a bounded negative result for the layered overlap objective, preserving the two ordinary-scene tradeoffs. A predefined bounded lane-candidate experiment can now test whether available route geometry, rather than this single coefficient, limits improvement. Retain the same Projects/endpoints and all quality metrics; do not tune indefinitely against these nine fixtures or claim general quality/native acceptance. The cap, sequential edge order, fast-path preference, axis-only grid state and estimated label bounds remain limits.

harness/experiments/auto-layout-20260925/results-lanes.md

@@ -0,0 +1,112 @@
+# Complete scoring/lane comparison
+
+**Stop tuning these nine fixtures; retain the variants as experimental evidence.**
+Bounded parallel lane candidates have some measurable value, but do not resolve
+the compact bipartite ambiguity and introduce a routing-cost concern. The
+stronger overlap coefficient is no longer present at the branch tip. No routing
+or Arrange replacement has been accepted for production.
+
+PL source `d0be9ff0674373fcf9623daf62bbf50dad02c4df` combines target-join J,
+coefficient 3.0/cap 80 and bounded lanes. L source
+`e8ec6dbb3160f62476a5557f14605f68959f65fe` restores coefficient 0.12, retaining
+J and lanes. Each leg keeps every obstacle coordinate and adds at most 64
+deterministic coordinates per axis at CLEARANCE offsets from settled other-edge
+segments. Fast/grid searches receive the same augmented space. Endpoint geometry,
+authored pins, attachments and model metadata are not edited by this operation.
+
+The [source review](lanes-source-review.md) records attribution limits: retained
+coordinates are bounded, but collection/sorting of prior segments is not charged
+to the search budget. Extra axes can hit the existing grid-cell cap and can alter
+grid scores through segment subdivision. This is not a proof of globally optimal
+paths or constant preparation cost. No new engine/runtime dependency was added.
+
+## Results
+
+Every one of the 37 complete Projects, node sets, port sets and exact endpoints
+matches its control in both comparisons. All nine candidate invariants,
+roundtrips and repeated-call checks hold. Values below are raw pairwise shared
+length for the crossed-bipartite fixture; complete vectors remain in the archive.
+
+| Router | Original scene | Existing Layout/reset | Layered candidate |
+| --- | ---: | ---: | ---: |
+| Released router | 730 | 276 | 344 |
+| J | 872 | 276 | 187 |
+| J + stronger penalty (P) | 730 | 276 | 187 |
+| J + stronger penalty + lanes (PL) | 724 | 72 | 176 |
+| J + lanes, original penalty (L) | 724 | 276 | 176 |
+
+PL's existing-Layout/reset result eliminates 204 nonterminal shared units but
+adds one proper crossing, 24 route-length units and 19392 area units. Contacts
+decrease 6→5; these tradeoffs stay explicit. L with the original coefficient
+does not achieve that baseline improvement. Both lane variants leave 104
+nonterminal units in the compact layered case, with nine point contacts. Its
+drawing area returns from J's 175960 to 165360. Eight other layered metric
+vectors are unchanged. The parent viewed the PL bipartite schematic: vertical
+channels are separated, but horizontal tails still join at ambiguous branches.
+
+Compared with J, L reduces original bipartite sharing 872→724 and original
+two-container sharing 54→12 without changing the other original quality fields;
+two-container baseline/reset sharing reduces 18→12. PL compared with P includes
+a two-container original sharing regression 6→12 while reducing one bend, 12
+length units and one contact. The [PL audit](penalty-lanes-audit.md) documents all
+seven changed rows; no scalar is treated as a universal quality score. Labels,
+obstacles and warnings remain separately checked. Core schematics and approximate
+label boxes do not establish actual glyph layout or native route traceability.
+
+## Verification and evidence
+
+Same frozen Windows Rust1.98.1 gnullvm environment, one Cargo job, locked/offline,
+incremental disabled. Linux excluded. All runs close with exit0, unchanged
+inputs and no runner failure:
+
+```text
+# PL: five matched tests, including all three new lane tests
+cargo test --locked --offline -p oa-core --lib lane
+# L: 188 tests passed, zero failed/ignored
+cargo test --locked --offline -p oa-core --lib --test release_routing --test routing_geometry --test routing_labels --test state_diagrams --test group_movement
+# Both variants: complete nine-fixture diagnostic
+cargo run --locked --offline -p oa-core --example auto_layout_probe
+# L: strict core/all-target Clippy passed
+cargo clippy --locked --offline -p oa-core --all-targets -- -D warnings
+```
+
+The full 188 check is for L, not PL: an existing private J test intentionally
+asserts the original 0.12 cost. PL's filtered run executes three new lane tests
+and two existing Scenario tests matched by `lane`; 130 other library tests are
+filtered. Lane witnesses cover base-coordinate preservation, 64-extra bounds,
+deduplication/order independence, relevance ranking, nonfinite rejection and
+fast/grid selection of a feasible parallel path under the experimental cost.
+
+**Cost signal:** routing_geometry's 18-test runtime is 16.43s under L versus
+4.30s under J on the same machine/environment. This excludes compilation, but
+is one suite observation per variant, not an isolated route benchmark or a
+performance bound. It warrants profiling before adopting per-leg lane scans.
+Whole cargo/probe elapsed times include compilation and are unsuitable for that
+comparison.
+
+The [independent final L/four-way audit](lanes-results-audit.md) confirms all 37
+fixed bindings and the 188-test result, checks the recorded geometry/contact
+evidence, and likewise recommends withholding L from production pending the
+independent corpus and route-only timing.
+
+[Evidence archive](run-lanes/lanes-e8ec6db.zip), 3518507 bytes, SHA256
+`5512b4cbd99e3bf03eb975e25fb980f7b1a95a5cb19f3687fb3d6d83d1839e8f`,
+contains original runs08–12, 74 offline images, complete comparisons, independent
+axis-based contact audits, binary identities and runners. [Manifest](
+run-lanes/manifest.json) binds every member, all byte-compared to originals.
+PL output SHA256 `04bb9ba4ab551a965cea130510cca6b96d9c1012911f191b14a7aa7efbf563dd`;
+L output SHA256 `64232f580600b7a874a6f4ceb128a6188fd5ff72655bc6b93d824ebed27ffb7d`.
+The earlier P result and original archive remain linked in [results-p.md](results-p.md).
+
+## Decision and next evidence
+
+Do not choose a global router policy from these nine scenes. Freeze a small
+independent corpus before the next run: realistic authored nested/folded content,
+mixed-direction shared/distinct-port fan-in/out with a fixed edge-ID permutation,
+and a modest sparse diagram for isolated routing-time/budget observations. Compare
+J and L with an explicit route-tracing rubric and full quality vector. Preserve
+the original Scene/Arrange distinction and source/history lifecycle constraints.
+This should decide whether the lane cost is justified or the simpler router
+should be retained before broadening the Layout prototype. Fold/filter rules,
+one-command Undo, API/source parity and real desktop acceptance remain required;
+the separately pending State-label issue36 is not silently included here.

harness/experiments/auto-layout-20260925/results-p.md

@@ -0,0 +1,50 @@
+# Capped overlap-penalty experiment
+
+**P alone does not solve the arranged bipartite overlap.** Source
+`3d7adff923dee5bed54dfdccc119dbee0c7c2773` changes only the overlap coefficient
+from 0.12 to 3.0 (plus an experiment comment), retaining the per-segment cap 80.
+Node placement, ports, target-join J logic, edge order and crossing cost remain
+unchanged. This is a transient diagnostic source variant, not a proposed default.
+
+Windows command `cargo run --locked --offline -p oa-core --example
+auto_layout_probe` completed exit 0 with unchanged inputs at
+2026-09-25T01:04:57Z. Same frozen Rust1.98.1 gnullvm environment as J; Linux
+excluded. Output SHA256
+`13111fe89e4e637d1af572a8a45b8bdd763e94b58a2ec5ec6ca83e40ffa209c7`.
+J's 185 passing tests and strict Clippy are not claimed for P; this run executes
+the diagnostic observer and its analytic primitives only.
+
+[Original evidence archive](run-p/penalty-3d7adff.zip), 916568 bytes, SHA256
+`6b819b01c8012aa72d423443f4dc04ae261f1ee9dc6907f0063c219ff173ad36`,
+contains receipts, complete Projects/geometry, independent contact audit,
+comparison, renderer output and runner. [Manifest](run-p/manifest.json) binds
+original bytes and post-run probe executable; every member was checked against
+its local original.
+
+Complete Projects, nodes, ports and route endpoints are exact versus J in all
+37 variants. All nine layered candidates retain the previous quality vector;
+in particular bipartite sharing remains 187 (115 nonterminal), with nine contacts
+and zero proper crossings. Two original-scene vectors change; the other 35 do
+not:
+
+| Original scene | Shared length J → P | Bends | Route length | Point contacts |
+| --- | ---: | ---: | ---: | ---: |
+| Crossed bipartite | 872 → 730 | 4 → 5 | 2064 → 2076 | 9 → 10 |
+| Reversed children in two containers | 54 → 6 | 4 → 5 | 1512 → 1524 | 2 → 3 |
+
+The bipartite result restores the first experiment's original-scene vector;
+the extra bend/length tradeoff was predicted by the low overlap cost diagnosis.
+Both contact increases remain visible rather than being counted as a clean
+readability win. These results concern core geometry, not native route tracing.
+
+The [independent P audit](penalty-results-audit.md) confirms these results and
+all nine recorded conservation/roundtrip/repetition checks. Both additional
+point contacts are T contacts; no proper crossing change is hidden by the table.
+
+The next L comparison adds a bounded number of deterministic parallel lane
+coordinates while preserving all existing obstacle coordinates and fixed
+endpoints. Use the same augmented geometry for fast/grid search. P+L and J+L
+will distinguish available alternatives from preference. The cap 80 may still
+reject a four-turn detour whose extra length/turn cost exceeds it; retain that
+outcome rather than retuning cap, ordering and spacing together. No weight or
+lane policy is accepted for production by this diagnostic run.

harness/experiments/auto-layout-20260925/run-lanes/.gitattributes

@@ -0,0 +1 @@
+* -text whitespace=blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol

harness/experiments/auto-layout-20260925/run-lanes/manifest.json

@@ -0,0 +1,565 @@
+{
+  "scope": "Finite PL/L experiments; no production/native/performance acceptance",
+  "runs": [
+    {
+      "name": "08-lane-tests",
+      "source_commit": "d0be9ff0674373fcf9623daf62bbf50dad02c4df",
+      "exit_code": 0
+    },
+    {
+      "name": "09-penalty-lanes-probe",
+      "source_commit": "d0be9ff0674373fcf9623daf62bbf50dad02c4df",
+      "exit_code": 0
+    },
+    {
+      "name": "10-lanes-core-tests",
+      "source_commit": "e8ec6dbb3160f62476a5557f14605f68959f65fe",
+      "exit_code": 0
+    },
+    {
+      "name": "11-lanes-probe",
+      "source_commit": "e8ec6dbb3160f62476a5557f14605f68959f65fe",
+      "exit_code": 0
+    },
+    {
+      "name": "12-lanes-clippy",
+      "source_commit": "e8ec6dbb3160f62476a5557f14605f68959f65fe",
+      "exit_code": 0
+    }
+  ],
+  "post_run_l_probe_binary": {
+    "bytes": 24202240,
+    "sha256": "3c6a6fd09bc86e7e6b3ff1ace05540c103393d66bbb02c46bf0ebd6214fbabb1"
+  },
+  "members": {
+    "08-lane-tests/command/changes.patch": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "08-lane-tests/command/context.json": {
+      "bytes": 3478,
+      "sha256": "7f30e52a87c964d86e86229061be72372a9cfc1a3fad9a37c326370c38aec4ad"
+    },
+    "08-lane-tests/command/inputs-after.json": {
+      "bytes": 1730052,
+      "sha256": "2173ea00107237f320ab249a6fcde0ec616421aa09d6c274ef563e9974b47e6e"
+    },
+    "08-lane-tests/command/inputs-before.json": {
+      "bytes": 1730052,
+      "sha256": "2173ea00107237f320ab249a6fcde0ec616421aa09d6c274ef563e9974b47e6e"
+    },
+    "08-lane-tests/command/output.log": {
+      "bytes": 670,
+      "sha256": "1b3cc48bee9bb4d564f0479a692b7b20fa6df5da3b8dccfda5d1487b6b93f53e"
+    },
+    "08-lane-tests/command/result.json": {
+      "bytes": 4121,
+      "sha256": "9a48e66ce638944e885e708b3f361ce2d099352e154536a46fafa6bca49af12f"
+    },
+    "08-lane-tests/command/stderr.log": {
+      "bytes": 304,
+      "sha256": "c534ac6e8df5add7c08f663cd516b9a0da947a93127ebda6c378ede9bd42f575"
+    },
+    "08-lane-tests/environment.json": {
+      "bytes": 9463,
+      "sha256": "14e53dd6359601bdd9be3ad24c527fca96310d9eb4ffa91965f71841f8df2f82"
+    },
+    "08-lane-tests/orchestration.log": {
+      "bytes": 170,
+      "sha256": "bf1ebdbbdd1955bd7b874592340e3d79a48a145a9b39faec898aaa807133f81a"
+    },
+    "09-penalty-lanes-probe/command/changes.patch": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "09-penalty-lanes-probe/command/context.json": {
+      "bytes": 3502,
+      "sha256": "4c95894559f60d51fda0e2af09b2ec66abf9dc687d623c1e67c9e042747d0084"
+    },
+    "09-penalty-lanes-probe/command/inputs-after.json": {
+      "bytes": 1730052,
+      "sha256": "2173ea00107237f320ab249a6fcde0ec616421aa09d6c274ef563e9974b47e6e"
+    },
+    "09-penalty-lanes-probe/command/inputs-before.json": {
+      "bytes": 1730052,
+      "sha256": "2173ea00107237f320ab249a6fcde0ec616421aa09d6c274ef563e9974b47e6e"
+    },
+    "09-penalty-lanes-probe/command/output.log": {
+      "bytes": 371062,
+      "sha256": "04bb9ba4ab551a965cea130510cca6b96d9c1012911f191b14a7aa7efbf563dd"
+    },
+    "09-penalty-lanes-probe/command/result.json": {
+      "bytes": 4166,
+      "sha256": "538aa79bcedd4cf646c63d5309ec738be4676e2045715db1035a4f334a536117"
+    },
+    "09-penalty-lanes-probe/command/stderr.log": {
+      "bytes": 279,
+      "sha256": "126be48ed1535d641835bd72b6fc5aa05a9a2120dd2012daa3e30108eb1703e2"
+    },
+    "09-penalty-lanes-probe/environment.json": {
+      "bytes": 9463,
+      "sha256": "14e53dd6359601bdd9be3ad24c527fca96310d9eb4ffa91965f71841f8df2f82"
+    },
+    "09-penalty-lanes-probe/orchestration.log": {
+      "bytes": 179,
+      "sha256": "4e398b4fed1ac76d6bd61cb18fe2c50cae2764f040d878006e464c5728428cd3"
+    },
+    "10-lanes-core-tests/command/changes.patch": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "10-lanes-core-tests/command/context.json": {
+      "bytes": 3655,
+      "sha256": "2ee756c13c33bccf0cb7c87492bb62be5d5203044a066af0af36389059b2181c"
+    },
+    "10-lanes-core-tests/command/inputs-after.json": {
+      "bytes": 1730052,
+      "sha256": "27af33c77ce384358dfbd8a6730d2eff7399575fb1cacbb2c338eaa441e5db91"
+    },
+    "10-lanes-core-tests/command/inputs-before.json": {
+      "bytes": 1730052,
+      "sha256": "27af33c77ce384358dfbd8a6730d2eff7399575fb1cacbb2c338eaa441e5db91"
+    },
+    "10-lanes-core-tests/command/output.log": {
+      "bytes": 19032,
+      "sha256": "bde8202db1c2f3f407a7dcbf6a1184830d0914e2bbba0e5f7cbd2c55d72d56b4"
+    },
+    "10-lanes-core-tests/command/result.json": {
+      "bytes": 4312,
+      "sha256": "828871867eb7ff0ccfd5953a694ae594ae145e89bf2eca831368297d1ea9b874"
+    },
+    "10-lanes-core-tests/command/stderr.log": {
+      "bytes": 990,
+      "sha256": "df86da47eb1884669f1d0ce14107713ea9afd9e3cbb68becf451a018a1bf7303"
+    },
+    "10-lanes-core-tests/environment.json": {
+      "bytes": 9463,
+      "sha256": "14e53dd6359601bdd9be3ad24c527fca96310d9eb4ffa91965f71841f8df2f82"
+    },
+    "10-lanes-core-tests/orchestration.log": {
+      "bytes": 176,
+      "sha256": "6a2f55638fd26b60333bcd61cc1faaa29baaf9041962cbc1cfacd762bfc933e5"
+    },
+    "11-lanes-probe/command/changes.patch": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "11-lanes-probe/command/context.json": {
+      "bytes": 3494,
+      "sha256": "d8ec80836b09c1859b7d482dbd2ebb0243495be3e022ce2cb5dcc5c47e9464bf"
+    },
+    "11-lanes-probe/command/inputs-after.json": {
+      "bytes": 1730052,
+      "sha256": "27af33c77ce384358dfbd8a6730d2eff7399575fb1cacbb2c338eaa441e5db91"
+    },
+    "11-lanes-probe/command/inputs-before.json": {
+      "bytes": 1730052,
+      "sha256": "27af33c77ce384358dfbd8a6730d2eff7399575fb1cacbb2c338eaa441e5db91"
+    },
+    "11-lanes-probe/command/output.log": {
+      "bytes": 371182,
+      "sha256": "64232f580600b7a874a6f4ceb128a6188fd5ff72655bc6b93d824ebed27ffb7d"
+    },
+    "11-lanes-probe/command/result.json": {
+      "bytes": 4142,
+      "sha256": "feee84c2fde115c22ea865033ff2d136da2aace1f1c8a7423c8add11358366a8"
+    },
+    "11-lanes-probe/command/stderr.log": {
+      "bytes": 278,
+      "sha256": "2e73f2722528e8f80b9e64f722643769e279d822835e9ea47e96cb07eaf51162"
+    },
+    "11-lanes-probe/environment.json": {
+      "bytes": 9463,
+      "sha256": "14e53dd6359601bdd9be3ad24c527fca96310d9eb4ffa91965f71841f8df2f82"
+    },
+    "11-lanes-probe/orchestration.log": {
+      "bytes": 171,
+      "sha256": "93c3867e1dc8b07314a7ac03db0d76b641eda2eaad1ad58a61914f1d6ec64794"
+    },
+    "12-lanes-clippy/command/changes.patch": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "12-lanes-clippy/command/context.json": {
+      "bytes": 3513,
+      "sha256": "eb644e36413cc55e61b7f6aa6162f7f17f21f67911123f951f1ed96c91b30430"
+    },
+    "12-lanes-clippy/command/inputs-after.json": {
+      "bytes": 1730052,
+      "sha256": "27af33c77ce384358dfbd8a6730d2eff7399575fb1cacbb2c338eaa441e5db91"
+    },
+    "12-lanes-clippy/command/inputs-before.json": {
+      "bytes": 1730052,
+      "sha256": "27af33c77ce384358dfbd8a6730d2eff7399575fb1cacbb2c338eaa441e5db91"
+    },
+    "12-lanes-clippy/command/output.log": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "12-lanes-clippy/command/result.json": {
+      "bytes": 4158,
+      "sha256": "ea20c2e64c26667f575b70b598a790aceb1804070c208e5f8f1dd7839e8b0a8f"
+    },
+    "12-lanes-clippy/command/stderr.log": {
+      "bytes": 177,
+      "sha256": "5e1eff044f676ea902db61f76e53375f034cc2cd33c8671a56d11dd4a2aa2936"
+    },
+    "12-lanes-clippy/environment.json": {
+      "bytes": 9463,
+      "sha256": "14e53dd6359601bdd9be3ad24c527fca96310d9eb4ffa91965f71841f8df2f82"
+    },
+    "12-lanes-clippy/orchestration.log": {
+      "bytes": 172,
+      "sha256": "44d905169275ce11c8f66e16ce232d750f6b2701e6fb085880e9ad013219d18b"
+    },
+    "pl-geometry/authored_detour_and_label-after.png": {
+      "bytes": 12492,
+      "sha256": "44e30b94ef11b176155ab3df90fe5b52788c07442a42a355d3458fa904c147bd"
+    },
+    "pl-geometry/authored_detour_and_label-before.png": {
+      "bytes": 12468,
+      "sha256": "097588fae4fd6253c25ab4b60be1ad685ead3a3012b206f382cec0be1341e700"
+    },
+    "pl-geometry/authored_detour_and_label-experimental_candidate-metrics.png": {
+      "bytes": 13162,
+      "sha256": "82a07de168cda7dacdad2bd532dae408172466b2776acf8cfaabef6711c0539b"
+    },
+    "pl-geometry/authored_detour_and_label-reset_only_control-metrics.png": {
+      "bytes": 12777,
+      "sha256": "e676edc49ec6ebb2fe29e976c36cba589f76330e7f9eb27b8835415a2ed5d225"
+    },
+    "pl-geometry/chain_7_row_wrap-after.png": {
+      "bytes": 14271,
+      "sha256": "a020c1535e3d6e48cb5e6d7ae8403a256767c68ce26876fd773f3b626c61e365"
+    },
+    "pl-geometry/chain_7_row_wrap-before.png": {
+      "bytes": 13771,
+      "sha256": "0b282cbd29eb3e29fa7d3bb9c3c9746caa14c77372b3191d78fa1a60743d0b11"
+    },
+    "pl-geometry/chain_7_row_wrap-experimental_candidate-metrics.png": {
+      "bytes": 14396,
+      "sha256": "3ca042155d918083c5f4135ae059205b29b8ee5944819a6040a22eeb572f5f04"
+    },
+    "pl-geometry/chain_7_row_wrap-reset_only_control-metrics.png": {
+      "bytes": 14549,
+      "sha256": "8828f289159deb0c2bedd130495197639775cd8edeb561f0de5501e2980d1e1d"
+    },
+    "pl-geometry/crossed_bipartite-after.png": {
+      "bytes": 13163,
+      "sha256": "bb809e93b44e802d05430903cf397618fb901efdb6c5ab272574064e20641af6"
+    },
+    "pl-geometry/crossed_bipartite-before.png": {
+      "bytes": 13399,
+      "sha256": "9b7af6a43ec655cdcb05da49b5fffea661d4f5c9a5ae70a0c74c6e7696b066d3"
+    },
+    "pl-geometry/crossed_bipartite-experimental_candidate-metrics.png": {
+      "bytes": 13856,
+      "sha256": "c386b537f077f014e73e99831fdbb57e64ae9709a30afd2909dd50d7443c1899"
+    },
+    "pl-geometry/crossed_bipartite-reset_only_control-metrics.png": {
+      "bytes": 13368,
+      "sha256": "bdcf079498dc2dce5245e47eac8038d736cea7af6176ada13bf682671c70b4b4"
+    },
+    "pl-geometry/diamond-after.png": {
+      "bytes": 12556,
+      "sha256": "6afcff1e5c10758e5eab3b803ec858d0af3da953be4af93df75257544a7252b2"
+    },
+    "pl-geometry/diamond-before.png": {
+      "bytes": 13228,
+      "sha256": "38e341a1ed51d4b4a94513f34c3d48b05c72177dcc3792dc660cb780fd7f98c9"
+    },
+    "pl-geometry/diamond-experimental_candidate-metrics.png": {
+      "bytes": 13555,
+      "sha256": "a61d178e2cd3fcff8fc4ed3c42e5ab71b042d26d776f59fe5eaadb3ef8481e5e"
+    },
+    "pl-geometry/diamond-reset_only_control-metrics.png": {
+      "bytes": 12982,
+      "sha256": "48414d7a859c774f2cef51d0fc1512b1c9fe1540c540f96fac7f9531583d8731"
+    },
+    "pl-geometry/fixed_ports-after.png": {
+      "bytes": 11889,
+      "sha256": "574cb0249c3bcc3140b9d61906332295a8462e32fbcd6b9526d8b05e202e38a0"
+    },
+    "pl-geometry/fixed_ports-before.png": {
+      "bytes": 12013,
+      "sha256": "d07ef2105aa63f3aaacb19e9a7ca4960239b01f05f734baa6270657a465b4ab0"
+    },
+    "pl-geometry/fixed_ports-experimental_candidate-metrics.png": {
+      "bytes": 12394,
+      "sha256": "d7fdcd7d4a1a014dd34243400dcd74a7596388fc5747853e5a6629535ca3083e"
+    },
+    "pl-geometry/fixed_ports-reset_only_control-metrics.png": {
+      "bytes": 12231,
+      "sha256": "237e181db92baf49c24554ec4325137b014413603b62cb08dee63e6e68fa3e8d"
+    },
+    "pl-geometry/flat_chain_4-after.png": {
+      "bytes": 12582,
+      "sha256": "7326cd482a61bea4cb787770449253a55f41e102794c8fc6a8500d9244c20cc7"
+    },
+    "pl-geometry/flat_chain_4-before.png": {
+      "bytes": 12723,
+      "sha256": "b086e2b23d4b68cb43366725a26fbb39fdc2e87d18cd7109c9b3ec950ab665ba"
+    },
+    "pl-geometry/flat_chain_4-experimental_candidate-metrics.png": {
+      "bytes": 13405,
+      "sha256": "3bb352dd5066a3b2cc5bb298c9f47a02416186421df4841b96c944e523d11104"
+    },
+    "pl-geometry/flat_chain_4-reset_only_control-metrics.png": {
+      "bytes": 12918,
+      "sha256": "eba3eede6771a1ebfc7b773b48b599f5ca49613ad7444ab26acfea7d20dde515"
+    },
+    "pl-geometry/long_ordinary_labels-after.png": {
+      "bytes": 12643,
+      "sha256": "f4f0c360e9ce44d631dd1d9f7c202954be943fdbede6288edbaddf9b890fcaec"
+    },
+    "pl-geometry/long_ordinary_labels-before.png": {
+      "bytes": 12661,
+      "sha256": "3c17c1195337cda7cd4141a15428b66cac1475421600b6ecffc3db57dbfd9f94"
+    },
+    "pl-geometry/long_ordinary_labels-experimental_candidate-metrics.png": {
+      "bytes": 13235,
+      "sha256": "d2931b576901fec68b23afd1a54d4c301eda4a75ba30184344749e0add277bc0"
+    },
+    "pl-geometry/long_ordinary_labels-reset_only_control-metrics.png": {
+      "bytes": 12969,
+      "sha256": "68aacc7196a4995ff8a884a15ec91a31bd386bdd2d232fd2c27696a7f83cf791"
+    },
+    "pl-geometry/manifest.json": {
+      "bytes": 8099,
+      "sha256": "dc9c09882d841e6ba050caabf411de8dd0e868879fe8f0b7a1b44cece9ffde8b"
+    },
+    "pl-geometry/nested_cross_boundary-after.png": {
+      "bytes": 13344,
+      "sha256": "51db6785ab89f5d92c61288604ae3c76aee467e291738b54466db5704c0eec8b"
+    },
+    "pl-geometry/nested_cross_boundary-before.png": {
+      "bytes": 13547,
+      "sha256": "3b3963f5ef5a42106a006f1825ae5d85b722aa3bf163452ba986ef3369b57cc2"
+    },
+    "pl-geometry/nested_cross_boundary-experimental_candidate-metrics.png": {
+      "bytes": 13535,
+      "sha256": "0ba365785753e748dc7c86c3f1eb5767f9ccb87c0ae0e18085e6a9d32b79f60d"
+    },
+    "pl-geometry/nested_cross_boundary-reset_only_control-metrics.png": {
+      "bytes": 13549,
+      "sha256": "fbe21b57616459ecdbbd083dccd73bd120f5b7ad59a8ad80ea38cbbf9c3f49c1"
+    },
+    "pl-geometry/two_containers_reversed_children-after.png": {
+      "bytes": 13957,
+      "sha256": "b0911f8afb39313e6ce43661396d6553276d5db53c659937acf87252ed502c6e"
+    },
+    "pl-geometry/two_containers_reversed_children-before.png": {
+      "bytes": 14083,
+      "sha256": "2d42d34af4674bbf1739e85967d743e6fc78c117ef1e7645724c504b006ee881"
+    },
+    "pl-geometry/two_containers_reversed_children-experimental_candidate-metrics.png": {
+      "bytes": 14500,
+      "sha256": "8a0744cf04d305a0431468395b3676604e03991e577f9f9d2f45e8497b1ef9ca"
+    },
+    "pl-geometry/two_containers_reversed_children-manual_planar_order_witness-metrics.png": {
+      "bytes": 14531,
+      "sha256": "60623d358d9cb930c2c2c4995c9286c653e597c411b8879b77ac099fe9b0406b"
+    },
+    "pl-geometry/two_containers_reversed_children-reset_only_control-metrics.png": {
+      "bytes": 14136,
+      "sha256": "f690678d5697cbec20e64bf92a128a8fd3a1dffe3948fcbe75ad99a4f33de96d"
+    },
+    "support/auto-layout-pl-comparison-20260925.json": {
+      "bytes": 75815,
+      "sha256": "81f57e651a8840aaaeacc085df2eb90174b2e494182f6cd40ccd6d50e7bb531e"
+    },
+    "support/auto-layout-pl-contact-audit-20260925.json": {
+      "bytes": 103918,
+      "sha256": "60ce7e9735ceef50a92d29a0414aafe3d8fb6174dab99eff6397e2abc88e0afa"
+    },
+    "support/auto-layout-pl-binary-20260925.json": {
+      "bytes": 220,
+      "sha256": "00f0ceb0e92a156de2d870e32b1d57d88465e5acedd9c5f5e733f183a750c46e"
+    },
+    "l-geometry/authored_detour_and_label-after.png": {
+      "bytes": 12492,
+      "sha256": "44e30b94ef11b176155ab3df90fe5b52788c07442a42a355d3458fa904c147bd"
+    },
+    "l-geometry/authored_detour_and_label-before.png": {
+      "bytes": 12468,
+      "sha256": "097588fae4fd6253c25ab4b60be1ad685ead3a3012b206f382cec0be1341e700"
+    },
+    "l-geometry/authored_detour_and_label-experimental_candidate-metrics.png": {
+      "bytes": 13162,
+      "sha256": "82a07de168cda7dacdad2bd532dae408172466b2776acf8cfaabef6711c0539b"
+    },
+    "l-geometry/authored_detour_and_label-reset_only_control-metrics.png": {
+      "bytes": 12777,
+      "sha256": "e676edc49ec6ebb2fe29e976c36cba589f76330e7f9eb27b8835415a2ed5d225"
+    },
+    "l-geometry/chain_7_row_wrap-after.png": {
+      "bytes": 14271,
+      "sha256": "a020c1535e3d6e48cb5e6d7ae8403a256767c68ce26876fd773f3b626c61e365"
+    },
+    "l-geometry/chain_7_row_wrap-before.png": {
+      "bytes": 13771,
+      "sha256": "0b282cbd29eb3e29fa7d3bb9c3c9746caa14c77372b3191d78fa1a60743d0b11"
+    },
+    "l-geometry/chain_7_row_wrap-experimental_candidate-metrics.png": {
+      "bytes": 14396,
+      "sha256": "3ca042155d918083c5f4135ae059205b29b8ee5944819a6040a22eeb572f5f04"
+    },
+    "l-geometry/chain_7_row_wrap-reset_only_control-metrics.png": {
+      "bytes": 14549,
+      "sha256": "8828f289159deb0c2bedd130495197639775cd8edeb561f0de5501e2980d1e1d"
+    },
+    "l-geometry/crossed_bipartite-after.png": {
+      "bytes": 13144,
+      "sha256": "54a1b5e983bc9b6f619e67c13173d0ff5000e30f080aaf6c0a9064f59036f4b7"
+    },
+    "l-geometry/crossed_bipartite-before.png": {
+      "bytes": 13399,
+      "sha256": "9b7af6a43ec655cdcb05da49b5fffea661d4f5c9a5ae70a0c74c6e7696b066d3"
+    },
+    "l-geometry/crossed_bipartite-experimental_candidate-metrics.png": {
+      "bytes": 13856,
+      "sha256": "c386b537f077f014e73e99831fdbb57e64ae9709a30afd2909dd50d7443c1899"
+    },
+    "l-geometry/crossed_bipartite-reset_only_control-metrics.png": {
+      "bytes": 13349,
+      "sha256": "0b2a8c49368258b23c15a8e06bf9b881f0e53fed8b5fd7d6f216a09837634abc"
+    },
+    "l-geometry/diamond-after.png": {
+      "bytes": 12556,
+      "sha256": "6afcff1e5c10758e5eab3b803ec858d0af3da953be4af93df75257544a7252b2"
+    },
+    "l-geometry/diamond-before.png": {
+      "bytes": 13228,
+      "sha256": "38e341a1ed51d4b4a94513f34c3d48b05c72177dcc3792dc660cb780fd7f98c9"
+    },
+    "l-geometry/diamond-experimental_candidate-metrics.png": {
+      "bytes": 13555,
+      "sha256": "a61d178e2cd3fcff8fc4ed3c42e5ab71b042d26d776f59fe5eaadb3ef8481e5e"
+    },
+    "l-geometry/diamond-reset_only_control-metrics.png": {
+      "bytes": 12982,
+      "sha256": "48414d7a859c774f2cef51d0fc1512b1c9fe1540c540f96fac7f9531583d8731"
+    },
+    "l-geometry/fixed_ports-after.png": {
+      "bytes": 11889,
+      "sha256": "574cb0249c3bcc3140b9d61906332295a8462e32fbcd6b9526d8b05e202e38a0"
+    },
+    "l-geometry/fixed_ports-before.png": {
+      "bytes": 12013,
+      "sha256": "d07ef2105aa63f3aaacb19e9a7ca4960239b01f05f734baa6270657a465b4ab0"
+    },
+    "l-geometry/fixed_ports-experimental_candidate-metrics.png": {
+      "bytes": 12394,
+      "sha256": "d7fdcd7d4a1a014dd34243400dcd74a7596388fc5747853e5a6629535ca3083e"
+    },
+    "l-geometry/fixed_ports-reset_only_control-metrics.png": {
+      "bytes": 12231,
+      "sha256": "237e181db92baf49c24554ec4325137b014413603b62cb08dee63e6e68fa3e8d"
+    },
+    "l-geometry/flat_chain_4-after.png": {
+      "bytes": 12582,
+      "sha256": "7326cd482a61bea4cb787770449253a55f41e102794c8fc6a8500d9244c20cc7"
+    },
+    "l-geometry/flat_chain_4-before.png": {
+      "bytes": 12723,
+      "sha256": "b086e2b23d4b68cb43366725a26fbb39fdc2e87d18cd7109c9b3ec950ab665ba"
+    },
+    "l-geometry/flat_chain_4-experimental_candidate-metrics.png": {
+      "bytes": 13405,
+      "sha256": "3bb352dd5066a3b2cc5bb298c9f47a02416186421df4841b96c944e523d11104"
+    },
+    "l-geometry/flat_chain_4-reset_only_control-metrics.png": {
+      "bytes": 12918,
+      "sha256": "eba3eede6771a1ebfc7b773b48b599f5ca49613ad7444ab26acfea7d20dde515"
+    },
+    "l-geometry/long_ordinary_labels-after.png": {
+      "bytes": 12643,
+      "sha256": "f4f0c360e9ce44d631dd1d9f7c202954be943fdbede6288edbaddf9b890fcaec"
+    },
+    "l-geometry/long_ordinary_labels-before.png": {
+      "bytes": 12661,
+      "sha256": "3c17c1195337cda7cd4141a15428b66cac1475421600b6ecffc3db57dbfd9f94"
+    },
+    "l-geometry/long_ordinary_labels-experimental_candidate-metrics.png": {
+      "bytes": 13235,
+      "sha256": "d2931b576901fec68b23afd1a54d4c301eda4a75ba30184344749e0add277bc0"
+    },
+    "l-geometry/long_ordinary_labels-reset_only_control-metrics.png": {
+      "bytes": 12969,
+      "sha256": "68aacc7196a4995ff8a884a15ec91a31bd386bdd2d232fd2c27696a7f83cf791"
+    },
+    "l-geometry/manifest.json": {
+      "bytes": 8099,
+      "sha256": "897b9d42b494bac1e5263a8bab42756c3038403948e6ac76028d86fd6e56ae20"
+    },
+    "l-geometry/nested_cross_boundary-after.png": {
+      "bytes": 13344,
+      "sha256": "51db6785ab89f5d92c61288604ae3c76aee467e291738b54466db5704c0eec8b"
+    },
+    "l-geometry/nested_cross_boundary-before.png": {
+      "bytes": 13547,
+      "sha256": "3b3963f5ef5a42106a006f1825ae5d85b722aa3bf163452ba986ef3369b57cc2"
+    },
+    "l-geometry/nested_cross_boundary-experimental_candidate-metrics.png": {
+      "bytes": 13535,
+      "sha256": "0ba365785753e748dc7c86c3f1eb5767f9ccb87c0ae0e18085e6a9d32b79f60d"
+    },
+    "l-geometry/nested_cross_boundary-reset_only_control-metrics.png": {
+      "bytes": 13549,
+      "sha256": "fbe21b57616459ecdbbd083dccd73bd120f5b7ad59a8ad80ea38cbbf9c3f49c1"
+    },
+    "l-geometry/two_containers_reversed_children-after.png": {
+      "bytes": 13957,
+      "sha256": "b0911f8afb39313e6ce43661396d6553276d5db53c659937acf87252ed502c6e"
+    },
+    "l-geometry/two_containers_reversed_children-before.png": {
+      "bytes": 14083,
+      "sha256": "2d42d34af4674bbf1739e85967d743e6fc78c117ef1e7645724c504b006ee881"
+    },
+    "l-geometry/two_containers_reversed_children-experimental_candidate-metrics.png": {
+      "bytes": 14500,
+      "sha256": "8a0744cf04d305a0431468395b3676604e03991e577f9f9d2f45e8497b1ef9ca"
+    },
+    "l-geometry/two_containers_reversed_children-manual_planar_order_witness-metrics.png": {
+      "bytes": 14531,
+      "sha256": "60623d358d9cb930c2c2c4995c9286c653e597c411b8879b77ac099fe9b0406b"
+    },
+    "l-geometry/two_containers_reversed_children-reset_only_control-metrics.png": {
+      "bytes": 14136,
+      "sha256": "f690678d5697cbec20e64bf92a128a8fd3a1dffe3948fcbe75ad99a4f33de96d"
+    },
+    "support/auto-layout-l-comparison-20260925.json": {
+      "bytes": 76659,
+      "sha256": "e1e23e6c2a50cd384457bb061d5b70a740f586f42767164fad9703ecbb4096a8"
+    },
+    "support/auto-layout-l-contact-audit-20260925.json": {
+      "bytes": 103893,
+      "sha256": "6f6cc674c27d3f43001fe1751ef3b09332caa9ddca396759f5525f811cbe1aaf"
+    },
+    "support/auto-layout-l-binary-20260925.json": {
+      "bytes": 220,
+      "sha256": "9c6d6e20c86237e5d1b917a981f2a5a8612d1c58b6e0706d4701e6c7cc59e06f"
+    },
+    "support/auto-layout-contact-audit-20260925.py": {
+      "bytes": 9838,
+      "sha256": "398b9677d2ef2333514dd9c1ba5bc2f020c9927f395ed33bf11ac59b68139f46"
+    },
+    "support/run-auto-layout-check-20260925.py": {
+      "bytes": 2771,
+      "sha256": "d652c4df47f13aefc723bc54362d7b61308b8983c8d39ae7721c012519358ea2"
+    },
+    "support/auto-layout-format-j-20260925.json": {
+      "bytes": 203,
+      "sha256": "5bd0e4b979aedf21bd38e4c41a1521dafffb78c3cccb61cd12dad56d4f4699e9"
+    },
+    "support/run.py": {
+      "bytes": 13814,
+      "sha256": "698ed7182726c77fa4a1c85fc6dd08187ed20689941f57e749e3f0bc845f3252"
+    }
+  },
+  "archive": {
+    "name": "lanes-e8ec6db.zip",
+    "bytes": 3518507,
+    "sha256": "5512b4cbd99e3bf03eb975e25fb980f7b1a95a5cb19f3687fb3d6d83d1839e8f"
+  }
+}

harness/experiments/auto-layout-20260925/run-p/.gitattributes

@@ -0,0 +1 @@
+* -text whitespace=blank-at-eol,blank-at-eof,space-before-tab,cr-at-eol

harness/experiments/auto-layout-20260925/run-p/manifest.json

@@ -0,0 +1,223 @@
+{
+  "source_commit": "3d7adff923dee5bed54dfdccc119dbee0c7c2773",
+  "scope": "Transient P coefficient3.0/cap80 experiment, not production acceptance or claim that J tests pass with P.",
+  "post_run_probe_binary": {
+    "bytes": 24156160,
+    "sha256": "8f3ac5aa1fa01be6a8ab664e8ae269f6527b8ffb7e326c2926c8fae7c3d7e366"
+  },
+  "members": {
+    "run/command/changes.patch": {
+      "bytes": 0,
+      "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    "run/command/context.json": {
+      "bytes": 3504,
+      "sha256": "6f6019b2be69e12e3270d8570e9e4950c93e42e8b3093a0e0324a30f7e5eb0ff"
+    },
+    "run/command/inputs-after.json": {
+      "bytes": 1727969,
+      "sha256": "607febcd0d74d11deaa07a44b8b9cf6c382fd65d55deadb2d8ac7e889797dcf1"
+    },
+    "run/command/inputs-before.json": {
+      "bytes": 1727969,
+      "sha256": "607febcd0d74d11deaa07a44b8b9cf6c382fd65d55deadb2d8ac7e889797dcf1"
+    },
+    "run/command/output.log": {
+      "bytes": 371606,
+      "sha256": "13111fe89e4e637d1af572a8a45b8bdd763e94b58a2ec5ec6ca83e40ffa209c7"
+    },
+    "run/command/result.json": {
+      "bytes": 4172,
+      "sha256": "6149122d05d77e02b463edb3dd359b06786bc4468c27d8cd625cbc1bc80c9894"
+    },
+    "run/command/stderr.log": {
+      "bytes": 279,
+      "sha256": "fe5d8d303700ef5b92bfaa95ac1f99a2214e1fc5f6c5ac8d83f6303aa258965b"
+    },
+    "run/environment.json": {
+      "bytes": 9463,
+      "sha256": "14e53dd6359601bdd9be3ad24c527fca96310d9eb4ffa91965f71841f8df2f82"
+    },
+    "run/orchestration.log": {
+      "bytes": 181,
+      "sha256": "db5af22d893966919b9342fd06b99e7e1c82c5c87593544b7762cc85f9a7e45a"
+    },
+    "geometry/authored_detour_and_label-after.png": {
+      "bytes": 12492,
+      "sha256": "44e30b94ef11b176155ab3df90fe5b52788c07442a42a355d3458fa904c147bd"
+    },
+    "geometry/authored_detour_and_label-before.png": {
+      "bytes": 12468,
+      "sha256": "097588fae4fd6253c25ab4b60be1ad685ead3a3012b206f382cec0be1341e700"
+    },
+    "geometry/authored_detour_and_label-experimental_candidate-metrics.png": {
+      "bytes": 13162,
+      "sha256": "82a07de168cda7dacdad2bd532dae408172466b2776acf8cfaabef6711c0539b"
+    },
+    "geometry/authored_detour_and_label-reset_only_control-metrics.png": {
+      "bytes": 12777,
+      "sha256": "e676edc49ec6ebb2fe29e976c36cba589f76330e7f9eb27b8835415a2ed5d225"
+    },
+    "geometry/chain_7_row_wrap-after.png": {
+      "bytes": 14271,
+      "sha256": "a020c1535e3d6e48cb5e6d7ae8403a256767c68ce26876fd773f3b626c61e365"
+    },
+    "geometry/chain_7_row_wrap-before.png": {
+      "bytes": 13771,
+      "sha256": "0b282cbd29eb3e29fa7d3bb9c3c9746caa14c77372b3191d78fa1a60743d0b11"
+    },
+    "geometry/chain_7_row_wrap-experimental_candidate-metrics.png": {
+      "bytes": 14396,
+      "sha256": "3ca042155d918083c5f4135ae059205b29b8ee5944819a6040a22eeb572f5f04"
+    },
+    "geometry/chain_7_row_wrap-reset_only_control-metrics.png": {
+      "bytes": 14549,
+      "sha256": "8828f289159deb0c2bedd130495197639775cd8edeb561f0de5501e2980d1e1d"
+    },
+    "geometry/crossed_bipartite-after.png": {
+      "bytes": 13144,
+      "sha256": "54a1b5e983bc9b6f619e67c13173d0ff5000e30f080aaf6c0a9064f59036f4b7"
+    },
+    "geometry/crossed_bipartite-before.png": {
+      "bytes": 13413,
+      "sha256": "8622726dfdfc01e93fcd2d9d22c6d082e5a169b9dcd59f788e876954431214fd"
+    },
+    "geometry/crossed_bipartite-experimental_candidate-metrics.png": {
+      "bytes": 13855,
+      "sha256": "e3cc0a326a2c8b577e40101c5f67ea9c3182bca6d3f0498cdc1f25a64df57b90"
+    },
+    "geometry/crossed_bipartite-reset_only_control-metrics.png": {
+      "bytes": 13349,
+      "sha256": "0b2a8c49368258b23c15a8e06bf9b881f0e53fed8b5fd7d6f216a09837634abc"
+    },
+    "geometry/diamond-after.png": {
+      "bytes": 12556,
+      "sha256": "6afcff1e5c10758e5eab3b803ec858d0af3da953be4af93df75257544a7252b2"
+    },
+    "geometry/diamond-before.png": {
+      "bytes": 13228,
+      "sha256": "38e341a1ed51d4b4a94513f34c3d48b05c72177dcc3792dc660cb780fd7f98c9"
+    },
+    "geometry/diamond-experimental_candidate-metrics.png": {
+      "bytes": 13555,
+      "sha256": "a61d178e2cd3fcff8fc4ed3c42e5ab71b042d26d776f59fe5eaadb3ef8481e5e"
+    },
+    "geometry/diamond-reset_only_control-metrics.png": {
+      "bytes": 12982,
+      "sha256": "48414d7a859c774f2cef51d0fc1512b1c9fe1540c540f96fac7f9531583d8731"
+    },
+    "geometry/fixed_ports-after.png": {
+      "bytes": 11889,
+      "sha256": "574cb0249c3bcc3140b9d61906332295a8462e32fbcd6b9526d8b05e202e38a0"
+    },
+    "geometry/fixed_ports-before.png": {
+      "bytes": 12013,
+      "sha256": "d07ef2105aa63f3aaacb19e9a7ca4960239b01f05f734baa6270657a465b4ab0"
+    },
+    "geometry/fixed_ports-experimental_candidate-metrics.png": {
+      "bytes": 12394,
+      "sha256": "d7fdcd7d4a1a014dd34243400dcd74a7596388fc5747853e5a6629535ca3083e"
+    },
+    "geometry/fixed_ports-reset_only_control-metrics.png": {
+      "bytes": 12231,
+      "sha256": "237e181db92baf49c24554ec4325137b014413603b62cb08dee63e6e68fa3e8d"
+    },
+    "geometry/flat_chain_4-after.png": {
+      "bytes": 12582,
+      "sha256": "7326cd482a61bea4cb787770449253a55f41e102794c8fc6a8500d9244c20cc7"
+    },
+    "geometry/flat_chain_4-before.png": {
+      "bytes": 12723,
+      "sha256": "b086e2b23d4b68cb43366725a26fbb39fdc2e87d18cd7109c9b3ec950ab665ba"
+    },
+    "geometry/flat_chain_4-experimental_candidate-metrics.png": {
+      "bytes": 13405,
+      "sha256": "3bb352dd5066a3b2cc5bb298c9f47a02416186421df4841b96c944e523d11104"
+    },
+    "geometry/flat_chain_4-reset_only_control-metrics.png": {
+      "bytes": 12918,
+      "sha256": "eba3eede6771a1ebfc7b773b48b599f5ca49613ad7444ab26acfea7d20dde515"
+    },
+    "geometry/long_ordinary_labels-after.png": {
+      "bytes": 12643,
+      "sha256": "f4f0c360e9ce44d631dd1d9f7c202954be943fdbede6288edbaddf9b890fcaec"
+    },
+    "geometry/long_ordinary_labels-before.png": {
+      "bytes": 12661,
+      "sha256": "3c17c1195337cda7cd4141a15428b66cac1475421600b6ecffc3db57dbfd9f94"
+    },
+    "geometry/long_ordinary_labels-experimental_candidate-metrics.png": {
+      "bytes": 13235,
+      "sha256": "d2931b576901fec68b23afd1a54d4c301eda4a75ba30184344749e0add277bc0"
+    },
+    "geometry/long_ordinary_labels-reset_only_control-metrics.png": {
+      "bytes": 12969,
+      "sha256": "68aacc7196a4995ff8a884a15ec91a31bd386bdd2d232fd2c27696a7f83cf791"
+    },
+    "geometry/manifest.json": {
+      "bytes": 8099,
+      "sha256": "c1b59384878e519efec99757efee571635f30d814247db2f183eebbf9c467a0f"
+    },
+    "geometry/nested_cross_boundary-after.png": {
+      "bytes": 13344,
+      "sha256": "51db6785ab89f5d92c61288604ae3c76aee467e291738b54466db5704c0eec8b"
+    },
+    "geometry/nested_cross_boundary-before.png": {
+      "bytes": 13547,
+      "sha256": "3b3963f5ef5a42106a006f1825ae5d85b722aa3bf163452ba986ef3369b57cc2"
+    },
+    "geometry/nested_cross_boundary-experimental_candidate-metrics.png": {
+      "bytes": 13535,
+      "sha256": "0ba365785753e748dc7c86c3f1eb5767f9ccb87c0ae0e18085e6a9d32b79f60d"
+    },
+    "geometry/nested_cross_boundary-reset_only_control-metrics.png": {
+      "bytes": 13549,
+      "sha256": "fbe21b57616459ecdbbd083dccd73bd120f5b7ad59a8ad80ea38cbbf9c3f49c1"
+    },
+    "geometry/two_containers_reversed_children-after.png": {
+      "bytes": 13955,
+      "sha256": "1722ff21eaadd831e00b2176d61f8fa65b083d2fd5b633a196a3335d48ca125e"
+    },
+    "geometry/two_containers_reversed_children-before.png": {
+      "bytes": 14092,
+      "sha256": "dcbc521b8e5efd6a201da8a724ed218a9f1331a8abb2eda299a5807828037cb9"
+    },
+    "geometry/two_containers_reversed_children-experimental_candidate-metrics.png": {
+      "bytes": 14500,
+      "sha256": "8a0744cf04d305a0431468395b3676604e03991e577f9f9d2f45e8497b1ef9ca"
+    },
+    "geometry/two_containers_reversed_children-manual_planar_order_witness-metrics.png": {
+      "bytes": 14531,
+      "sha256": "60623d358d9cb930c2c2c4995c9286c653e597c411b8879b77ac099fe9b0406b"
+    },
+    "geometry/two_containers_reversed_children-reset_only_control-metrics.png": {
+      "bytes": 14134,
+      "sha256": "ce6bc93dc38fe5b25552c8ebc5e778da175df53992e6a70ded8377fd99372587"
+    },
+    "support/auto-layout-p-comparison-20260925.json": {
+      "bytes": 77494,
+      "sha256": "9f228fbe78e1888c5d93e87dddd8d2effc01bab723929a87423c61e23f5cad66"
+    },
+    "support/auto-layout-p-contact-audit-20260925.json": {
+      "bytes": 104912,
+      "sha256": "6f4add5c81f6d16c45efabbefd9e36c9beb637b6823993f0d51adc3e20485ad9"
+    },
+    "support/auto-layout-contact-audit-20260925.py": {
+      "bytes": 9838,
+      "sha256": "398b9677d2ef2333514dd9c1ba5bc2f020c9927f395ed33bf11ac59b68139f46"
+    },
+    "support/run-auto-layout-check-20260925.py": {
+      "bytes": 2771,
+      "sha256": "d652c4df47f13aefc723bc54362d7b61308b8983c8d39ae7721c012519358ea2"
+    },
+    "support/run.py": {
+      "bytes": 13814,
+      "sha256": "698ed7182726c77fa4a1c85fc6dd08187ed20689941f57e749e3f0bc845f3252"
+    }
+  },
+  "archive": {
+    "name": "penalty-3d7adff.zip",
+    "bytes": 916568,
+    "sha256": "6b819b01c8012aa72d423443f4dc04ae261f1ee9dc6907f0063c219ff173ad36"
+  }
+}