The effect vocabulary (ADR-0003) plus the nine trace effects (docs/observability.md constraint 2) - one @type t() union, in this one module, that every interpreter function emits from and every consumer pattern-matches against, including Statifier.Session, which drives <send>/<cancel>/<invoke>. This module defines the vocabulary and the trace gate; it never emits an effect itself.

Every effect is {tag, payload_struct}

An effect is always a two-element tuple: a vocabulary tag, and a struct carrying its named fields. The tag keeps case effect do {:log, log} -> ... reading the way ADR-0003 writes it and makes "is this a trace effect?" a single match (trace?/1); the struct payload gives named fields, dialyzer coverage, and room to grow the <send>/<send_delayed>/ <cancel>/<invoke> payloads without changing any arity. There are no positional tuples with four or five elements anywhere in this vocabulary.

The vocabulary

Every tag in this vocabulary is produced today: :log, :done, :budget_exhausted, :invoke, :cancel_invoke, :autoforward, :datamodel_change, :datamodel_init, :send, :send_delayed, :cancel, and all nine trace effects.

Trace effects carry indexes and counters, never structs

Every effect in this vocabulary, core and trace alike, carries macrostep/microstep/round (constraint 4, ADR-0046); trace payloads additionally carry, wherever one names an entity, a constraint-3 identity - a state index, a t_index, a c_index - never a %Statifier.Machine.State{}, %Statifier.Machine.Transition{}, or a compiled content-node struct. Tooling resolves an identity back to its node through Statifier.Machine.at/2, transition/2, or content/2 (docs/observability.md:73-74). round is the only one of the three that advances in a round that runs no microstep at all - a livelocked or eventless round still stamps a fresh round on everything it emits, which is what keeps such a trace ordered (ADR-0020).

Trace effects are ordinary list members, never a side channel

A trace effect is just another element of the same [effect] list a microstep returns, in the same order, delivered the same way. There is no separate trace stream to keep in sync (docs/observability.md:75-76).

The gate: trace/3

require Statifier.Effect, as: Effect

Effect.trace(machine_state, Effect.Trace.EntrySet, indexes: entry_order)

expands to

if machine_state.trace do
  [{:trace, Statifier.Effect.Trace.EntrySet.new(machine_state, indexes: entry_order)}]
else
  []
end

Two properties make this the gate the untraced hot path needs:

• Single evaluation. The machine_state argument is bound to a variable inside the quoted block before the if, so a call site passing an expression (Effect.trace(begin_microstep(ms), ...)) evaluates it exactly once. Writing unquote(machine_state) twice - once for .trace, once as new/2's argument - would double-evaluate it; that is the bug this shape exists to avoid.
• Laziness. fields is spliced only inside the if's do branch. When machine_state.trace is false, the gate is one boolean field read and an empty list: no payload struct is built, and the fields expression is never evaluated at all - not even for its side effects.

Every trace payload module defines new/2, taking the machine_state (from which it stamps macrostep/microstep/round) and a keyword list of its own fields, so no call site ever repeats the counters and no call site can forget them.