public record CaseId(long value) {}

public record Dependency(
        CaseId from,
        CaseId to,
        DependencyType type,
        int riskWeight
) {}

enum DependencyType {
    BLOCKS,
    RELATES_TO,
    ESCALATES_TO,
    DUPLICATES
}

import java.time.Instant;
import java.util.Objects;

public record CaseNode(
        long id,
        CaseStatus status,
        int baseRisk,
        Instant createdAt,
        Instant escalationDeadline,
        String jurisdiction,
        String category
) {
    public CaseNode {
        if (id <= 0) throw new IllegalArgumentException("id must be positive");
        if (baseRisk < 0) throw new IllegalArgumentException("baseRisk must be non-negative");
        Objects.requireNonNull(status);
        Objects.requireNonNull(createdAt);
        Objects.requireNonNull(escalationDeadline);
        Objects.requireNonNull(jurisdiction);
        Objects.requireNonNull(category);
    }
}

enum CaseStatus {
    OPEN,
    UNDER_REVIEW,
    ESCALATED,
    ENFORCEMENT_ACTION,
    CLOSED
}

public record CaseEdge(
        long from,
        long to,
        EdgeType type,
        int weight
) {
    public CaseEdge {
        if (from <= 0 || to <= 0) throw new IllegalArgumentException("case ids must be positive");
        if (weight < 0) throw new IllegalArgumentException("weight must be non-negative");
        Objects.requireNonNull(type);
    }
}

enum EdgeType {
    BLOCKS,
    DEPENDS_ON,
    RELATES_TO,
    ESCALATES_TO
}

import java.util.*;

public final class CaseGraph {
    private final Map<Long, CaseNode> casesById;
    private final Map<Long, List<CaseEdge>> outgoing;
    private final Map<Long, List<CaseEdge>> incoming;

    private CaseGraph(
            Map<Long, CaseNode> casesById,
            Map<Long, List<CaseEdge>> outgoing,
            Map<Long, List<CaseEdge>> incoming
    ) {
        this.casesById = casesById;
        this.outgoing = outgoing;
        this.incoming = incoming;
    }

    public static CaseGraph build(List<CaseNode> cases, List<CaseEdge> edges) {
        Map<Long, CaseNode> byId = new HashMap<>(capacityFor(cases.size()));

        for (CaseNode node : cases) {
            CaseNode previous = byId.put(node.id(), node);
            if (previous != null) {
                throw new IllegalArgumentException("duplicate case id: " + node.id());
            }
        }

        Map<Long, List<CaseEdge>> out = new HashMap<>();
        Map<Long, List<CaseEdge>> in = new HashMap<>();

        for (CaseNode node : cases) {
            out.put(node.id(), new ArrayList<>());
            in.put(node.id(), new ArrayList<>());
        }

        for (CaseEdge edge : edges) {
            if (!byId.containsKey(edge.from())) {
                throw new IllegalArgumentException("missing from case: " + edge.from());
            }
            if (!byId.containsKey(edge.to())) {
                throw new IllegalArgumentException("missing to case: " + edge.to());
            }
            out.get(edge.from()).add(edge);
            in.get(edge.to()).add(edge);
        }

        return new CaseGraph(
                Collections.unmodifiableMap(byId),
                freeze(out),
                freeze(in)
        );
    }

    public CaseNode get(long id) {
        CaseNode node = casesById.get(id);
        if (node == null) throw new NoSuchElementException("case not found: " + id);
        return node;
    }

    public Collection<CaseNode> nodes() {
        return casesById.values();
    }

    public List<CaseEdge> outgoing(long id) {
        return outgoing.getOrDefault(id, List.of());
    }

    public List<CaseEdge> incoming(long id) {
        return incoming.getOrDefault(id, List.of());
    }

    public int nodeCount() {
        return casesById.size();
    }

    public int edgeCount() {
        int count = 0;
        for (List<CaseEdge> edges : outgoing.values()) count += edges.size();
        return count;
    }

