@spec enter_state(
  machine_state :: Statifier.MachineState.t(),
  state_index :: non_neg_integer()
) ::
  {Statifier.MachineState.t(), [Statifier.Effect.t()]}

enterStates's per-state datamodel step (Appendix D :312, prose in the moduledoc's "no Appendix D procedure body" section above) - binds state_index's own <datamodel> (Machine.at(machine, state_index).data) under binding == :late.

This function does not itself test "is this the first time state_index has been entered" - Appendix D's s.isFirstEntry (appendix-d.txt:312). Statifier.Interpreter.ExitEntry.arrive/3 is the only caller, and it tests membership in MachineState.entered_states (the ADR-0002 substitute for s.isFirstEntry, documented at that field) before calling this function, so by the time this function runs, "first entry" has already been decided. Splitting it this way keeps this module free of MachineState.configuration/ entered_states mutation, which arrive/3 already owns for every other step of the same pseudocode body.

A no-op, returning {machine_state, []} unchanged, in three cases: under binding == :early (every d_index was already bound at initialize/1, before any state was entered), under binding == :late on a state whose own <datamodel> is empty (data == [] - nothing to bind), and on state_index == 0 for the reason below.

Why state_index == 0 is a no-op

Index 0 is the document root, and it is in configuration like any other state, so arrive/3 calls this function for it. But the root's own data list is the top-level data list - the <datamodel> that is a child of <scxml> - which initialize/1 has already bound (Decision 3: top-level <data> binds at initialization under both bindings, since 5.3.3's "the state that contains it" has no answer for a <data> contained in no state). Binding it a second time here is duplication, and not harmless duplication: this function deliberately applies no environment override, so the second pass would overwrite an environment-supplied value with the document's own and violate 5.3.2's

"The SCXML Processor MUST use any values provided by the environment
at instantiation time in place of those contained in the top-level
<data> elements."

Only binding == "late" reaches this path at all, and only a document whose environment seeds a top-level id observes it - which is why no corpus file catches it. Spec 6.4.3 makes it reachable in practice: an invoked session's <param>/namelist values arrive as exactly this environment seed, so without this guard a late-bound invoked child would silently discard the values its parent passed it - the child-session half of <invoke> that would deliver them does not exist yet, per docs/architecture.md's "Sessions and invoke" section.

Otherwise: one Evaluator.context/1 for state_index's whole data list (B.2.2's "no ordering dependencies" licenses this exactly as it does in initialize/1), each d_index bound through the same bind_value/4 this module's initialize/1 uses - same seeded-:undefined-on-failure, raise_platform/4 shape, Decision 2/3 unchanged, and the same {:datamodel_change, %Effect.DatamodelChange{}} emission per successful binding (decision 3). There is no environment override on this path: Decision 1 scopes that skip to top-level <data> only, and a state-scoped <data> on any state but the root is never top-level.

@spec initialize(machine_state :: Statifier.MachineState.t()) ::
  {Statifier.MachineState.t(), [Statifier.Effect.t()]}

interpret's datamodel preamble (Appendix D :101-102, prose above), plus the top-level half of enterStates' per-state binding (:312) that late binding would otherwise defer forever - see the moduledoc's "no Appendix D procedure body" section and spec 5.3.3's binding rule for why the if doc.binding == "early": guard that wraps the interpret call site in the pseudocode moves off that call site and into this function instead: a top-level <data> is contained in no state, so under binding="late" it never reaches enterStates' statesToEnter loop at all, and deferring its binding to a state entry that never happens would leave it permanently unassigned - a spec violation, not a conforming late-binding delay.

Returns {MachineState.t(), [Effect.t()]}, like every other function in Statifier.Interpreter: the first effect on the list is always the {:datamodel_init, %Effect.DatamodelInit{}} baseline, built from machine_state right after seed/2 and before the binding fold - the datamodel as it stands the instant every declared <data> exists but before any of them has a value (see Statifier.Effect.DatamodelInit's own moduledoc for what the map does and does not carry). Every effect after it, in ascending d_index order, is a {:datamodel_change, %Effect.DatamodelChange{}} for one successful <data> binding (bind_value/4, decision 3) - a failed or environment-skipped binding emits nothing (decision 5). No trace effect is produced either way (docs/observability.md's minimum trace vocabulary is a closed table and datamodel binding is not a member of it); the one observable event a failed binding can produce, error.execution, is already an ordinary internal event that travels on machine_state's own queue.

@spec write_location(
  machine_state :: Statifier.MachineState.t(),
  datamodel_context :: Predicator.Context.t(),
  path_source :: String.t(),
  value :: term()
) ::
  {:ok, Statifier.MachineState.t(), Predicator.Context.t(),
   Statifier.Interpreter.Datamodel.Write.t()}
  | {:error, term()}

Writes value at path_source (a raw, uncompiled path expression such as "foo.bar.baz" or "items[0]") against machine_state's datamodel, rebinding the written root into datamodel_context for callers that thread a context across a block (ADR-0028). Extracted from Statifier.Machine.Content.Assign's defimpl - see that module's moduledoc for the vivification and system-variable reasoning this function's five steps carry out unchanged; this is a pure mechanics move, not a new decision.

1. Resolve path_source against datamodel_context.data (the normalized view, so a bracket key such as items[i] reads i exactly as an expression would).
2. Reject a resolved root beginning with "_" (spec 5.10 - a system variable).
3. Require the resolved root to already be a key of machine_state.datamodel - auto-vivification only ever creates intermediate containers, never an undeclared top-level variable.
4. Write into the raw machine_state.datamodel, never the normalized .data read in step 1.
5. Bind just the written root into datamodel_context - O(size of that root), not O(size of the datamodel).

Every predicator failure returns as a bare {:error, term()} - the caller is the sole error.execution conversion site (ADR-0003).

On success, the fourth element is a Statifier.Interpreter.Datamodel.Write report of the write - the resolved path, the prior_value read at that full path immediately before the write, and the new_value written. Reporting is all this function does; building an effect from the report is each caller's own job.