resonate-recursive-fan-out-pattern-rust

Spawn and aggregate durable child workflows with bounded concurrency in Rust.

6|Updated Jan 8, 2026
One-click install
npx skills add https://github.com/resonatehq/resonate-skills --skill resonate-recursive-fan-out-pattern-rust
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: resonate-recursive-fan-out-pattern-rust
Source: https://github.com/resonatehq/resonate-skills/tree/main/resonate-recursive-fan-out-pattern-rust
Command: npx skills add https://github.com/resonatehq/resonate-skills --skill resonate-recursive-fan-out-pattern-rust

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Enables robust parallel spawning and result aggregation for batch, tree, or crawl-style workloads where each child is an independent durable unit and parent processes must remain crash-safe and replayable.

Core Features & Use Cases

  • Parallel durable spawning: Fire N child invocations using ctx.run or ctx.rpc and collect their DurableFuture results.
  • Recursive traversal: Implement depth-limited tree or web crawling that spawns children of the same durable function.
  • Bounded concurrency & failure modes: Process in chunks to limit in-flight work and optionally tolerate partial failures when awaiting children.
  • Use Case: Enrich a large batch of order IDs in parallel, crawl a site to fixed depth, or implement map-reduce style workers with durable retries.

Quick Start

Fan out a list of order IDs in Rust using ctx.run or ctx.rpc to spawn parallel durable children, await their results, and return the aggregated list.

Frequently Asked Questions about resonate-recursive-fan-out-pattern-rust

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I fan out parallel tasks in Rust and aggregate the results durably?

You can fan out parallel durable children using ctx.run or ctx.rpc to spawn independent DurableFuture invocations, await their results, and return an aggregated list. This ensures crash-safe replayable batch processing.

What is a durable recursive fan-out pattern for web crawling or tree traversal?

A durable recursive fan-out pattern spawns child workflows of the same durable function to traverse trees or crawl sites to a fixed depth. Each child is an independent durable unit, preserving ordering and supporting bounded concurrency with chunking.

How do I limit concurrency when spawning many durable child workflows at once?

You limit concurrency by processing child invocations in chunks, bounding the number of in-flight DurableFuture tasks. This chunking mechanism prevents resource exhaustion during large batch processing or map-reduce workloads.

Can I tolerate partial failures when awaiting results from parallel durable tasks?

Yes, you can optionally tolerate partial failures when awaiting results from spawned child workflows. This allows the parent workflow to continue aggregating successfully completed durable units instead of failing the entire batch.

When should I use durable workflows for batch processing instead of standard async tasks?

Use durable workflows for batch processing when you need crash-safe replayable execution and independent retries for each unit. This is essential for enriching large batches of order IDs or map-reduce workloads where partial progress must survive failures.