shizumaat
diff --git a/‎src/auto_patch/config.py‎
Lines changed: 17 additions & 0 deletions b/‎src/auto_patch/config.py‎
Lines changed: 17 additions & 0 deletions
diff --git a/‎src/auto_patch/junction_repair.py‎
Lines changed: 151 additions & 0 deletions b/‎src/auto_patch/junction_repair.py‎
Lines changed: 151 additions & 0 deletions
diff --git a/‎src/auto_patch/pipeline.py‎
Lines changed: 16 additions & 0 deletions b/‎src/auto_patch/pipeline.py‎
Lines changed: 16 additions & 0 deletions
diff --git a/‎tests/test_source_clip.py‎
Lines changed: 103 additions & 0 deletions b/‎tests/test_source_clip.py‎
Lines changed: 103 additions & 0 deletions
@@ -1027,6 +1027,23 @@ def parallel_airports_worker_count(n_tasks: int) -> int:
 # law, byte-identical to the pre-feature build.
 ANISO_EDGES = _os.environ.get("O4_ANISO_EDGES", "1") == "1"
 
+# FORMATION-TIME SOURCE CLIP (KCLT off-source phantom, Fix C).  The global
+# slice births every face 100 % on source, but DOWNSTREAM recuts (the
+# route-proximity cut, frontage straightening) can sweep an apron / junction
+# face off the real source pavement (apt.dat row-110 ∪ DSF ∪ runway) — KCLT
+# junction #278 is 8.3 k m² at 35 % on source (a near-runway band the
+# route-proximity cut carved off a real 18R-end apron; the 65 % off-source
+# remainder is RESA grass).  When ON, a formation-time pass clips every
+# apron / junction shape whose on-source fraction < 0.5 back to the source
+# union (∪ runway, buffered by the runway-frontage halo so contact survives)
+# BEFORE the pre-solve node-unification, so the clipped edges are re-noded /
+# welded / solved normally.  The off-source remainder (grass, off-source by
+# construction) is DROPPED — re-minting it as groundside pavement would just
+# relocate the phantom onto a DEM-following surface.  O4_SOURCE_CLIP=0 reverts
+# byte-identically (the pass is inert — no shape is touched).
+SOURCE_CLIP_PARTIAL_COVERAGE = (
+    _os.environ.get("O4_SOURCE_CLIP", "1") == "1")
+
 # JUNCTION MESH CONSTRAINTS (user 2026-06-30).  A JUNCTION is taxi-centerline
 # fill: aircraft travel ALONG the spine through it, so the only grade paths that
 # physically exist are the spine (longitudinal) and the triangle-mesh EDGES X-Plane
 
@@ -72,6 +72,7 @@
     "_clamp_junction_free_vertices",
     "_merge_sliver_junctions_into_neighbours",
     "_subdivide_violating_junctions",
+    "source_clip_partial_coverage_shapes",
 ]
 
 
