dirigent-examples 0.18.4__tar.gz → 0.20.0__tar.gz

{dirigent_examples-0.18.4 → dirigent_examples-0.20.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: dirigent-examples
-Version: 0.18.4
+Version: 0.20.0
 Summary: The dirigent example corpus: the shelves of runnable documents, installed.
 License-Expression: LicenseRef-Proprietary
 License-File: LICENSE
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: dirigent-client==0.18.4
-Requires-Dist: dirigent-plugin==0.18.4
+Requires-Dist: dirigent-client==0.20.0
+Requires-Dist: dirigent-plugin==0.20.0
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 

{dirigent_examples-0.18.4 → dirigent_examples-0.20.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-examples"
-version = "0.18.4"
+version = "0.20.0"
 description = "The dirigent example corpus: the shelves of runnable documents, installed."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -11,8 +11,8 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-    "dirigent-client==0.18.4",
-    "dirigent-plugin==0.18.4",
+    "dirigent-client==0.20.0",
+    "dirigent-plugin==0.20.0",
 ]
 
 [project.entry-points."dirigent.plugins.v1"]

{dirigent_examples-0.18.4 → dirigent_examples-0.20.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-examples"
-version = "0.18.4"
+version = "0.20.0"
 description = "The dirigent example corpus: the shelves of runnable documents, installed."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -12,8 +12,8 @@ classifiers = [
 ]
 dependencies = [
     # The python/ shelf is SDK scripts a reader runs, so the corpus carries the client.
-    "dirigent-client==0.18.4",
-    "dirigent-plugin==0.18.4",
+    "dirigent-client==0.20.0",
+    "dirigent-plugin==0.20.0",
 ]
 
 [project.entry-points."dirigent.plugins.v1"]

{dirigent_examples-0.18.4 → dirigent_examples-0.20.0}/src/dirigent_examples/shelves/README.md

@@ -14,6 +14,7 @@ The documents live on topic shelves, each with its own README:
 | --- | --- |
 | [`graph/`](graph) | The shapes a DAG takes: lines, branches, fans, joins, and skips. |
 | [`patterns/`](patterns) | One engine behaviour per file: rules, retries, the two clocks, item policies, triggers, concurrency, and the reference language. |
+| [`playground/`](playground) | Documents that need something to happen: generated rows, a step that fails twice, a shape that drifts, a page to walk. |
 | [`failure/`](failure) | Retries, budgets, timeouts, tolerated failures, and the cleanup edge. |
 | [`transform/`](transform) | The reshaping verbs: jq programs and the `convert.std` codec, no allowlist anywhere. |
 | [`recipes/`](recipes) | One question per file: how to group, join, pivot, clean, convert, check, store, and call. |
@@ -62,14 +63,17 @@ is the list of what to create first.
 **The tiering rule.** `examples/` is what runs: every document there is runnable, though some
 need infrastructure whose setup their headers document -- the [`docker/`](docker) shelf needs a
 Docker socket or a daemon a connection names, [`queues/`](queues) needs the brokers
-`infra/compose.queues.yaml` starts, `sql-postgres-readonly.yaml` needs a PostgreSQL, and
-`s3-round-trip.yaml` needs an S3-compatible endpoint and a connection to it.
+`infra/compose.queues.yaml` starts, `sql-postgres-readonly.yaml` needs a PostgreSQL,
+`s3-round-trip.yaml` needs an S3-compatible endpoint and a connection to it, and the documents
+that make a real HTTP call need a `dg dev` to make it to.
 `preview/` is for what cannot run yet because the *code* does not exist: documents whose block
 ids belong to adapter packs nobody has written. A missing credential is not a preview; a
 missing package is.
 
-The HTTP examples call [Postman Echo](https://postman-echo.com), a public request-and-
-response service, so you can run any of them for real without standing anything up:
+Almost nothing here reaches the network. Where a document needs something to *happen* --
+rows to fan out over, a step that fails twice, a shape that drifts, a payload over the
+storage threshold -- it uses `playground.generate`, a node that generates it and reaches
+nothing at all. So you can run any of these for real without standing anything up:
 
 ```bash
 dg run --local examples/hello-world.yaml
@@ -110,9 +114,20 @@ dg apply examples/graph/linear.yaml
 dg run linear -p day=2026-01-01 --watch
 ```
 
+The documents that are *about* HTTP are the exception, and they call the playground routes a
+dirigent instance serves under `/api/v1/playground`, unauthenticated: the whole
+[`recipes/` HTTP section](recipes/README.md), the connection and webhook files on
+[`patterns/`](patterns), [`demo/requires.yaml`](demo/requires.yaml) and
+[`composition/chained-instances.yaml`](composition/chained-instances.yaml). A local run mounts
+no API of its own, so start an instance first and they reach that:
+
+```bash
+dg dev &
+dg run --local examples/recipes/http-get-with-query.yaml
+```
+
 The CI lane that walks these files never touches the network: it validates the documents
-and round-trips them, and the execution tests elsewhere use a mock transport. Postman Echo
-is for humans running the examples for real.
+and round-trips them, and the execution tests elsewhere use a mock transport.
 
 ## Engine patterns
 
@@ -143,7 +158,9 @@ they name credentials rather than carrying them, so the credential has to exist
 document is applied. On a server, create it once:
 
 ```bash
-dg connection create http postman-echo --set base_url=https://postman-echo.com
+dg connection create http playground \
+  --set base_url=http://127.0.0.1:3333/api/v1/playground \
+  --set basic_username=playground --set basic_password=playground
 ```
 
 A local run has no server to hold it, so it is handed the connection instead:
@@ -152,9 +169,9 @@ A local run has no server to hold it, so it is handed the connection instead:
 dg run --local examples/demo/requires.yaml --connections examples/connections.yaml
 ```
 
-[connections.yaml](connections.yaml) is that file. The basic-auth credentials in it are
-Postman's own public demo pair. `basic_password` is a `SecretStr`, so it is encrypted at
-rest and redacted in every API response.
+[connections.yaml](connections.yaml) is that file. The basic-auth credentials in it are the
+playground's own documented pair, which guards nothing. `basic_password` is a `SecretStr`, so
+it is encrypted at rest and redacted in every API response.
 
 ## Schemas
 
@@ -181,7 +198,9 @@ than while learning the format. Each file answers one question a person doing da
 actually asks -- how do I group and sum, how do I join two lists, which types survive a
 parquet round trip, where do credentials live -- in a complete pipeline whose header comment
 is the lesson. Nothing on the shelf needs infrastructure, a credential, or an allowlist
-entry: the data is inline, generated by a jq program, or fetched from Postman Echo.
+entry: the data is inline, generated by a jq program, or generated by `playground.generate`.
+The recipes under HTTP and webhooks call the instance's own playground, so those want a
+`dg dev` running.
 
 ```bash
 dg run --local examples/recipes/jq-group-by-and-sum.yaml
@@ -286,7 +305,7 @@ what a failure looks like, so the seeded one is deliberately mixed:
 | Documents refused | 18 | Nine in [docker/](docker) and two in [git/](git) name a compose or a build block the seed does not allowlist, some of them also a connection it does not create; four name a connection that does not exist, one of them (`warehouse-nobody-created`) built by the seed on purpose; one names a schema no instance here holds; and two require a pipeline or a target applied after them |
 | Schedules | 17, all paused | `--paused` is what stops seventeen clocks starting to fire at somebody who has not looked at them |
 | Runs | 3 succeeded, 1 with errors, 2 failed | `hello-world`, `transform/jq-reshape.yaml` and `triggers/cron-windowed.yaml` settle green; `optional-step.yaml` settles `completed_with_errors`, which is a third status rather than a shade of failed; `error-handler.yaml` fails by design, and `s3-round-trip.yaml` cannot reach an object store nobody started |
-| Connections | 10 healthy, 4 red | The ten that answer are `postman-echo` and the public endpoints the documents carry for their own standalone runs; `artifacts` points at `127.0.0.1:9000`, `work-db` at a database nobody started, and `orders-topic` and `shop-queue` at the two brokers in `infra/compose.queues.yaml`, where nothing is listening unless you started what their headers document |
+| Connections | 10 healthy, 4 red | The ten that answer are `playground` and the instance's own playground routes the documents carry for their own standalone runs; `artifacts` points at `127.0.0.1:9000`, `work-db` at a database nobody started, and `orders-topic` and `shop-queue` at the two brokers in `infra/compose.queues.yaml`, where nothing is listening unless you started what their headers document |
 
 The refusals are reported by code with the reason the instance gave, and the seeding carries
 on past each one -- a refusal is a thing to look at, not an error to fix.

{dirigent_examples-0.18.4 → dirigent_examples-0.20.0}/src/dirigent_examples/shelves/composition/chained-instances.yaml

@@ -18,9 +18,10 @@
 # The secret lives on the connection, never in this file: a document names a credential, it
 # does not carry one.
 #
-# The receiver here is Postman Echo, which reflects whatever it is posted, so this runs
-# against no instance at all and the reflected body shows what went on the wire, signature
-# header included:
+# The receiver here is this instance's own playground, which reflects whatever it is posted,
+# so this runs against one instance rather than two and the reflected body shows what went on
+# the wire, signature header included:
+#   dg dev &
 #   dg run --local examples/composition/chained-instances.yaml \
 #     --connections examples/connections.yaml -p day=2026-01-01
 #
@@ -40,7 +41,7 @@ requires:
     - http.request
     - webhook.post
   connections:
-    - postman-echo
+    - playground
 
 params:
   type: object
@@ -56,8 +57,8 @@ steps:
   produce:
     block: http.request
     config:
-      connection: postman-echo
-      path: /post
+      connection: playground
+      path: /request
       method: POST
       body:
         day: "${params.day}"
@@ -70,11 +71,11 @@ steps:
       max_attempts: 3
       backoff: 5s
     config:
-      connection: postman-echo
-      path: /post
+      connection: playground
+      path: /request
       # The receiving instance verifies the signature against the same secret, so a handoff
       # cannot be forged by anything that merely knows the URL.
-      sign_with: postman-echo
+      sign_with: playground
       # A receiver that queues the work answers 202, which is a success here even though the
       # work has not happened yet: the handoff is what this step is responsible for.
       success_status: [200, 201, 202]
@@ -83,14 +84,14 @@ steps:
       body:
         day: "${params.day}"
         upstream_run: "${run.id}"
-        rows: "${steps.produce.output.body.json.rows}"
+        rows: "${steps.produce.output.body.request.body.rows}"
 
   confirm:
     block: http.request
     depends_on: [hand_off]
     config:
-      connection: postman-echo
-      path: /post
+      connection: playground
+      path: /request
       method: POST
       body:
         handed_off_with_status: "${steps.hand_off.output.status}"

{dirigent_examples-0.18.4 → dirigent_examples-0.20.0}/src/dirigent_examples/shelves/composition/composition-child.yaml

@@ -20,7 +20,7 @@ code: composition-child
 name: The called pipeline
 description: Load one region's data for one day; callable on its own or by a parent pipeline.
 
-tags: [composition, http, storage]
+tags: [composition, playground, storage]
 
 params:
   type: object
@@ -37,13 +37,14 @@ params:
 
 steps:
   fetch:
-    block: http.request
+    block: playground.generate
     retry:
       max_attempts: 3
     config:
-      url: https://postman-echo.com/post
-      method: POST
-      body:
+      # Stands in for the region's source read. Seeded from the region's own name, so two
+      # children of the same parent load genuinely different rows.
+      rows: 10
+      input:
         region: "${params.region}"
         day: "${params.day}"
 
@@ -54,7 +55,7 @@ steps:
       # The child writes under its own run's scratch, so two children of the same parent
       # never write to the same place, whatever region they were given.
       target: "${run.scratch}/regions/${params.region}.json"
-      value: "${steps.fetch.output.body}"
+      value: "${steps.fetch.output.records}"
 
   archive:
     block: storage.copy

{dirigent_examples-0.18.4 → dirigent_examples-0.20.0}/src/dirigent_examples/shelves/connections.yaml

@@ -1,35 +1,38 @@
 # Connections for `dg run --local`, which has no instance to hold credentials.
 #
 # On a server these live encrypted in the database and are created once:
-#   dg connection create http postman-echo --set base_url=https://postman-echo.com
+#   dg connection create http playground \
+#     --set base_url=http://127.0.0.1:3333/api/v1/playground
 #
 # A local run has no server, so it is given them here instead, and they are sealed with
 # an ephemeral key that is thrown away with the throwaway database:
-#   dg run --local examples/graph/linear.yaml --connections examples/connections.yaml
+#   dg run --local examples/demo/requires.yaml --connections examples/connections.yaml
 #
-# The basic-auth credentials below are Postman's own public demo pair, documented at
-# https://postman-echo.com. basic_password is a SecretStr, so it is encrypted at rest and
-# redacted in every API response.
+# The playground is served by a dirigent instance under /api/v1/playground, unauthenticated,
+# so a document that needs a real HTTP hop calls its own instance and nothing else. Start one
+# with `dg dev` before running anything that names this connection. The basic-auth pair below
+# is the playground's own documented credential: it guards nothing, and basic_password is a
+# SecretStr, so it is encrypted at rest and redacted in every API response.
 #
 # hmac_secret is the shared secret webhook.post signs an outbound body with, and the one a
 # receiving instance declares its inbound webhook with. It is a SecretStr too.
 
 connections:
-  postman-echo:
+  playground:
     kind: http
     config:
       # A document names the connection and a path; the base URL lives here, so moving an
       # instance from staging to production edits the connection and no pipeline.
-      base_url: https://postman-echo.com
-      basic_username: postman
+      base_url: http://127.0.0.1:3333/api/v1/playground
+      basic_username: playground
       # Sealed on the way in and never read back out: an applied connection returns which
       # fields are set, never what they are set to.
-      basic_password: password
+      basic_password: playground
       hmac_secret: a shared secret between two dirigent instances
       timeout: 30s
       # What dg connection check calls. A connection with no health path can only be tested
       # by a real run.
-      health_path: /get
+      health_path: /request
 
   # The Kafka cluster infra/compose.queues.yaml brings up: one Redpanda node, unprotected,
   # on the port it advertises itself as. A cluster that authenticates writes security:

{dirigent_examples-0.18.4 → dirigent_examples-0.20.0}/src/dirigent_examples/shelves/demo/params-showcase.yaml

@@ -35,7 +35,7 @@ code: params-showcase
 name: Every parameter shape
 description: Everything a run form is built from, in one parameter schema.
 
-tags: [demo, http]
+tags: [demo, playground]
 
 params:
   type: object
@@ -72,21 +72,18 @@ params:
 
 steps:
   process:
-    block: http.request
+    block: playground.generate
     # The fan-out is over a parameter, so how wide the run is is decided when it starts
     # rather than when the document is written.
     for_each: "${params.regions}"
     items: continue
     config:
-      url: https://postman-echo.com/post
-      method: POST
-      query:
+      # Every resolved parameter, carried into the step's own output, so the run shows what
+      # the schema above actually produced. A whole reference keeps its type: batch_size
+      # arrives as a number and dry_run as a boolean.
+      input:
         day: "${params.day}"
         dataset: "${params.dataset}"
         region: "${item}"
         batch_size: "${params.batch_size}"
         dry_run: "${params.dry_run}"
-      body:
-        day: "${params.day}"
-        dataset: "${params.dataset}"
-        region: "${item}"

{dirigent_examples-0.18.4 → dirigent_examples-0.20.0}/src/dirigent_examples/shelves/demo/requires.yaml

@@ -9,10 +9,16 @@
 #
 # The connection carries the credentials, and the document carries only its name. Create it
 # once on a server:
-#   dg connection create http postman-echo --set base_url=https://postman-echo.com
+#   dg connection create http playground \
+#     --set base_url=http://127.0.0.1:3333/api/v1/playground \
+#     --set basic_username=playground --set basic_password=playground
 #
 # Or hand it to a local run, which has no server to hold it:
+#   dg dev &
 #   dg run --local examples/demo/requires.yaml --connections examples/connections.yaml
+#
+# The playground is served by a dirigent instance under /api/v1/playground, so the calls below
+# reach the instance `dg dev` started and nothing on the public internet.
 
 format: dirigent/v1
 kind: pipeline
@@ -28,7 +34,7 @@ requires:
     - storage.write
     - storage.copy
   connections:
-    - postman-echo
+    - playground
 
 steps:
   authenticate:
@@ -36,16 +42,16 @@ steps:
     config:
       # The connection holds the base URL and the credential, so the document names a path
       # and never a secret. What is stored is which connection, not what is in it.
-      connection: postman-echo
-      path: /basic-auth
+      connection: playground
+      path: /auth
       method: GET
 
   publish:
     block: http.request
     depends_on: [authenticate]
     config:
-      connection: postman-echo
-      path: /post
+      connection: playground
+      path: /request
       method: POST
       body:
         authenticated: "${steps.authenticate.output.status}"

{dirigent_examples-0.18.4 → dirigent_examples-0.20.0}/src/dirigent_examples/shelves/failure/error-handler.yaml

@@ -25,13 +25,15 @@
 # than one bad step.
 #
 # As written the load fails, so the notify branch runs and the success branch is skipped.
+# The load is a playground.generate step with `fail_until` set, which fails the attempts
+# inside that window on purpose, so the failing path is real and reaches nothing to fail at.
 #
 # This one uses shell.run, which executes code on the worker and is refused unless the
 # instance allowlists it: export DIRIGENT_ENABLED_UNSAFE_BLOCKS='["shell.run"]', or pass
 # --enable-unsafe shell.run to a local run.
 #
 #   dg run --local examples/failure/error-handler.yaml
-#   dg run --local examples/failure/error-handler.yaml -p status=200   # the other branch
+#   dg run --local examples/failure/error-handler.yaml -p fail_until=0   # the other branch
 
 format: dirigent/v1
 kind: pipeline
@@ -39,36 +41,39 @@ code: error-handler
 name: Handle a failing step
 description: Load a batch, alert on failure, and always release the lock afterwards.
 
-tags: [failure, execute, http, graph]
+tags: [failure, execute, playground, graph]
 
 params:
   type: object
   properties:
-    status:
+    fail_until:
       type: integer
-      description: The status the load endpoint is asked to return.
-      default: 500
+      description: How many of the load's attempts fail; 0 makes it succeed on the first.
+      default: 9
+      minimum: 0
+      maximum: 9
 
 steps:
   load_batch:
-    block: http.request
+    block: playground.generate
     retry:
       max_attempts: 2
       backoff: 1s
     config:
-      url: "https://postman-echo.com/status/${params.status}"
-      method: GET
+      # Both attempts are inside the failing window, so the budget is spent and the step
+      # settles failed. The failure is classified transient, which is what a budget buys.
+      fail_until: "${params.fail_until}"
+      rows: 3
+      seed: 4
 
   notify_failure:
-    block: http.request
+    block: playground.generate
     depends_on: [load_batch]
     # one_failed is what makes this a handler: it runs only on the path where the load
     # failed, and skips silently on the path where it did not.
     rule: one_failed
     config:
-      url: https://postman-echo.com/post
-      method: POST
-      body:
+      input:
         text: the nightly load failed
 
   publish_success:
@@ -79,11 +84,11 @@ steps:
       argv: [echo, "load succeeded"]
 
   release_lock:
-    block: http.request
+    block: playground.generate
     depends_on: [notify_failure, publish_success]
     # Exactly one of the two branches above runs and the other skips, so all_done is what
     # releases the lock either way. all_success would wait for a step that never runs.
     rule: all_done
     config:
-      url: https://postman-echo.com/delete
-      method: DELETE
+      input:
+        released: nightly-load

{dirigent_examples-0.18.4 → dirigent_examples-0.20.0}/src/dirigent_examples/shelves/failure/retries.yaml

@@ -10,36 +10,40 @@
 # A tolerated failure reads as succeeded to its dependents, so the branch carries on, while
 # the run itself reports completed_with_errors rather than succeeded.
 #
-# As written, publish hits a deliberate 503 three times over six seconds and then gives up,
-# which is what makes the retry visible. Pass a different status to watch the publish
-# succeed -- the optional cache still times out, so the run still ends completed_with_errors:
+# As written, publish fails three attempts over six seconds and then gives up, which is what
+# makes the retry visible. `fail_until` is how the playground node fails on cue: it reads the
+# attempt number the engine hands it and fails while that number is inside the window. Set it
+# to 0 to watch the publish succeed -- the optional cache still times out, so the run still
+# ends completed_with_errors:
 #
 # This one uses shell.run, which executes code on the worker and is refused unless the
 # instance allowlists it: export DIRIGENT_ENABLED_UNSAFE_BLOCKS='["shell.run"]', or pass
 # --enable-unsafe shell.run to a local run.
 #
-#   dg run --local examples/failure/retries.yaml              # completed_with_errors
-#   dg run --local examples/failure/retries.yaml -p status=200  # publish succeeds; completed_with_errors
+#   dg run --local examples/failure/retries.yaml                  # completed_with_errors
+#   dg run --local examples/failure/retries.yaml -p fail_until=0  # publish succeeds; completed_with_errors
 
 format: dirigent/v1
 kind: pipeline
 code: retries
 name: Retry behavior
-description: Publish to a service that refuses, then warm an optional cache that is slow.
+description: Publish through a step that refuses, then warm an optional cache that is slow.
 
-tags: [failure, execute, http, retry]
+tags: [failure, execute, playground, retry]
 
 params:
   type: object
   properties:
-    status:
+    fail_until:
       type: integer
-      description: The status the publish endpoint is asked to return.
-      default: 503
+      description: How many of the publish's attempts fail; 0 makes the first one land.
+      default: 9
+      minimum: 0
+      maximum: 9
 
 steps:
   publish:
-    block: http.request
+    block: playground.generate
     continue_on_failure: true
     retry:
       # 2s, then 4s, then give up: multiplier doubles the wait and max_backoff caps it, so a
@@ -51,22 +55,22 @@ steps:
       multiplier: 2.0
       jitter: 0.2
     config:
-      url: "https://postman-echo.com/status/${params.status}"
-      method: GET
+      fail_until: "${params.fail_until}"
+      rows: 12
+      seed: 8
 
   warm_cache:
-    block: http.request
+    block: playground.generate
     depends_on: [publish]
     continue_on_failure: true
-    # The endpoint sleeps five seconds and the timeout is one, so this fails on time rather
-    # than on the service: an optional step is not allowed to hold the run open.
+    # The step takes five seconds and the timeout is one, so this fails on time rather than
+    # on the work: an optional step is not allowed to hold the run open.
     timeout: 1s
     retry:
       max_attempts: 2
       backoff: 1s
     config:
-      url: https://postman-echo.com/delay/5
-      method: GET
+      delay: 5s
 
   finish:
     block: shell.run

{dirigent_examples-0.18.4 → dirigent_examples-0.20.0}/src/dirigent_examples/shelves/graph/README.md

@@ -2,7 +2,8 @@
 
 The shapes a DAG takes: a straight line, branches that split and join, a fan over a list,
 and a chain deep enough to watch the engine walk it. Every one runs with `dg run --local`,
-and the ones that call out use only Postman Echo.
+and none of them calls out at all: where a step has to do something it is
+`playground.generate`, a node that reaches nothing.
 
 ```bash
 dg run --local examples/graph/linear.yaml -p day=2026-01-01 --enable-unsafe shell.run

{dirigent_examples-0.18.4 → dirigent_examples-0.20.0}/src/dirigent_examples/shelves/graph/fan-in.yaml

@@ -11,7 +11,7 @@
 #      absent rather than null, so the list can be shorter than the input, and index 0 is
 #      the first item that worked rather than the first one asked for.
 #
-# The list can be indexed: ${steps.fetch.output.0.status} is the integer 200. Bear rule 3
+# The list can be indexed: ${steps.fetch.output.0.records} is the first item's rows. Bear rule 3
 # in mind before using it -- with one failure upstream, index 0 is a different dataset than
 # it was yesterday. Reading the whole list is the honest form.
 #
@@ -26,25 +26,25 @@
 # with rule: all_done is refused -- there is no stored output to read, and the attempt
 # settles as rejected rather than silently receiving an empty list.
 #
-# One block, used twice, and it runs no code on the worker, so this one needs no allowlist:
+# One block, used twice, and it reaches nothing at all, so this one runs offline:
 #
 #   dg run --local examples/graph/fan-in.yaml
 #   dg run --local examples/graph/fan-in.yaml -p datasets='["temperature","humidity"]'
 #
-# The latency point: four slow fetches cost four parked rows and nothing else. The engine
+# The latency point: four slow reads cost four parked rows and nothing else. The engine
 # is not holding four workers for the duration; it is holding four rows in the database.
 
 format: dirigent/v1
 kind: pipeline
 code: fan-in
 name: Branches that join
-description: Fetch several datasets in parallel, then send the whole batch on in one call.
+description: Read several datasets in parallel, then hand the whole batch on in one step.
 
-tags: [graph, http]
+tags: [graph, playground]
 
 requires:
   blocks:
-    - http.request
+    - playground.generate
 
 params:
   type: object
@@ -57,24 +57,30 @@ params:
 
 steps:
   fetch:
-    block: http.request
+    block: playground.generate
     for_each: "${params.datasets}"
     items: continue
     config:
-      url: https://postman-echo.com/get
-      method: GET
-      query:
-        dataset: "${item}"
+      # The element is the input, so each item's output carries its own dataset. A fan-in
+      # reads outputs and never elements, so anything an element knows has to be in there.
+      input: "${item}"
+      seed: 5
+      fields:
+        station: license_plate
+        celsius:
+          provider: pyfloat
+          args:
+            min_value: -10
+            max_value: 30
+            right_digits: 1
 
   report:
-    block: http.request
+    block: playground.generate
     depends_on: [fetch]
     config:
-      url: https://postman-echo.com/post
-      method: POST
-      body:
-        # A fan-out step's output is the list of its elements' outputs, in the order the
-        # elements were created, so one reference collects the whole fan and an index
-        # reaches one element of it.
+      # A fan-out step's output is the list of its elements' outputs, in the order the
+      # elements were created, so one reference collects the whole fan and an index
+      # reaches one element of it.
+      input:
         collected: "${steps.fetch.output}"
-        first_status: "${steps.fetch.output.0.status}"
+        first_dataset: "${steps.fetch.output.0.records.0.value}"