/**
 * The blocks that run branches and join them: `parallel`, whose branches are
 * written in the file and all start at once, and `map`, one branch per item
 * of a list frozen when it starts, and written down.
 *
 * The join waits for every branch, and a failed one stays in the block's
 * output. Each branch opens a memory scope of its own, and in a `map` a
 * ledger of its own, so no two branches share a subagent or an obligation.
 * Under `fail-fast`, the first branch to fail cuts those in flight and skips
 * those not started, which end `cancelled`. With `copies: true`, each branch
 * runs in a copy of the tree, and `copies.ts` lands their patches: each copy
 * opened, and what landing it gave, is written down too, and a resume takes
 * back the copies the journal left open.
 */
import type { CheckedMapNode, CheckedParallelNode } from "../checked.ts";
import { type Visited } from "./ended.ts";
import type { Here, Walker } from "./walk.ts";
/** Every branch at once, its output an object of each as it ended, by branch name. */
export declare function visitParallel(walker: Walker, node: CheckedParallelNode, path: string, here: Here): Promise<Visited>;
/**
 * Its body once per item, `concurrency` at a time, its output a list in item
 * order. A list longer than `max:` fails the map before any item runs; it is
 * never cut short. A resumed map runs over the list it froze.
 */
export declare function visitMap(walker: Walker, node: CheckedMapNode, path: string, here: Here): Promise<Visited>;
//# sourceMappingURL=blocks.d.ts.map