[brett19]

Face surfaces now keep their trimmed surface cache (SmTrimSrfCache) the way upstream's smsurf_GetSurfaceCache does. IntersectTSBound takes its cached branch on that cache, with its context mark.

How the cache history is modelled

• Where it lives. A surface's cache slot was already shared with its evaluation copies (Surface::cache_tree_state). It now also holds the trimmed cache (TrimCacheSlot: empty, stored, or checked out while in use). A stored cache's own surface copy gets a slot of its own, so the slot never owns itself.
• Lookup. query::face::p2::face_surface_cache follows SmCacheMgrTSrf::CacheMakeOrValidate:
  • a stored cache is reused, whether it was built with the face or standalone, unless m_bFaceWasModified is set and editing is off (then it is made again);
  • a new cache is built with the face, or standalone while the owner is cleared, and kept;
  • a lookup while the cache is checked out gets an unkept build. That was the old behaviour; upstream would find the same object.
• Other readers and writers.
  • PointClassify reads the kept cache (GetObjectCache).
  • Notify(PRE_EDIT) marks it modified.
  • A face-unaware smsurf_GetSurfaceCache made while the face's owner is cleared keeps the standalone cache it built (Surface::keep_standalone_trim_cache).
• Owner-cleared scopes. IntersectVertices and IntersectEdges clear the surface's owner while they read gaps (SmCurveClass.cpp:14700, 15315), so the port's gap reads now run in an owner-cleared scope. A C++ probe confirmed it (not committed): heal.face_props' first cache is standalone (m_bHaveTSurfaceCache 0, point test 0, no UV trims).
• Scratch copies. The classification snapshots, HasSeamProblem's seam objects and curve_class::p4's binormal and sector copies stand for the B-rep itself. They now share its cache slots (Brep::clone_sharing_surface_caches). These are the fix: B-rep copies keep geometry owners #681 copy sites this change needed; the other copy sites are unchanged.

The pattern for copy sites (how the face cache reaches curve_on_classify)

curve_on_classify still takes &Brep. Nothing new is threaded through its signature: the face cache travels with the surface object, and the mutable work happens on a copy that stands for the B-rep.

1. Make the copy with Brep::clone_sharing_surface_caches(), not clone().
   • Each face surface of the copy shares the original's cache slot, so a trimmed cache made, reused or marked on the copy is the original surface's own.
   • The trimmed cache is stored on the slot as TrimSrfCache<EntityRef>, and the ids are the same in the copy.
   • curve_on_classify_cached's private snapshot is made this way. A caller that already holds a &mut Brep can pass it as the snapshot, through CurveOnClassifyCache, as fix: IsInnerShell classifies on the B-rep itself (region nesting) #694 does.
2. Fetch the cache with query::face::p2::face_surface_cache(k, &mut brep, f) on whichever B-rep is mutable (the copy or the real one).
   • The call returns a FaceSurfaceCache lease, and lease.release() gives the cache back to the slot. Release on every path, errors included.
   • While the cache is out, nested lookups get an unkept cache and PointClassify finds none.
3. Map the handles to the caller's. Code in another handle space maps EntityRef vertex uses and edge uses, as BoundaryFace::cache_handle does in IntersectTSBound, or uses TrimSrfCache::map_handles.
4. Mark scopes where upstream clears the surface owner with Brep::begin_surface_owner_cleared(f) / end_surface_owner_cleared(f) (CreateUVTrimCurve(s), IntersectVertices/IntersectEdges gap reads). A cache made inside one is standalone and kept.

• UV trims and tolerance growth made on a copy still stay on the copy (the existing deviation). Only the cache history is shared. fix: IsInnerShell classifies on the B-rep itself (region nesting) #694's &mut route keeps those as well.

Consumers

• IntersectTSBound fetches the face cache itself. When the cache is up to date it visits only the leaf nodes' vertex uses and edge uses, under SmNewMarkAndLock, and makes a missing UV trim curve (GetOrCreateUVTrimCurve) when it visits an edge use.
  • BoundaryFace maps the cache's handles to the caller's (cache_handle).
  • The CurveOnClassifyObjects::trim_cache hook is gone.
• The ray path (face::p4::global_line_intersect*). A face-owned surface solves on the kept face cache. The caller-held cache now only stands for a surface without a face, which fixes fix: IsInnerShell classifies on the B-rep itself (region nesting) #694's 14 IsInnerShell deferrals.
• ComputeUVPoint's global solve. It checks out the face cache around the solve, which stands for m_bHaveTSurfaceCache off. The fast drop tests against the face when the cache is trimmed and has point testing on.
• EvaluateBinormal.

Marks

The context marks and locks are now atomics, and Context::claim_mark returns a guard that unlocks on drop. So IntersectTSBound claims Mark2 with &Kernel, without an &mut Kernel cascade through CurveOnClassify's ~15 callers and its traits. Please review this choice.

Harness

• The shared graph import's gap refill would now build face caches with UV trims the C++ B-rep lacks (topology.brep_p4). It now runs as during a Boolean operation and drops the caches it kept.
• topology.brep_p4 seeds the cache states the C++ file read leaves.
• intersect.curve_class_p9's ComputeUVPoint fixture attaches a cache with point testing off first, as its shim does.

Results (CI vs main 9bc152f)

heal.face_props                 1431 -> 1439 pass, 97 -> 89 deferred (the 15 surface.surface_p2 cache-history deferrals are gone)
offset.offset_geometry_creation  832 ->  835 pass, 66 -> 63 deferred

No other unit changes. topology.face_p1, sweep.trans_sweep_geometry and blend.fillet_corner_p1 differ from the 9bc152f reports, but the same way as on the latest main.

Merged locally with #694 (not part of this PR):

PASS topology.topology_traverser cases=909 passed=909   (#694 alone: 895 passed, 14 deferred)
topology.brep_p6: the 7 region-nesting cases pass, Mark2 included (their known_mismatches entries can go)
primitive.primitive_creation_p2: gen0201, gen0214 pass

skin_concentric_loops still differs (record[7] cpp 1, rust 2), so #694 keeps that entry.

Local checks: fmt, clippy -D warnings (with difftest/cpp), cargo test -p solidcore (2083 passed) and wasm all pass. Details are in plan/findings.md ("Face surfaces keep their trimmed surface caches").

🤖 Generated with Claude Code