The W3C Basic HTTP Event I/O Processor (SCXML appendix C.2), a Statifier.Send.Processor a host registers like any other send type (ADR-0069, ADR-0075).

Registering it

Register it under the spec's processor URI and its short form basichttp, with the base URL the host's own front answers at:

base = "https://example.org/scxml"

Statifier.Session.start_link(chart,
  send_types: %{
    "http://www.w3.org/TR/scxml/#BasicHTTPEventProcessor" =>
      {Statifier.Send.BasicHTTP, base_url: base},
    "basichttp" => {Statifier.Send.BasicHTTP, base_url: base}
  }
)

Neither string is a built-in spelling, so the registration redirects no built-in send (ADR-0075 decision 2). The options:

• :base_url (required) - the address the host's front answers at. The session's _ioprocessors carries an entry under each registered string, both holding the same "location": this URL, /, and the session's _sessionid (C.2.3, ADR-0075 decision 3). A registration from which no entry can be built (no :base_url, or a value that is not a string) is refused when the session starts fresh, with {:error, {:send_types, {:invalid_registration, type, {:missing_option, :base_url}}}}, before any session process is spawned and so with no crash report (check_registration/2). A resumed session is not refused: its position carries the entries it started with.
• :transport - a Statifier.Send.BasicHTTP.Transport module the POSTs go through. Default Statifier.Send.BasicHTTP.Transport.Httpc, on OTP's :httpc; this package adds no dependency for it (ADR-0075 decision 6).

Outbound (C.2.2)

deliver/3 plans and perform/2 POSTs, the split every processor has (Statifier.Send.Processor). The mapping (ADR-0075 decision 4):

• event becomes the form parameter _scxmleventname, and each namelist entry and <param> a form parameter, in an application/x-www-form-urlencoded body.
• A <content> child is the body, sent as text/plain; when the send also names an event, _scxmleventname travels as a query parameter of the target URL.
• The two are told apart by data's shape: a map that is not a struct is form-encoded, :undefined sends _scxmleventname alone as a form body, and any other value is the body. A <content expr> that evaluates to a map is therefore form-encoded, and one that evaluates to a struct (a Date, for example) is the body, its inspect/1 text sent as text/plain.
• A send with neither target nor targetexpr raises C.2.2's error.communication on the sender's internal queue, carrying the send id, and makes no request.

A parameter value is written as text: a string as it is, a number or a boolean as its literal, nil as null, :undefined as the empty string. A list or a map is written as JSON text through Elixir's JSON ([1,2], {"title":"Dune"}), and :undefined inside it as JSON null, when every value inside has a JSON form: a string that is UTF-8, a number, a boolean, nil, :undefined, a list, or a map whose keys are all strings. A list or a map holding anything else (an atom key, a struct such as a Date, a tuple) keeps its inspect/1 text whole, as does any other value that is none of these. The same rule writes a <content> body that is a list, still sent as text/plain.

One attempt, and a miss reaches the sender. perform/2 makes one POST. On a transport error, or a status outside 2xx, it reports the miss through Statifier.Session.failed_send/3 to the sending session it finds in Statifier.Registry under the plan context's session_id, so the sender sees C.1's error.communication carrying the send id, and it returns {:error, reason}. When no live session is registered under that id it returns {:error, reason} only, and the dead-letter rule of failed_send/3's documentation is the host's (ADR-0075 decision 8, point d).

At-least-once, deduplicated by the receiver (ADR-0075's Amendment of 2026-09-30). The processor keeps no memory across perform/2 calls, so a host that performs the same instruction twice POSTs twice. Every POST therefore carries the send's ADR-0054 decision 3 dedup key in the scxml-send-key header: eight fields joined by /, in the record's order - the session scope (the plan context's session_id), the send id, macrostep, microstep, round, c_index, owner and ordinal. The session scope and the send id are percent-encoded (every byte outside RFC 3986's unreserved set), the counters are decimal, and owner is spelled onentry.S.B, onexit.S.B, transition.T or finalize.S.B with its indexes. A receiver that deduplicates on the header sees each send once, which is ADR-0069's idempotency MUST end to end; a receiver that ignores it sees at-least-once delivery.

perform/2 runs in the process that performs the instruction, which for Statifier.Session is the sending session, so a slow location holds that session for the length of the request; the default transport bounds each request with a timeout.

A delayed send is this processor's timer (ADR-0069 decision 4). A <send delay> is held by a timer process perform/2 starts, and cancel/2 plans the cancellation of every timer held under the send id (spec 6.3). The session performing the send keeps the timer through Statifier.Session.HaltNotice until it ends, and tells it when the session halts. When the delay passes, the timer POSTs unless its mailbox already holds a cancel, its session's halt notice (:done, :cancelled or :budget_exhausted) or its session's end, so a cancel the timer has received before the POST always wins, and a session that has stopped, or halted, discards the send (spec 6.2). The timer never calls the session, so a session busy at fire time does not delay or drop the POST. A transport that raises inside the timer is a miss like any other: it reaches the sender as error.communication through Statifier.Session.failed_send/3, with the reason {:raised, exception}. A delayed send performed outside a Statifier.Session has no session to hold it and is discarded.

Inbound (C.2.1)

decode/1 turns one HTTP request into a %Statifier.Event{}. It is pure and knows no session: a front resolves the location to a session (or to an execution, for a durable host), calls it, and enqueues the event as an external event. The status rule a front applies (ADR-0075 decision 5):

• {:ok, event} - answer 204 once the event is enqueued, before it is processed (a front that has already enqueued a request carrying the same scxml-send-key answers 204 again and enqueues nothing);
• {:error, {:method_not_allowed, method}} - answer 405 with Allow: POST;
• any other {:error, _} - answer 400;
• a location that names no session the front can reach - the front's own 404.