@@ -1660,6 +1661,156 @@ def _drop_off_source_residue(
     return len(to_drop)
 
 
+# The junction sliver floor (MIN_JUNCTION_AREA, documented in junction_rules
+# next to WIDEN_MAX_ABANDONED_PAVEMENT_M2): a clipped piece smaller than this
+# has no mesh-scale presence and is dropped, exactly as the residue passes
+# discard sub-floor apron / junction fragments.
+SOURCE_CLIP_MIN_PIECE_AREA_M2 = 50.0
+
+
+def source_clip_partial_coverage_shapes(
+        layout: "PavementLayout",
+        icao: str = "",
+        min_on_source_frac: float = 0.5,
+        ) -> int:
+    """Formation-time SOURCE CLIP for partial-coverage apron / junction shapes.
+
+    The global slice births every face 100 % on source
+    (``pipeline._SLICE_SOURCE_CLIP``), but DOWNSTREAM recuts — the apron
+    route-proximity cut, the ``_enforce_runway_1to1_sharing`` frontage
+    straightening — can leave an apron / junction whose polygon is mostly OFF
+    the real source pavement (apt.dat row-110 ∪ DSF ∪ runway).  KCLT junction
+    #278 is 8.3 k m² at 35 % on source (the near-runway band carved off a real
+    18R-end apron; the 65 % off-source remainder is RESA grass); #763 is a
+    383 m² frontage split piece at 32 %.
+
+    For each apron / junction shape whose on-source fraction <
+    ``min_on_source_frac`` (judged by ``verification.check_source_adjacency`` —
+    the SAME source union and on-source method the verify pass uses, so there
+    is ONE definition of "on source"), clip the polygon to the source union
+    (∪ runway) buffered by ``RUNWAY_REWRITE_CARVE_RUNWAY_HALO_M`` (the 1to1
+    carve's runway-frontage halo — a small margin so the shape's near-runway
+    contact strip survives).  The largest clipped piece replaces the shape's
+    polygon; other pieces ≥ ``SOURCE_CLIP_MIN_PIECE_AREA_M2`` become their own
+    shapes of the same role.
+
+    Never touches runway / runway_crossing / groundside / boundary / clearance
+    / service shapes (apron / junction only).  The clip only removes area from
+    the ORIGINAL polygon, and aprons / junctions are already cut away from the
+    runway upstream, so the runway-inclusive clip target can never introduce a
+    runway overlap — it only preserves frontage CONTACT.
+
+    ORDERING CONSTRAINT: this runs PRE-solve (before the per-surface elevation
+    assignment), immediately before ``_unify_airside_geometry``, so the clipped
+    edges are re-noded / welded / graded normally.  Apron / junction shapes
+    carry no solved ``node_altitudes`` at this point; a clip changes the vertex
+    count, so any (unexpected) pre-existing per-vertex list cannot be realigned
+    and is cleared — the solver reassigns it.
+
+    REMAINDER TRADEOFF: the clipped-away off-source remainder is off source BY
+    CONSTRUCTION (it failed the source test), so it is DROPPED rather than
+    handed to groundside DEM-follow — re-minting RESA grass as groundside
+    pavement would merely relocate the phantom onto a DEM-following surface,
+    and dropping it uncovers no real source (coverage-safe: the dual
+    ``check_source_coverage`` invariant only guards INTERIOR source gaps).
+
+    Gated by ``config.SOURCE_CLIP_PARTIAL_COVERAGE`` (O4_SOURCE_CLIP, default
+    ON); OFF is byte-identical (the pass returns 0 without touching a shape).
+    Returns the number of shapes clipped.
+    """
+    from .config import SOURCE_CLIP_PARTIAL_COVERAGE
+    if not SOURCE_CLIP_PARTIAL_COVERAGE:
+        return 0
+    src = getattr(layout, "source_pavement_union", None)
+    if src is None or src.is_empty:
+        return 0
+    rwy = getattr(layout, "runway_union", None)
+    src_union = src
+    if rwy is not None and not rwy.is_empty:
+        try:
+            src_union = src.union(rwy)
+        except _GEOM_EXC:
+            pass
+    from .junction_rules import (
+        RUNWAY_REWRITE_CARVE_RUNWAY_HALO_M, _polygonal_parts)
+    try:
+        clip_target = src_union.buffer(RUNWAY_REWRITE_CARVE_RUNWAY_HALO_M)
+    except _GEOM_EXC:
+        return 0
+    if clip_target is None or clip_target.is_empty:
+        return 0
+    # Reuse the verifier's on-source method EXACTLY (one definition of
+    # "on source"); filter its below-threshold list to apron / junction.
+    from .verification import check_source_adjacency
+    try:
+        candidates = check_source_adjacency(layout, min_on_source_frac)
+    except _GEOM_EXC:
+        return 0
+    idxs = [idx for (idx, _a, _f, _l) in candidates
+            if 0 <= idx < len(layout.shapes)
+            and layout.shapes[idx].role in (ROLE_APRON, ROLE_JUNCTION)]
+    if not idxs:
+        return 0
+    new_shapes: list[BuiltShape] = []
+    n_clipped = 0
+    for i in idxs:
+        s = layout.shapes[i]
+        poly = s.polygon
+        if poly is None or poly.is_empty:
+            continue
+        try:
+            clipped = poly.intersection(clip_target)
+        except _GEOM_EXC:
+            continue
+        clipped = _polygonal_parts(clipped)
+        if clipped is None or clipped.is_empty:
+            # No source under this shape at all — leave it to the near-zero
+            # branch of _drop_off_source_residue; never null a shape here.
+            continue
+        if clipped.geom_type == "Polygon":
+            raw_pieces = [clipped]
+        elif clipped.geom_type == "MultiPolygon":
+            raw_pieces = list(clipped.geoms)
+        else:
+            raw_pieces = []
+        pieces = sorted(
+            (p for p in raw_pieces
+             if p.geom_type == "Polygon" and not p.is_empty and p.is_valid
+             and p.area >= SOURCE_CLIP_MIN_PIECE_AREA_M2),
+            key=lambda p: p.area, reverse=True)
+        if not pieces:
+            # The whole on-source portion is below the sliver floor.  Do NOT
+            # drop the shape here — whole-shape phantom removal is
+            # ``_drop_off_source_residue``'s job, which HONOURS the
+            # route-proximity-cut exemption that protects a real-pavement
+            # parent from the KCLT #255 rests-on-source hole.  This pass only
+            # ever CLIPS a shape that has a genuine on-source piece to keep;
+            # it never nulls a shape (so gate-off equivalence holds trivially
+            # for every non-clipped shape).
+            continue
+        s.polygon = pieces[0]
+        s.node_altitudes = None          # solver reassigns (geometry changed)
+        for extra in pieces[1:]:
+            new_shapes.append(BuiltShape(
+                polygon=extra, role=s.role, ref=s.ref,
+                source_axis=s.source_axis, is_bridge=s.is_bridge,
+                from_route_proximity_cut=getattr(
+                    s, "from_route_proximity_cut", False)))
+        n_clipped += 1
+    if new_shapes:
+        layout.shapes.extend(new_shapes)
+    if n_clipped:
+        try:
+            UI.vprint(1,
+                f"  [pav-builder] {icao}: source-clipped {n_clipped} "
+                f"partial-coverage apron/junction shape(s) to the source "
+                f"pavement (< {min_on_source_frac*100:.0f}% on source; "
+                f"off-source remainder dropped).")
+        except _GEOM_EXC:
+            pass
+    return n_clipped
+
+
 def _decompose_airside_holed_shapes(
         layout: "PavementLayout",
         icao: str = "",
 
@@ -5014,6 +5014,22 @@ def _adjacent_taxi_letter(_road_poly):
         from .pavement.vertices import _round_turnback_corners
         _round_turnback_corners(layout, icao)
 
+        # ── Formation-time SOURCE CLIP (KCLT off-source phantom, Fix C) ──
+        # An apron / junction face can acquire off-source area through
+        # DOWNSTREAM recuts (route-proximity cut, frontage straightening) even
+        # though the slice birthed it 100 % on source — KCLT #278 (8.3 k m² at
+        # 35 %) is the near-runway band carved off a real 18R-end apron.  Clip
+        # every < 50 %-on-source apron / junction back to the source pavement
+        # (∪ runway halo) HERE — after merge_small_apron_fragments / groundside
+        # emit / full-width-corridor consolidation (pass 1) have settled the
+        # apron/junction set, and BEFORE _unify_airside_geometry below so the
+        # clipped edges are re-noded, welded, and graded like any other pre-
+        # solve geometry.  Gate O4_SOURCE_CLIP → no-op (byte-identical) off.
+        if os.environ.get("O4_SOURCE_CLIP", "1") == "1":
+            from .junction_repair import source_clip_partial_coverage_shapes
+            source_clip_partial_coverage_shapes(layout, icao=icao)
+            _covp(layout, "post-source-clip")
+
         # ── Airside node-unification (refactor Phases 6+7, PRE-solve) ──
         # Weld + full conformance + final corner snaps, run HERE so the solver
         # sees the FINAL node-set and grades every shared vertex to ONE
 
@@ -0,0 +1,103 @@
+"""Unit tests for the formation-time SOURCE-CLIP pass
+(``junction_repair.source_clip_partial_coverage_shapes``, Fix C).
+
+Pure synthetic geometry — no X-Plane install, no airport build.  A
+partial-coverage (< 50 % on source) apron/junction is clipped back to the
+recorded source pavement (∪ runway halo); a well-covered (≥ 50 %) shape is
+left untouched; and the gate (``config.SOURCE_CLIP_PARTIAL_COVERAGE``) is
+byte-inert when off.
+"""
+from __future__ import annotations
+
+from shapely.geometry import Polygon
+
+# Import cycle gotcha (junction_repair <-> elevation): import through
+# auto_patch.pipeline FIRST so the modules initialise in the right order
+# (src/auto_patch/CLAUDE.md).
+import auto_patch.pipeline  # noqa: F401
+import auto_patch.config as config
+from auto_patch.junction_repair import source_clip_partial_coverage_shapes
+from auto_patch.layout import (
+    PavementLayout, BuiltShape, ROLE_APRON, ROLE_JUNCTION,
+)
+
+# Source pavement is the unit-scaled square x,y in [0, 100].
+_SOURCE = Polygon([(0.0, 0.0), (100.0, 0.0), (100.0, 100.0), (0.0, 100.0)])
+
+
+def _layout() -> PavementLayout:
+    """A 30 %-on-source junction, a 60 %-on-source apron, and a source union.
+
+    * junction spans x in [70, 170] (10 000 m²); 3 000 m² (30 %) is on source.
+    * apron spans x in [40, 140] (10 000 m²); 6 000 m² (60 %) is on source.
+    """
+    junction = BuiltShape(
+        polygon=Polygon([(70.0, 0.0), (170.0, 0.0),
+                         (170.0, 100.0), (70.0, 100.0)]),
+        role=ROLE_JUNCTION, ref="J")
+    apron = BuiltShape(
+        polygon=Polygon([(40.0, 0.0), (140.0, 0.0),
+                         (140.0, 100.0), (40.0, 100.0)]),
+        role=ROLE_APRON, ref="A")
+    layout = PavementLayout(icao="TEST", anchor=(35.22, -80.94),
+                            shapes=[junction, apron])
+    layout.source_pavement_union = _SOURCE
+    layout.runway_union = None
+    return layout
+
+
+def test_partial_coverage_shape_is_clipped_to_source():
+    layout = _layout()
+    # A pre-existing (stale) node_altitudes list must be cleared by the clip.
+    layout.shapes[0].node_altitudes = [10.0, 10.0, 10.0, 10.0, 10.0]
+
+    n = source_clip_partial_coverage_shapes(layout, icao="TEST")
+    assert n == 1, "exactly the 30 %-on-source junction should clip"
+
+    # The junction is clipped back to (source ∪ runway) buffered by the
+    # runway-frontage halo (3 m): x in [70, 103], ~3 300 m², and now mostly
+    # on source.
+    junction = layout.shapes[0]
+    on = junction.polygon.intersection(_SOURCE).area
+    frac = on / junction.polygon.area
+    assert junction.polygon.area < 4000.0, junction.polygon.area
+    assert frac > 0.85, f"clipped junction should be near-fully on source: {frac}"
+    assert junction.polygon.bounds[2] <= 103.0 + 1e-6, junction.polygon.bounds
+    # node_altitudes cleared (geometry changed; the solver reassigns).
+    assert junction.node_altitudes is None
+
+
+def test_off_source_remainder_is_dropped_not_re_minted():
+    layout = _layout()
+    source_clip_partial_coverage_shapes(layout, icao="TEST")
+    # The clipped-away off-source remainder (x in [103, 170], RESA-grass
+    # analogue) must NOT survive as any shape — dropping it uncovers no real
+    # source, so nothing covers a deep-off-source probe point.
+    remainder_pt = (150.0, 50.0)
+    from shapely.geometry import Point
+    p = Point(*remainder_pt)
+    assert not any(s.polygon is not None and s.polygon.contains(p)
+                   for s in layout.shapes), \
+        "off-source remainder was re-minted instead of dropped"
+
+
+def test_well_covered_shape_is_untouched():
+    layout = _layout()
+    apron_before = layout.shapes[1].polygon
+    source_clip_partial_coverage_shapes(layout, icao="TEST")
+    # The 60 %-on-source apron is above the 0.5 threshold → not a candidate.
+    apron_after = next(s for s in layout.shapes if s.ref == "A")
+    assert apron_after.polygon.equals(apron_before), \
+        "a >= 50 %-on-source shape must not be clipped"
+
+
+def test_gate_off_is_inert(monkeypatch):
+    monkeypatch.setattr(config, "SOURCE_CLIP_PARTIAL_COVERAGE", False)
+    layout = _layout()
+    before = [s.polygon for s in layout.shapes]
+    n = source_clip_partial_coverage_shapes(layout, icao="TEST")
+    assert n == 0
+    after = [s.polygon for s in layout.shapes]
+    assert len(after) == len(before)
+    assert all(a.equals(b) for a, b in zip(after, before)), \
+        "gate-off must leave every shape untouched"