yaml-flow 3.1.1 → 5.0.0

package/dist/index.cjs

@@ -1,13 +1,13 @@
 'use strict';
 
 var addFormats = require('ajv-formats');
-var fs = require('fs');
-var crypto$1 = require('crypto');
 var child_process = require('child_process');
+var jsonata2 = require('jsonata');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var addFormats__default = /*#__PURE__*/_interopDefault(addFormats);
+var jsonata2__default = /*#__PURE__*/_interopDefault(jsonata2);
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -6420,6 +6420,814 @@ var require_ajv = __commonJS({
   }
 });
 
+// node_modules/ajv/dist/vocabularies/dynamic/dynamicAnchor.js
+var require_dynamicAnchor = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/dynamicAnchor.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.dynamicAnchor = void 0;
+    var codegen_1 = require_codegen();
+    var names_1 = require_names();
+    var compile_1 = require_compile();
+    var ref_1 = require_ref();
+    var def = {
+      keyword: "$dynamicAnchor",
+      schemaType: "string",
+      code: (cxt) => dynamicAnchor(cxt, cxt.schema)
+    };
+    function dynamicAnchor(cxt, anchor) {
+      const { gen, it } = cxt;
+      it.schemaEnv.root.dynamicAnchors[anchor] = true;
+      const v = (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`;
+      const validate = it.errSchemaPath === "#" ? it.validateName : _getValidate(cxt);
+      gen.if((0, codegen_1._)`!${v}`, () => gen.assign(v, validate));
+    }
+    exports$1.dynamicAnchor = dynamicAnchor;
+    function _getValidate(cxt) {
+      const { schemaEnv, schema, self } = cxt.it;
+      const { root, baseId, localRefs, meta } = schemaEnv.root;
+      const { schemaId } = self.opts;
+      const sch = new compile_1.SchemaEnv({ schema, schemaId, root, baseId, localRefs, meta });
+      compile_1.compileSchema.call(self, sch);
+      return (0, ref_1.getValidate)(cxt, sch);
+    }
+    exports$1.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/dynamicRef.js
+var require_dynamicRef = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/dynamicRef.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.dynamicRef = void 0;
+    var codegen_1 = require_codegen();
+    var names_1 = require_names();
+    var ref_1 = require_ref();
+    var def = {
+      keyword: "$dynamicRef",
+      schemaType: "string",
+      code: (cxt) => dynamicRef(cxt, cxt.schema)
+    };
+    function dynamicRef(cxt, ref) {
+      const { gen, keyword, it } = cxt;
+      if (ref[0] !== "#")
+        throw new Error(`"${keyword}" only supports hash fragment reference`);
+      const anchor = ref.slice(1);
+      if (it.allErrors) {
+        _dynamicRef();
+      } else {
+        const valid = gen.let("valid", false);
+        _dynamicRef(valid);
+        cxt.ok(valid);
+      }
+      function _dynamicRef(valid) {
+        if (it.schemaEnv.root.dynamicAnchors[anchor]) {
+          const v = gen.let("_v", (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`);
+          gen.if(v, _callRef(v, valid), _callRef(it.validateName, valid));
+        } else {
+          _callRef(it.validateName, valid)();
+        }
+      }
+      function _callRef(validate, valid) {
+        return valid ? () => gen.block(() => {
+          (0, ref_1.callRef)(cxt, validate);
+          gen.let(valid, true);
+        }) : () => (0, ref_1.callRef)(cxt, validate);
+      }
+    }
+    exports$1.dynamicRef = dynamicRef;
+    exports$1.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/recursiveAnchor.js
+var require_recursiveAnchor = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/recursiveAnchor.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var dynamicAnchor_1 = require_dynamicAnchor();
+    var util_1 = require_util();
+    var def = {
+      keyword: "$recursiveAnchor",
+      schemaType: "boolean",
+      code(cxt) {
+        if (cxt.schema)
+          (0, dynamicAnchor_1.dynamicAnchor)(cxt, "");
+        else
+          (0, util_1.checkStrictMode)(cxt.it, "$recursiveAnchor: false is ignored");
+      }
+    };
+    exports$1.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/recursiveRef.js
+var require_recursiveRef = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/recursiveRef.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var dynamicRef_1 = require_dynamicRef();
+    var def = {
+      keyword: "$recursiveRef",
+      schemaType: "string",
+      code: (cxt) => (0, dynamicRef_1.dynamicRef)(cxt, cxt.schema)
+    };
+    exports$1.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/index.js
+var require_dynamic = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/index.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var dynamicAnchor_1 = require_dynamicAnchor();
+    var dynamicRef_1 = require_dynamicRef();
+    var recursiveAnchor_1 = require_recursiveAnchor();
+    var recursiveRef_1 = require_recursiveRef();
+    var dynamic = [dynamicAnchor_1.default, dynamicRef_1.default, recursiveAnchor_1.default, recursiveRef_1.default];
+    exports$1.default = dynamic;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/validation/dependentRequired.js
+var require_dependentRequired = __commonJS({
+  "node_modules/ajv/dist/vocabularies/validation/dependentRequired.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var dependencies_1 = require_dependencies();
+    var def = {
+      keyword: "dependentRequired",
+      type: "object",
+      schemaType: "object",
+      error: dependencies_1.error,
+      code: (cxt) => (0, dependencies_1.validatePropertyDeps)(cxt)
+    };
+    exports$1.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/applicator/dependentSchemas.js
+var require_dependentSchemas = __commonJS({
+  "node_modules/ajv/dist/vocabularies/applicator/dependentSchemas.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var dependencies_1 = require_dependencies();
+    var def = {
+      keyword: "dependentSchemas",
+      type: "object",
+      schemaType: "object",
+      code: (cxt) => (0, dependencies_1.validateSchemaDeps)(cxt)
+    };
+    exports$1.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/validation/limitContains.js
+var require_limitContains = __commonJS({
+  "node_modules/ajv/dist/vocabularies/validation/limitContains.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var util_1 = require_util();
+    var def = {
+      keyword: ["maxContains", "minContains"],
+      type: "array",
+      schemaType: "number",
+      code({ keyword, parentSchema, it }) {
+        if (parentSchema.contains === void 0) {
+          (0, util_1.checkStrictMode)(it, `"${keyword}" without "contains" is ignored`);
+        }
+      }
+    };
+    exports$1.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/next.js
+var require_next = __commonJS({
+  "node_modules/ajv/dist/vocabularies/next.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var dependentRequired_1 = require_dependentRequired();
+    var dependentSchemas_1 = require_dependentSchemas();
+    var limitContains_1 = require_limitContains();
+    var next2 = [dependentRequired_1.default, dependentSchemas_1.default, limitContains_1.default];
+    exports$1.default = next2;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.js
+var require_unevaluatedProperties = __commonJS({
+  "node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var codegen_1 = require_codegen();
+    var util_1 = require_util();
+    var names_1 = require_names();
+    var error = {
+      message: "must NOT have unevaluated properties",
+      params: ({ params }) => (0, codegen_1._)`{unevaluatedProperty: ${params.unevaluatedProperty}}`
+    };
+    var def = {
+      keyword: "unevaluatedProperties",
+      type: "object",
+      schemaType: ["boolean", "object"],
+      trackErrors: true,
+      error,
+      code(cxt) {
+        const { gen, schema, data, errsCount, it } = cxt;
+        if (!errsCount)
+          throw new Error("ajv implementation error");
+        const { allErrors, props } = it;
+        if (props instanceof codegen_1.Name) {
+          gen.if((0, codegen_1._)`${props} !== true`, () => gen.forIn("key", data, (key) => gen.if(unevaluatedDynamic(props, key), () => unevaluatedPropCode(key))));
+        } else if (props !== true) {
+          gen.forIn("key", data, (key) => props === void 0 ? unevaluatedPropCode(key) : gen.if(unevaluatedStatic(props, key), () => unevaluatedPropCode(key)));
+        }
+        it.props = true;
+        cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
+        function unevaluatedPropCode(key) {
+          if (schema === false) {
+            cxt.setParams({ unevaluatedProperty: key });
+            cxt.error();
+            if (!allErrors)
+              gen.break();
+            return;
+          }
+          if (!(0, util_1.alwaysValidSchema)(it, schema)) {
+            const valid = gen.name("valid");
+            cxt.subschema({
+              keyword: "unevaluatedProperties",
+              dataProp: key,
+              dataPropType: util_1.Type.Str
+            }, valid);
+            if (!allErrors)
+              gen.if((0, codegen_1.not)(valid), () => gen.break());
+          }
+        }
+        function unevaluatedDynamic(evaluatedProps, key) {
+          return (0, codegen_1._)`!${evaluatedProps} || !${evaluatedProps}[${key}]`;
+        }
+        function unevaluatedStatic(evaluatedProps, key) {
+          const ps = [];
+          for (const p in evaluatedProps) {
+            if (evaluatedProps[p] === true)
+              ps.push((0, codegen_1._)`${key} !== ${p}`);
+          }
+          return (0, codegen_1.and)(...ps);
+        }
+      }
+    };
+    exports$1.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.js
+var require_unevaluatedItems = __commonJS({
+  "node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var codegen_1 = require_codegen();
+    var util_1 = require_util();
+    var error = {
+      message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
+      params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
+    };
+    var def = {
+      keyword: "unevaluatedItems",
+      type: "array",
+      schemaType: ["boolean", "object"],
+      error,
+      code(cxt) {
+        const { gen, schema, data, it } = cxt;
+        const items = it.items || 0;
+        if (items === true)
+          return;
+        const len = gen.const("len", (0, codegen_1._)`${data}.length`);
+        if (schema === false) {
+          cxt.setParams({ len: items });
+          cxt.fail((0, codegen_1._)`${len} > ${items}`);
+        } else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
+          const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items}`);
+          gen.if((0, codegen_1.not)(valid), () => validateItems(valid, items));
+          cxt.ok(valid);
+        }
+        it.items = true;
+        function validateItems(valid, from) {
+          gen.forRange("i", from, len, (i) => {
+            cxt.subschema({ keyword: "unevaluatedItems", dataProp: i, dataPropType: util_1.Type.Num }, valid);
+            if (!it.allErrors)
+              gen.if((0, codegen_1.not)(valid), () => gen.break());
+          });
+        }
+      }
+    };
+    exports$1.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/unevaluated/index.js
+var require_unevaluated = __commonJS({
+  "node_modules/ajv/dist/vocabularies/unevaluated/index.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var unevaluatedProperties_1 = require_unevaluatedProperties();
+    var unevaluatedItems_1 = require_unevaluatedItems();
+    var unevaluated = [unevaluatedProperties_1.default, unevaluatedItems_1.default];
+    exports$1.default = unevaluated;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/draft2020.js
+var require_draft2020 = __commonJS({
+  "node_modules/ajv/dist/vocabularies/draft2020.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var core_1 = require_core2();
+    var validation_1 = require_validation();
+    var applicator_1 = require_applicator();
+    var dynamic_1 = require_dynamic();
+    var next_1 = require_next();
+    var unevaluated_1 = require_unevaluated();
+    var format_1 = require_format2();
+    var metadata_1 = require_metadata();
+    var draft2020Vocabularies = [
+      dynamic_1.default,
+      core_1.default,
+      validation_1.default,
+      (0, applicator_1.default)(true),
+      format_1.default,
+      metadata_1.metadataVocabulary,
+      metadata_1.contentVocabulary,
+      next_1.default,
+      unevaluated_1.default
+    ];
+    exports$1.default = draft2020Vocabularies;
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/schema.json
+var require_schema = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/schema.json"(exports$1, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/schema",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/core": true,
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true,
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+        "https://json-schema.org/draft/2020-12/vocab/validation": true,
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+        "https://json-schema.org/draft/2020-12/vocab/content": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Core and Validation specifications meta-schema",
+      allOf: [
+        { $ref: "meta/core" },
+        { $ref: "meta/applicator" },
+        { $ref: "meta/unevaluated" },
+        { $ref: "meta/validation" },
+        { $ref: "meta/meta-data" },
+        { $ref: "meta/format-annotation" },
+        { $ref: "meta/content" }
+      ],
+      type: ["object", "boolean"],
+      $comment: "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
+      properties: {
+        definitions: {
+          $comment: '"definitions" has been replaced by "$defs".',
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          deprecated: true,
+          default: {}
+        },
+        dependencies: {
+          $comment: '"dependencies" has been split and replaced by "dependentSchemas" and "dependentRequired" in order to serve their differing semantics.',
+          type: "object",
+          additionalProperties: {
+            anyOf: [{ $dynamicRef: "#meta" }, { $ref: "meta/validation#/$defs/stringArray" }]
+          },
+          deprecated: true,
+          default: {}
+        },
+        $recursiveAnchor: {
+          $comment: '"$recursiveAnchor" has been replaced by "$dynamicAnchor".',
+          $ref: "meta/core#/$defs/anchorString",
+          deprecated: true
+        },
+        $recursiveRef: {
+          $comment: '"$recursiveRef" has been replaced by "$dynamicRef".',
+          $ref: "meta/core#/$defs/uriReferenceString",
+          deprecated: true
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/applicator.json
+var require_applicator2 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/applicator.json"(exports$1, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/applicator",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Applicator vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        prefixItems: { $ref: "#/$defs/schemaArray" },
+        items: { $dynamicRef: "#meta" },
+        contains: { $dynamicRef: "#meta" },
+        additionalProperties: { $dynamicRef: "#meta" },
+        properties: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          default: {}
+        },
+        patternProperties: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          propertyNames: { format: "regex" },
+          default: {}
+        },
+        dependentSchemas: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          default: {}
+        },
+        propertyNames: { $dynamicRef: "#meta" },
+        if: { $dynamicRef: "#meta" },
+        then: { $dynamicRef: "#meta" },
+        else: { $dynamicRef: "#meta" },
+        allOf: { $ref: "#/$defs/schemaArray" },
+        anyOf: { $ref: "#/$defs/schemaArray" },
+        oneOf: { $ref: "#/$defs/schemaArray" },
+        not: { $dynamicRef: "#meta" }
+      },
+      $defs: {
+        schemaArray: {
+          type: "array",
+          minItems: 1,
+          items: { $dynamicRef: "#meta" }
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/unevaluated.json
+var require_unevaluated2 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/unevaluated.json"(exports$1, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/unevaluated",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Unevaluated applicator vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        unevaluatedItems: { $dynamicRef: "#meta" },
+        unevaluatedProperties: { $dynamicRef: "#meta" }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/content.json
+var require_content = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/content.json"(exports$1, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/content",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/content": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Content vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        contentEncoding: { type: "string" },
+        contentMediaType: { type: "string" },
+        contentSchema: { $dynamicRef: "#meta" }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/core.json
+var require_core3 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/core.json"(exports$1, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/core",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/core": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Core vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        $id: {
+          $ref: "#/$defs/uriReferenceString",
+          $comment: "Non-empty fragments not allowed.",
+          pattern: "^[^#]*#?$"
+        },
+        $schema: { $ref: "#/$defs/uriString" },
+        $ref: { $ref: "#/$defs/uriReferenceString" },
+        $anchor: { $ref: "#/$defs/anchorString" },
+        $dynamicRef: { $ref: "#/$defs/uriReferenceString" },
+        $dynamicAnchor: { $ref: "#/$defs/anchorString" },
+        $vocabulary: {
+          type: "object",
+          propertyNames: { $ref: "#/$defs/uriString" },
+          additionalProperties: {
+            type: "boolean"
+          }
+        },
+        $comment: {
+          type: "string"
+        },
+        $defs: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" }
+        }
+      },
+      $defs: {
+        anchorString: {
+          type: "string",
+          pattern: "^[A-Za-z_][-A-Za-z0-9._]*$"
+        },
+        uriString: {
+          type: "string",
+          format: "uri"
+        },
+        uriReferenceString: {
+          type: "string",
+          format: "uri-reference"
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/format-annotation.json
+var require_format_annotation = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/format-annotation.json"(exports$1, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/format-annotation",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Format vocabulary meta-schema for annotation results",
+      type: ["object", "boolean"],
+      properties: {
+        format: { type: "string" }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/meta-data.json
+var require_meta_data = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/meta-data.json"(exports$1, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/meta-data",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Meta-data vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        title: {
+          type: "string"
+        },
+        description: {
+          type: "string"
+        },
+        default: true,
+        deprecated: {
+          type: "boolean",
+          default: false
+        },
+        readOnly: {
+          type: "boolean",
+          default: false
+        },
+        writeOnly: {
+          type: "boolean",
+          default: false
+        },
+        examples: {
+          type: "array",
+          items: true
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json
+var require_validation2 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json"(exports$1, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/validation",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/validation": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Validation vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        type: {
+          anyOf: [
+            { $ref: "#/$defs/simpleTypes" },
+            {
+              type: "array",
+              items: { $ref: "#/$defs/simpleTypes" },
+              minItems: 1,
+              uniqueItems: true
+            }
+          ]
+        },
+        const: true,
+        enum: {
+          type: "array",
+          items: true
+        },
+        multipleOf: {
+          type: "number",
+          exclusiveMinimum: 0
+        },
+        maximum: {
+          type: "number"
+        },
+        exclusiveMaximum: {
+          type: "number"
+        },
+        minimum: {
+          type: "number"
+        },
+        exclusiveMinimum: {
+          type: "number"
+        },
+        maxLength: { $ref: "#/$defs/nonNegativeInteger" },
+        minLength: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
+        pattern: {
+          type: "string",
+          format: "regex"
+        },
+        maxItems: { $ref: "#/$defs/nonNegativeInteger" },
+        minItems: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
+        uniqueItems: {
+          type: "boolean",
+          default: false
+        },
+        maxContains: { $ref: "#/$defs/nonNegativeInteger" },
+        minContains: {
+          $ref: "#/$defs/nonNegativeInteger",
+          default: 1
+        },
+        maxProperties: { $ref: "#/$defs/nonNegativeInteger" },
+        minProperties: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
+        required: { $ref: "#/$defs/stringArray" },
+        dependentRequired: {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/$defs/stringArray"
+          }
+        }
+      },
+      $defs: {
+        nonNegativeInteger: {
+          type: "integer",
+          minimum: 0
+        },
+        nonNegativeIntegerDefault0: {
+          $ref: "#/$defs/nonNegativeInteger",
+          default: 0
+        },
+        simpleTypes: {
+          enum: ["array", "boolean", "integer", "null", "number", "object", "string"]
+        },
+        stringArray: {
+          type: "array",
+          items: { type: "string" },
+          uniqueItems: true,
+          default: []
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/index.js
+var require_json_schema_2020_12 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/index.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var metaSchema = require_schema();
+    var applicator = require_applicator2();
+    var unevaluated = require_unevaluated2();
+    var content = require_content();
+    var core = require_core3();
+    var format = require_format_annotation();
+    var metadata = require_meta_data();
+    var validation = require_validation2();
+    var META_SUPPORT_DATA = ["/properties"];
+    function addMetaSchema2020($data) {
+      [
+        metaSchema,
+        applicator,
+        unevaluated,
+        content,
+        core,
+        with$data(this, format),
+        metadata,
+        with$data(this, validation)
+      ].forEach((sch) => this.addMetaSchema(sch, void 0, false));
+      return this;
+      function with$data(ajv, sch) {
+        return $data ? ajv.$dataMetaSchema(sch, META_SUPPORT_DATA) : sch;
+      }
+    }
+    exports$1.default = addMetaSchema2020;
+  }
+});
+
+// node_modules/ajv/dist/2020.js
+var require__ = __commonJS({
+  "node_modules/ajv/dist/2020.js"(exports$1, module) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.MissingRefError = exports$1.ValidationError = exports$1.CodeGen = exports$1.Name = exports$1.nil = exports$1.stringify = exports$1.str = exports$1._ = exports$1.KeywordCxt = exports$1.Ajv2020 = void 0;
+    var core_1 = require_core();
+    var draft2020_1 = require_draft2020();
+    var discriminator_1 = require_discriminator();
+    var json_schema_2020_12_1 = require_json_schema_2020_12();
+    var META_SCHEMA_ID = "https://json-schema.org/draft/2020-12/schema";
+    var Ajv20202 = class extends core_1.default {
+      constructor(opts = {}) {
+        super({
+          ...opts,
+          dynamicRef: true,
+          next: true,
+          unevaluated: true
+        });
+      }
+      _addVocabularies() {
+        super._addVocabularies();
+        draft2020_1.default.forEach((v) => this.addVocabulary(v));
+        if (this.opts.discriminator)
+          this.addKeyword(discriminator_1.default);
+      }
+      _addDefaultMetaSchema() {
+        super._addDefaultMetaSchema();
+        const { $data, meta } = this.opts;
+        if (!meta)
+          return;
+        json_schema_2020_12_1.default.call(this, $data);
+        this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
+      }
+      defaultMeta() {
+        return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
+      }
+    };
+    exports$1.Ajv2020 = Ajv20202;
+    module.exports = exports$1 = Ajv20202;
+    module.exports.Ajv2020 = Ajv20202;
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.default = Ajv20202;
+    var validate_1 = require_validate();
+    Object.defineProperty(exports$1, "KeywordCxt", { enumerable: true, get: function() {
+      return validate_1.KeywordCxt;
+    } });
+    var codegen_1 = require_codegen();
+    Object.defineProperty(exports$1, "_", { enumerable: true, get: function() {
+      return codegen_1._;
+    } });
+    Object.defineProperty(exports$1, "str", { enumerable: true, get: function() {
+      return codegen_1.str;
+    } });
+    Object.defineProperty(exports$1, "stringify", { enumerable: true, get: function() {
+      return codegen_1.stringify;
+    } });
+    Object.defineProperty(exports$1, "nil", { enumerable: true, get: function() {
+      return codegen_1.nil;
+    } });
+    Object.defineProperty(exports$1, "Name", { enumerable: true, get: function() {
+      return codegen_1.Name;
+    } });
+    Object.defineProperty(exports$1, "CodeGen", { enumerable: true, get: function() {
+      return codegen_1.CodeGen;
+    } });
+    var validation_error_1 = require_validation_error();
+    Object.defineProperty(exports$1, "ValidationError", { enumerable: true, get: function() {
+      return validation_error_1.default;
+    } });
+    var ref_error_1 = require_ref_error();
+    Object.defineProperty(exports$1, "MissingRefError", { enumerable: true, get: function() {
+      return ref_error_1.default;
+    } });
+  }
+});
+
 // src/step-machine/reducer.ts
 function applyStepResult(flow, state, stepName, stepResult) {
   const stepConfig = flow.steps[stepName];
@@ -6445,7 +7253,7 @@ function applyStepResult(flow, state, stepName, stepResult) {
       };
     }
   }
-  const nextStep = stepConfig.transitions[stepResult.result];
+  const nextStep = stepConfig.failure_transitions?.[stepResult.result] ?? stepConfig.transitions[stepResult.result];
   if (!nextStep) {
     throw new Error(
       `No transition defined for result "${stepResult.result}" in step "${stepName}"`
@@ -6650,6 +7458,15 @@ var StepMachine = class {
           );
         }
       }
+      if (stepConfig.failure_transitions) {
+        for (const [result, target] of Object.entries(stepConfig.failure_transitions)) {
+          if (!steps[target] && !terminal_states[target]) {
+            throw new Error(
+              `Step "${stepName}" failure_transition "${result}" points to unknown step "${target}"`
+            );
+          }
+        }
+      }
     }
   }
   on(eventType, listener) {
@@ -6879,6 +7696,9 @@ function validateStepFlowConfig(flow) {
       if (!step.transitions || typeof step.transitions !== "object") {
         errors.push(`Step "${stepName}" must have a "transitions" object`);
       }
+      if (step.failure_transitions !== void 0 && typeof step.failure_transitions !== "object") {
+        errors.push(`Step "${stepName}" failure_transitions must be an object when provided`);
+      }
     }
   }
   if (!f.terminal_states || typeof f.terminal_states !== "object") {
@@ -6999,6 +7819,11 @@ var flow_schema_default = {
           additionalProperties: { type: "string" },
           minProperties: 1
         },
+        failure_transitions: {
+          type: "object",
+          description: "Mapping of failure-like results (e.g. failure, timeout) -> next step name",
+          additionalProperties: { type: "string" }
+        },
         retry: {
           $ref: "#/definitions/retry_config"
         },
@@ -7937,8 +8762,8 @@ function apply(state, event, graph) {
       return applyInjectTokens(state, event.tokens);
     case "agent-action":
       return applyAgentAction(state, event.action, graph, event.config);
-    case "task-creation":
-      return applyTaskCreation(state, event.taskName, event.taskConfig);
+    case "task-upsert":
+      return applyTaskUpsert(state, event.taskName, event.taskConfig);
     default:
       return state;
   }
@@ -7995,7 +8820,7 @@ function applyAgentAction(state, action, graph, config) {
       return state;
   }
 }
-function applyTaskCreation(state, taskName, taskConfig) {
+function applyTaskUpsert(state, taskName, taskConfig) {
   if (!taskName || !taskConfig || !Array.isArray(taskConfig.provides)) {
     return state;
   }
@@ -8003,7 +8828,7 @@ function applyTaskCreation(state, taskName, taskConfig) {
     ...state,
     tasks: {
       ...state.tasks,
-      [taskName]: createDefaultGraphEngineStore()
+      [taskName]: state.tasks[taskName] ?? createDefaultGraphEngineStore()
     },
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -9275,43 +10100,51 @@ function applyEvent(live, event) {
   if ("executionId" in event && event.executionId && event.executionId !== state.executionId) {
     return live;
   }
-  let newState;
   switch (event.type) {
+    // --- Execution state transitions ---
     case "task-started":
-      newState = applyTaskStart(state, event.taskName);
-      break;
+      return { config, state: applyTaskStart(state, event.taskName) };
     case "task-completed":
-      newState = applyTaskCompletion(state, config, event.taskName, event.result, event.dataHash, event.data);
-      break;
+      return { config, state: applyTaskCompletion(state, config, event.taskName, event.result, event.dataHash, event.data) };
     case "task-failed":
-      newState = applyTaskFailure(state, config, event.taskName, event.error);
-      break;
+      return { config, state: applyTaskFailure(state, config, event.taskName, event.error) };
     case "task-progress":
-      newState = applyTaskProgress(state, event.taskName, event.message, event.progress);
-      break;
+      return { config, state: applyTaskProgress(state, event.taskName, event.message, event.progress) };
     case "task-restart":
-      newState = applyTaskRestart(state, event.taskName);
-      break;
+      return { config, state: applyTaskRestart(state, event.taskName) };
     case "inject-tokens":
-      newState = {
-        ...state,
-        availableOutputs: [.../* @__PURE__ */ new Set([...state.availableOutputs, ...event.tokens])],
-        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      return {
+        config,
+        state: {
+          ...state,
+          availableOutputs: [.../* @__PURE__ */ new Set([...state.availableOutputs, ...event.tokens])],
+          lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+        }
       };
-      break;
     case "agent-action":
-      newState = applyAgentAction2(state, event.action);
-      break;
+      return { config, state: applyAgentAction2(state, event.action) };
+    // --- Structural mutations ---
+    case "task-upsert":
+      return addNode(live, event.taskName, event.taskConfig);
+    case "task-removal":
+      return removeNode(live, event.taskName);
+    case "node-requires-add":
+      return addRequires(live, event.nodeName, event.tokens);
+    case "node-requires-remove":
+      return removeRequires(live, event.nodeName, event.tokens);
+    case "node-provides-add":
+      return addProvides(live, event.nodeName, event.tokens);
+    case "node-provides-remove":
+      return removeProvides(live, event.nodeName, event.tokens);
     default:
       return live;
   }
-  return { config, state: newState };
 }
 function applyEvents(live, events) {
   return events.reduce((current, event) => applyEvent(current, event), live);
 }
 function addNode(live, name, taskConfig) {
-  if (live.config.tasks[name]) return live;
+  const exists = !!live.config.tasks[name];
   return {
     config: {
       ...live.config,
@@ -9319,7 +10152,10 @@ function addNode(live, name, taskConfig) {
     },
     state: {
       ...live.state,
-      tasks: { ...live.state.tasks, [name]: createDefaultGraphEngineStore3() },
+      tasks: {
+        ...live.state.tasks,
+        [name]: exists ? live.state.tasks[name] : createDefaultGraphEngineStore3()
+      },
       lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
     }
   };
@@ -10026,6 +10862,8 @@ function getDownstream(live, nodeName) {
   }));
   return { nodeName, nodes, tokens: [...tokenSet] };
 }
+
+// src/continuous-event-graph/journal.ts
 var MemoryJournal = class {
   buffer = [];
   append(event) {
@@ -10040,39 +10878,11 @@ var MemoryJournal = class {
     return this.buffer.length;
   }
 };
-var FileJournal = class {
-  constructor(path) {
-    this.path = path;
-    if (!fs.existsSync(path)) {
-      fs.writeFileSync(path, "", "utf-8");
-    }
-  }
-  path;
-  pending = 0;
-  append(event) {
-    fs.appendFileSync(this.path, JSON.stringify(event) + "\n", "utf-8");
-    this.pending++;
-  }
-  drain() {
-    const content = fs.readFileSync(this.path, "utf-8").trim();
-    fs.writeFileSync(this.path, "", "utf-8");
-    this.pending = 0;
-    if (!content) return [];
-    return content.split("\n").map((line) => JSON.parse(line));
-  }
-  get size() {
-    try {
-      const content = fs.readFileSync(this.path, "utf-8").trim();
-      if (!content) return 0;
-      return content.split("\n").length;
-    } catch {
-      return this.pending;
-    }
-  }
-};
+
+// src/continuous-event-graph/reactive.ts
 function computeDataHash(data) {
   const json = stableStringify(data);
-  return crypto$1.createHash("sha256").update(json).digest("hex").slice(0, 16);
+  return fnv1a64Hex(json);
 }
 function stableStringify(value) {
   if (value === null || value === void 0 || typeof value !== "object") {
@@ -10085,28 +10895,65 @@ function stableStringify(value) {
   const keys = Object.keys(obj).sort();
   return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
 }
+function fnv1a64Hex(input) {
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  const mod = 0xffffffffffffffffn;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= BigInt(input.charCodeAt(i));
+    hash = hash * prime & mod;
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+function base64UrlEncode(input) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(input, "utf8").toString("base64url");
+  }
+  if (typeof btoa === "function") {
+    const bytes = new TextEncoder().encode(input);
+    let binary = "";
+    for (const b of bytes) binary += String.fromCharCode(b);
+    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+  }
+  throw new Error("No base64 encoder available in this runtime");
+}
+function base64UrlDecode(input) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(input, "base64url").toString("utf8");
+  }
+  if (typeof atob === "function") {
+    const base64 = input.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+    const binary = atob(padded);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+    return new TextDecoder().decode(bytes);
+  }
+  throw new Error("No base64 decoder available in this runtime");
+}
 function encodeCallbackToken(taskName) {
   const payload = JSON.stringify({ t: taskName, n: Date.now().toString(36) + Math.random().toString(36).slice(2, 6) });
-  return Buffer.from(payload).toString("base64url");
+  return base64UrlEncode(payload);
 }
 function decodeCallbackToken(token) {
   try {
-    const payload = JSON.parse(Buffer.from(token, "base64url").toString());
+    const payload = JSON.parse(base64UrlDecode(token));
     if (typeof payload?.t === "string") return { taskName: payload.t };
     return null;
   } catch {
     return null;
   }
 }
-function createReactiveGraph(config, options, executionId) {
+function createReactiveGraph(configOrLive, options, executionId) {
   const {
     handlers: initialHandlers,
-    journal = new MemoryJournal(),
     onDrain
   } = options;
-  let live = createLiveGraph(config, executionId);
+  const inputQueue = new MemoryJournal();
+  let live = "state" in configOrLive && "config" in configOrLive ? configOrLive : createLiveGraph(configOrLive, executionId);
   let disposed = false;
   const handlers = new Map(Object.entries(initialHandlers));
+  const internalJournal = new MemoryJournal();
   let draining = false;
   let drainQueued = false;
   function drain() {
@@ -10126,7 +10973,9 @@ function createReactiveGraph(config, options, executionId) {
     }
   }
   function drainOnce() {
-    const events = journal.drain();
+    const internalEvents = internalJournal.drain();
+    const inputEvents = inputQueue.drain();
+    const events = [...internalEvents, ...inputEvents];
     if (events.length > 0) {
       live = applyEvents(live, events);
     }
@@ -10137,6 +10986,26 @@ function createReactiveGraph(config, options, executionId) {
     for (const taskName of result.eligible) {
       dispatchTask(taskName);
     }
+    for (const event of events) {
+      if (event.type === "task-progress") {
+        const { taskName, update } = event;
+        const taskConfig = live.config.tasks[taskName];
+        if (!taskConfig) continue;
+        const taskState = live.state.tasks[taskName];
+        if (!taskState || taskState.status !== "running") continue;
+        const callbackToken = encodeCallbackToken(taskName);
+        runPipeline(taskName, callbackToken, update).catch((error) => {
+          if (disposed) return;
+          internalJournal.append({
+            type: "task-failed",
+            taskName,
+            error: error.message ?? String(error),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          drain();
+        });
+      }
+    }
   }
   function resolveUpstreamState(taskName) {
     const taskConfig = live.config.tasks[taskName];
@@ -10158,7 +11027,7 @@ function createReactiveGraph(config, options, executionId) {
     }
     return state;
   }
-  async function runPipeline(taskName, callbackToken) {
+  async function runPipeline(taskName, callbackToken, update) {
     const taskConfig = live.config.tasks[taskName];
     const handlerNames = taskConfig.taskHandlers ?? [];
     const upstreamState = resolveUpstreamState(taskName);
@@ -10172,7 +11041,8 @@ function createReactiveGraph(config, options, executionId) {
         state: upstreamState,
         taskState: live.state.tasks[taskName],
         config: taskConfig,
-        callbackToken
+        callbackToken,
+        update
       };
       const status = await handler(input);
       if (status === "task-initiate-failure") {
@@ -10186,15 +11056,16 @@ function createReactiveGraph(config, options, executionId) {
     if (!handlerNames || handlerNames.length === 0) {
       return;
     }
-    journal.append({
+    internalJournal.append({
       type: "task-started",
       taskName,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
+    drain();
     const callbackToken = encodeCallbackToken(taskName);
     runPipeline(taskName, callbackToken).catch((error) => {
       if (disposed) return;
-      journal.append({
+      internalJournal.append({
         type: "task-failed",
         taskName,
         error: error.message ?? String(error),
@@ -10209,16 +11080,16 @@ function createReactiveGraph(config, options, executionId) {
       if (event.type === "task-completed" && event.data && !event.dataHash) {
         event = { ...event, dataHash: computeDataHash(event.data) };
       }
-      journal.append(event);
+      inputQueue.append(event);
       drain();
     },
     pushAll(events) {
       if (disposed) return;
       for (const event of events) {
         if (event.type === "task-completed" && event.data && !event.dataHash) {
-          journal.append({ ...event, dataHash: computeDataHash(event.data) });
+          inputQueue.append({ ...event, dataHash: computeDataHash(event.data) });
         } else {
-          journal.append(event);
+          inputQueue.append(event);
         }
       }
       drain();
@@ -10230,7 +11101,7 @@ function createReactiveGraph(config, options, executionId) {
       const { taskName } = decoded;
       if (!live.config.tasks[taskName]) return;
       if (errors && errors.length > 0) {
-        journal.append({
+        inputQueue.append({
           type: "task-failed",
           taskName,
           error: errors.join("; "),
@@ -10238,7 +11109,7 @@ function createReactiveGraph(config, options, executionId) {
         });
       } else {
         const dataHash = data && Object.keys(data).length > 0 ? computeDataHash(data) : void 0;
-        journal.append({
+        inputQueue.append({
           type: "task-completed",
           taskName,
           data,
@@ -10250,31 +11121,33 @@ function createReactiveGraph(config, options, executionId) {
     },
     addNode(name, taskConfig) {
       if (disposed) return;
-      live = addNode(live, name, taskConfig);
+      inputQueue.append({ type: "task-upsert", taskName: name, taskConfig, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
       drain();
     },
     removeNode(name) {
       if (disposed) return;
-      live = removeNode(live, name);
+      inputQueue.append({ type: "task-removal", taskName: name, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      drain();
     },
     addRequires(nodeName, tokens) {
       if (disposed) return;
-      live = addRequires(live, nodeName, tokens);
+      inputQueue.append({ type: "node-requires-add", nodeName, tokens, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
       drain();
     },
     removeRequires(nodeName, tokens) {
       if (disposed) return;
-      live = removeRequires(live, nodeName, tokens);
+      inputQueue.append({ type: "node-requires-remove", nodeName, tokens, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
       drain();
     },
     addProvides(nodeName, tokens) {
       if (disposed) return;
-      live = addProvides(live, nodeName, tokens);
+      inputQueue.append({ type: "node-provides-add", nodeName, tokens, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
       drain();
     },
     removeProvides(nodeName, tokens) {
       if (disposed) return;
-      live = removeProvides(live, nodeName, tokens);
+      inputQueue.append({ type: "node-provides-remove", nodeName, tokens, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      drain();
     },
     registerHandler(name, fn) {
       handlers.set(name, fn);
@@ -10285,7 +11158,7 @@ function createReactiveGraph(config, options, executionId) {
     retrigger(taskName) {
       if (disposed) return;
       if (!live.config.tasks[taskName]) return;
-      journal.append({
+      inputQueue.append({
         type: "task-restart",
         taskName,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -10296,7 +11169,7 @@ function createReactiveGraph(config, options, executionId) {
       if (disposed) return;
       for (const name of taskNames) {
         if (!live.config.tasks[name]) continue;
-        journal.append({
+        inputQueue.append({
           type: "task-restart",
           taskName: name,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
@@ -10304,6 +11177,9 @@ function createReactiveGraph(config, options, executionId) {
       }
       drain();
     },
+    snapshot() {
+      return snapshot(live);
+    },
     getState() {
       return live;
     },
@@ -10671,13 +11547,11 @@ function createNoopHandler(getResolve, staticData) {
 var live_cards_schema_default = {
   $schema: "http://json-schema.org/draft-07/schema#",
   $id: "https://nsreehari.github.io/boards/live-cards.schema.json",
-  title: "LiveCards Node Schema",
-  description: "Schema for Card and ExternalSource nodes in the LiveCards Board/Canvas engine",
   definitions: {
     bind_ref: {
-      description: "A state path reference, e.g. 'state.raw_quotes' or 'state.compute_vars.total'",
+      description: "A card data path reference, e.g. 'card_data.raw_quotes' or 'requires.upstream'",
       type: "string",
-      pattern: "^state\\."
+      pattern: "^(card_data|requires|fetched_sources|computed_values)(\\.|$)"
     },
     bind_or_literal: {
       description: "A literal value or a bind reference object",
@@ -10746,7 +11620,7 @@ var live_cards_schema_default = {
           ]
         },
         input: {
-          description: "state.path, literal, array of inputs, or nested compute_expr",
+          description: "card_data.path, literal, array of inputs, or nested compute_expr",
           oneOf: [
             { type: "string" },
             { type: "number" },
@@ -10770,38 +11644,43 @@ var live_cards_schema_default = {
         tags: { type: "array", items: { type: "string" } }
       }
     },
-    data: {
+    requires: {
+      type: "array",
+      items: { type: "string" },
+      description: "IDs of upstream nodes this node depends on"
+    },
+    provides: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["bindTo", "src"],
+        properties: {
+          bindTo: { type: "string", description: "Token name published downstream" },
+          src: { type: "string", description: "Path to read value from (card_data.*, requires.*, fetched_sources.*, computed_values.*)" }
+        }
+      },
+      description: "Explicit bindings exposing computed or card_data values downstream as named tokens"
+    },
+    compute_step: {
+      description: "A single ordered compute step: reads card_data.*/requires.*/computed_values.*, writes to computed_values[bindTo]",
       type: "object",
+      required: ["bindTo", "expr"],
       properties: {
-        requires: {
-          type: "array",
-          items: { type: "string" },
-          description: "IDs of upstream nodes this node depends on"
-        },
-        provides: {
-          type: "object",
-          description: "Subset of state exposed downstream. Keys are published names, values are bind refs.",
-          additionalProperties: { $ref: "#/definitions/bind_or_literal" }
-        }
+        bindTo: { type: "string", description: "Key in computed_values to write result" },
+        expr: { type: "string", description: "JSONata expression evaluated against { card_data, requires, fetched_sources, computed_values }" }
       }
     },
     source_def: {
+      description: "One source entry. The engine only cares about 'bindTo' (compute namespace key) and 'outputFile' (delivery signal). Every other property is yours \u2014 add whatever your task-executor needs: kind, url, headers, mailbox, channel, model, query, etc. The full object is passed verbatim as the --in JSON to the executor.",
       type: "object",
-      required: ["kind", "bindTo"],
+      required: ["bindTo"],
+      additionalProperties: true,
       properties: {
-        kind: { enum: ["api", "websocket", "static", "llm"] },
-        bindTo: { $ref: "#/definitions/bind_ref", description: "state path to write fetched data into" },
-        method: { enum: ["GET", "POST", "PUT", "DELETE"], default: "GET" },
-        url_template: { type: "string", description: "URL with {{var}} placeholders" },
-        headers: { type: "object", additionalProperties: { $ref: "#/definitions/bind_or_literal" } },
-        body_template: { type: "object", description: "Request body with {{var}} placeholders or bind refs" },
-        template_vars: {
-          type: "object",
-          additionalProperties: { $ref: "#/definitions/bind_or_literal" },
-          description: "Variables for url/body templates \u2014 static values or bind refs"
-        },
-        poll_interval: { type: "integer", minimum: 0, description: "Auto-refresh in seconds (0 = manual)" },
-        transform: { type: "string", description: "Dot-path to extract from response, e.g. 'data.items'" }
+        bindTo: { type: "string", description: "Key under fetched_sources.* available in compute expressions" },
+        outputFile: { type: "string", description: "Board-relative path the executor writes its JSON result to. Presence of this file signals delivery." },
+        optionalForCompletionGating: { type: "boolean", default: false, description: "When true this source does not gate card completion. Default false when absent, so sources are completion-gating by default." },
+        timeout: { type: "integer", minimum: 0, default: 12e4, description: "Executor/script timeout in ms. Default: 120 000 (2 min)." },
+        script: { type: "string", description: "Legacy direct-run: shell command executed when no .task-executor is registered. stdout is captured as the result." }
       }
     },
     render_element: {
@@ -10825,19 +11704,17 @@ var live_cards_schema_default = {
             "text",
             "markdown",
             "custom",
-            "file-upload",
-            "chat",
             "actions"
           ]
         },
         label: { type: "string", description: "Heading above this element" },
         className: { type: "string", description: "Bootstrap grid class, e.g. 'col-12 col-md-6'" },
-        visible: { type: "string", description: "state path \u2014 element shown only if truthy" },
+        visible: { type: "string", description: "card_data/requires/fetched_sources/computed_values path \u2014 element shown only if truthy" },
         data: {
           type: "object",
           properties: {
-            bind: { $ref: "#/definitions/bind_ref", description: "state path to read data from" },
-            writeTo: { $ref: "#/definitions/bind_ref", description: "state path for user input (form, filter, todo, notes)" },
+            bind: { $ref: "#/definitions/bind_ref", description: "card_data/requires/fetched_sources/computed_values path to read data from" },
+            writeTo: { $ref: "#/definitions/bind_ref", description: "card_data path for user input (form, filter, todo, notes)" },
             columns: { type: "array", items: { type: "string" }, description: "table: visible columns" },
             maxRows: { type: "integer", description: "table/list: max rows to display" },
             sortable: { type: "boolean", default: true, description: "table: enable click-to-sort" },
@@ -10870,7 +11747,7 @@ var live_cards_schema_default = {
                   label: { type: "string" },
                   style: { type: "string", description: "Bootstrap button variant, e.g. 'success', 'outline-danger'" },
                   size: { type: "string", default: "sm" },
-                  disabled: { oneOf: [{ type: "boolean" }, { type: "string", description: "state path \u2014 truthy = disabled" }] }
+                  disabled: { oneOf: [{ type: "boolean" }, { type: "string", description: "card_data/requires/fetched_sources/computed_values path \u2014 truthy = disabled" }] }
                 }
               }
             }
@@ -10919,69 +11796,118 @@ var live_cards_schema_default = {
       }
     }
   },
-  oneOf: [
-    {
-      title: "Card",
-      description: "A renderable card node with view elements",
+  title: "LiveCard",
+  description: "A unified card node. Behavior depends on which sections are present (sources, compute, view, etc.)",
+  type: "object",
+  required: ["id"],
+  additionalProperties: false,
+  properties: {
+    id: { type: "string" },
+    requires: { $ref: "#/definitions/requires" },
+    provides: { $ref: "#/definitions/provides" },
+    meta: { $ref: "#/definitions/meta" },
+    view: { $ref: "#/definitions/view" },
+    card_data: {
       type: "object",
-      required: ["id", "type", "view", "state"],
-      additionalProperties: false,
+      description: "Authored card data supplied in the card definition",
       properties: {
-        id: { type: "string" },
-        type: { const: "card" },
-        meta: { $ref: "#/definitions/meta" },
-        data: { $ref: "#/definitions/data" },
-        view: { $ref: "#/definitions/view" },
-        state: {
-          type: "object",
-          additionalProperties: true,
-          properties: {
-            status: { enum: ["fresh", "stale", "loading", "error"] },
-            lastRun: { type: "string", format: "date-time" },
-            error: { type: "string" }
+        files: {
+          type: "array",
+          description: "Optional uploaded-file metadata maintained by host handlers. Stored name is normalized and serial-prefixed (for example 001-my_file.pdf).",
+          items: {
+            type: "object",
+            required: ["name", "stored_name"],
+            properties: {
+              name: { type: "string", minLength: 1 },
+              stored_name: {
+                type: "string",
+                minLength: 5,
+                maxLength: 32,
+                pattern: "^[0-9]{3,}-[a-z0-9._-]+$"
+              },
+              size: {
+                oneOf: [
+                  { type: "integer", minimum: 0 },
+                  { type: "null" }
+                ]
+              },
+              mime_type: { type: "string" },
+              path: { type: "string", pattern: "^[^\\s]+/files/[0-9]{3,}-[a-z0-9._-]+$" },
+              uploaded_at: { type: "string", format: "date-time" }
+            },
+            additionalProperties: false
           }
-        },
-        compute: {
-          type: "object",
-          description: "Derived state: key = state path to write, value = compute_expr",
-          additionalProperties: { $ref: "#/definitions/compute_expr" }
         }
-      }
+      },
+      additionalProperties: true
     },
-    {
-      title: "ExternalSource",
-      description: "A data-only node that fetches from external systems (no view)",
-      type: "object",
-      required: ["id", "type", "source", "state"],
-      additionalProperties: false,
-      properties: {
-        id: { type: "string" },
-        type: { const: "source" },
-        meta: { $ref: "#/definitions/meta" },
-        data: { $ref: "#/definitions/data" },
-        source: { $ref: "#/definitions/source_def" },
-        state: {
-          type: "object",
-          additionalProperties: true,
-          properties: {
-            status: { enum: ["fresh", "stale", "loading", "error"] },
-            lastRun: { type: "string", format: "date-time" },
-            error: { type: "string" }
-          }
-        },
-        compute: {
-          type: "object",
-          description: "Derived state: key = state path to write, value = compute_expr",
-          additionalProperties: { $ref: "#/definitions/compute_expr" }
-        }
-      }
+    sources: {
+      type: "array",
+      description: "Source entries. Each entry is passed verbatim to the board's .task-executor (registered via init --task-executor) as the --in JSON file. The executor fetches/generates the data and writes JSON to --out. If no executor is registered, the built-in executor runs the entry's 'cli' command directly. Sources gate completion by default. Set optionalForCompletionGating: true for enrichment-only sources that should not block task-completed.",
+      items: { $ref: "#/definitions/source_def" }
+    },
+    compute: {
+      type: "array",
+      description: "Ordered array of compute steps. Each reads card_data.*/requires.*/fetched_sources.*/computed_values.* and writes to ephemeral computed_values[bindTo].",
+      items: { $ref: "#/definitions/compute_step" }
     }
-  ]
+  }
 };
 
 // src/card-compute/schema-validator.ts
 var import_ajv3 = __toESM(require_ajv());
 var _compiled3 = null;
+var NAMESPACE_REFERENCE_RE = /\b(card_data|requires|fetched_sources|computed_values|sources)\b/g;
+var ROOT_PATH_NAMESPACE_RE = /^\s*(card_data|requires|fetched_sources|computed_values|sources)(\.|$)/;
+function referencedNamespaces(expression) {
+  const namespaces = /* @__PURE__ */ new Set();
+  let match;
+  NAMESPACE_REFERENCE_RE.lastIndex = 0;
+  while ((match = NAMESPACE_REFERENCE_RE.exec(expression)) !== null) {
+    namespaces.add(match[1]);
+  }
+  return namespaces;
+}
+function parseRootPathNamespace(pathValue) {
+  const match = ROOT_PATH_NAMESPACE_RE.exec(pathValue);
+  return match ? match[1] : null;
+}
+function validateJsonataExprWithNamespaces(expr, path, allowedNamespaces, errors) {
+  try {
+    jsonata2__default.default(expr);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    errors.push(`${path}: invalid JSONata expression (${message})`);
+    return;
+  }
+  const usedNamespaces = referencedNamespaces(expr);
+  for (const namespace of usedNamespaces) {
+    if (!allowedNamespaces.has(namespace)) {
+      errors.push(`${path}: disallowed namespace "${namespace}" in expression`);
+    }
+  }
+}
+function walkViewPathReferences(value, path, errors) {
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => {
+      walkViewPathReferences(entry, `${path}/${index}`, errors);
+    });
+    return;
+  }
+  if (typeof value === "string") {
+    const rootNamespace = parseRootPathNamespace(value);
+    if (!rootNamespace) return;
+    if (!(/* @__PURE__ */ new Set(["card_data", "requires", "fetched_sources", "computed_values"])).has(rootNamespace)) {
+      errors.push(`${path}: disallowed namespace "${rootNamespace}" in view reference`);
+    }
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+  const record = value;
+  for (const [key, next2] of Object.entries(record)) {
+    walkViewPathReferences(next2, `${path}/${key}`, errors);
+  }
+}
 function getValidator3() {
   if (_compiled3) return _compiled3;
   const ajv = new import_ajv3.default({ allErrors: true });
@@ -10999,6 +11925,42 @@ function validateLiveCardSchema(node) {
   });
   return { ok: false, errors };
 }
+function validateLiveCardRuntimeExpressions(node) {
+  const errors = [];
+  if (!node || typeof node !== "object" || Array.isArray(node)) {
+    return { ok: true, errors: [] };
+  }
+  const asRecord = node;
+  const compute = asRecord.compute;
+  if (Array.isArray(compute)) {
+    compute.forEach((step, i) => {
+      if (!step || typeof step !== "object" || Array.isArray(step)) return;
+      const expr = step.expr;
+      if (typeof expr !== "string" || expr.trim().length === 0) return;
+      validateJsonataExprWithNamespaces(
+        expr,
+        `/compute/${i}/expr`,
+        /* @__PURE__ */ new Set(["card_data", "requires", "fetched_sources", "computed_values"]),
+        errors
+      );
+    });
+  }
+  const view = asRecord.view;
+  if (view && typeof view === "object" && !Array.isArray(view)) {
+    walkViewPathReferences(view, "/view", errors);
+  }
+  return { ok: errors.length === 0, errors };
+}
+function validateLiveCard(node) {
+  return validateLiveCardDefinition(node);
+}
+function validateLiveCardDefinition(node) {
+  const schema = validateLiveCardSchema(node);
+  if (!schema.ok) return schema;
+  const runtime = validateLiveCardRuntimeExpressions(node);
+  if (!runtime.ok) return { ok: false, errors: runtime.errors };
+  return { ok: true, errors: [] };
+}
 
 // src/card-compute/index.ts
 function deepGet(obj, path) {
@@ -11020,288 +11982,43 @@ function deepSet(obj, path, value) {
   }
   cur[parts[parts.length - 1]] = value;
 }
-var _fns = {};
-_fns.sum = (input, _e, opts) => {
-  const a = Array.isArray(input) ? input : [];
-  return opts.field ? a.reduce((s, r) => s + (Number(r[opts.field]) || 0), 0) : a.reduce((s, v) => s + (Number(v) || 0), 0);
-};
-_fns.avg = (input, _e, opts) => {
-  const s = _fns.sum(input, _e, opts);
-  const n = Array.isArray(input) ? input.length : 1;
-  return n ? s / n : 0;
-};
-_fns.min = (input, _e, opts) => {
-  const a = Array.isArray(input) ? input : [];
-  const vals = opts.field ? a.map((r) => Number(r[opts.field])) : a.map(Number);
-  return vals.length ? Math.min(...vals) : 0;
-};
-_fns.max = (input, _e, opts) => {
-  const a = Array.isArray(input) ? input : [];
-  const vals = opts.field ? a.map((r) => Number(r[opts.field])) : a.map(Number);
-  return vals.length ? Math.max(...vals) : 0;
-};
-_fns.count = (input) => Array.isArray(input) ? input.length : input != null ? 1 : 0;
-_fns.first = (input) => Array.isArray(input) ? input[0] : input;
-_fns.last = (input) => Array.isArray(input) ? input[input.length - 1] : input;
-_fns.add = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.reduce((s, v) => s + Number(v), 0);
-};
-_fns.sub = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 ? Number(a[0]) - Number(a[1]) : 0;
-};
-_fns.mul = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.reduce((s, v) => s * Number(v), 1);
-};
-_fns.div = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 && Number(a[1]) !== 0 ? Number(a[0]) / Number(a[1]) : 0;
-};
-_fns.round = (input, _e, opts) => {
-  const decimals = opts.decimals != null ? opts.decimals : 0;
-  const factor = Math.pow(10, decimals);
-  return Math.round(Number(input) * factor) / factor;
-};
-_fns.abs = (input) => Math.abs(Number(input));
-_fns.mod = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 ? Number(a[0]) % Number(a[1]) : 0;
-};
-_fns.gt = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 && Number(a[0]) > Number(a[1]);
-};
-_fns.gte = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 && Number(a[0]) >= Number(a[1]);
-};
-_fns.lt = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 && Number(a[0]) < Number(a[1]);
-};
-_fns.lte = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 && Number(a[0]) <= Number(a[1]);
-};
-_fns.eq = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 && a[0] === a[1];
-};
-_fns.neq = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 && a[0] !== a[1];
-};
-_fns.and = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.every(Boolean);
-};
-_fns.or = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.some(Boolean);
-};
-_fns.not = (input) => !input;
-_fns.concat = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.map((v) => v != null ? String(v) : "").join("");
-};
-_fns.upper = (input) => String(input || "").toUpperCase();
-_fns.lower = (input) => String(input || "").toLowerCase();
-_fns.template = (input, _e, opts) => {
-  let t = String(opts.format || "");
-  if (input && typeof input === "object" && !Array.isArray(input)) {
-    for (const k of Object.keys(input)) {
-      const v = input[k];
-      t = t.split("{{" + k + "}}").join(v != null ? String(v) : "");
-    }
-  }
-  return t;
-};
-_fns.join = (input, _e, opts) => {
-  const a = Array.isArray(input) ? input : [];
-  const sep = opts.separator != null ? String(opts.separator) : ", ";
-  return a.map((v) => v != null ? String(v) : "").join(sep);
-};
-_fns.split = (input, _e, opts) => {
-  const sep = opts.separator != null ? String(opts.separator) : ",";
-  return String(input || "").split(sep).map((s) => s.trim());
-};
-_fns.trim = (input) => String(input || "").trim();
-_fns.pluck = (input, _e, opts) => Array.isArray(input) ? input.map((r) => r[opts.field]) : [];
-_fns.filter = (input, _e, opts) => {
-  if (!Array.isArray(input)) return [];
-  if (opts.field) return input.filter((r) => !!r[opts.field]);
-  return input.filter(Boolean);
-};
-_fns.map = (input) => Array.isArray(input) ? input.slice() : [];
-_fns.sort = (input, _e, opts) => {
-  const a = Array.isArray(input) ? input.slice() : [];
-  const f = opts.field;
-  const dir = opts.direction === "desc" ? -1 : 1;
-  if (f) return a.sort((x, y) => x[f] > y[f] ? dir : x[f] < y[f] ? -dir : 0);
-  return a.sort((x, y) => x > y ? dir : x < y ? -dir : 0);
-};
-_fns.slice = (input, _e, opts) => Array.isArray(input) ? input.slice(opts.start || 0, opts.end) : input;
-_fns.flat = (input, _e, opts) => {
-  const depth = opts.depth != null ? opts.depth : 1;
-  return Array.isArray(input) ? input.flat(depth) : [input];
-};
-_fns.unique = (input) => {
-  if (!Array.isArray(input)) return [input];
-  const seen = /* @__PURE__ */ new Set();
-  return input.filter((v) => {
-    const key = typeof v === "object" ? JSON.stringify(v) : v;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-};
-_fns.group = (input, _e, opts) => {
-  const a = Array.isArray(input) ? input : [];
-  const g = {};
-  a.forEach((r) => {
-    const k = String(r[opts.field] || "");
-    if (!g[k]) g[k] = [];
-    g[k].push(r);
-  });
-  return g;
-};
-_fns.flatten_keys = (input) => {
-  if (!input || typeof input !== "object" || Array.isArray(input)) return [];
-  const result = [];
-  for (const k of Object.keys(input)) {
-    const vals = Array.isArray(input[k]) ? input[k] : [input[k]];
-    vals.forEach((v) => result.push({ key: k, value: v }));
-  }
-  return result;
-};
-_fns.entries = (input) => {
-  if (!input || typeof input !== "object" || Array.isArray(input)) return [];
-  return Object.keys(input).map((k) => ({ key: k, value: input[k] }));
-};
-_fns.from_entries = (input) => {
-  if (!Array.isArray(input)) return {};
-  const obj = {};
-  input.forEach((item) => {
-    if (item.key != null) obj[item.key] = item.value;
-  });
-  return obj;
-};
-_fns.length = (input) => {
-  if (Array.isArray(input)) return input.length;
-  if (typeof input === "string") return input.length;
-  if (input && typeof input === "object") return Object.keys(input).length;
-  return 0;
-};
-_fns.get = (input, _e, opts) => deepGet(input, opts.field || opts.path || "");
-_fns.default = (input, _e, opts) => input != null ? input : opts.value;
-_fns.coalesce = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] != null) return a[i];
-  }
-  return null;
-};
-_fns.now = () => (/* @__PURE__ */ new Date()).toISOString();
-_fns.diff_days = (input) => {
-  const a = Array.isArray(input) ? input : [];
-  return a.length >= 2 ? Math.floor((new Date(a[0]).getTime() - new Date(a[1]).getTime()) / 864e5) : 0;
-};
-_fns.format_date = (input, _e, opts) => {
-  try {
-    const d = new Date(input);
-    if (opts.format === "iso") return d.toISOString();
-    if (opts.format === "date") return d.toLocaleDateString();
-    if (opts.format === "time") return d.toLocaleTimeString();
-    return d.toLocaleDateString();
-  } catch {
-    return String(input);
-  }
-};
-_fns.parse_date = (input) => {
-  try {
-    return new Date(input).toISOString();
-  } catch {
-    return null;
-  }
-};
-_fns.to_number = (input) => Number(input) || 0;
-_fns.to_string = (input) => input != null ? String(input) : "";
-_fns.to_bool = (input) => !!input;
-_fns.type_of = (input) => Array.isArray(input) ? "array" : typeof input;
-_fns.is_null = (input) => input == null;
-_fns.is_empty = (input) => {
-  if (input == null) return true;
-  if (Array.isArray(input)) return input.length === 0;
-  if (typeof input === "string") return input.length === 0;
-  if (typeof input === "object") return Object.keys(input).length === 0;
-  return false;
-};
-var _customFns = {};
-function evalExpr(expr, node) {
-  if (expr == null) return expr;
-  if (typeof expr !== "object" || Array.isArray(expr)) return expr;
-  const e = expr;
-  if (!e.fn) return expr;
-  let input = e.input;
-  if (typeof input === "string" && input.startsWith("state.")) {
-    input = deepGet(node, input);
-  } else if (Array.isArray(input)) {
-    input = input.map((v) => {
-      if (typeof v === "string" && v.startsWith("state.")) return deepGet(node, v);
-      if (v && typeof v === "object" && v.fn) return evalExpr(v, node);
-      return v;
-    });
-  } else if (input && typeof input === "object" && input.fn) {
-    input = evalExpr(input, node);
-  }
-  if (e.fn === "if") {
-    const cond = evalExpr(e.cond, node);
-    if (cond) {
-      return e.then && typeof e.then === "object" && e.then.fn ? evalExpr(e.then, node) : e.then;
-    } else {
-      return e.else && typeof e.else === "object" && e.else.fn ? evalExpr(e.else, node) : e.else;
-    }
-  }
-  if (e.fn === "filter" && Array.isArray(input) && e.where) {
-    return input.filter((item) => {
-      const tmp = { state: { ...node.state, $: item } };
-      return evalExpr(e.where, tmp);
-    });
-  }
-  if (e.fn === "map" && Array.isArray(input) && e.apply) {
-    return input.map((item) => {
-      const tmp = { state: { ...node.state, $: item } };
-      return evalExpr(e.apply, tmp);
-    });
-  }
-  const fn = _customFns[e.fn] || _fns[e.fn];
-  if (!fn) {
-    console.warn('CardCompute: unknown function "' + e.fn + '"');
-    return void 0;
-  }
-  return fn(input, evalExpr, e);
-}
-function run(node) {
-  if (!node || !node.compute) return node;
-  if (!node.state) node.state = {};
-  for (const key of Object.keys(node.compute)) {
+async function run(node, options) {
+  if (!node?.compute?.length) return node;
+  if (!node.card_data) node.card_data = {};
+  node.computed_values = {};
+  node._sourcesData = options?.sourcesData ?? {};
+  const ctx = {
+    card_data: node.card_data,
+    requires: node.requires ?? {},
+    fetched_sources: node._sourcesData,
+    computed_values: node.computed_values
+  };
+  for (const step of node.compute) {
     try {
-      const val = evalExpr(node.compute[key], node);
-      deepSet(node.state, key, val);
+      const val = await jsonata2__default.default(step.expr).evaluate(ctx);
+      deepSet(node.computed_values, step.bindTo, val);
+      ctx.computed_values = node.computed_values;
     } catch (err) {
-      console.error(`CardCompute.run error on "${node.id || "?"}.${key}":`, err);
+      console.error(`CardCompute.run error on "${node.id ?? "?"}.${step.bindTo}":`, err);
     }
   }
   return node;
 }
+async function evalExpr(expr, node) {
+  const ctx = {
+    card_data: node.card_data ?? {},
+    requires: node.requires ?? {},
+    fetched_sources: node._sourcesData ?? {},
+    computed_values: node.computed_values ?? {}
+  };
+  return jsonata2__default.default(expr).evaluate(ctx);
+}
 function resolve(node, path) {
+  if (path.startsWith("fetched_sources.")) {
+    return deepGet(node._sourcesData ?? {}, path.slice("fetched_sources.".length));
+  }
   return deepGet(node, path);
 }
-function registerFunction(name, fn) {
-  _customFns[name] = fn;
-}
 var VALID_ELEMENT_KINDS = /* @__PURE__ */ new Set([
   "metric",
   "table",
@@ -11318,34 +12035,19 @@ var VALID_ELEMENT_KINDS = /* @__PURE__ */ new Set([
   "markdown",
   "custom"
 ]);
-var VALID_SOURCE_KINDS = /* @__PURE__ */ new Set(["api", "websocket", "static", "llm"]);
-var VALID_STATUSES = /* @__PURE__ */ new Set(["fresh", "stale", "loading", "error"]);
-var CARD_ALLOWED_KEYS = /* @__PURE__ */ new Set(["id", "type", "meta", "data", "view", "state", "compute"]);
-var SOURCE_ALLOWED_KEYS = /* @__PURE__ */ new Set(["id", "type", "meta", "data", "source", "state", "compute"]);
+var ALLOWED_KEYS = /* @__PURE__ */ new Set(["id", "meta", "requires", "provides", "view", "card_data", "compute", "sources"]);
 function validateNode(node) {
   const errors = [];
   if (!node || typeof node !== "object" || Array.isArray(node)) {
     return { ok: false, errors: ["Node must be a non-null object"] };
   }
   const n = node;
-  if (typeof n.id !== "string" || !n.id) {
-    errors.push("id: required, must be a non-empty string");
-  }
-  if (n.type !== "card" && n.type !== "source") {
-    errors.push('type: must be "card" or "source"');
-    return { ok: false, errors };
-  }
-  const allowed = n.type === "card" ? CARD_ALLOWED_KEYS : SOURCE_ALLOWED_KEYS;
+  if (typeof n.id !== "string" || !n.id) errors.push("id: required, must be a non-empty string");
   for (const key of Object.keys(n)) {
-    if (!allowed.has(key)) errors.push(`Unknown top-level key: "${key}"`);
+    if (!ALLOWED_KEYS.has(key)) errors.push(`Unknown top-level key: "${key}"`);
   }
-  if (n.state == null || typeof n.state !== "object" || Array.isArray(n.state)) {
-    errors.push("state: required, must be an object");
-  } else {
-    const state = n.state;
-    if (state.status != null && !VALID_STATUSES.has(state.status)) {
-      errors.push(`state.status: must be one of: ${[...VALID_STATUSES].join(", ")}`);
-    }
+  if (n.card_data == null || typeof n.card_data !== "object" || Array.isArray(n.card_data)) {
+    errors.push("card_data: required, must be an object");
   }
   if (n.meta != null) {
     if (typeof n.meta !== "object" || Array.isArray(n.meta)) {
@@ -11356,37 +12058,58 @@ function validateNode(node) {
       if (meta.tags != null && !Array.isArray(meta.tags)) errors.push("meta.tags: must be an array");
     }
   }
-  if (n.data != null) {
-    if (typeof n.data !== "object" || Array.isArray(n.data)) {
-      errors.push("data: must be an object");
+  if (n.requires != null && !Array.isArray(n.requires)) errors.push("requires: must be an array of strings");
+  if (n.provides != null) {
+    if (!Array.isArray(n.provides)) {
+      errors.push("provides: must be an array of { bindTo, src } bindings");
     } else {
-      const data = n.data;
-      if (data.requires != null && !Array.isArray(data.requires)) errors.push("data.requires: must be an array of strings");
-      if (data.provides != null && (typeof data.provides !== "object" || Array.isArray(data.provides))) errors.push("data.provides: must be an object");
+      n.provides.forEach((p, i) => {
+        if (!p || typeof p !== "object" || Array.isArray(p)) {
+          errors.push(`provides[${i}]: must be an object with bindTo and src`);
+        } else {
+          const b = p;
+          if (typeof b.bindTo !== "string" || !b.bindTo) errors.push(`provides[${i}]: missing required "bindTo" string`);
+          if (typeof b.src !== "string" || !b.src) errors.push(`provides[${i}]: missing required "src" string`);
+        }
+      });
     }
   }
   if (n.compute != null) {
-    if (typeof n.compute !== "object" || Array.isArray(n.compute)) {
-      errors.push("compute: must be an object");
+    if (!Array.isArray(n.compute)) {
+      errors.push("compute: must be an array of compute steps");
+    } else {
+      n.compute.forEach((step, i) => {
+        if (!step || typeof step !== "object" || Array.isArray(step)) {
+          errors.push(`compute[${i}]: must be a compute step object`);
+        } else {
+          const s = step;
+          if (typeof s.bindTo !== "string" || !s.bindTo) errors.push(`compute[${i}]: missing required "bindTo" property`);
+          if (typeof s.expr !== "string" || !s.expr) errors.push(`compute[${i}]: missing required "expr" string (JSONata expression)`);
+        }
+      });
+    }
+  }
+  if (n.sources != null) {
+    if (!Array.isArray(n.sources)) {
+      errors.push("sources: must be an array");
     } else {
-      for (const [key, expr] of Object.entries(n.compute)) {
-        if (!expr || typeof expr !== "object" || Array.isArray(expr)) {
-          errors.push(`compute.${key}: must be a compute expression object`);
-        } else if (!expr.fn) {
-          errors.push(`compute.${key}: missing required "fn" property`);
+      n.sources.forEach((src, i) => {
+        if (!src || typeof src !== "object" || Array.isArray(src)) {
+          errors.push(`sources[${i}]: must be an object`);
         } else {
-          const fn = expr.fn;
-          if (!_fns[fn] && !_customFns[fn]) {
-            errors.push(`compute.${key}: unknown function "${fn}"`);
+          const s = src;
+          if (typeof s.bindTo !== "string" || !s.bindTo) errors.push(`sources[${i}]: missing required "bindTo" property`);
+          if (s.outputFile != null && typeof s.outputFile !== "string") errors.push(`sources[${i}]: outputFile must be a string`);
+          if (s.optionalForCompletionGating != null && typeof s.optionalForCompletionGating !== "boolean") {
+            errors.push(`sources[${i}]: optionalForCompletionGating must be a boolean`);
           }
         }
-      }
+      });
     }
   }
-  if (n.type === "card") {
-    if (n.source != null) errors.push('Card nodes must not have "source" \u2014 use type "source" instead');
-    if (n.view == null || typeof n.view !== "object" || Array.isArray(n.view)) {
-      errors.push("view: required for card nodes, must be an object");
+  if (n.view != null) {
+    if (typeof n.view !== "object" || Array.isArray(n.view)) {
+      errors.push("view: must be an object");
     } else {
       const view = n.view;
       if (!Array.isArray(view.elements) || view.elements.length === 0) {
@@ -11407,44 +12130,27 @@ function validateNode(node) {
           }
         });
       }
-      if (view.layout != null && (typeof view.layout !== "object" || Array.isArray(view.layout))) {
-        errors.push("view.layout: must be an object");
-      }
-      if (view.features != null && (typeof view.features !== "object" || Array.isArray(view.features))) {
-        errors.push("view.features: must be an object");
-      }
-    }
-  }
-  if (n.type === "source") {
-    if (n.view != null) errors.push('Source nodes must not have "view" \u2014 use type "card" instead');
-    if (n.source == null || typeof n.source !== "object" || Array.isArray(n.source)) {
-      errors.push("source: required for source nodes, must be an object");
-    } else {
-      const src = n.source;
-      if (!src.kind || !VALID_SOURCE_KINDS.has(src.kind)) {
-        errors.push(`source.kind: required, must be one of: ${[...VALID_SOURCE_KINDS].join(", ")}`);
-      }
-      if (typeof src.bindTo !== "string" || !src.bindTo) {
-        errors.push("source.bindTo: required, must be a state path string");
-      } else if (!src.bindTo.startsWith("state.")) {
-        errors.push('source.bindTo: must start with "state."');
-      }
+      if (view.layout != null && (typeof view.layout !== "object" || Array.isArray(view.layout))) errors.push("view.layout: must be an object");
+      if (view.features != null && (typeof view.features !== "object" || Array.isArray(view.features))) errors.push("view.features: must be an object");
     }
   }
   return { ok: errors.length === 0, errors };
 }
+function enrichSources(sources, context) {
+  if (!sources || sources.length === 0) return [];
+  return sources.map((src) => ({
+    ...src,
+    _requires: context.requires ?? {},
+    _sourcesData: context.sourcesData ?? {},
+    _computed_values: context.computed_values ?? {}
+  }));
+}
 var CardCompute = {
   run,
   eval: evalExpr,
   resolve,
   validate: validateNode,
-  registerFunction,
-  get functions() {
-    const all = {};
-    for (const k of Object.keys(_fns)) all[k] = _fns[k];
-    for (const k of Object.keys(_customFns)) all[k] = _customFns[k];
-    return all;
-  }
+  enrichSources
 };
 
 // src/continuous-event-graph/live-cards-bridge.ts
@@ -11477,19 +12183,26 @@ function liveCardsToReactiveGraph(input, options = {}) {
   }
   const sharedState = options.sharedState ?? /* @__PURE__ */ new Map();
   const tasks = {};
+  const allTokens = /* @__PURE__ */ new Set();
+  const tokenToCardId = /* @__PURE__ */ new Map();
   for (const card of cards) {
-    const requires = card.data?.requires ?? [];
+    for (const binding of card.provides ?? [{ bindTo: card.id, src: "card_data" }]) {
+      allTokens.add(binding.bindTo);
+      tokenToCardId.set(binding.bindTo, card.id);
+    }
+  }
+  for (const card of cards) {
+    const requires = card.requires ?? [];
     for (const req of requires) {
-      if (!cardMap.has(req)) {
-        throw new Error(`Card "${card.id}" requires "${req}" but no card with that ID exists`);
+      if (!allTokens.has(req)) {
+        throw new Error(`Card "${card.id}" requires "${req}" but no card provides that token`);
       }
     }
     tasks[card.id] = {
       requires: requires.length > 0 ? requires : void 0,
-      provides: [card.id],
+      provides: (card.provides ?? [{ bindTo: card.id, src: "card_data" }]).map((p) => p.bindTo),
       taskHandlers: [card.id],
-      // each card has a named handler matching its ID
-      description: card.meta?.title ?? `${card.type}: ${card.id}`
+      description: card.meta?.title ?? card.id
     };
   }
   const config = {
@@ -11508,10 +12221,10 @@ function liveCardsToReactiveGraph(input, options = {}) {
     graphRef.resolveCallback(token, data, errors);
   };
   for (const card of cards) {
-    if (card.type === "source") {
+    if (card.sources && card.sources.length > 0) {
       handlers[card.id] = buildSourceHandler(card, sourceHandlers, defaultSourceHandler, sharedState, getResolve);
     } else {
-      handlers[card.id] = buildCardHandler(card, cardHandlers, sharedState, cardMap, getResolve);
+      handlers[card.id] = buildCardHandler(card, cardHandlers, sharedState, cardMap, tokenToCardId, getResolve);
     }
   }
   const graph = createReactiveGraph(
@@ -11539,13 +12252,13 @@ function buildSourceHandler(card, sourceHandlers, defaultSourceHandler, sharedSt
     };
   }
   return async (input) => {
-    const state = { ...card.state };
-    sharedState.set(card.id, state);
-    getResolve()(input.callbackToken, state);
+    const data = { ...card.card_data };
+    sharedState.set(card.id, data);
+    getResolve()(input.callbackToken, data);
     return "task-initiated";
   };
 }
-function buildCardHandler(card, cardHandlers, sharedState, cardMap, getResolve) {
+function buildCardHandler(card, cardHandlers, sharedState, _cardMap, tokenToCardId, getResolve) {
   if (cardHandlers[card.id]) {
     const userHandler = cardHandlers[card.id];
     return async (input) => {
@@ -11553,46 +12266,273 @@ function buildCardHandler(card, cardHandlers, sharedState, cardMap, getResolve)
     };
   }
   return async (input) => {
+    const requiresData = {};
+    const requires = card.requires ?? [];
+    for (const token of requires) {
+      const producerId = tokenToCardId.get(token) ?? token;
+      const upstreamState = sharedState.get(producerId);
+      if (upstreamState) {
+        requiresData[token] = upstreamState[token] ?? upstreamState;
+      }
+    }
     const computeNode = {
       id: card.id,
-      state: { ...card.state },
+      card_data: { ...card.card_data },
+      requires: requiresData,
       compute: card.compute
     };
-    const requires = card.data?.requires ?? [];
-    for (const upstreamId of requires) {
-      const upstreamState = sharedState.get(upstreamId);
-      if (upstreamState) {
-        computeNode.state[upstreamId] = upstreamState;
-      }
-      const upstreamCard = cardMap.get(upstreamId);
-      if (upstreamCard?.data?.provides && upstreamState) {
-        for (const [key, bindRef] of Object.entries(upstreamCard.data.provides)) {
-          if (typeof bindRef === "string" && bindRef.startsWith("state.")) {
-            const path = bindRef.slice(6);
-            const value = deepGet2(upstreamState, path);
-            if (value !== void 0) {
-              computeNode.state[key] = value;
-            }
-          }
-        }
+    await CardCompute.run(computeNode);
+    let resultData;
+    if (card.provides && card.provides.length > 0) {
+      resultData = {};
+      for (const { bindTo, src } of card.provides) {
+        resultData[bindTo] = CardCompute.resolve(computeNode, src);
       }
+    } else {
+      resultData = { ...computeNode.card_data, ...computeNode.computed_values };
     }
-    CardCompute.run(computeNode);
-    const resultState = { ...computeNode.state };
+    const resultState = { ...computeNode.card_data, ...computeNode.computed_values };
     sharedState.set(card.id, resultState);
-    getResolve()(input.callbackToken, resultState);
+    getResolve()(input.callbackToken, resultData);
     return "task-initiated";
   };
 }
-function deepGet2(obj, path) {
-  if (!path || !obj) return void 0;
-  const parts = path.split(".");
-  let cur = obj;
-  for (const part of parts) {
-    if (cur == null) return void 0;
-    cur = cur[part];
+
+// src/board-livegraph-runtime/index.ts
+function deepClone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function toTaskConfig(card) {
+  const provides = card.provides && card.provides.length > 0 ? card.provides.map((p) => p.bindTo) : [card.id];
+  return {
+    requires: card.requires && card.requires.length > 0 ? [...card.requires] : void 0,
+    provides,
+    taskHandlers: [card.id],
+    description: card.meta?.title ?? card.id
+  };
+}
+function buildTokenProviders(cards) {
+  const tokenToCardId = /* @__PURE__ */ new Map();
+  for (const [cardId, card] of cards.entries()) {
+    const bindings = card.provides && card.provides.length > 0 ? card.provides : [{ bindTo: cardId, src: "card_data" }];
+    for (const binding of bindings) tokenToCardId.set(binding.bindTo, cardId);
   }
-  return cur;
+  return tokenToCardId;
+}
+function validateRequires(cards, changedCardId) {
+  const tokenProviders = buildTokenProviders(cards);
+  const card = cards.get(changedCardId);
+  if (!card) return;
+  for (const req of card.requires ?? []) {
+    if (!tokenProviders.has(req)) {
+      throw new Error(`Card "${changedCardId}" requires token "${req}" but no card provides it`);
+    }
+  }
+}
+function createBoardLiveGraphRuntime(input, options = {}) {
+  const boardMeta = Array.isArray(input) ? {} : {
+    id: input.id,
+    title: input.title,
+    mode: input.mode,
+    positions: input.positions,
+    settings: input.settings
+  };
+  const initialCards = Array.isArray(input) ? input : input.nodes;
+  const cards = /* @__PURE__ */ new Map();
+  for (const card of initialCards) {
+    if (cards.has(card.id)) throw new Error(`Duplicate card ID: "${card.id}"`);
+    cards.set(card.id, deepClone(card));
+  }
+  const listeners = /* @__PURE__ */ new Set();
+  const taskExecutor = options.taskExecutor;
+  const sourceAdapters = options.sourceAdapters ?? {};
+  const defaultSourceAdapter = options.defaultSourceAdapter;
+  let graphRef = null;
+  const notifyListeners = (events, graph2) => {
+    const update = {
+      events,
+      graph: graph2,
+      nodes: getRenderableNodes()
+    };
+    for (const listener of listeners) listener(update);
+  };
+  const makeHandler = (cardId) => {
+    return async (inputArgs) => {
+      const card = cards.get(cardId);
+      if (!card) return "task-initiate-failure";
+      const requiresData = {};
+      for (const token of card.requires ?? []) {
+        const upstream = inputArgs.state[token];
+        if (!upstream || typeof upstream !== "object") continue;
+        const providesData2 = upstream.provides_data;
+        if (!providesData2 || typeof providesData2 !== "object") continue;
+        if (!Object.prototype.hasOwnProperty.call(providesData2, token)) continue;
+        requiresData[token] = providesData2[token];
+      }
+      const sourcesData = {};
+      if (card.sources && card.sources.length > 0) {
+        const adapter = sourceAdapters[cardId] ?? defaultSourceAdapter;
+        const fetched = taskExecutor ? await taskExecutor({ card, input: inputArgs }) : adapter ? await adapter({ card, input: inputArgs }) : void 0;
+        if (fetched && typeof fetched === "object") {
+          for (const src of card.sources) {
+            if (Object.prototype.hasOwnProperty.call(fetched, src.bindTo)) {
+              sourcesData[src.bindTo] = fetched[src.bindTo];
+            } else if (card.sources.length === 1) {
+              sourcesData[src.bindTo] = fetched;
+            }
+          }
+        }
+      }
+      const computeNode = {
+        id: card.id,
+        card_data: deepClone(card.card_data ?? {}),
+        requires: requiresData,
+        sources: card.sources,
+        compute: card.compute
+      };
+      computeNode._sourcesData = sourcesData;
+      if (computeNode.compute && computeNode.compute.length > 0) {
+        await CardCompute.run(computeNode, { sourcesData });
+      }
+      const providesData = {};
+      if (card.provides && card.provides.length > 0) {
+        for (const { bindTo, src } of card.provides) {
+          providesData[bindTo] = CardCompute.resolve(computeNode, src);
+        }
+      } else {
+        providesData[card.id] = {
+          ...computeNode.card_data ?? {},
+          ...computeNode.computed_values ?? {},
+          ...computeNode._sourcesData ?? {}
+        };
+      }
+      const resultData = {
+        provides_data: providesData,
+        card_data: computeNode.card_data ?? {},
+        computed_values: computeNode.computed_values ?? {},
+        fetched_sources: sourcesData,
+        requires: requiresData
+      };
+      graphRef?.resolveCallback(inputArgs.callbackToken, resultData);
+      return "task-initiated";
+    };
+  };
+  const tasks = {};
+  const handlers = {};
+  for (const [cardId, card] of cards.entries()) {
+    validateRequires(cards, cardId);
+    tasks[cardId] = toTaskConfig(card);
+    handlers[cardId] = makeHandler(cardId);
+  }
+  const config = {
+    id: boardMeta.id ?? `browser-board-${Date.now()}`,
+    settings: {
+      completion: "manual",
+      execution_mode: "eligibility-mode",
+      ...boardMeta.settings ?? {},
+      ...options.graphSettings ?? {}
+    },
+    tasks
+  };
+  const userOnDrain = options.reactiveOptions?.onDrain;
+  const graph = createReactiveGraph(
+    config,
+    {
+      ...options.reactiveOptions ?? {},
+      handlers,
+      onDrain: (events, live, scheduleResult) => {
+        userOnDrain?.(events, live, scheduleResult);
+        notifyListeners(events, live);
+      }
+    },
+    options.executionId
+  );
+  graphRef = graph;
+  function getRenderableNodes() {
+    const live = graph.getState();
+    const out = [];
+    for (const [cardId, baseCard] of cards.entries()) {
+      const data = live.state.tasks[cardId]?.data;
+      const runtimeState = live.state.tasks[cardId];
+      const mergedCardData = {
+        ...baseCard.card_data ?? {},
+        ...data && typeof data.card_data === "object" ? data.card_data : {}
+      };
+      const cardStatus = runtimeState?.status === "running" ? "loading" : runtimeState?.status;
+      const cardDataForView = {
+        ...mergedCardData,
+        ...cardStatus ? { status: cardStatus } : {},
+        ...runtimeState?.lastUpdated ? { lastRun: runtimeState.lastUpdated } : {},
+        ...runtimeState?.status === "failed" && runtimeState.error ? { error: runtimeState.error } : {}
+      };
+      out.push({
+        id: cardId,
+        card: deepClone(baseCard),
+        card_data: cardDataForView,
+        fetched_sources: data && typeof data.fetched_sources === "object" ? deepClone(data.fetched_sources) : {},
+        requires: data && typeof data.requires === "object" ? deepClone(data.requires) : {},
+        computed_values: data && typeof data.computed_values === "object" ? deepClone(data.computed_values) : {},
+        runtime_state: runtimeState ? deepClone(runtimeState) : {}
+      });
+    }
+    return out;
+  }
+  const runtime = {
+    getGraph: () => graph,
+    getState: () => graph.getState(),
+    getSchedule: () => graph.getSchedule(),
+    getNodes: () => getRenderableNodes(),
+    getBoard: () => ({
+      ...boardMeta,
+      nodes: getRenderableNodes()
+    }),
+    subscribe(listener) {
+      listeners.add(listener);
+      listener({ events: [], graph: graph.getState(), nodes: getRenderableNodes() });
+      return () => listeners.delete(listener);
+    },
+    addCard(card) {
+      if (cards.has(card.id)) throw new Error(`Card "${card.id}" already exists`);
+      cards.set(card.id, deepClone(card));
+      validateRequires(cards, card.id);
+      graph.registerHandler(card.id, makeHandler(card.id));
+      graph.addNode(card.id, toTaskConfig(card));
+    },
+    upsertCard(card) {
+      cards.set(card.id, deepClone(card));
+      validateRequires(cards, card.id);
+      graph.registerHandler(card.id, makeHandler(card.id));
+      graph.addNode(card.id, toTaskConfig(card));
+    },
+    removeCard(cardId) {
+      cards.delete(cardId);
+      graph.unregisterHandler(cardId);
+      graph.removeNode(cardId);
+    },
+    patchCardState(cardId, patch) {
+      const card = cards.get(cardId);
+      if (!card) throw new Error(`Card "${cardId}" not found`);
+      card.card_data = { ...card.card_data ?? {}, ...patch };
+      graph.retrigger(cardId);
+    },
+    retrigger(cardId) {
+      graph.retrigger(cardId);
+    },
+    retriggerAll() {
+      graph.retriggerAll(Array.from(cards.keys()));
+    },
+    push(event) {
+      graph.push(event);
+    },
+    pushAll(events) {
+      graph.pushAll(events);
+    },
+    dispose() {
+      listeners.clear();
+      graph.dispose();
+    }
+  };
+  return runtime;
 }
 
 // src/inference/core.ts
@@ -11846,13 +12786,196 @@ function createHttpAdapter(opts) {
   };
 }
 
+// schema/board-status.schema.json
+var board_status_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://yaml-flow.dev/schema/board-status.schema.json",
+  title: "Board Status Object",
+  type: "object",
+  additionalProperties: false,
+  required: ["schema_version", "meta", "summary", "cards"],
+  properties: {
+    schema_version: {
+      type: "string",
+      const: "v1"
+    },
+    meta: {
+      type: "object",
+      additionalProperties: false,
+      required: ["board"],
+      properties: {
+        board: {
+          type: "object",
+          additionalProperties: false,
+          required: ["path"],
+          properties: {
+            path: { type: "string" }
+          }
+        }
+      }
+    },
+    summary: {
+      type: "object",
+      additionalProperties: false,
+      required: ["card_count", "completed", "eligible", "pending", "blocked", "unresolved"],
+      properties: {
+        card_count: { type: "integer", minimum: 0 },
+        completed: { type: "integer", minimum: 0 },
+        eligible: { type: "integer", minimum: 0 },
+        pending: { type: "integer", minimum: 0 },
+        blocked: { type: "integer", minimum: 0 },
+        unresolved: { type: "integer", minimum: 0 },
+        failed: { type: "integer", minimum: 0 },
+        in_progress: { type: "integer", minimum: 0 },
+        orphan_cards: { type: "integer", minimum: 0 },
+        topology: {
+          type: "object",
+          additionalProperties: false,
+          required: ["edge_count", "max_fan_out_card", "max_fan_out"],
+          properties: {
+            edge_count: { type: "integer", minimum: 0 },
+            max_fan_out_card: { type: ["string", "null"] },
+            max_fan_out: { type: "integer", minimum: 0 }
+          }
+        }
+      }
+    },
+    cards: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: [
+          "name",
+          "status",
+          "requires",
+          "requires_satisfied",
+          "requires_missing",
+          "provides_declared",
+          "provides_runtime",
+          "blocked_by",
+          "unblocks",
+          "runtime"
+        ],
+        properties: {
+          name: { type: "string" },
+          status: { type: "string" },
+          error: {
+            type: "object",
+            additionalProperties: false,
+            required: ["message"],
+            properties: {
+              message: { type: "string" },
+              code: { type: "string" },
+              at: { type: ["string", "null"] },
+              source: { type: "string" }
+            }
+          },
+          requires: { type: "array", items: { type: "string" } },
+          requires_satisfied: { type: "array", items: { type: "string" } },
+          requires_missing: { type: "array", items: { type: "string" } },
+          provides_declared: { type: "array", items: { type: "string" } },
+          provides_runtime: { type: "array", items: { type: "string" } },
+          blocked_by: { type: "array", items: { type: "string" } },
+          unblocks: { type: "array", items: { type: "string" } },
+          runtime: {
+            type: "object",
+            additionalProperties: false,
+            required: [
+              "attempt_count",
+              "restart_count",
+              "in_progress_since",
+              "last_transition_at",
+              "last_completed_at",
+              "last_restarted_at",
+              "status_age_ms"
+            ],
+            properties: {
+              attempt_count: { type: "integer", minimum: 0 },
+              restart_count: { type: "integer", minimum: 0 },
+              in_progress_since: { type: ["string", "null"] },
+              last_transition_at: { type: ["string", "null"] },
+              last_completed_at: { type: ["string", "null"] },
+              last_restarted_at: { type: ["string", "null"] },
+              status_age_ms: { type: ["integer", "null"], minimum: 0 }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// schema/card-runtime.schema.json
+var card_runtime_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://yaml-flow.dev/schema/card-runtime.schema.json",
+  title: "Card Runtime Computed Artifact",
+  description: "Published per-card runtime artifact written to runtime-out/cards/<card-id>.computed.json. Contains only values produced by the compute step.",
+  type: "object",
+  required: ["schema_version", "card_id", "computed_values"],
+  additionalProperties: false,
+  properties: {
+    schema_version: {
+      type: "string",
+      const: "v1",
+      description: "Artifact schema version."
+    },
+    card_id: {
+      type: "string",
+      description: "The ID of the card this artifact belongs to."
+    },
+    computed_values: {
+      type: "object",
+      description: "Key/value map of outputs produced by the card's JSONata compute steps.",
+      additionalProperties: true
+    }
+  }
+};
+
+// src/runtime-artifacts/schema-validator.ts
+var import__ = __toESM(require__());
+var boardStatusValidator = null;
+var cardRuntimeValidator = null;
+function createAjv() {
+  const ajv = new import__.default({ allErrors: true, strict: false });
+  addFormats__default.default(ajv);
+  return ajv;
+}
+function toValidationResult(validate) {
+  const errors = (validate.errors ?? []).map((error) => {
+    const instancePath = error.instancePath || "/";
+    return `${instancePath}: ${error.message ?? "unknown error"}`;
+  });
+  return { ok: false, errors };
+}
+function getBoardStatusValidator() {
+  if (boardStatusValidator) return boardStatusValidator;
+  boardStatusValidator = createAjv().compile(board_status_schema_default);
+  return boardStatusValidator;
+}
+function getCardRuntimeValidator() {
+  if (cardRuntimeValidator) return cardRuntimeValidator;
+  cardRuntimeValidator = createAjv().compile(card_runtime_schema_default);
+  return cardRuntimeValidator;
+}
+function validateBoardStatusSchema(statusObject) {
+  const validate = getBoardStatusValidator();
+  if (validate(statusObject)) return { ok: true, errors: [] };
+  return toValidationResult(validate);
+}
+function validateCardRuntimeSchema(cardRuntimeObject) {
+  const validate = getCardRuntimeValidator();
+  if (validate(cardRuntimeObject)) return { ok: true, errors: [] };
+  return toValidationResult(validate);
+}
+
 exports.COMPLETION_STRATEGIES = COMPLETION_STRATEGIES;
 exports.CONFLICT_STRATEGIES = CONFLICT_STRATEGIES;
 exports.CardCompute = CardCompute;
 exports.DEFAULTS = DEFAULTS;
 exports.EXECUTION_MODES = EXECUTION_MODES;
 exports.EXECUTION_STATUS = EXECUTION_STATUS;
-exports.FileJournal = FileJournal;
 exports.FileStore = FileStore;
 exports.FlowEngine = StepMachine;
 exports.LocalStorageStore = LocalStorageStore;
@@ -11875,6 +12998,7 @@ exports.buildInferencePrompt = buildInferencePrompt;
 exports.checkCircuitBreaker = checkCircuitBreaker;
 exports.computeAvailableOutputs = computeAvailableOutputs;
 exports.computeStepInput = computeStepInput;
+exports.createBoardLiveGraphRuntime = createBoardLiveGraphRuntime;
 exports.createCallbackHandler = createCallbackHandler;
 exports.createCliAdapter = createCliAdapter;
 exports.createDefaultGraphEngineStore = createDefaultGraphEngineStore;
@@ -11936,10 +13060,15 @@ exports.resolveVariables = resolveVariables;
 exports.restore = restore;
 exports.schedule = schedule;
 exports.snapshot = snapshot;
+exports.validateBoardStatusSchema = validateBoardStatusSchema;
+exports.validateCardRuntimeSchema = validateCardRuntimeSchema;
 exports.validateFlowSchema = validateFlowSchema;
 exports.validateGraph = validateGraph;
 exports.validateGraphConfig = validateGraphConfig;
 exports.validateGraphSchema = validateGraphSchema;
+exports.validateLiveCard = validateLiveCard;
+exports.validateLiveCardDefinition = validateLiveCardDefinition;
+exports.validateLiveCardRuntimeExpressions = validateLiveCardRuntimeExpressions;
 exports.validateLiveCardSchema = validateLiveCardSchema;
 exports.validateLiveGraph = validateLiveGraph;
 exports.validateReactiveGraph = validateReactiveGraph;