    private static int capacityFor(int expectedSize) {
        if (expectedSize < 3) return expectedSize + 1;
        if (expectedSize < (1 << 30)) return (int) (expectedSize / 0.75f + 1.0f);
        return Integer.MAX_VALUE;
    }

    private static Map<Long, List<CaseEdge>> freeze(Map<Long, List<CaseEdge>> map) {
        Map<Long, List<CaseEdge>> frozen = new HashMap<>(capacityFor(map.size()));
        for (Map.Entry<Long, List<CaseEdge>> entry : map.entrySet()) {
            frozen.put(entry.getKey(), List.copyOf(entry.getValue()));
        }
        return Collections.unmodifiableMap(frozen);
    }
}

public enum GraphView {
    DOMAIN_DIRECTION,
    PROCESSING_DIRECTION
}

public final class GraphViews {
    private GraphViews() {}

    public static List<CaseEdge> processingOutgoing(CaseGraph graph, long caseId) {
        List<CaseEdge> result = new ArrayList<>();

        // Edges that already mean from-before-to in domain direction.
        for (CaseEdge edge : graph.outgoing(caseId)) {
            if (edge.type() == EdgeType.BLOCKS || edge.type() == EdgeType.ESCALATES_TO) {
                result.add(edge);
            }
        }

        // Reverse DEPENDS_ON: if X depends on caseId, then caseId must be processed before X.
        for (CaseEdge edge : graph.incoming(caseId)) {
            if (edge.type() == EdgeType.DEPENDS_ON) {
                result.add(new CaseEdge(edge.to(), edge.from(), edge.type(), edge.weight()));
            }
        }

        return result;
    }
}

public final class CaseScheduler {
    public List<Long> processingOrder(CaseGraph graph) {
        Map<Long, Integer> indegree = new HashMap<>();
        for (CaseNode node : graph.nodes()) {
            indegree.put(node.id(), 0);
        }

        for (CaseNode node : graph.nodes()) {
            for (CaseEdge edge : GraphViews.processingOutgoing(graph, node.id())) {
                indegree.merge(edge.to(), 1, Integer::sum);
            }
        }

        ArrayDeque<Long> ready = new ArrayDeque<>();
        for (Map.Entry<Long, Integer> entry : indegree.entrySet()) {
            if (entry.getValue() == 0) ready.addLast(entry.getKey());
        }

        List<Long> order = new ArrayList<>(graph.nodeCount());
        while (!ready.isEmpty()) {
            long current = ready.removeFirst();
            order.add(current);

            for (CaseEdge edge : GraphViews.processingOutgoing(graph, current)) {
                int nextDegree = indegree.merge(edge.to(), -1, Integer::sum);
                if (nextDegree == 0) ready.addLast(edge.to());
            }
        }

        if (order.size() != graph.nodeCount()) {
            throw new IllegalStateException("processing graph contains a cycle");
        }

        return order;
    }
}

PriorityQueue<Long> ready = new PriorityQueue<>();

ArrayDeque<Long> ready = new ArrayDeque<>(initialNodesSortedByDeadline);

public final class StrongComponents {
    private int index;
    private final Map<Long, Integer> indexOf = new HashMap<>();
    private final Map<Long, Integer> lowLink = new HashMap<>();
    private final ArrayDeque<Long> stack = new ArrayDeque<>();
    private final Set<Long> onStack = new HashSet<>();
    private final List<List<Long>> components = new ArrayList<>();

    public List<List<Long>> find(CaseGraph graph) {
        index = 0;
        indexOf.clear();
        lowLink.clear();
        stack.clear();
        onStack.clear();
        components.clear();

        for (CaseNode node : graph.nodes()) {
            if (!indexOf.containsKey(node.id())) {
                dfs(graph, node.id());
            }
        }
        return List.copyOf(components);
    }

