Flow

Start a configured named flow and return after admission, with its queue already registered. At most two background branches run beside main; background branches may start peers. Only one live invocation per name is allowed, including paused or stopping invocations. Invalid or duplicate names, capacity errors and branch errors stop the whole Run, as do System.stop() and Main Stop. Main completion joins live workers: explicitly stop long-lived workers. Params are copied with the same safe-value limits as Flow.send().

Flow.start(name, params=None)

# Start recognition and telemetry beside the main flow
recognition_no = Flow.start("recognition", {"region": "arena", "threshold": 0.86})
telemetry_no = Flow.start("telemetry")

# Inside the configured recognition flow, read this branch's copied input
region_name = Flow.params.get("region", "full_screen")
threshold = Flow.params.get("threshold", 0.8)

Enqueue a deep copy for the currently running named invocation without waiting. FIFO delivery is thread-safe, including while paused. Safe values are None, Boolean, finite numbers, String, list, tuple and dict with String keys; maximum depth is 8, total values 512 and total text length 65536. Callables, resource/domain objects and cycles are errors. Each invocation has a new queue; stop or completion discards pending messages.

Flow.send(name, data)

# Send an ARM command to the configured watcher
Flow.start("watch_enemy")
accepted = Flow.send("watch_enemy", {"command": "ARM"})
print(accepted)

Remove the oldest message from the current execution branch queue, suspending without a busy loop until a message or timeout. Main and background branches can receive; nested named foreground groups use their owning branch queue. Cancellation wakes the wait promptly. Pause preserves queued messages. Received collections are detached copies.

Flow.receive(timeout=None)

# Configured watch_enemy flow: wait for ARM, then check commands between work
message = Flow.receive()
if message is not None and message.get("command") == "ARM":
    while True:
        command = Flow.poll()
        if command is not None:
            print(command)
        if Region().find("enemy", timeout=0).found:
            print("enemy")
        wait(100)

Remove the oldest message from the current execution branch queue immediately. Uses the same queue and detached payload rules as Flow.receive().

Flow.poll()

# Check for a command without waiting
message = Flow.poll()
if message is not None:
    print(message)

Check whether a named invocation is active, including while paused. The result may change immediately after the call.

Flow.running(name)

print(Flow.running("watch_enemy"))

Request cancellation of only the target background branch without waiting for cleanup. Main and peers keep running; main cannot be stopped with this API. A named foreground group owned by a background branch targets that owning branch. Self-stop terminates the calling branch. The name remains reserved until asynchronous cleanup completes, so do not immediately restart it. The dock still provides only Pause/Resume for background branches; Main Pause/Resume applies to all branches and global Resume clears local pause flags.

Flow.stop(name)

print(Flow.stop("watch_enemy"))