The Dependency Map

The Dependency Map graphs the references eXLib can resolve for an expression — not what you assume it depends on by reading the code. It reads in both directions: Depends on fans in from an expression to the resolved sources it reads, and Drives fans out from a controller to the resolved expressions in the comp that read it.

Resolution is deliberately bounded so a pathological rig cannot hold After Effects' UI thread: one host pass handles at most 500 chains and stops after 2.5 seconds. If that limit is reached, the map reports the scan as incomplete instead of presenting the partial graph as exhaustive.

Opening the map

Right-click anywhere in the editor — or use the command palette — and choose Dependency Map. It opens as a panel docked beside the editor.

Depends on

Depends on is the default direction. It fans in: the layers, properties, and effect controls eXLib resolved from your selected expression's chain, drawn as a graph rather than a list.

Drives

Drives is the other direction. Select a controller property and switch the toggle — it lights amber, since it's the non-default reading of the graph — to fan out at the parameter level: the expressions resolved in this comp that read that controller, not just "this layer reads that layer."

That parameter-level precision matters more than it sounds like it should. Two layers can carry the exact same expression text and still point at two entirely different controllers — Drives tracks what each layer's copy actually resolves to, not the text the layers happen to share.

Several roots, one merged graph

Select several properties — or, in Drives mode, several controllers — and the map merges them into one graph instead of drawing a separate diagram for each. A source that two or more of your selections both read becomes a single node with two incoming edges, so the overlap between your selections is exactly what you see. Selecting just one property or controller still draws a single graph — nothing changes for the common case.

Reveal in timeline

Clicking a node, in either direction, selects and reveals that layer or property in After Effects' timeline — the same reveal gesture used elsewhere in the panel.

What the map cannot show you

It's comp-scoped. The map only ever resolves references inside the comp you're currently working in.

Drives also tells you what it couldn't follow, and why. Some references are legitimately unaddressable by static analysis, and the Drives footer says so explicitly instead of silently omitting them. It itemizes every unresolvable reference by named cause, with a breakdown tooltip on hover:

Cause	What it means
In another comp	Reads a property in a different composition — out of this scan's scope, not a failure
Unreadable layer target	The layer argument is a variable or the two-argument form — resolving it would be a guess
Layer not in this comp	Names a layer that isn't in this comp — a dead reference
Indexed accessor	Addresses a slot by number, e.g. effect(2) — resolved only as far as its parent group
Computed accessor name	Builds the accessor name at runtime, e.g. effect("FACE " + i) — unaddressable by construction, in any tool
Property not found	The addressed property isn't in this comp's snapshot — renamed, deleted, or unreadable

In practice, most of the references a comp-scoped scan can't follow turn out to be computed accessor names — expressions that build a property name from a string at runtime. No static analysis, in eXLib or anywhere else, can resolve a name that doesn't exist until the expression runs. When the map tells you a reference is unresolvable for that reason, that's a statement about what's knowable without running the expression.

Related

• Comp Expressions
• Reveal in Timeline
• The Pickwhip
• The ae-expression Editor