    private void dfs(CaseGraph graph, long v) {
        indexOf.put(v, index);
        lowLink.put(v, index);
        index++;
        stack.push(v);
        onStack.add(v);

        for (CaseEdge edge : graph.outgoing(v)) {
            long w = edge.to();
            if (!indexOf.containsKey(w)) {
                dfs(graph, w);
                lowLink.put(v, Math.min(lowLink.get(v), lowLink.get(w)));
            } else if (onStack.contains(w)) {
                lowLink.put(v, Math.min(lowLink.get(v), indexOf.get(w)));
            }
        }

        if (Objects.equals(lowLink.get(v), indexOf.get(v))) {
            List<Long> component = new ArrayList<>();
            long w;
            do {
                w = stack.pop();
                onStack.remove(w);
                component.add(w);
            } while (w != v);
            components.add(component);
        }
    }
}

public record ImpactScore(long caseId, double score, int affectedCount) {}

public interface DeadlineUrgency {
    double urgency(CaseNode node);
}

public final class LinearDeadlineUrgency implements DeadlineUrgency {
    private final java.time.Clock clock;

    public LinearDeadlineUrgency(java.time.Clock clock) {
        this.clock = Objects.requireNonNull(clock);
    }

    @Override
    public double urgency(CaseNode node) {
        long seconds = java.time.Duration.between(
                java.time.Instant.now(clock),
                node.escalationDeadline()
        ).toSeconds();

        if (seconds <= 0) return 2.0;
        if (seconds <= 86_400) return 1.5;
        if (seconds <= 7 * 86_400L) return 1.2;
        return 1.0;
    }
}

public final class ImpactAnalyzer {
    private final DeadlineUrgency urgency;

    public ImpactAnalyzer(DeadlineUrgency urgency) {
        this.urgency = Objects.requireNonNull(urgency);
    }

    public ImpactScore score(CaseGraph graph, long root) {
        CaseNode rootNode = graph.get(root);
        Set<Long> visited = new HashSet<>();
        ArrayDeque<Long> queue = new ArrayDeque<>();
        queue.add(root);
        visited.add(root);

        int weightedEdgeSum = 0;

        while (!queue.isEmpty()) {
            long current = queue.removeFirst();
            for (CaseEdge edge : graph.outgoing(current)) {
                weightedEdgeSum += edge.weight();
                if (visited.add(edge.to())) {
                    queue.addLast(edge.to());
                }
            }
        }

        int affected = Math.max(0, visited.size() - 1);
        double statusMultiplier = statusMultiplier(rootNode.status());
        double score = rootNode.baseRisk()
                * statusMultiplier
                * urgency.urgency(rootNode)
                + affected * 3.0
                + weightedEdgeSum * 0.2;

        return new ImpactScore(root, score, affected);
    }

    private static double statusMultiplier(CaseStatus status) {
        return switch (status) {
            case OPEN -> 1.0;
            case UNDER_REVIEW -> 1.1;
            case ESCALATED -> 1.5;
            case ENFORCEMENT_ACTION -> 2.0;
            case CLOSED -> 0.2;
        };
    }
}

public final class CasePrioritizer {
    private final ImpactAnalyzer analyzer;

    public CasePrioritizer(ImpactAnalyzer analyzer) {
        this.analyzer = Objects.requireNonNull(analyzer);
    }

    public List<ImpactScore> topK(CaseGraph graph, int k) {
        if (k <= 0) return List.of();

        PriorityQueue<ImpactScore> heap = new PriorityQueue<>(
                Comparator.comparingDouble(ImpactScore::score)
        );

        for (CaseNode node : graph.nodes()) {
            ImpactScore score = analyzer.score(graph, node.id());
            if (heap.size() < k) {
                heap.add(score);
            } else if (score.score() > heap.peek().score()) {
                heap.poll();
                heap.add(score);
            }
        }

        ArrayList<ImpactScore> result = new ArrayList<>(heap);
        result.sort(Comparator.comparingDouble(ImpactScore::score).reversed());
        return result;
    }
}

