Node

@[remote]'s tag test (a generated <Actor>_Remote.dispatch calls it): does [d] carry a message of the type of [witness]'s parameter, as in Node.accepts(d, fn (_ : T) -> ())? The compiler rewrites the call to tag_is_schema(d, "<tag>", "<schema>") with the tag and schema hash Node.send mints for that type. Panics if reached at run time (an entry point skipped that rewrite).

Does [d] carry T's tag, ignoring the schema, for accepts_tag(d, fn (_ : T) -> ())? Tells a same-named type of ANOTHER shape. The compiler rewrites it to tag_is; panics if reached at run time.

The typed send through a peer's queue [q] under [policy]: msg's type must derive Json and the compiler mints the tag, exactly as for send, rewriting the call to enqueue_tagged_schema. Returns Ok(seq) once the frame is admitted to the queue (not yet written). Panics if reached at run time (a pipeline that skipped the compiler's rewrite).

match Node.enqueue(q, to, Ping({ n: 1 }), NodeQueue.DropNew) do
  Ok(seq) -> seq
  Err(NodeQueue.Backpressure) -> -1
  Err(_) -> -2
end

send_tagged through a peer's outbound queue [q] (NodeQueue, credit-based flow control): the frame is admitted under [policy] and written by the queue's writer when the receiver's credit covers it. Ok(seq) means admitted, not written, and counts as one message sent; Err(Backpressure) / Err(NoConnection) are the queue's. enqueue lowers to this exactly as send lowers to send_tagged.

enqueue_tagged with the message type's schema hash [schema] in the frame (what enqueue lowers to; `\

The receiver's half of the codec: [d]'s payload parsed as JSON, ready for a from_json pinned to the hosted type. Err with the parser's message when the payload is not valid JSON.

match Node.payload(d) do
  Ok(j) -> handle(j)
  Err(e) -> println("bad payload: " ++ e)
end

The resolved form of schema_matches: does [d] carry exactly schema hash [schema]? (A delivery with no schema carries `\

Does [d] carry T's schema hash, for schema_matches(d, fn (_ : T) -> ())? Picks the migrate_msg input type an old shape decodes as. The compiler rewrites it to schema_is; panics if reached at run time.

T's schema hash as a String, for schema_of(fn (_ : T) -> ()). The compiler replaces the call with the hash; panics if reached at run time.

The typed remote send: deliver [msg] to the process [to] on [peer]. msg's type must derive Json (a typecheck error at the call site otherwise); the compiler rewrites every call to send_tagged_schema with the type's qualified name as the tag (see the module comment). Returns Ok(seq) once the frame is written, the seq a later DELIVERY_FAILED echoes; a failed write is Err(NoConnection). Panics if reached at run time: only a pipeline that skipped the compiler's rewrite gets here.

match Node.send(peer, to, Ping({ n: 1 })) do
  Ok(seq) -> seq
  Err(_) -> -1
end

The explicit form of send: the tag and the JSON value in hand. send lowers to this; a receiver-side helper or a test may call it directly. Takes the next number of this process's send sequence, serializes [json] as the payload and writes one ACTOR_MSG with NodeSend.cast on the peer's data connection (its only connection when it has no data one). Returns Ok(seq) once the frame is written (a later DELIVERY_FAILED echoes the seq), or NodeSend.cast's error: NoConnection when the write fails, Refused when certificate mode forbids the raw send.

match Node.send_tagged(peer, to, "Chat.Msg", Json.Str("hi")) do
  Ok(seq) -> seq
  Err(_) -> -1
end

send_tagged with the message type's schema hash: the form a typed send lowers to (build step 9). [schema] is computed by the compiler; it rides the frame (NodeSend.cast_schema) so a receiver can tell a same-named type of another shape. "" sends no schema, exactly as send_tagged.

Does [d] carry type tag [tag], exactly? (What accepts_tag resolves to; the schema is not looked at.)

The resolved form of accepts (build step 9): [d]'s tag must equal [tag], and its schema hash must equal [schema] unless either is "". A sender built before schema hashes sends none and is taken at its tag.