@jarenjs/flow 0.67.0 → 0.72.2

package/README.md

@@ -139,7 +139,7 @@ const dag = compileDag({
   nodes: {
     rows:   { kind: 'input' },
     adults: { kind: 'query',
-      query: { $for: { r: '$[*]' }, $where: { $ge: ['$r.age', 18] }, $return: '$r' } },
+      query: [{ $for: { r: '$[*]' }, $where: { $ge: ['$r.age', 18] }, $return: '$r' }] },
     view:   { kind: 'jslt',
       stylesheet: [{ match: '$', body: ['ul', {},
         [{ $for: { p: '$[*]' }, $return: ['li', {}, '$p.name'] }]] }] },
@@ -155,6 +155,10 @@ const dag = compileDag({
 await dag.run(people);   // ['ul', {}, [['li', {}, 'ada'], …]] — a vnode, as JSON
 ```
 
+The query's outer array keeps `adults` an array for zero, one or many
+rows. Without it, the engine's one-result sequence becomes that row;
+the next node's `$[*]` would iterate its members instead of rows.
+
 Cycles, port rules and the exactly-one-output rule are **compile-time**
 rejections (JF0xxx with `docPath`); a `task` node's handler is resolved
 at compile too, and called as `handler({ with, input }, signal)` with
@@ -270,8 +274,10 @@ Every subpath a consumer can import, derived from the manifest by
 | Import | Kind | Declarations |
 |---|---|---|
 | `@jarenjs/flow` | JavaScript | declared |
+| `@jarenjs/flow/schemas/jaren-dag.authoring.schema.json` | schema | — |
 | `@jarenjs/flow/schemas/jaren-dag.draft-07.schema.json` | schema | — |
 | `@jarenjs/flow/schemas/jaren-dag.schema.json` | schema | — |
+| `@jarenjs/flow/schemas/jaren-fsm.authoring.schema.json` | schema | — |
 | `@jarenjs/flow/schemas/jaren-fsm.draft-07.schema.json` | schema | — |
 | `@jarenjs/flow/schemas/jaren-fsm.schema.json` | schema | — |
 | `@jarenjs/flow/package.json` | metadata | — |

package/docs/FLOW-FORMAT.md

@@ -261,7 +261,7 @@ extending it is a format revision, not an option.
   "nodes": {
     "rows": { "kind": "input" },
     "adults": { "kind": "query",
-      "query": { "$for": { "r": "$[*]" }, "$where": { "$ge": ["$r.age", 18] }, "$return": "$r" } },
+      "query": [{ "$for": { "r": "$[*]" }, "$where": { "$ge": ["$r.age", 18] }, "$return": "$r" }] },
     "names": { "kind": "jslt",
       "stylesheet": [{ "match": "$", "body": ["ul", {},
         [{ "$for": { "p": "$[*]" }, "$return": ["li", {}, "$p.name"] }]] }] },
@@ -312,7 +312,15 @@ A node's `$` is decided by its inbound edges:
 
 A delivery whose `select` yields the empty sequence delivers `null`; a
 `query`/`jslt` node whose own result is empty likewise yields `null` —
-`undefined` is not a JSON value and never flows through a graph.
+`undefined` is not a JSON value and never flows through a graph. The
+query engine's singleton rule also applies: one result is that value,
+while two or more results become an array. To deliver an array for every
+cardinality, wrap the query in an array constructor, as `adults.query`
+does above. Its downstream `$[*]` therefore always iterates rows. The
+stylesheet also collects its `li` children in an explicit array: zero,
+one and two adults yield respectively `["ul", {}, []]`,
+`["ul", {}, [["li", {}, "ada"]]]`, and
+`["ul", {}, [["li", {}, "ada"], ["li", {}, "lin"]]]` for those names.
 Values pass **by reference**: nodes and hosts MUST NOT mutate what
 they receive.
 
@@ -425,19 +433,21 @@ await dag.run(input, { runId: 'run-42' });
   runs twice after a crash is the caller's bug, bluntly. The
   mitigation is an idempotency key threaded through the node's
   `with` props and honoured by the effectful system itself.
-- Resuming under a DIFFERENT document than the one that saved is
-  undefined behaviour — keep the document stable with the run (the
-  `@jarenjs/db` queue stores it on the job row for exactly this
-  reason). Values recorded for node ids the current document does not
+- A standalone checkpoint store owns run identity: it must bind the run
+  id to the workflow, input and `taskVersions` before returning saved
+  values. `compileDag` validates the registry but cannot infer the
+  provenance of an arbitrary host store. Use the `@jarenjs/db` DAG job
+  runner for persisted identity comparison before node-value loading. Values recorded for node ids the current document does not
   declare (or no longer declares `checkpoint`) are ignored.
 
 ### §7.8 Declared task versions
 
 A checkpointed node's value is REPLAYED on a later run instead of being
 recomputed. That is sound only while the handler that produced it is the
-same handler. So a `task` node that declares `checkpoint: true` must also
-declare `version`: a non-empty string naming the identity of the
-implementation it depends on.
+same handler. Every `task` in a workflow containing any checkpoint must
+declare `version`: a nonblank string naming its implementation identity.
+This includes recomputed tasks: an upstream implementation can affect a
+downstream checkpoint even when its own result is never saved.
 
 ```jsonc
 { "kind": "task", "run": "summarise", "version": "2026-09-05", "checkpoint": true }
@@ -463,9 +473,13 @@ declared identity it depends on, keyed by node id and SORTED, so two
 compiles of the same document produce the same map — byte for byte —
 whatever order the declarations were written in. A handler that is itself
 a compiled workflow may expose its own `taskVersions`; those compose under
-the node's path (`outer`, `outer/inner`), so a composed run has one
+the node's path (`outer`, `outer/inner`), with each node-id segment escaped
+as JSON Pointer (`~` becomes `~0`, `/` becomes `~1`), so a composed run has one
 identity rather than two. Every task id is retained as an own member,
-including names inherited by ordinary JavaScript objects.
+including names inherited by ordinary JavaScript objects. Registry nested
+maps must contain nonblank string versions and valid escaped paths.
+A literal `outer/inner` node is `outer~1inner`, distinct from a nested
+`inner` task under `outer`.
 
 ```js
 compileDag(doc, { tasks: { summarise: { version: '2026-09-05', run: handler } } })

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jarenjs/flow",
   "private": false,
-  "version": "0.67.0",
+  "version": "0.72.2",
   "type": "module",
   "main": "./src/index.js",
   "types": "./dist/types/index.d.ts",
@@ -49,7 +49,7 @@
     "prepack": "npm run build:types"
   },
   "dependencies": {
-    "@jarenjs/core": "^0.67.0",
-    "@jarenjs/json": "^0.67.0"
+    "@jarenjs/core": "^0.72.2",
+    "@jarenjs/json": "^0.72.2"
   }
 }

package/schemas/jaren-dag.authoring.schema.json

@@ -0,0 +1,212 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://jarenjs.dev/schemas/jaren-dag/0.1/authoring",
+  "title": "Jaren dataflow graph 0.1 (authoring profile)",
+  "description": "Authoring profile of the canonical grammar: the document SHAPE only, with queryDocument, stylesheetDocument left open. Constrains decoding on small models, where the full grammar does not decode at all. It is deliberately WEAKER than the canonical schema - a document valid here may be nonsense - so the engine compiler is the gate that makes it safe, and generated documents must be compiled before use.",
+  "type": "object",
+  "required": [
+    "$dag",
+    "nodes",
+    "edges"
+  ],
+  "properties": {
+    "$dag": {
+      "description": "The dag format version; required.",
+      "const": "0.1"
+    },
+    "nodes": {
+      "description": "Node declarations, id to declaration. The id is what edges reference.",
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/$defs/node"
+      }
+    },
+    "edges": {
+      "description": "The wiring: data flows from a node's result to a consumer's input scope, in document order for port-object assembly.",
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/edge"
+      }
+    }
+  },
+  "$defs": {
+    "node": {
+      "anyOf": [
+        {
+          "description": "Yields the run's input value (null when absent). Accepts no inbound edge.",
+          "type": "object",
+          "properties": {
+            "kind": {
+              "const": "input"
+            },
+            "checkpoint": {
+              "type": "boolean",
+              "description": "Opt-in durable checkpointing (FLOW-FORMAT §7.6): asserts this node's output is JSON-serializable; recorded values are seeded on resume instead of re-evaluated."
+            }
+          },
+          "required": [
+            "kind"
+          ]
+        },
+        {
+          "description": "The run's result is this node's input scope value. Exactly one per document; no outbound edge.",
+          "type": "object",
+          "properties": {
+            "kind": {
+              "const": "output"
+            },
+            "checkpoint": {
+              "type": "boolean",
+              "description": "Opt-in durable checkpointing (FLOW-FORMAT §7.6): asserts this node's output is JSON-serializable; recorded values are seeded on resume instead of re-evaluated."
+            }
+          },
+          "required": [
+            "kind"
+          ]
+        },
+        {
+          "description": "Yields its literal value. Accepts no inbound edge.",
+          "type": "object",
+          "properties": {
+            "kind": {
+              "const": "const"
+            },
+            "value": {
+              "description": "Any JSON value, delivered by reference."
+            },
+            "checkpoint": {
+              "type": "boolean",
+              "description": "Opt-in durable checkpointing (FLOW-FORMAT §7.6): asserts this node's output is JSON-serializable; recorded values are seeded on resume instead of re-evaluated."
+            }
+          },
+          "required": [
+            "kind",
+            "value"
+          ]
+        },
+        {
+          "description": "A Jaren JSON Query evaluated with $ bound to the node's input scope; an empty result yields null.",
+          "type": "object",
+          "properties": {
+            "kind": {
+              "const": "query"
+            },
+            "query": {
+              "description": "The query document.",
+              "allOf": [
+                {
+                  "$ref": "#/$defs/queryDocument"
+                }
+              ]
+            },
+            "checkpoint": {
+              "type": "boolean",
+              "description": "Opt-in durable checkpointing (FLOW-FORMAT §7.6): asserts this node's output is JSON-serializable; recorded values are seeded on resume instead of re-evaluated."
+            }
+          },
+          "required": [
+            "kind",
+            "query"
+          ]
+        },
+        {
+          "description": "A JSLT stylesheet transforming the node's input scope; an empty result yields null.",
+          "type": "object",
+          "properties": {
+            "kind": {
+              "const": "jslt"
+            },
+            "stylesheet": {
+              "description": "The stylesheet document (bare rule array or envelope form).",
+              "allOf": [
+                {
+                  "$ref": "#/$defs/stylesheetDocument"
+                }
+              ]
+            },
+            "checkpoint": {
+              "type": "boolean",
+              "description": "Opt-in durable checkpointing (FLOW-FORMAT §7.6): asserts this node's output is JSON-serializable; recorded values are seeded on resume instead of re-evaluated."
+            }
+          },
+          "required": [
+            "kind",
+            "stylesheet"
+          ]
+        },
+        {
+          "description": "A registered async handler, called as handler({ with, input }, signal); the handler must honor the run's shared AbortSignal.",
+          "type": "object",
+          "properties": {
+            "kind": {
+              "const": "task"
+            },
+            "run": {
+              "description": "The compile-time registry handler name.",
+              "type": "string",
+              "minLength": 1
+            },
+            "version": {
+              "description": "Declared nonblank handler identity (FLOW-FORMAT section 7.8). The compiler requires it on every task in a workflow containing checkpoints, including recomputed tasks that can affect saved downstream results. The registry must supply the same token; identity is never derived from source.",
+              "type": "string",
+              "minLength": 1,
+              "pattern": "\\S"
+            },
+            "with": {
+              "description": "Handler props: a query resolved against the node's input scope (null when absent or empty).",
+              "allOf": [
+                {
+                  "$ref": "#/$defs/queryDocument"
+                }
+              ]
+            },
+            "checkpoint": {
+              "type": "boolean",
+              "description": "Opt-in durable checkpointing (FLOW-FORMAT §7.6): asserts this node's output is JSON-serializable; recorded values are seeded on resume instead of re-evaluated."
+            }
+          },
+          "required": [
+            "kind",
+            "run"
+          ]
+        }
+      ]
+    },
+    "edge": {
+      "type": "object",
+      "properties": {
+        "from": {
+          "description": "The producing node id.",
+          "type": "string"
+        },
+        "to": {
+          "description": "The consuming node id.",
+          "type": "string"
+        },
+        "port": {
+          "description": "Names this delivery in the consumer's input-scope object; when any inbound edge of a node is ported, all must be, uniquely.",
+          "type": "string",
+          "minLength": 1
+        },
+        "select": {
+          "description": "A query applied to the source value before delivery; an empty result delivers null.",
+          "allOf": [
+            {
+              "$ref": "#/$defs/queryDocument"
+            }
+          ]
+        }
+      },
+      "required": [
+        "from",
+        "to"
+      ]
+    },
+    "queryDocument": {
+      "description": "A Jaren query expression; validate against the full grammar and compile locally."
+    },
+    "stylesheetDocument": {
+      "description": "A JSLT stylesheet; validate and compile locally."
+    }
+  }
+}

package/schemas/jaren-dag.draft-07.schema.json

@@ -95,7 +95,7 @@
               "description": "The query document.",
               "allOf": [
                 {
-                  "$ref": "https://jarenjs.dev/schemas/jaren-query/0.1/draft-07"
+                  "$ref": "#/definitions/queryDocument"
                 }
               ]
             },
@@ -120,7 +120,7 @@
               "description": "The stylesheet document (bare rule array or envelope form).",
               "allOf": [
                 {
-                  "$ref": "https://jarenjs.dev/schemas/jaren-jslt/0.1/draft-07"
+                  "$ref": "#/definitions/stylesheetDocument"
                 }
               ]
             },
@@ -147,15 +147,16 @@
               "minLength": 1
             },
             "version": {
-              "description": "The declared identity of the handler implementation this node depends on (FLOW-FORMAT section 7.8). REQUIRED when checkpoint is true: a recorded value is replayed only while the handler that produced it is the same one, and that identity is declared, never derived from source. The registry must supply the same token.",
+              "description": "Declared nonblank handler identity (FLOW-FORMAT section 7.8). The compiler requires it on every task in a workflow containing checkpoints, including recomputed tasks that can affect saved downstream results. The registry must supply the same token; identity is never derived from source.",
               "type": "string",
-              "minLength": 1
+              "minLength": 1,
+              "pattern": "\\S"
             },
             "with": {
               "description": "Handler props: a query resolved against the node's input scope (null when absent or empty).",
               "allOf": [
                 {
-                  "$ref": "https://jarenjs.dev/schemas/jaren-query/0.1/draft-07"
+                  "$ref": "#/definitions/queryDocument"
                 }
               ]
             },
@@ -191,7 +192,7 @@
           "description": "A query applied to the source value before delivery; an empty result delivers null.",
           "allOf": [
             {
-              "$ref": "https://jarenjs.dev/schemas/jaren-query/0.1/draft-07"
+              "$ref": "#/definitions/queryDocument"
             }
           ]
         }
@@ -200,6 +201,12 @@
         "from",
         "to"
       ]
+    },
+    "queryDocument": {
+      "$ref": "https://jarenjs.dev/schemas/jaren-query/0.1/draft-07"
+    },
+    "stylesheetDocument": {
+      "$ref": "https://jarenjs.dev/schemas/jaren-jslt/0.1/draft-07"
     }
   }
 }

package/schemas/jaren-dag.schema.json

@@ -95,7 +95,7 @@
               "description": "The query document.",
               "allOf": [
                 {
-                  "$ref": "https://jarenjs.dev/schemas/jaren-query/0.1"
+                  "$ref": "#/$defs/queryDocument"
                 }
               ]
             },
@@ -120,7 +120,7 @@
               "description": "The stylesheet document (bare rule array or envelope form).",
               "allOf": [
                 {
-                  "$ref": "https://jarenjs.dev/schemas/jaren-jslt/0.1"
+                  "$ref": "#/$defs/stylesheetDocument"
                 }
               ]
             },
@@ -147,15 +147,16 @@
               "minLength": 1
             },
             "version": {
-              "description": "The declared identity of the handler implementation this node depends on (FLOW-FORMAT section 7.8). REQUIRED when checkpoint is true: a recorded value is replayed only while the handler that produced it is the same one, and that identity is declared, never derived from source. The registry must supply the same token.",
+              "description": "Declared nonblank handler identity (FLOW-FORMAT section 7.8). The compiler requires it on every task in a workflow containing checkpoints, including recomputed tasks that can affect saved downstream results. The registry must supply the same token; identity is never derived from source.",
               "type": "string",
-              "minLength": 1
+              "minLength": 1,
+              "pattern": "\\S"
             },
             "with": {
               "description": "Handler props: a query resolved against the node's input scope (null when absent or empty).",
               "allOf": [
                 {
-                  "$ref": "https://jarenjs.dev/schemas/jaren-query/0.1"
+                  "$ref": "#/$defs/queryDocument"
                 }
               ]
             },
@@ -191,7 +192,7 @@
           "description": "A query applied to the source value before delivery; an empty result delivers null.",
           "allOf": [
             {
-              "$ref": "https://jarenjs.dev/schemas/jaren-query/0.1"
+              "$ref": "#/$defs/queryDocument"
             }
           ]
         }
@@ -200,6 +201,12 @@
         "from",
         "to"
       ]
+    },
+    "queryDocument": {
+      "$ref": "https://jarenjs.dev/schemas/jaren-query/0.1"
+    },
+    "stylesheetDocument": {
+      "$ref": "https://jarenjs.dev/schemas/jaren-jslt/0.1"
     }
   }
 }

package/schemas/jaren-fsm.authoring.schema.json

@@ -0,0 +1,130 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://jarenjs.dev/schemas/jaren-fsm/0.1/authoring",
+  "title": "Jaren finite state machine 0.1 (authoring profile)",
+  "description": "Authoring profile of the canonical grammar: the document SHAPE only, with queryDocument left open. Constrains decoding on small models, where the full grammar does not decode at all. It is deliberately WEAKER than the canonical schema - a document valid here may be nonsense - so the engine compiler is the gate that makes it safe, and generated documents must be compiled before use.",
+  "type": "object",
+  "properties": {
+    "$fsm": {
+      "description": "The fsm format version; absent implies 0.1.",
+      "const": "0.1"
+    },
+    "initial": {
+      "description": "The id of the machine's initial state, or null when the document does not choose one (a session must then be started with an explicit state).",
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "states": {
+      "description": "Declared states, in document order. A string is shorthand for { id }.",
+      "type": "array",
+      "items": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "object",
+            "properties": {
+              "id": {
+                "description": "The state id transitions refer to.",
+                "type": "string"
+              },
+              "entry": {
+                "$ref": "#/$defs/effects"
+              },
+              "exit": {
+                "$ref": "#/$defs/effects"
+              },
+              "final": {
+                "description": "Marks a terminal state; a session reports done here.",
+                "type": "boolean"
+              }
+            },
+            "required": [
+              "id"
+            ]
+          }
+        ]
+      }
+    },
+    "transitions": {
+      "description": "The transition table. Document order IS the selection order: the first entry whose from-state, event (a null or absent event matches any name) and guard all match fires.",
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "from": {
+            "description": "The state this transition leaves.",
+            "type": "string"
+          },
+          "event": {
+            "description": "The event name this transition answers; null or absent matches any event (a wildcard). A transition never fires spontaneously.",
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "guard": {
+            "description": "A Jaren JSON Query document asserted by effective boolean value against the evaluation scope { state, event, payload, context }; null or absent means no guard. A plain string not starting with '$' is a literal and therefore always true — projection-produced display guards are vacuous by design.",
+            "anyOf": [
+              {
+                "type": "null"
+              },
+              {
+                "$ref": "#/$defs/queryDocument"
+              }
+            ]
+          },
+          "to": {
+            "description": "The state this transition enters.",
+            "type": "string"
+          },
+          "effects": {
+            "$ref": "#/$defs/effects"
+          }
+        },
+        "required": [
+          "from",
+          "to"
+        ]
+      }
+    }
+  },
+  "required": [
+    "initial",
+    "states",
+    "transitions"
+  ],
+  "$defs": {
+    "effects": {
+      "description": "Effect descriptors, returned as resolved data when their state or transition fires — the engine never executes them.",
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "run": {
+            "description": "The host-registered handler name.",
+            "type": "string",
+            "minLength": 1
+          },
+          "with": {
+            "description": "Handler props: a Jaren JSON Query document evaluated against the scope at fire time; an empty result omits the member.",
+            "allOf": [
+              {
+                "$ref": "#/$defs/queryDocument"
+              }
+            ]
+          }
+        },
+        "required": [
+          "run"
+        ]
+      }
+    },
+    "queryDocument": {
+      "description": "A Jaren query expression; validate against the full grammar and compile locally."
+    }
+  }
+}

package/schemas/jaren-fsm.draft-07.schema.json

@@ -73,7 +73,7 @@
                 "type": "null"
               },
               {
-                "$ref": "https://jarenjs.dev/schemas/jaren-query/0.1/draft-07"
+                "$ref": "#/definitions/queryDocument"
               }
             ]
           },
@@ -113,7 +113,7 @@
             "description": "Handler props: a Jaren JSON Query document evaluated against the scope at fire time; an empty result omits the member.",
             "allOf": [
               {
-                "$ref": "https://jarenjs.dev/schemas/jaren-query/0.1/draft-07"
+                "$ref": "#/definitions/queryDocument"
               }
             ]
           }
@@ -122,6 +122,9 @@
           "run"
         ]
       }
+    },
+    "queryDocument": {
+      "$ref": "https://jarenjs.dev/schemas/jaren-query/0.1/draft-07"
     }
   }
 }

package/schemas/jaren-fsm.schema.json

@@ -11,14 +11,19 @@
     },
     "initial": {
       "description": "The id of the machine's initial state, or null when the document does not choose one (a session must then be started with an explicit state).",
-      "type": ["string", "null"]
+      "type": [
+        "string",
+        "null"
+      ]
     },
     "states": {
       "description": "Declared states, in document order. A string is shorthand for { id }.",
       "type": "array",
       "items": {
         "anyOf": [
-          { "type": "string" },
+          {
+            "type": "string"
+          },
           {
             "type": "object",
             "properties": {
@@ -26,14 +31,20 @@
                 "description": "The state id transitions refer to.",
                 "type": "string"
               },
-              "entry": { "$ref": "#/$defs/effects" },
-              "exit": { "$ref": "#/$defs/effects" },
+              "entry": {
+                "$ref": "#/$defs/effects"
+              },
+              "exit": {
+                "$ref": "#/$defs/effects"
+              },
               "final": {
                 "description": "Marks a terminal state; a session reports done here.",
                 "type": "boolean"
               }
             },
-            "required": ["id"]
+            "required": [
+              "id"
+            ]
           }
         ]
       }
@@ -50,26 +61,42 @@
           },
           "event": {
             "description": "The event name this transition answers; null or absent matches any event (a wildcard). A transition never fires spontaneously.",
-            "type": ["string", "null"]
+            "type": [
+              "string",
+              "null"
+            ]
           },
           "guard": {
             "description": "A Jaren JSON Query document asserted by effective boolean value against the evaluation scope { state, event, payload, context }; null or absent means no guard. A plain string not starting with '$' is a literal and therefore always true — projection-produced display guards are vacuous by design.",
             "anyOf": [
-              { "type": "null" },
-              { "$ref": "https://jarenjs.dev/schemas/jaren-query/0.1" }
+              {
+                "type": "null"
+              },
+              {
+                "$ref": "#/$defs/queryDocument"
+              }
             ]
           },
           "to": {
             "description": "The state this transition enters.",
             "type": "string"
           },
-          "effects": { "$ref": "#/$defs/effects" }
+          "effects": {
+            "$ref": "#/$defs/effects"
+          }
         },
-        "required": ["from", "to"]
+        "required": [
+          "from",
+          "to"
+        ]
       }
     }
   },
-  "required": ["initial", "states", "transitions"],
+  "required": [
+    "initial",
+    "states",
+    "transitions"
+  ],
   "$defs": {
     "effects": {
       "description": "Effect descriptors, returned as resolved data when their state or transition fires — the engine never executes them.",
@@ -84,11 +111,20 @@
           },
           "with": {
             "description": "Handler props: a Jaren JSON Query document evaluated against the scope at fire time; an empty result omits the member.",
-            "allOf": [{ "$ref": "https://jarenjs.dev/schemas/jaren-query/0.1" }]
+            "allOf": [
+              {
+                "$ref": "#/$defs/queryDocument"
+              }
+            ]
           }
         },
-        "required": ["run"]
+        "required": [
+          "run"
+        ]
       }
+    },
+    "queryDocument": {
+      "$ref": "https://jarenjs.dev/schemas/jaren-query/0.1"
     }
   }
 }

package/src/dag.js

@@ -95,7 +95,7 @@ function normalizeTaskEntry(entry, name) {
       `compileDag: the registered handler '${name}' is not a function, nor { run, version }`);
   }
   if (entry.version !== undefined
-    && (typeof entry.version !== 'string' || entry.version === '')) {
+    && (typeof entry.version !== 'string' || entry.version.trim() === '')) {
     throw new TypeError(
       `compileDag: the registered handler '${name}' has a version that is not a non-empty string`);
   }
@@ -103,6 +103,10 @@ function normalizeTaskEntry(entry, name) {
     throw new TypeError(
       `compileDag: the registered handler '${name}' has a taskVersions that is not an object`);
   }
+  if (entry.taskVersions !== undefined && Object.entries(entry.taskVersions).some(([path, version]) =>
+    /~(?:[^01]|$)/.test(path) || typeof version !== 'string' || version.trim() === '')) {
+    throw new TypeError(`compileDag: the registered handler '${name}' has invalid taskVersions paths or versions`);
+  }
   return {
     run: entry.run,
     version: entry.version ?? null,
@@ -156,6 +160,7 @@ export function compileDag(doc, options) {
   /** @type {Map<string, any>} */
   const nodes = new Map();
   const order = Object.keys(doc.nodes);
+  const durable = order.some((id) => doc.nodes[id]?.checkpoint === true);
   for (const id of order) {
     const decl = doc.nodes[id];
     const base = `/nodes/${encodeJSONPointerSegment(id)}`;
@@ -202,7 +207,7 @@ export function compileDag(doc, options) {
             `task node '${id}' must carry a non-empty string "run"`, `${base}/run`);
         }
         if (decl.version !== undefined
-          && (typeof decl.version !== 'string' || decl.version === '')) {
+          && (typeof decl.version !== 'string' || decl.version.trim() === '')) {
           throw new FlowCompileError('JF0011',
             `task node '${id}' has a "version" member that is not a non-empty string`,
             `${base}/version`);
@@ -212,9 +217,9 @@ export function compileDag(doc, options) {
         // same implementation. That identity is declared, never derived:
         // hashing a closure's source would call a reformat a new task and
         // a changed dependency the same one
-        if (node.checkpoint && decl.version === undefined) {
+        if (durable && decl.version === undefined) {
           throw new FlowCompileError('JF0011',
-            `task node '${id}' declares checkpoint, so it must also declare a "version" — `
+            `task node '${id}' belongs to a workflow with checkpoints, so it must also declare a "version" — `
             + 'a checkpointed result is replayed only while the handler that produced it is '
             + 'the same one, and that identity has to be stated', `${base}/version`);
         }
@@ -461,6 +466,8 @@ export function compileDag(doc, options) {
         loaded = await checkpoint.load(runId);
       }
       catch (err) {
+        if (signal !== undefined && onAbort !== null)
+          signal.removeEventListener('abort', onAbort);
         const cause = asError(err);
         throw new FlowRuntimeError('JF2009',
           `the checkpoint store failed to load run '${runId}': ${cause.message}`,
@@ -631,10 +638,11 @@ export function compileDag(doc, options) {
   const versions = {};
   for (const node of nodes.values()) {
     if (node.kind !== 'task' || node.version === null) continue;
-    setObjectMember(versions, node.id, node.version);
+    const pathPrefix = encodeJSONPointerSegment(node.id);
+    setObjectMember(versions, pathPrefix, node.version);
     if (node.nestedVersions === null) continue;
     for (const [path, version] of Object.entries(node.nestedVersions)) {
-      setObjectMember(versions, `${node.id}/${path}`, version);
+      setObjectMember(versions, `${pathPrefix}/${path}`, version);
     }
   }
   const taskVersions = Object.freeze(Object.fromEntries(