node i neighbors live in:
edgeTo[offset[i] ... offset[i + 1])

public final class CompactDirectedGraph {
    private final long[] nodeIds;
    private final Map<Long, Integer> indexById;
    private final int[] offsets;
    private final int[] to;
    private final int[] weight;

    public CompactDirectedGraph(List<CaseNode> nodes, List<CaseEdge> edges) {
        this.nodeIds = new long[nodes.size()];
        this.indexById = new HashMap<>((int) (nodes.size() / 0.75f) + 1);

        for (int i = 0; i < nodes.size(); i++) {
            long id = nodes.get(i).id();
            nodeIds[i] = id;
            Integer previous = indexById.put(id, i);
            if (previous != null) throw new IllegalArgumentException("duplicate id: " + id);
        }

        int n = nodes.size();
        int[] degree = new int[n];
        for (CaseEdge edge : edges) {
            Integer from = indexById.get(edge.from());
            Integer dest = indexById.get(edge.to());
            if (from == null || dest == null) throw new IllegalArgumentException("edge endpoint missing");
            degree[from]++;
        }

        offsets = new int[n + 1];
        for (int i = 0; i < n; i++) {
            offsets[i + 1] = offsets[i] + degree[i];
        }

        to = new int[edges.size()];
        weight = new int[edges.size()];

        int[] cursor = offsets.clone();
        for (CaseEdge edge : edges) {
            int from = indexById.get(edge.from());
            int dest = indexById.get(edge.to());
            int pos = cursor[from]++;
            to[pos] = dest;
            weight[pos] = edge.weight();
        }
    }

    public int nodeCount() {
        return nodeIds.length;
    }

    public long nodeId(int index) {
        return nodeIds[index];
    }

    public int indexOf(long id) {
        Integer idx = indexById.get(id);
        if (idx == null) throw new NoSuchElementException("unknown id: " + id);
        return idx;
    }

    public int edgeStart(int nodeIndex) {
        return offsets[nodeIndex];
    }

    public int edgeEnd(int nodeIndex) {
        return offsets[nodeIndex + 1];
    }

    public int edgeTo(int edgeIndex) {
        return to[edgeIndex];
    }

    public int edgeWeight(int edgeIndex) {
        return weight[edgeIndex];
    }
}

HashMap -> ArrayList -> CaseEdge object -> boxed references / fields

int[] offsets + int[] to + int[] weight

public final class CompactTraversals {
    public static int reachableCount(CompactDirectedGraph graph, int start) {
        boolean[] visited = new boolean[graph.nodeCount()];
        int[] stack = new int[graph.nodeCount()];
        int top = 0;
        int count = 0;

        stack[top++] = start;
        visited[start] = true;

        while (top > 0) {
            int current = stack[--top];
            count++;

            for (int e = graph.edgeStart(current); e < graph.edgeEnd(current); e++) {
                int next = graph.edgeTo(e);
                if (!visited[next]) {
                    visited[next] = true;
                    stack[top++] = next;
                }
            }
        }

        return count;
    }
}

import org.junit.jupiter.api.Test;
import java.time.Instant;
import java.util.List;

import static org.junit.jupiter.api.Assertions.*;

class CaseGraphTest {
    @Test
    void rejectsDuplicateCaseIds() {
        CaseNode a = node(1);
        CaseNode duplicate = node(1);

        IllegalArgumentException ex = assertThrows(
                IllegalArgumentException.class,
                () -> CaseGraph.build(List.of(a, duplicate), List.of())
        );

        assertTrue(ex.getMessage().contains("duplicate"));
    }

    @Test
    void rejectsMissingEdgeEndpoint() {
        CaseNode a = node(1);
        CaseEdge edge = new CaseEdge(1, 99, EdgeType.RELATES_TO, 1);

        assertThrows(
                IllegalArgumentException.class,
                () -> CaseGraph.build(List.of(a), List.of(edge))
        );
    }

