@@ -40,12 +40,11 @@ def prune_surf(self, mounting_margin=None):
         """Prune surface radii so all valid rays pass through, then enforce manufacturability.
 
         Traces 16 meridional fields from 0 to the full FoV to find the maximum
-        sensor-reaching ray height [mm] on each surface, expands it by a mounting
-        margin, then caps the proposed radii to satisfy an edge-sag limit and
-        edge-clearance (air-gap / edge-thickness) constraints with neighbouring surfaces.
+        ray height [mm] on each surface, expands it by a mounting margin, then
+        caps the proposed radii to satisfy an edge-sag limit and edge-clearance
+        (air-gap / edge-thickness) constraints with neighbouring surfaces.
         Aperture surfaces are not resized. The capped radii are committed via
-        each surface's `update_r`. With no sensor-reaching ray height, the saved
-        radius is used without a mounting margin; geometry caps still apply.
+        each surface's `update_r`.
 
         Args:
             mounting_margin (float or None, optional): Absolute mounting margin
@@ -76,11 +75,8 @@ def prune_surf(self, mounting_margin=None):
 
         # Ray record, shape [num_rays, num_surfaces + 2, 3]
         ray_o_record = torch.stack(ray_o_record, dim=-2)
-        ray_o_record = ray_o_record.reshape(-1, ray_o_record.shape[-2], 3)
-        # A ray lost later must not inflate an earlier surface's aperture.
-        reaches_sensor = torch.isfinite(ray_o_record[:, -1, :]).all(-1)
-        ray_o_record = torch.where(reaches_sensor[:, None, None], ray_o_record, 0.0)
         ray_o_record = torch.nan_to_num(ray_o_record, nan=0.0, posinf=0.0, neginf=0.0)
+        ray_o_record = ray_o_record.reshape(-1, ray_o_record.shape[-2], 3)
 
         # Compute the maximum ray height for each surface
         ray_r_record = (ray_o_record[..., :2] ** 2).sum(-1).sqrt()
@@ -95,9 +91,7 @@ def prune_surf(self, mounting_margin=None):
             if surf_r_max[i] > 0:
                 base = float(surf_r_max[i].item())
             else:
-                # No ray evidence: repeated pruning must not add another margin.
-                proposed_r[i] = float(saved_radii[i])
-                continue
+                base = float(self.surfaces[i].r)
 
             # Expand the ray-traced radius by a mounting margin
             if mounting_margin is None:
 
@@ -178,68 +178,6 @@ def _get_curvature_params(self):
         """
         return self.c, self.k
 
-    def newtons_method(self, ray):
-        """Find an intersection, rejecting rays entering behind the aperture rim."""
-        t, valid = super().newtons_method(ray)
-        return t, valid & ~self._enters_through_edge(ray)
-
-    @torch.no_grad()
-    def _enters_through_edge(self, ray):
-        """Identify rays entering the aperture or conic domain behind the face.
-
-        The entry point is pulled radially inside the boundary before evaluating
-        sag, so a grazing ray is not sampled past its intersection. Rays starting
-        inside the valid region retain the usual Newton validity checks.
-
-        Args:
-            ray (Ray): Input ray bundle in local surface coordinates.
-
-        Returns:
-            mask (torch.Tensor): Boolean edge-entry mask, shape [...].
-        """
-        o, d = ray.o, ray.d
-        c, k = self._get_curvature_params()
-        aperture_sq = (self.w**2 + self.h**2) / 4 if self.is_square else self.r**2
-        conic_power = (1 + k) * c**2
-        domain_sq = torch.where(
-            conic_power > 0,
-            1 / torch.where(conic_power > 0, conic_power, 1.0),
-            torch.full_like(conic_power, float("inf")),
-        )
-        radius_sq = domain_sq.clamp(max=aperture_sq).to(o)
-        a = d[..., :2].square().sum(-1)
-        b = (o[..., :2] * d[..., :2]).sum(-1)
-        outside = o[..., :2].square().sum(-1) - radius_sq
-        disc = b.square() - a * outside
-        axial = a == 0
-        denominator = torch.where(axial, 1.0, a)
-        root = disc.clamp(min=0).sqrt()
-        t_in = torch.where(axial, -float("inf"), (-b - root) / denominator)
-        t_out = torch.where(axial, float("inf"), (-b + root) / denominator)
-        reaches = torch.where(axial, outside <= 0, disc > 0)
-        starts_inside = outside <= 0
-
-        if self.is_square:
-            # Square apertures use half-side lengths, not a circular substitute.
-            half_size = o.new_tensor([self.w / 2, self.h / 2])
-            parallel = d[..., :2] == 0
-            safe_d = torch.where(parallel, 1.0, d[..., :2])
-            t1 = (-half_size - o[..., :2]) / safe_d
-            t2 = (half_size - o[..., :2]) / safe_d
-            near = torch.where(parallel, -float("inf"), torch.minimum(t1, t2))
-            far = torch.where(parallel, float("inf"), torch.maximum(t1, t2))
-            t_in = torch.maximum(t_in, near.amax(-1))
-            t_out = torch.minimum(t_out, far.amin(-1))
-            inside_square = o[..., :2].abs() <= half_size
-            reaches = reaches & (~parallel | inside_square).all(-1)
-            starts_inside = starts_inside & inside_square.all(-1)
-
-        enters = reaches & ~starts_inside & (t_in > 0) & (t_out > t_in)
-        entry = o + d * torch.where(enters, t_in, 0.0).unsqueeze(-1)
-        xy = torch.where(enters.unsqueeze(-1), entry[..., :2], 0.0) * (1 - 1e-6)
-        behind = (self._sag(xy[..., 0], xy[..., 1]) - entry[..., 2]) * d[..., 2] < 0
-        return enters & behind
-
     def paraxial_power(self, n1, n2, wvln=None):
         """Return the paraxial optical power of this surface [1/mm].