yaml-flow 3.1.1 → 5.0.0

package/dist/index.js

@@ -1,7 +1,6 @@
 import addFormats from 'ajv-formats';
-import { existsSync, writeFileSync, appendFileSync, readFileSync } from 'fs';
-import { createHash } from 'crypto';
 import { exec, execFile } from 'child_process';
+import jsonata2 from 'jsonata';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -6414,6 +6413,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];
@@ -6439,7 +7246,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}"`
@@ -6644,6 +7451,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) {
@@ -6873,6 +7689,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") {
@@ -6993,6 +7812,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"
         },
@@ -7931,8 +8755,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;
   }
@@ -7989,7 +8813,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;
   }
@@ -7997,7 +8821,7 @@ function applyTaskCreation(state, taskName, taskConfig) {
     ...state,
     tasks: {
       ...state.tasks,
-      [taskName]: createDefaultGraphEngineStore()
+      [taskName]: state.tasks[taskName] ?? createDefaultGraphEngineStore()
     },
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -9269,43 +10093,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,
@@ -9313,7 +10145,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()
     }
   };
@@ -10020,6 +10855,8 @@ function getDownstream(live, nodeName) {
   }));
   return { nodeName, nodes, tokens: [...tokenSet] };
 }
+
+// src/continuous-event-graph/journal.ts
 var MemoryJournal = class {
   buffer = [];
   append(event) {
@@ -10034,39 +10871,11 @@ var MemoryJournal = class {
     return this.buffer.length;
   }
 };
-var FileJournal = class {
-  constructor(path) {
-    this.path = path;
-    if (!existsSync(path)) {
-      writeFileSync(path, "", "utf-8");
-    }
-  }
-  path;
-  pending = 0;
-  append(event) {
-    appendFileSync(this.path, JSON.stringify(event) + "\n", "utf-8");
-    this.pending++;
-  }
-  drain() {
-    const content = readFileSync(this.path, "utf-8").trim();
-    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 = 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 createHash("sha256").update(json).digest("hex").slice(0, 16);
+  return fnv1a64Hex(json);
 }
 function stableStringify(value) {
   if (value === null || value === void 0 || typeof value !== "object") {
@@ -10079,28 +10888,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() {
@@ -10120,7 +10966,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);
     }
@@ -10131,6 +10979,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];
@@ -10152,7 +11020,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);
@@ -10166,7 +11034,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") {
@@ -10180,15 +11049,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),
@@ -10203,16 +11073,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();
@@ -10224,7 +11094,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("; "),
@@ -10232,7 +11102,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,
@@ -10244,31 +11114,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);
@@ -10279,7 +11151,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()
@@ -10290,7 +11162,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()
@@ -10298,6 +11170,9 @@ function createReactiveGraph(config, options, executionId) {
       }
       drain();
     },
+    snapshot() {
+      return snapshot(live);
+    },
     getState() {
       return live;
     },
@@ -10665,13 +11540,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",
@@ -10740,7 +11613,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" },
@@ -10764,38 +11637,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: {
@@ -10819,19 +11697,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" },
@@ -10864,7 +11740,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" }] }
                 }
               }
             }
@@ -10913,69 +11789,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(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 });
@@ -10993,6 +11918,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) {
@@ -11014,288 +11975,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(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(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",
@@ -11312,34 +12028,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)) {
@@ -11350,37 +12051,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) {
@@ -11401,44 +12123,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
@@ -11471,19 +12176,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 = {
@@ -11502,10 +12214,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(
@@ -11533,13 +12245,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) => {
@@ -11547,46 +12259,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
@@ -11840,6 +12779,190 @@ function createHttpAdapter(opts) {
   };
 }
 
-export { COMPLETION_STRATEGIES, CONFLICT_STRATEGIES, CardCompute, DEFAULTS, EXECUTION_MODES, EXECUTION_STATUS, FileJournal, FileStore, StepMachine as FlowEngine, LocalStorageStore, MemoryJournal, MemoryStore, StepMachine, TASK_STATUS, addDynamicTask, addNode, addProvides, addRequires, apply, applyAll, applyEvent, applyEvents, applyInferences, applyStepResult, batch, buildInferencePrompt, checkCircuitBreaker, computeAvailableOutputs, computeStepInput, createCallbackHandler, createCliAdapter, createDefaultGraphEngineStore, createStepMachine as createEngine, createFireAndForgetHandler, createHttpAdapter, createInitialExecutionState, createInitialState, createLiveGraph, createNoopHandler, createReactiveGraph, createScriptHandler, createShellHandler, createStepMachine, createWebhookHandler, detectStuckState, disableNode, drainTokens, enableNode, exportGraphConfig, exportGraphConfigToFile, extractReturnData, flowToMermaid, getAllTasks, getCandidateTasks, getDownstream, getMaxExecutions, getNode, getProvides, getRefreshStrategy, getRequires, getTask, getUnreachableNodes, getUnreachableTokens, getUpstream, graphToMermaid, hasTask, inferAndApply, inferCompletions, injectTokens, inspect, isExecutionComplete, isNonActiveTask, isRerunnable, isTaskCompleted, isTaskRunning, liveCardsToReactiveGraph, loadGraphConfig, loadStepFlow, mutateGraph, next, planExecution, removeNode, removeProvides, removeRequires, resetNode, resolveConfigTemplates, resolveVariables, restore, schedule, snapshot, validateFlowSchema, validateGraph, validateGraphConfig, validateGraphSchema, validateLiveCardSchema, validateLiveGraph, validateReactiveGraph, validateStepFlowConfig };
+// 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(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);
+}
+
+export { COMPLETION_STRATEGIES, CONFLICT_STRATEGIES, CardCompute, DEFAULTS, EXECUTION_MODES, EXECUTION_STATUS, FileStore, StepMachine as FlowEngine, LocalStorageStore, MemoryJournal, MemoryStore, StepMachine, TASK_STATUS, addDynamicTask, addNode, addProvides, addRequires, apply, applyAll, applyEvent, applyEvents, applyInferences, applyStepResult, batch, buildInferencePrompt, checkCircuitBreaker, computeAvailableOutputs, computeStepInput, createBoardLiveGraphRuntime, createCallbackHandler, createCliAdapter, createDefaultGraphEngineStore, createStepMachine as createEngine, createFireAndForgetHandler, createHttpAdapter, createInitialExecutionState, createInitialState, createLiveGraph, createNoopHandler, createReactiveGraph, createScriptHandler, createShellHandler, createStepMachine, createWebhookHandler, detectStuckState, disableNode, drainTokens, enableNode, exportGraphConfig, exportGraphConfigToFile, extractReturnData, flowToMermaid, getAllTasks, getCandidateTasks, getDownstream, getMaxExecutions, getNode, getProvides, getRefreshStrategy, getRequires, getTask, getUnreachableNodes, getUnreachableTokens, getUpstream, graphToMermaid, hasTask, inferAndApply, inferCompletions, injectTokens, inspect, isExecutionComplete, isNonActiveTask, isRerunnable, isTaskCompleted, isTaskRunning, liveCardsToReactiveGraph, loadGraphConfig, loadStepFlow, mutateGraph, next, planExecution, removeNode, removeProvides, removeRequires, resetNode, resolveConfigTemplates, resolveVariables, restore, schedule, snapshot, validateBoardStatusSchema, validateCardRuntimeSchema, validateFlowSchema, validateGraph, validateGraphConfig, validateGraphSchema, validateLiveCard, validateLiveCardDefinition, validateLiveCardRuntimeExpressions, validateLiveCardSchema, validateLiveGraph, validateReactiveGraph, validateStepFlowConfig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map