    private static CaseNode node(long id) {
        return new CaseNode(
                id,
                CaseStatus.OPEN,
                10,
                Instant.parse("2026-01-01T00:00:00Z"),
                Instant.parse("2026-02-01T00:00:00Z"),
                "ID",
                "MARKET_ABUSE"
        );
    }
}

@Test
void processingOrderPlacesDependencyBeforeDependent() {
    CaseNode a = node(1);
    CaseNode b = node(2);

    // A depends on B, so B should be processed before A.
    CaseEdge dependency = new CaseEdge(1, 2, EdgeType.DEPENDS_ON, 1);
    CaseGraph graph = CaseGraph.build(List.of(a, b), List.of(dependency));

    List<Long> order = new CaseScheduler().processingOrder(graph);

    assertTrue(order.indexOf(2L) < order.indexOf(1L));
}

@Test
void topologicalOrderRespectsAllProcessingEdges() {
    CaseGraph graph = randomDag(100, 300, 42L);
    List<Long> order = new CaseScheduler().processingOrder(graph);

    Map<Long, Integer> position = new HashMap<>();
    for (int i = 0; i < order.size(); i++) {
        position.put(order.get(i), i);
    }

    for (CaseNode node : graph.nodes()) {
        for (CaseEdge edge : GraphViews.processingOutgoing(graph, node.id())) {
            assertTrue(
                    position.get(edge.from()) < position.get(edge.to()),
                    "edge order violated: " + edge
            );
        }
    }
}

@Test
void compactReachabilityMatchesObjectGraphReachability() {
    CaseGraph objectGraph = randomGraph(200, 800, 123L);
    CompactDirectedGraph compact = toCompact(objectGraph);

    for (CaseNode node : objectGraph.nodes()) {
        int objectCount = objectReachableCount(objectGraph, node.id());
        int compactCount = CompactTraversals.reachableCount(
                compact,
                compact.indexOf(node.id())
        );
        assertEquals(objectCount, compactCount, "start=" + node.id());
    }
}

import org.openjdk.jmh.annotations.*;

import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Warmup(iterations = 5)
@Measurement(iterations = 10)
@Fork(2)
@State(Scope.Benchmark)
public class GraphTraversalBenchmark {
    @Param({"1000", "100000"})
    int nodes;

    @Param({"4", "12"})
    int avgDegree;

    CaseGraph objectGraph;
    CompactDirectedGraph compactGraph;
    int compactStart;
    long objectStart;

    @Setup(Level.Trial)
    public void setup() {
        objectGraph = GraphFixtures.randomObjectGraph(nodes, nodes * avgDegree, 42L);
        compactGraph = GraphFixtures.toCompact(objectGraph);
        objectStart = objectGraph.nodes().iterator().next().id();
        compactStart = compactGraph.indexOf(objectStart);
    }

    @Benchmark
    public int objectGraphReachability() {
        return GraphFixtures.objectReachableCount(objectGraph, objectStart);
    }

    @Benchmark
    public int compactGraphReachability() {
        return CompactTraversals.reachableCount(compactGraph, compactStart);
    }
}

IllegalStateException: cycle detected

cycle detected in processing graph tenant=abc largestSccSize=17 sampleCaseIds=[101,205,901]

import java.util.concurrent.atomic.AtomicReference;

public final class CaseGraphService {
    private final AtomicReference<CaseSnapshot> current = new AtomicReference<>();

    public void rebuild(List<CaseNode> nodes, List<CaseEdge> edges) {
        CaseGraph graph = CaseGraph.build(nodes, edges);
        CaseSnapshot snapshot = CaseSnapshot.from(graph);
        current.set(snapshot);
    }

    public List<ImpactScore> topCases(int k) {
        CaseSnapshot snapshot = requireSnapshot();
        return snapshot.prioritizer().topK(snapshot.graph(), k);
    }

