Refuse what a node cannot publish, and stop timing out work that is fine

Four things the python SDK turned up, each fixed where every client sees it.

A key no port declares is now an error rather than a silent drop, on the
return, the yield and the emit alike — the contract the docs already stated.
The SDK reads literal yields at sync time, so a typo fails before anything
runs, and an emission of one fails the call rather than being logged where
nobody looks.

NaN and infinity are refused at the port. JSON cannot spell either, so one
that travelled came back as a 500, a socket frame that stopped the canvas, or
a metric batch the database dropped whole.

An artifact input takes `@run:<id>.<output>` or a bare digest, resolved on the
engine — so the CLI, the run dialog and a python caller mean the same thing,
and a sweep can pass one at all.

Node timeouts are off by default. The clock measured silence, which a training
node is full of, and remote workers had already stopped enforcing it — their
heartbeat reset it. Now a heartbeat proves the agent rather than the node,
ninety seconds of nothing fails the call either way, and the engine touches
work it is still running so a long node is not redelivered at sixty seconds.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019V5bsYGNxcgPs4xXmTPx69

backend/fluksio/flow/messages.py

@@ -11,6 +11,7 @@ consume each other's messages.
 from __future__ import annotations
 
 import json
+import math
 from enum import Enum
 from typing import Any
 
@@ -65,11 +66,42 @@ _ITEM_TYPES = frozenset(
 )
 
 
+#: How deep to look for a non-finite number. Deeper than any payload that
+#: reads well on a canvas, and a bound on a value that refers to itself.
+_WALK_DEPTH = 8
+
+
 def _is_number(value: Any) -> bool:
     """A measurement. bool is an int subclass; a flag is not a number here."""
     return isinstance(value, (int, float)) and not isinstance(value, bool)
 
 
+def _nonfinite(value: Any, depth: int = 0) -> float | None:
+    """The first NaN or infinity in a value, however deeply it sits.
+
+    JSON cannot spell either: ``json.dumps`` writes a bare ``NaN``, which a
+    strict parser refuses. So a metric that goes non-finite leaves the engine
+    as a response nobody can read, a socket frame that stops a canvas, or a row
+    the database rejects — all of them a long way from the node that produced
+    it. Naming it here costs one walk of a value already about to be encoded.
+    """
+    if isinstance(value, float) and not math.isfinite(value):
+        return value
+    if depth >= _WALK_DEPTH:
+        return None
+    if isinstance(value, dict):
+        items: Any = value.values()
+    elif isinstance(value, (list, tuple)):
+        items = value
+    else:
+        return None
+    for item in items:
+        found = _nonfinite(item, depth + 1)
+        if found is not None:
+            return found
+    return None
+
+
 def _is_record(value: Any) -> bool:
     return isinstance(value, dict) and all(
         isinstance(key, str) and (item is None or isinstance(item, _SCALARS))
@@ -188,6 +220,13 @@ class MessageSpec(BaseModel):
     def check(self, value: Any) -> None:
         """Raise if ``value`` does not match this port's declared type."""
         where = self.name or self.port
+        stray = _nonfinite(value)
+        if stray is not None:
+            raise TypeError(
+                f"{where}: {stray} cannot travel as JSON. A subset with nothing "
+                "in it, or a division that had no denominator, is what usually "
+                "produces one — publish None, or a number that says so."
+            )
         if self.dtype is DType.SERIES:
             ok = _is_series(value)
         elif self.dtype is DType.LIST: