refactor(router): orphan revalidation → shared parallel helper via policy args (#568 sub-item 2) - #578

Summary

Sub-item 2 of #568 (the M11 item): resolveOrphanLayoutWithRevalidation inlined ~130 lines of parallel-slot resolution that duplicated resolveParallelSegmentsWithRevalidation. This folds the orphan loop into the shared helper, carrying the two divergences as explicit policy args — byte-for-byte behavior-preserving for both paths, no consumer-observable change.

This is a refactor, but it touches the partial-revalidation hot path, so the bar is provable behavior-preservation. The headline is the coverage built first: the existing pinning suite silently failed to lock the divergence the issue is about, and that gap is now closed.

The two divergences, carried as policy args

The orphan loop is now a single call:

const parallelResult = await resolveParallelSegmentsWithRevalidation(
  orphan, params, context, belongsToRoute, clientSegmentIds, prevParams,
  request, prevUrl, nextUrl, routeKey, deps, actionContext, stale,
  { parentChainDefault: "force-render", loaderOrder: "before" },
);

entry.shortCode === orphan.shortCode (orphan is passed as entry), so all parallel ids and the loader shortCodeOverride are unchanged. The orphan layout's own loader / inherited-parent-loader / handler resolution (everything before the loop) is untouched.

Coverage-first — the part that matters

The existing parallel-revalidate-fns-invocation.test.ts did not actually lock either divergence: every orphan case used belongsToRoute=true, where (A)'s two policies coincide, and the revalidate fns overrode the seed. It would stay green under any unification. So before refactoring, I added pinning tests (written and verified green on the unmodified code):

• (A) belongsToRoute=false, slot ∉ client, parent ∈ client (isNewParent=false), zero revalidate fns (so the seed is the final decision), sentinel-returning handler so "resolved vs skipped" is observable: the main path SKIPS the slot (component null, handler never runs); the orphan path FORCE-RENDERS it (handler runs). Empirically non-vacuous — flipping the orphan to "type-derived" turns the orphan test red while main stays green.
• (B) loaderOrder flips slot-vs-loader emission order, and the orphan path chooses "before" (a slot's loaders precede its slot segment).

These stay green after the refactor — that is the behavior-preservation proof for the policy semantics.

Test plan

• pnpm run typecheck — 12/12
• pnpm run test:unit:all (repo root) — 0 failures
• pnpm run lint / pnpm run format — clean
• semantic-matrix — 61/61 dev + production, no row changes
• parallel e2e (parallel-reval-after-action, parallel-loader-reval, parallel-loader-inherit, parallel-meta) — 65/65 dev + production (incl. the fix(router): invoke parallel slot revalidate() fns when slot missing from clientSegmentIds #482 orphan-parallel-after-action scenario)
• New pinning tests for (A) + (B), green before and after the refactor; the (A) test proven non-vacuous
• Adversarially verified byte-identical for both paths (seed equivalence incl. the reason string, emission order for 1-slot / 2-slots-same-entry / 2-slots-different-entries, shortCodeOverride, all other invariants) — refuted: false, high confidence

Notes

• Closes sub-item 2 of Matrix-critical refactors from review (fresh/revalidation unification, trie suffix order, loader-cache rebind) #568. Sub-item 1 (unify the fresh.ts vs revalidation.ts resolution trees) remains deferred — it's a strategy-parameterized traversal, not a literal dedup (the "byte-identical" premise is false), and is tracked on Matrix-critical refactors from review (fresh/revalidation unification, trie suffix order, loader-cache rebind) #568.
• The loaderOrder ordering rested on a literal arg with no test; that latent fragility is now closed by the (B) tests.