    private CaseSnapshot requireSnapshot() {
        CaseSnapshot snapshot = current.get();
        if (snapshot == null) throw new IllegalStateException("snapshot not initialized");
        return snapshot;
    }
}

public record CaseSnapshot(
        CaseGraph graph,
        CasePrioritizer prioritizer,
        java.time.Instant builtAt
) {
    public static CaseSnapshot from(CaseGraph graph) {
        ImpactAnalyzer analyzer = new ImpactAnalyzer(
                new LinearDeadlineUrgency(java.time.Clock.systemUTC())
        );
        return new CaseSnapshot(
                graph,
                new CasePrioritizer(analyzer),
                java.time.Instant.now()
        );
    }
}

public record PriorityEntry(long caseId, double score, long version) {}

public final class VersionedCaseQueue {
    private final PriorityQueue<PriorityEntry> heap = new PriorityQueue<>(
            Comparator.comparingDouble(PriorityEntry::score).reversed()
                    .thenComparingLong(PriorityEntry::caseId)
    );
    private final Map<Long, Long> latestVersion = new HashMap<>();

    public void offer(long caseId, double score) {
        long nextVersion = latestVersion.getOrDefault(caseId, 0L) + 1;
        latestVersion.put(caseId, nextVersion);
        heap.offer(new PriorityEntry(caseId, score, nextVersion));
    }

    public Optional<PriorityEntry> pollValid() {
        while (!heap.isEmpty()) {
            PriorityEntry entry = heap.poll();
            long current = latestVersion.getOrDefault(entry.caseId(), -1L);
            if (entry.version() == current) {
                latestVersion.remove(entry.caseId());
                return Optional.of(entry);
            }
        }
        return Optional.empty();
    }

    public int heapSizeIncludingStaleEntries() {
        return heap.size();
    }
}

entry.version == latestVersion[entry.caseId]

public record RuleMatch(String ruleId, long caseId, String reason) {}

public interface CaseRule {
    Optional<RuleMatch> match(CaseNode node);
}

public final class JurisdictionRiskRule implements CaseRule {
    @Override
    public Optional<RuleMatch> match(CaseNode node) {
        if (node.jurisdiction().equals("ID") && node.baseRisk() >= 80) {
            return Optional.of(new RuleMatch(
                    "ID_HIGH_RISK",
                    node.id(),
                    "Indonesian jurisdiction with high base risk"
            ));
        }
        return Optional.empty();
    }
}

import java.time.LocalDate;
import java.time.ZoneOffset;
import java.util.NavigableMap;
import java.util.TreeMap;

public final class DeadlineIndex {
    private final NavigableMap<LocalDate, Integer> countByDay = new TreeMap<>();

    public void add(CaseNode node) {
        LocalDate day = node.escalationDeadline()
                .atZone(ZoneOffset.UTC)
                .toLocalDate();
        countByDay.merge(day, 1, Integer::sum);
    }

    public int countBetween(LocalDate fromInclusive, LocalDate toInclusive) {
        int total = 0;
        for (int count : countByDay.subMap(fromInclusive, true, toInclusive, true).values()) {
            total += count;
        }
        return total;
    }

    public Optional<LocalDate> earliestDeadline() {
        return countByDay.isEmpty()
                ? Optional.empty()
                : Optional.of(countByDay.firstKey());
    }
}

# Algorithmic Design: <System Name>

## Problem
What decision/query/computation does this subsystem provide?

## Inputs
- Entity types
- Relations
- Weights/costs
- Time fields
- Update frequency

## Outputs
- Result shape
- Ordering/tie-breaker
- Exact vs approximate guarantees

## Domain Semantics
- Edge direction
- Weight meaning
- Status/lifecycle semantics
- Invalid states

## Operation Profile
| Operation | Frequency | Latency Target | Complexity Target |
|---|---:|---:|---|

