Compute trigger counts in a DAG

You are given a directed acyclic graph (DAG) that represents trigger dependencies between tasks.

• Each node represents a task.
• There is exactly one entry node.
• When a node is triggered once, it immediately triggers each of its outgoing neighbors once.
• A node may have multiple incoming edges; its total trigger count is the sum of triggers from all its parents.
• The entry node is triggered exactly once initially.

Your job is to compute how many times each node is triggered.

Input

• A list of directed edges edges, where each edge is a pair (u, v) meaning there is an edge u -> v.
• A designated entry node ID.
• You may assume:
• The graph is acyclic.
• All nodes that appear in edges are valid nodes.
• Node IDs can be strings or integers (you can pick a representation and document it).

Example:

• Nodes: A, B, C, D, E, F
• Edges:
• A -> B
• B -> C
• B -> D
• C -> D
• D -> E
• D -> F
• E -> F
• Entry node: A

Trigger propagation:

• A is triggered once (given).
• B is triggered once (from A).
• C is triggered once (from B).
• D is triggered twice (once from B, once from C).
• E is triggered twice (both from D).
• F is triggered four times (twice from D, twice from E).

So the result is something equivalent to:

A: 1
B: 1
C: 1
D: 2
E: 2
F: 4

Task

Implement a function in Python with a signature such as:

def count_triggers(edges, entry):
 """Return a mapping from node to its trigger count."""

The function should:

• Validate that all reachable nodes from entry are handled.
• Run efficiently for graphs with up to around 10^5 nodes and 10^5 edges.

You may assume there are no cycles in the input graph.