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

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

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: dirigent-examples
-Version: 0.20.0
+Version: 0.22.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.20.0
-Requires-Dist: dirigent-plugin==0.20.0
+Requires-Dist: dirigent-client==0.22.0
+Requires-Dist: dirigent-plugin==0.22.0
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 

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

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-examples"
-version = "0.20.0"
+version = "0.22.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.20.0",
-    "dirigent-plugin==0.20.0",
+    "dirigent-client==0.22.0",
+    "dirigent-plugin==0.22.0",
 ]
 
 [project.entry-points."dirigent.plugins.v1"]

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

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-examples"
-version = "0.20.0"
+version = "0.22.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.20.0",
-    "dirigent-plugin==0.20.0",
+    "dirigent-client==0.22.0",
+    "dirigent-plugin==0.22.0",
 ]
 
 [project.entry-points."dirigent.plugins.v1"]

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

@@ -18,7 +18,7 @@ The documents live on topic shelves, each with its own README:
 | [`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. |
-| [`triggers/`](triggers) | What starts a run on its own: the three clocks, and the inbound webhook. |
+| [`triggers/`](triggers) | What starts a run on its own: the three clocks, the inbound webhook, and a watch on a sensor. |
 | [`sensors/`](sensors) | Steps that wait for the world: a drop landing, a clock window opening. |
 | [`queues/`](queues) | A run started by a message: a Kafka topic and a RabbitMQ queue, waited on as sensors. |
 | [`execute/`](execute) | Code on the worker: a shell step behind the allowlist. |

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

@@ -18,3 +18,4 @@ dg run --local examples/failure/retries.yaml
 | [step-timeout.yaml](step-timeout.yaml) | A timeout ends the attempt, and the policy decides whether another one starts. |
 | [optional-step.yaml](optional-step.yaml) | `completed_with_errors`: a step that may fail without failing the run, and the third status that says so. |
 | [error-handler.yaml](error-handler.yaml) | The cleanup edge: alert on failure, and always release the lock, however the load went. |
+| [fan-out-too-wide.yaml](fan-out-too-wide.yaml) | `fan_out_max_items`: a listing wider than one grid may be fails the fan-out as rejected, before any item is written. |

dirigent_examples-0.22.0/src/dirigent_examples/shelves/failure/fan-out-too-wide.yaml

@@ -0,0 +1,94 @@
+# A listing wider than the instance lets one grid be, refused before any item runs.
+#
+# Every fan-out grid is bounded by the instance setting fan_out_max_items, 10000 unless an
+# operator says otherwise. A grid fixed when the run is created is checked then, and a run
+# over the bound is refused outright. A grid read from a step's output can only be checked
+# when that output exists, so it is checked there: the step that would have fanned out fails
+# as rejected with run.fan_out_too_wide, naming how many items it would have been and the
+# bound, and nothing is written for any of them. rejected is never retried, because the same
+# list would be refused the same way.
+#
+# The bound is there because a grid is rows: every item is a run item and an attempt, written
+# in one transaction, and a listing that answers with a million entries by mistake should cost
+# one refused step rather than a million rows.
+#
+# Hop by hop:
+#
+#   pages     eleven pages of a listing, one item per page, each a thousand generated rows.
+#   flatten   the join: one list of every row, 11000 of them.
+#   each_row  a fan-out over that list. 11000 is over the 10000 the instance allows, so the
+#             step fails as rejected and nothing runs.
+#   notify    rule: one_failed, the error branch, which reads what went wrong.
+#
+# EXPECT THIS RUN TO END failed, in a few seconds, with `each_row` failed as
+# run.fan_out_too_wide and `notify` run.
+#
+# To change it: -p pages='[1,2,3,4,5]' lists 5000 rows, under the bound, and the fan-out
+# runs all 5000 of them, which takes a while.
+# DIRIGENT_FAN_OUT_MAX_ITEMS=100 lowers the bound for one instance instead, and even one page
+# is refused.
+#
+#   dg run --local examples/failure/fan-out-too-wide.yaml
+#   DIRIGENT_FAN_OUT_MAX_ITEMS=100 dg run --local examples/failure/fan-out-too-wide.yaml -p pages='[1]'
+
+format: dirigent/v1
+kind: pipeline
+code: fan-out-too-wide
+name: A fan-out too wide to write
+description: |
+  A `for_each` over a step's output that lists more than `fan_out_max_items` fails as
+  rejected with `run.fan_out_too_wide`, before a single item is written.
+
+  The error branch behind it still runs, and the run ends failed.
+
+tags: [failure, transform, fan-out, rules]
+
+requires:
+  blocks:
+    - playground.generate
+    - transform.jq
+
+params:
+  type: object
+  properties:
+    pages:
+      type: array
+      default: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+      minItems: 1
+      maxItems: 20
+      items:
+        type: integer
+      description: The thousand-row pages the listing has; eleven is over the default bound.
+
+steps:
+  pages:
+    block: playground.generate
+    for_each: ${params.pages}
+    config:
+      rows: 1000
+      seed: 1
+      fields:
+        code: uuid4
+
+  flatten:
+    block: transform.jq
+    depends_on: [pages]
+    config:
+      input: ${steps.pages.output}
+      program: '[.[].records[]]'
+
+  each_row:
+    block: transform.jq
+    depends_on: [flatten]
+    for_each: ${steps.flatten.output.value}
+    config:
+      input: ${item}
+      program: '.code'
+
+  notify:
+    block: transform.jq
+    depends_on: [each_row]
+    rule: one_failed
+    config:
+      input: {failed: each_row}
+      program: '"\(.failed) was refused: the listing was wider than the instance allows"'

{dirigent_examples-0.20.0 → dirigent_examples-0.22.0}/src/dirigent_examples/shelves/graph/fan-out.yaml

@@ -1,8 +1,8 @@
 # Fan-out: one step mapped over a list, with one run item per element.
 #
-# for_each is expanded when the run is created, so the item grid exists from the moment the
-# run is visible. It may read params, run, and item -- but not another step's output,
-# because the cardinality has to be known before anything executes.
+# This for_each reads params, so it is expanded when the run is created and the item grid
+# exists from the moment the run is visible. One that reads another step's output is written
+# when that step has settled instead; patterns/fan-out-over-an-output.yaml shows it.
 #
 # items: continue is the item policy: a region that fails does not stop the others, its
 # failure is recorded against its own run item, and the run reports completed_with_errors

{dirigent_examples-0.20.0 → dirigent_examples-0.22.0}/src/dirigent_examples/shelves/open-data/who-gho-indicators-to-parquet.yaml

@@ -6,10 +6,9 @@
 # in Dim1, and the number in NumericValue. The envelope is OData's; the rows inside it are what
 # anyone actually wants.
 #
-# What this shows, beyond the fetch: how a fan-out is read back. `for_each` is expanded when the
-# run is created, so it can read params, run and item -- and never another step's output. And a
-# fan-out step stores one output: the list of its items' outputs, in item order, with a failed
-# item absent from it. So there is no way for item three of one step to ask item three of another
+# What this shows, beyond the fetch: how a fan-out is read back. `for_each` here reads params,
+# so the grid is fixed when the run is created. And a fan-out step stores one output: the list
+# of its items' outputs, in item order, with a failed item absent from it. So there is no way for item three of one step to ask item three of another
 # what it produced; what a downstream step gets is the whole list at once. That is why the
 # flattening below is a single step over every envelope, and why the country is read out of
 # SpatialDim: the join key lives in the data, where a fan-in can see it.

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

@@ -65,6 +65,11 @@ One step definition, many run items.
 | [fan-out-then-join.yaml](fan-out-then-join.yaml) | The join, which is just a step with no `for_each` of its own | `succeeded` |
 | [fan-out-nested-objects.yaml](fan-out-nested-objects.yaml) | Elements that are objects, and `${item.limits.max_ms}` | `succeeded` |
 | [fan-out-item-wise.yaml](fan-out-item-wise.yaml) | A second fan-out over the same grid, and the item it pairs with | `succeeded` |
+| [fan-out-over-an-output.yaml](fan-out-over-an-output.yaml) | List, then fan out over what was listed: a grid written when its source succeeds | `succeeded` |
+| [fan-out-over-an-empty-listing.yaml](fan-out-over-an-empty-listing.yaml) | A listing that found nothing: the fan-out over it is skipped, and so is what needed it | `succeeded` |
+| [fan-out-over-a-nested-path.yaml](fan-out-over-a-nested-path.yaml) | A list four fields inside an output, reached with the dotted path | `succeeded` |
+| [fan-out-late-item-wise.yaml](fan-out-late-item-wise.yaml) | Adopting a listed grid, and `${steps.<name>.item.output}` over it | `succeeded` |
+| [fan-out-late-after-continue.yaml](fan-out-late-after-continue.yaml) | A late grid over a fan-out under `items: continue`: only the survivors | `completed_with_errors` |
 
 ## Parameters
 

{dirigent_examples-0.20.0 → dirigent_examples-0.22.0}/src/dirigent_examples/shelves/patterns/fan-out-item-wise.yaml

@@ -12,8 +12,8 @@
 #
 # Three things the pairing buys, and one it costs:
 #
-#   1. Cardinality is still fixed when the run is created. The grid comes from a step that was
-#      itself expanded then, so nothing here waits on execution to know how wide it is.
+#   1. The width is the adopted grid's. Here that grid comes from params, so it was fixed when
+#      the run was created; adopting a grid read from a step's output expands when that one does.
 #   2. The names must be a direct dependency: the adopted step goes in depends_on. Pairing
 #      across a step that is not waited for would read an item that has not run.
 #   3. Adoption chains. A third step may map over the second's items and still reach the

dirigent_examples-0.22.0/src/dirigent_examples/shelves/patterns/fan-out-late-after-continue.yaml

@@ -0,0 +1,77 @@
+# A fan-out whose failures were tolerated, feeding a fan-out over what it did produce.
+#
+# A fan-out step's output is the list of its items' outputs, and only the items that
+# succeeded are in it. So a late grid read from a fan-out under items: continue is exactly as
+# wide as the part of the batch that worked: the failed item is not a hole in the list, it is
+# absent from it, and the step after it never makes an item for it.
+#
+# The source has to be allowed to finish for this to happen. Under the default fail_fast one
+# failed item fails the whole step, and a fan-out behind it under all_success is skipped,
+# with nothing expanded. Under continue the source succeeds while one item did, and the run
+# ends completed_with_errors to say that something was tolerated.
+#
+# Hop by hop:
+#
+#   probe    one item per station. Each element says how many attempts its station fails;
+#            lighthouse fails one, and the default policy gives a step a single attempt, so
+#            that item fails and the other two succeed.
+#   publish  a fan-out over probe's output. Two stations succeeded, so it has two items;
+#            the one that failed is not in the list, so there is no item for it at all.
+#   tally    the join: how many were published, which is two.
+#
+# EXPECT THIS RUN TO END completed_with_errors, with one failed item under `probe`, two items
+# under `publish`, and a tally of two.
+#
+# To change it: set lighthouse's fail to 0 and every station gets through, `publish` has
+# three items, and the run succeeds.
+#
+#   dg run --local examples/patterns/fan-out-late-after-continue.yaml
+
+format: dirigent/v1
+kind: pipeline
+code: fan-out-late-after-continue
+name: A late grid over what survived
+description: |
+  A late grid read from a fan-out under `items: continue` has one item per item that
+  succeeded; a failed item is absent from the list, so nothing is made for it.
+
+  The run ends completed_with_errors, which says a failure was tolerated.
+
+tags: [patterns, transform, fan-out, failure, references]
+
+requires:
+  blocks:
+    - playground.generate
+    - transform.jq
+
+steps:
+  probe:
+    block: playground.generate
+    for_each:
+      - {station: harbour, fail: 0}
+      - {station: lighthouse, fail: 1}
+      - {station: pier, fail: 0}
+    # One refusal does not stop the other stations, and the step still succeeds.
+    items: continue
+    config:
+      input: {station: "${item.station}"}
+      # playground.generate fails this many attempts before it succeeds, and rejected is a
+      # class no retry is spent on.
+      fail_until: ${item.fail}
+      fail_as: rejected
+
+  publish:
+    block: transform.jq
+    depends_on: [probe]
+    # probe's output is only its succeeded items' outputs, so this grid is the survivors.
+    for_each: ${steps.probe.output}
+    config:
+      input: ${item.records}
+      program: '.[0].station'
+
+  tally:
+    block: transform.jq
+    depends_on: [publish]
+    config:
+      input: ${steps.publish.output}
+      program: '{published: length, stations: [.[].value]}'

dirigent_examples-0.22.0/src/dirigent_examples/shelves/patterns/fan-out-late-item-wise.yaml

@@ -0,0 +1,94 @@
+# Two fan-outs over one listed grid: item three of the second reads item three of the first.
+#
+# fan-out-item-wise.yaml pairs two fan-outs over a grid that was fixed when the run was
+# created. This is the same pairing over a grid nobody knew the width of until a step had
+# listed it. `measure` fans out over what `stations` listed, and `label` adopts that grid with
+# for_each: ${steps.measure.items}, so each of its items reads its own match with
+# ${steps.measure.item.output} rather than the whole batch.
+#
+# An adopter of a late grid is late too. The run is created with both `measure` and `label`
+# waiting as one pending attempt each. `measure` expands when `stations` succeeds; `label`
+# expands when `measure` has settled, into the same number of items at the same indices, so
+# the pairing holds by position exactly as it does over a fixed grid.
+#
+# Hop by hop:
+#
+#   stations  the listing: three seeded stations.
+#   measure   one item per listed station, each adding a generated reading to its record.
+#   label     adopts measure's grid. ${item} is the same station measure had at that index,
+#             and ${steps.measure.item.output.records} is that item's own output -- one
+#             record, the station with its reading -- not the list of all three.
+#   board     the join: one line per station, in listing order.
+#
+# EXPECT THIS RUN TO SUCCEED at once, with three items under `measure`, three under `label`
+# at the same indices, and a board of three lines.
+#
+# To change it: -p stations=6 widens both grids together; they always match.
+#
+#   dg run --local examples/patterns/fan-out-late-item-wise.yaml
+#   dg run --local examples/patterns/fan-out-late-item-wise.yaml -p stations=6
+
+format: dirigent/v1
+kind: pipeline
+code: fan-out-late-item-wise
+name: One listed item to one item
+description: |
+  A step adopting a grid that was expanded from an output, `for_each: ${steps.<name>.items}`,
+  expands with the same indices once that grid has settled.
+
+  Each of its items reads its match with `${steps.<name>.item.output}`.
+
+tags: [patterns, transform, fan-out, references]
+
+requires:
+  blocks:
+    - playground.generate
+    - transform.jq
+
+params:
+  type: object
+  properties:
+    stations:
+      type: integer
+      default: 3
+      minimum: 1
+      maximum: 50
+      description: How many stations the listing finds, which is how wide both grids become.
+
+steps:
+  stations:
+    block: playground.generate
+    config:
+      rows: ${params.stations}
+      seed: 7
+      fields:
+        station: city
+
+  measure:
+    block: playground.generate
+    depends_on: [stations]
+    for_each: ${steps.stations.output.records}
+    config:
+      input: ${item}
+      fields:
+        celsius:
+          provider: pyint
+          args: {min_value: -20, max_value: 30}
+
+  label:
+    block: transform.jq
+    # The adopted step goes in depends_on: this grid is measure's, and it exists once measure
+    # has settled.
+    depends_on: [measure]
+    for_each: ${steps.measure.items}
+    config:
+      # The matching item's own output: one station, with its reading.
+      input: ${steps.measure.item.output.records}
+      program: '.[0] | "\(.station): \(.celsius) C"'
+
+  board:
+    block: transform.jq
+    depends_on: [label]
+    config:
+      input: ${steps.label.output}
+      program: '[.[].value]'

{dirigent_examples-0.20.0 → dirigent_examples-0.22.0}/src/dirigent_examples/shelves/patterns/fan-out-literal-list.yaml

@@ -7,12 +7,10 @@
 # ordinary run.
 #
 # What a fan-out actually is: one step definition, N run items, one attempt each, all of them
-# claimable at once. The item grid exists from the moment the run is visible, because
-# for_each is expanded when the run is CREATED. That has a consequence worth knowing before
-# you reach for it: for_each may read params, run, and another fan-out's grid as
-# ${steps.<step>.items}, but never a step's output, because the cardinality has to be known
-# before anything executes. A fan-out over a list fetched at run time is not expressible, and
-# that is deliberate rather than missing.
+# claimable at once. A literal list is expanded when the run is CREATED, so the item grid exists
+# from the moment the run is visible. A list fetched at run time is the other shape: a for_each
+# over ${steps.<step>.output.<field>} is written when that step has settled, and
+# fan-out-over-an-output.yaml is that on its own.
 #
 # Hop by hop:
 #

dirigent_examples-0.22.0/src/dirigent_examples/shelves/patterns/fan-out-over-a-nested-path.yaml

@@ -0,0 +1,83 @@
+# A fan-out over a list that sits deep inside another step's output.
+#
+# A real answer is rarely a bare list. It is an envelope -- a catalogue, a page of results, a
+# network with regions inside it -- and the list worth fanning out over is a few fields down.
+# `for_each` walks there with the same dotted path every reference uses: the output, then
+# each field in turn, until it reaches the list. Nothing has to reshape the envelope first.
+#
+# The path is read when `stations` has succeeded, so it is checked then too. A field the
+# output does not have fails `per_station` as rejected with reference.no_field, naming what
+# was there instead; a field that holds something other than a list fails it with
+# run.fan_out_not_a_list. Either way nothing is written and nothing runs.
+#
+# Hop by hop:
+#
+#   catalogue    a fixed envelope standing in for an API's answer: a network, its regions,
+#                and the stations of each region.
+#   per_station  one item per station of the northern region, read from four fields down.
+#                ${item} is one station object, so ${item.code} is its code.
+#   collected    the join: every station code, in the order the catalogue listed them.
+#
+# EXPECT THIS RUN TO SUCCEED at once, with three items under `per_station` and a join naming
+# st-101, st-102 and st-103.
+#
+# To change it: write `south` for `north` in the path and the fan-out is the southern
+# region's two stations; write `east`, which the catalogue does not have, and `per_station`
+# fails as rejected. A reference cannot hold another reference, so the path is written out.
+#
+#   dg run --local examples/patterns/fan-out-over-a-nested-path.yaml
+
+format: dirigent/v1
+kind: pipeline
+code: fan-out-over-a-nested-path
+name: Fan out over a nested path
+description: |
+  `for_each: ${steps.<name>.output.<field>.<field>...}` reaches a list several fields inside
+  an upstream step's output, so an envelope needs no reshaping before it is fanned out over.
+
+  A missing field fails the fan-out as rejected, with nothing run.
+
+tags: [patterns, transform, fan-out, references]
+
+requires:
+  blocks:
+    - value.const
+    - playground.generate
+    - transform.jq
+
+steps:
+  catalogue:
+    block: value.const
+    config:
+      value:
+        network:
+          name: Coastal network
+          regions:
+            north:
+              stations:
+                - {code: st-101, name: Harbour}
+                - {code: st-102, name: Lighthouse}
+                - {code: st-103, name: Pier}
+            south:
+              stations:
+                - {code: st-201, name: Dunes}
+                - {code: st-202, name: Estuary}
+
+  per_station:
+    block: playground.generate
+    depends_on: [catalogue]
+    # value.const answers under `value`, and the list is four fields inside that.
+    for_each: ${steps.catalogue.output.value.network.regions.north.stations}
+    config:
+      input: ${item}
+      fields:
+        celsius:
+          provider: pyint
+          args: {min_value: -5, max_value: 25}
+
+  collected:
+    block: transform.jq
+    depends_on: [per_station]
+    config:
+      input: ${steps.per_station.output}
+      program: '[.[].records[0].code]'

dirigent_examples-0.22.0/src/dirigent_examples/shelves/patterns/fan-out-over-an-empty-listing.yaml

@@ -0,0 +1,92 @@
+# A listing that came back empty, and the fan-out over it that therefore never runs.
+#
+# fan-out-over-an-output.yaml fans out over whatever a step listed. This is the same shape on
+# the day the listing finds nothing: `stations` succeeds with no records, so `read` has no
+# items to write. A late grid follows the rule every grid follows -- an empty list skips the
+# step -- and a skip is a real terminal outcome, so everything behind it under the default
+# all_success edge is skipped too.
+#
+# Nothing here failed. An empty listing is a quiet day, not an error, and the run ends
+# succeeded. `read` is skipped with a reason: its one attempt carries run.fan_out_empty and
+# says which step left the list empty.
+#
+# Hop by hop:
+#
+#   stations  the listing, asked for zero rows, so its `records` is [].
+#   read      one item per listed station, and there are none: skipped, with nothing written.
+#   summary   the join behind it, skipped because `read` was.
+#   report    rule: all_done, so it runs whatever happened above it; it reads the listing,
+#             which is the one thing that did happen, and says how many stations there were.
+#
+# EXPECT THIS RUN TO SUCCEED at once, with `read` and `summary` skipped and `report` saying
+# zero stations.
+#
+# To change it: -p stations=3 gives the listing something to find, and every step runs.
+#
+#   dg run --local examples/patterns/fan-out-over-an-empty-listing.yaml
+#   dg run --local examples/patterns/fan-out-over-an-empty-listing.yaml -p stations=3
+
+format: dirigent/v1
+kind: pipeline
+code: fan-out-over-an-empty-listing
+name: Fan out over an empty listing
+description: |
+  A `for_each` over a step's output that turns out to be an empty list skips the step, and
+  the skip carries down every `all_success` edge behind it.
+
+  The run still succeeds: an empty listing is a day with nothing to do.
+
+tags: [patterns, transform, fan-out, references, rules]
+
+requires:
+  blocks:
+    - playground.generate
+    - transform.jq
+
+params:
+  type: object
+  properties:
+    stations:
+      type: integer
+      default: 0
+      minimum: 0
+      maximum: 50
+      description: How many stations the listing finds; zero is the case this file is about.
+
+steps:
+  stations:
+    block: playground.generate
+    config:
+      rows: ${params.stations}
+      seed: 7
+      fields:
+        station: city
+
+  read:
+    block: playground.generate
+    depends_on: [stations]
+    # An empty list here writes no items, and a fan-out with none is skipped.
+    for_each: ${steps.stations.output.records}
+    config:
+      input: ${item}
+      fields:
+        celsius:
+          provider: pyint
+          args: {min_value: -20, max_value: 30}
+
+  summary:
+    block: transform.jq
+    depends_on: [read]
+    config:
+      input: ${steps.read.output}
+      program: 'length'
+
+  report:
+    block: transform.jq
+    depends_on: [summary]
+    # all_done runs once `summary` has settled, skipped included, which is what lets the run
+    # say what the empty day looked like.
+    rule: all_done
+    config:
+      input: ${steps.stations.output}
+      program: '{stations: .rows}'