## Data Structures
- Primary store
- Indexes
- Derived structures
- Snapshot/version strategy

## Algorithms
- Algorithm chosen
- Why it fits
- Alternatives rejected
- Correctness argument

## Invariants
- Model invariants
- Index invariants
- Algorithm invariants
- Production monitors

## Complexity Budget
- Time
- Space
- Expected size
- Worst-case behavior
- 10x growth behavior

## Failure Modes
- Modelling failures
- Complexity failures
- Concurrency failures
- Data-quality failures

## Testing Strategy
- Unit examples
- Edge cases
- Random/property tests
- Differential tests
- Regression tests

## Benchmark Plan
- Dataset shapes
- Metrics
- Baseline
- Acceptance threshold

## Observability
- Metrics
- Logs
- Debug dumps
- Alert conditions

## Rollout Plan
- Shadow mode
- Compare old/new result
- Gradual enablement
- Kill switch

for (CaseNode node : cases) {
    for (CaseEdge edge : allEdges) {
        if (edge.from() == node.id()) {
            // process neighbor
        }
    }
}

100,000 * 1,000,000 = 100,000,000,000 comparisons

Map<Long, List<CaseEdge>> outgoing = buildOutgoingIndex(edges);

Comparator<ImpactScore> bad = Comparator.comparingDouble(ImpactScore::score);

TreeSet<ImpactScore> set = new TreeSet<>(Comparator.comparingDouble(ImpactScore::score));

Comparator<ImpactScore> safe = Comparator
        .comparingDouble(ImpactScore::score)
        .reversed()
        .thenComparingLong(ImpactScore::caseId);

// There is no efficient decreaseKey/increaseKey in java.util.PriorityQueue.
entry.score = newScore; // bad if mutable

void dfs(int v) {
    visited[v] = true;
    for (int next : adj[v]) {
        if (!visited[next]) dfs(next);
    }
}

ArrayDeque<Integer> stack = new ArrayDeque<>();
stack.push(start);
visited[start] = true;

while (!stack.isEmpty()) {
    int v = stack.pop();
    for (int next : adj[v]) {
        if (!visited[next]) {
            visited[next] = true;
            stack.push(next);
        }
    }
}

public final class CaseImpactEngine {
    private final CaseGraph graph;
    private final StrongComponents scc;
    private final CaseScheduler scheduler;
    private final CasePrioritizer prioritizer;
    private final DeadlineIndex deadlineIndex;

    private CaseImpactEngine(
            CaseGraph graph,
            StrongComponents scc,
            CaseScheduler scheduler,
            CasePrioritizer prioritizer,
            DeadlineIndex deadlineIndex
    ) {
        this.graph = graph;
        this.scc = scc;
        this.scheduler = scheduler;
        this.prioritizer = prioritizer;
        this.deadlineIndex = deadlineIndex;
    }

    public static CaseImpactEngine build(
            List<CaseNode> nodes,
            List<CaseEdge> edges,
            java.time.Clock clock
    ) {
        CaseGraph graph = CaseGraph.build(nodes, edges);

        DeadlineIndex deadlineIndex = new DeadlineIndex();
        for (CaseNode node : nodes) {
            deadlineIndex.add(node);
        }

        ImpactAnalyzer analyzer = new ImpactAnalyzer(new LinearDeadlineUrgency(clock));

        return new CaseImpactEngine(
                graph,
                new StrongComponents(),
                new CaseScheduler(),
                new CasePrioritizer(analyzer),
                deadlineIndex
        );
    }

    public List<List<Long>> stronglyConnectedComponents() {
        return scc.find(graph);
    }

    public List<Long> processingOrder() {
        return scheduler.processingOrder(graph);
    }

    public List<ImpactScore> topImpactCases(int k) {
        return prioritizer.topK(graph, k);
    }

    public Optional<java.time.LocalDate> earliestDeadline() {
        return deadlineIndex.earliestDeadline();
    }
}