yaml-flow 4.0.0 → 5.1.0

package/dist/index.cjs

@@ -1,14 +1,13 @@
 'use strict';
 
 var addFormats = require('ajv-formats');
-var crypto$1 = require('crypto');
 var child_process = require('child_process');
-var jsonata = require('jsonata');
+var jsonata2 = require('jsonata');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var addFormats__default = /*#__PURE__*/_interopDefault(addFormats);
-var jsonata__default = /*#__PURE__*/_interopDefault(jsonata);
+var jsonata2__default = /*#__PURE__*/_interopDefault(jsonata2);
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -6421,6 +6420,814 @@ var require_ajv = __commonJS({
   }
 });
 
+// node_modules/ajv/dist/vocabularies/dynamic/dynamicAnchor.js
+var require_dynamicAnchor = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/dynamicAnchor.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.dynamicAnchor = void 0;
+    var codegen_1 = require_codegen();
+    var names_1 = require_names();
+    var compile_1 = require_compile();
+    var ref_1 = require_ref();
+    var def = {
+      keyword: "$dynamicAnchor",
+      schemaType: "string",
+      code: (cxt) => dynamicAnchor(cxt, cxt.schema)
+    };
+    function dynamicAnchor(cxt, anchor) {
+      const { gen, it } = cxt;
+      it.schemaEnv.root.dynamicAnchors[anchor] = true;
+      const v = (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`;
+      const validate = it.errSchemaPath === "#" ? it.validateName : _getValidate(cxt);
+      gen.if((0, codegen_1._)`!${v}`, () => gen.assign(v, validate));
+    }
+    exports$1.dynamicAnchor = dynamicAnchor;
+    function _getValidate(cxt) {
+      const { schemaEnv, schema, self } = cxt.it;
+      const { root, baseId, localRefs, meta } = schemaEnv.root;
+      const { schemaId } = self.opts;
+      const sch = new compile_1.SchemaEnv({ schema, schemaId, root, baseId, localRefs, meta });
+      compile_1.compileSchema.call(self, sch);
+      return (0, ref_1.getValidate)(cxt, sch);
+    }
+    exports$1.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/dynamicRef.js
+var require_dynamicRef = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/dynamicRef.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.dynamicRef = void 0;
+    var codegen_1 = require_codegen();
+    var names_1 = require_names();
+    var ref_1 = require_ref();
+    var def = {
+      keyword: "$dynamicRef",
+      schemaType: "string",
+      code: (cxt) => dynamicRef(cxt, cxt.schema)
+    };
+    function dynamicRef(cxt, ref) {
+      const { gen, keyword, it } = cxt;
+      if (ref[0] !== "#")
+        throw new Error(`"${keyword}" only supports hash fragment reference`);
+      const anchor = ref.slice(1);
+      if (it.allErrors) {
+        _dynamicRef();
+      } else {
+        const valid = gen.let("valid", false);
+        _dynamicRef(valid);
+        cxt.ok(valid);
+      }
+      function _dynamicRef(valid) {
+        if (it.schemaEnv.root.dynamicAnchors[anchor]) {
+          const v = gen.let("_v", (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`);
+          gen.if(v, _callRef(v, valid), _callRef(it.validateName, valid));
+        } else {
+          _callRef(it.validateName, valid)();
+        }
+      }
+      function _callRef(validate, valid) {
+        return valid ? () => gen.block(() => {
+          (0, ref_1.callRef)(cxt, validate);
+          gen.let(valid, true);
+        }) : () => (0, ref_1.callRef)(cxt, validate);
+      }
+    }
+    exports$1.dynamicRef = dynamicRef;
+    exports$1.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/recursiveAnchor.js
+var require_recursiveAnchor = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/recursiveAnchor.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var dynamicAnchor_1 = require_dynamicAnchor();
+    var util_1 = require_util();
+    var def = {
+      keyword: "$recursiveAnchor",
+      schemaType: "boolean",
+      code(cxt) {
+        if (cxt.schema)
+          (0, dynamicAnchor_1.dynamicAnchor)(cxt, "");
+        else
+          (0, util_1.checkStrictMode)(cxt.it, "$recursiveAnchor: false is ignored");
+      }
+    };
+    exports$1.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/recursiveRef.js
+var require_recursiveRef = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/recursiveRef.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var dynamicRef_1 = require_dynamicRef();
+    var def = {
+      keyword: "$recursiveRef",
+      schemaType: "string",
+      code: (cxt) => (0, dynamicRef_1.dynamicRef)(cxt, cxt.schema)
+    };
+    exports$1.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/index.js
+var require_dynamic = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/index.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var dynamicAnchor_1 = require_dynamicAnchor();
+    var dynamicRef_1 = require_dynamicRef();
+    var recursiveAnchor_1 = require_recursiveAnchor();
+    var recursiveRef_1 = require_recursiveRef();
+    var dynamic = [dynamicAnchor_1.default, dynamicRef_1.default, recursiveAnchor_1.default, recursiveRef_1.default];
+    exports$1.default = dynamic;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/validation/dependentRequired.js
+var require_dependentRequired = __commonJS({
+  "node_modules/ajv/dist/vocabularies/validation/dependentRequired.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var dependencies_1 = require_dependencies();
+    var def = {
+      keyword: "dependentRequired",
+      type: "object",
+      schemaType: "object",
+      error: dependencies_1.error,
+      code: (cxt) => (0, dependencies_1.validatePropertyDeps)(cxt)
+    };
+    exports$1.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/applicator/dependentSchemas.js
+var require_dependentSchemas = __commonJS({
+  "node_modules/ajv/dist/vocabularies/applicator/dependentSchemas.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var dependencies_1 = require_dependencies();
+    var def = {
+      keyword: "dependentSchemas",
+      type: "object",
+      schemaType: "object",
+      code: (cxt) => (0, dependencies_1.validateSchemaDeps)(cxt)
+    };
+    exports$1.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/validation/limitContains.js
+var require_limitContains = __commonJS({
+  "node_modules/ajv/dist/vocabularies/validation/limitContains.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var util_1 = require_util();
+    var def = {
+      keyword: ["maxContains", "minContains"],
+      type: "array",
+      schemaType: "number",
+      code({ keyword, parentSchema, it }) {
+        if (parentSchema.contains === void 0) {
+          (0, util_1.checkStrictMode)(it, `"${keyword}" without "contains" is ignored`);
+        }
+      }
+    };
+    exports$1.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/next.js
+var require_next = __commonJS({
+  "node_modules/ajv/dist/vocabularies/next.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var dependentRequired_1 = require_dependentRequired();
+    var dependentSchemas_1 = require_dependentSchemas();
+    var limitContains_1 = require_limitContains();
+    var next2 = [dependentRequired_1.default, dependentSchemas_1.default, limitContains_1.default];
+    exports$1.default = next2;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.js
+var require_unevaluatedProperties = __commonJS({
+  "node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var codegen_1 = require_codegen();
+    var util_1 = require_util();
+    var names_1 = require_names();
+    var error = {
+      message: "must NOT have unevaluated properties",
+      params: ({ params }) => (0, codegen_1._)`{unevaluatedProperty: ${params.unevaluatedProperty}}`
+    };
+    var def = {
+      keyword: "unevaluatedProperties",
+      type: "object",
+      schemaType: ["boolean", "object"],
+      trackErrors: true,
+      error,
+      code(cxt) {
+        const { gen, schema, data, errsCount, it } = cxt;
+        if (!errsCount)
+          throw new Error("ajv implementation error");
+        const { allErrors, props } = it;
+        if (props instanceof codegen_1.Name) {
+          gen.if((0, codegen_1._)`${props} !== true`, () => gen.forIn("key", data, (key) => gen.if(unevaluatedDynamic(props, key), () => unevaluatedPropCode(key))));
+        } else if (props !== true) {
+          gen.forIn("key", data, (key) => props === void 0 ? unevaluatedPropCode(key) : gen.if(unevaluatedStatic(props, key), () => unevaluatedPropCode(key)));
+        }
+        it.props = true;
+        cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
+        function unevaluatedPropCode(key) {
+          if (schema === false) {
+            cxt.setParams({ unevaluatedProperty: key });
+            cxt.error();
+            if (!allErrors)
+              gen.break();
+            return;
+          }
+          if (!(0, util_1.alwaysValidSchema)(it, schema)) {
+            const valid = gen.name("valid");
+            cxt.subschema({
+              keyword: "unevaluatedProperties",
+              dataProp: key,
+              dataPropType: util_1.Type.Str
+            }, valid);
+            if (!allErrors)
+              gen.if((0, codegen_1.not)(valid), () => gen.break());
+          }
+        }
+        function unevaluatedDynamic(evaluatedProps, key) {
+          return (0, codegen_1._)`!${evaluatedProps} || !${evaluatedProps}[${key}]`;
+        }
+        function unevaluatedStatic(evaluatedProps, key) {
+          const ps = [];
+          for (const p in evaluatedProps) {
+            if (evaluatedProps[p] === true)
+              ps.push((0, codegen_1._)`${key} !== ${p}`);
+          }
+          return (0, codegen_1.and)(...ps);
+        }
+      }
+    };
+    exports$1.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.js
+var require_unevaluatedItems = __commonJS({
+  "node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var codegen_1 = require_codegen();
+    var util_1 = require_util();
+    var error = {
+      message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
+      params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
+    };
+    var def = {
+      keyword: "unevaluatedItems",
+      type: "array",
+      schemaType: ["boolean", "object"],
+      error,
+      code(cxt) {
+        const { gen, schema, data, it } = cxt;
+        const items = it.items || 0;
+        if (items === true)
+          return;
+        const len = gen.const("len", (0, codegen_1._)`${data}.length`);
+        if (schema === false) {
+          cxt.setParams({ len: items });
+          cxt.fail((0, codegen_1._)`${len} > ${items}`);
+        } else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
+          const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items}`);
+          gen.if((0, codegen_1.not)(valid), () => validateItems(valid, items));
+          cxt.ok(valid);
+        }
+        it.items = true;
+        function validateItems(valid, from) {
+          gen.forRange("i", from, len, (i) => {
+            cxt.subschema({ keyword: "unevaluatedItems", dataProp: i, dataPropType: util_1.Type.Num }, valid);
+            if (!it.allErrors)
+              gen.if((0, codegen_1.not)(valid), () => gen.break());
+          });
+        }
+      }
+    };
+    exports$1.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/unevaluated/index.js
+var require_unevaluated = __commonJS({
+  "node_modules/ajv/dist/vocabularies/unevaluated/index.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var unevaluatedProperties_1 = require_unevaluatedProperties();
+    var unevaluatedItems_1 = require_unevaluatedItems();
+    var unevaluated = [unevaluatedProperties_1.default, unevaluatedItems_1.default];
+    exports$1.default = unevaluated;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/draft2020.js
+var require_draft2020 = __commonJS({
+  "node_modules/ajv/dist/vocabularies/draft2020.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var core_1 = require_core2();
+    var validation_1 = require_validation();
+    var applicator_1 = require_applicator();
+    var dynamic_1 = require_dynamic();
+    var next_1 = require_next();
+    var unevaluated_1 = require_unevaluated();
+    var format_1 = require_format2();
+    var metadata_1 = require_metadata();
+    var draft2020Vocabularies = [
+      dynamic_1.default,
+      core_1.default,
+      validation_1.default,
+      (0, applicator_1.default)(true),
+      format_1.default,
+      metadata_1.metadataVocabulary,
+      metadata_1.contentVocabulary,
+      next_1.default,
+      unevaluated_1.default
+    ];
+    exports$1.default = draft2020Vocabularies;
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/schema.json
+var require_schema = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/schema.json"(exports$1, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/schema",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/core": true,
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true,
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+        "https://json-schema.org/draft/2020-12/vocab/validation": true,
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+        "https://json-schema.org/draft/2020-12/vocab/content": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Core and Validation specifications meta-schema",
+      allOf: [
+        { $ref: "meta/core" },
+        { $ref: "meta/applicator" },
+        { $ref: "meta/unevaluated" },
+        { $ref: "meta/validation" },
+        { $ref: "meta/meta-data" },
+        { $ref: "meta/format-annotation" },
+        { $ref: "meta/content" }
+      ],
+      type: ["object", "boolean"],
+      $comment: "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
+      properties: {
+        definitions: {
+          $comment: '"definitions" has been replaced by "$defs".',
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          deprecated: true,
+          default: {}
+        },
+        dependencies: {
+          $comment: '"dependencies" has been split and replaced by "dependentSchemas" and "dependentRequired" in order to serve their differing semantics.',
+          type: "object",
+          additionalProperties: {
+            anyOf: [{ $dynamicRef: "#meta" }, { $ref: "meta/validation#/$defs/stringArray" }]
+          },
+          deprecated: true,
+          default: {}
+        },
+        $recursiveAnchor: {
+          $comment: '"$recursiveAnchor" has been replaced by "$dynamicAnchor".',
+          $ref: "meta/core#/$defs/anchorString",
+          deprecated: true
+        },
+        $recursiveRef: {
+          $comment: '"$recursiveRef" has been replaced by "$dynamicRef".',
+          $ref: "meta/core#/$defs/uriReferenceString",
+          deprecated: true
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/applicator.json
+var require_applicator2 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/applicator.json"(exports$1, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/applicator",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Applicator vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        prefixItems: { $ref: "#/$defs/schemaArray" },
+        items: { $dynamicRef: "#meta" },
+        contains: { $dynamicRef: "#meta" },
+        additionalProperties: { $dynamicRef: "#meta" },
+        properties: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          default: {}
+        },
+        patternProperties: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          propertyNames: { format: "regex" },
+          default: {}
+        },
+        dependentSchemas: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          default: {}
+        },
+        propertyNames: { $dynamicRef: "#meta" },
+        if: { $dynamicRef: "#meta" },
+        then: { $dynamicRef: "#meta" },
+        else: { $dynamicRef: "#meta" },
+        allOf: { $ref: "#/$defs/schemaArray" },
+        anyOf: { $ref: "#/$defs/schemaArray" },
+        oneOf: { $ref: "#/$defs/schemaArray" },
+        not: { $dynamicRef: "#meta" }
+      },
+      $defs: {
+        schemaArray: {
+          type: "array",
+          minItems: 1,
+          items: { $dynamicRef: "#meta" }
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/unevaluated.json
+var require_unevaluated2 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/unevaluated.json"(exports$1, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/unevaluated",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Unevaluated applicator vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        unevaluatedItems: { $dynamicRef: "#meta" },
+        unevaluatedProperties: { $dynamicRef: "#meta" }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/content.json
+var require_content = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/content.json"(exports$1, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/content",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/content": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Content vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        contentEncoding: { type: "string" },
+        contentMediaType: { type: "string" },
+        contentSchema: { $dynamicRef: "#meta" }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/core.json
+var require_core3 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/core.json"(exports$1, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/core",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/core": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Core vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        $id: {
+          $ref: "#/$defs/uriReferenceString",
+          $comment: "Non-empty fragments not allowed.",
+          pattern: "^[^#]*#?$"
+        },
+        $schema: { $ref: "#/$defs/uriString" },
+        $ref: { $ref: "#/$defs/uriReferenceString" },
+        $anchor: { $ref: "#/$defs/anchorString" },
+        $dynamicRef: { $ref: "#/$defs/uriReferenceString" },
+        $dynamicAnchor: { $ref: "#/$defs/anchorString" },
+        $vocabulary: {
+          type: "object",
+          propertyNames: { $ref: "#/$defs/uriString" },
+          additionalProperties: {
+            type: "boolean"
+          }
+        },
+        $comment: {
+          type: "string"
+        },
+        $defs: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" }
+        }
+      },
+      $defs: {
+        anchorString: {
+          type: "string",
+          pattern: "^[A-Za-z_][-A-Za-z0-9._]*$"
+        },
+        uriString: {
+          type: "string",
+          format: "uri"
+        },
+        uriReferenceString: {
+          type: "string",
+          format: "uri-reference"
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/format-annotation.json
+var require_format_annotation = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/format-annotation.json"(exports$1, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/format-annotation",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Format vocabulary meta-schema for annotation results",
+      type: ["object", "boolean"],
+      properties: {
+        format: { type: "string" }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/meta-data.json
+var require_meta_data = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/meta-data.json"(exports$1, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/meta-data",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Meta-data vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        title: {
+          type: "string"
+        },
+        description: {
+          type: "string"
+        },
+        default: true,
+        deprecated: {
+          type: "boolean",
+          default: false
+        },
+        readOnly: {
+          type: "boolean",
+          default: false
+        },
+        writeOnly: {
+          type: "boolean",
+          default: false
+        },
+        examples: {
+          type: "array",
+          items: true
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json
+var require_validation2 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json"(exports$1, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/validation",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/validation": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Validation vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        type: {
+          anyOf: [
+            { $ref: "#/$defs/simpleTypes" },
+            {
+              type: "array",
+              items: { $ref: "#/$defs/simpleTypes" },
+              minItems: 1,
+              uniqueItems: true
+            }
+          ]
+        },
+        const: true,
+        enum: {
+          type: "array",
+          items: true
+        },
+        multipleOf: {
+          type: "number",
+          exclusiveMinimum: 0
+        },
+        maximum: {
+          type: "number"
+        },
+        exclusiveMaximum: {
+          type: "number"
+        },
+        minimum: {
+          type: "number"
+        },
+        exclusiveMinimum: {
+          type: "number"
+        },
+        maxLength: { $ref: "#/$defs/nonNegativeInteger" },
+        minLength: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
+        pattern: {
+          type: "string",
+          format: "regex"
+        },
+        maxItems: { $ref: "#/$defs/nonNegativeInteger" },
+        minItems: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
+        uniqueItems: {
+          type: "boolean",
+          default: false
+        },
+        maxContains: { $ref: "#/$defs/nonNegativeInteger" },
+        minContains: {
+          $ref: "#/$defs/nonNegativeInteger",
+          default: 1
+        },
+        maxProperties: { $ref: "#/$defs/nonNegativeInteger" },
+        minProperties: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
+        required: { $ref: "#/$defs/stringArray" },
+        dependentRequired: {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/$defs/stringArray"
+          }
+        }
+      },
+      $defs: {
+        nonNegativeInteger: {
+          type: "integer",
+          minimum: 0
+        },
+        nonNegativeIntegerDefault0: {
+          $ref: "#/$defs/nonNegativeInteger",
+          default: 0
+        },
+        simpleTypes: {
+          enum: ["array", "boolean", "integer", "null", "number", "object", "string"]
+        },
+        stringArray: {
+          type: "array",
+          items: { type: "string" },
+          uniqueItems: true,
+          default: []
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/index.js
+var require_json_schema_2020_12 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/index.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    var metaSchema = require_schema();
+    var applicator = require_applicator2();
+    var unevaluated = require_unevaluated2();
+    var content = require_content();
+    var core = require_core3();
+    var format = require_format_annotation();
+    var metadata = require_meta_data();
+    var validation = require_validation2();
+    var META_SUPPORT_DATA = ["/properties"];
+    function addMetaSchema2020($data) {
+      [
+        metaSchema,
+        applicator,
+        unevaluated,
+        content,
+        core,
+        with$data(this, format),
+        metadata,
+        with$data(this, validation)
+      ].forEach((sch) => this.addMetaSchema(sch, void 0, false));
+      return this;
+      function with$data(ajv, sch) {
+        return $data ? ajv.$dataMetaSchema(sch, META_SUPPORT_DATA) : sch;
+      }
+    }
+    exports$1.default = addMetaSchema2020;
+  }
+});
+
+// node_modules/ajv/dist/2020.js
+var require__ = __commonJS({
+  "node_modules/ajv/dist/2020.js"(exports$1, module) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.MissingRefError = exports$1.ValidationError = exports$1.CodeGen = exports$1.Name = exports$1.nil = exports$1.stringify = exports$1.str = exports$1._ = exports$1.KeywordCxt = exports$1.Ajv2020 = void 0;
+    var core_1 = require_core();
+    var draft2020_1 = require_draft2020();
+    var discriminator_1 = require_discriminator();
+    var json_schema_2020_12_1 = require_json_schema_2020_12();
+    var META_SCHEMA_ID = "https://json-schema.org/draft/2020-12/schema";
+    var Ajv20202 = class extends core_1.default {
+      constructor(opts = {}) {
+        super({
+          ...opts,
+          dynamicRef: true,
+          next: true,
+          unevaluated: true
+        });
+      }
+      _addVocabularies() {
+        super._addVocabularies();
+        draft2020_1.default.forEach((v) => this.addVocabulary(v));
+        if (this.opts.discriminator)
+          this.addKeyword(discriminator_1.default);
+      }
+      _addDefaultMetaSchema() {
+        super._addDefaultMetaSchema();
+        const { $data, meta } = this.opts;
+        if (!meta)
+          return;
+        json_schema_2020_12_1.default.call(this, $data);
+        this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
+      }
+      defaultMeta() {
+        return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
+      }
+    };
+    exports$1.Ajv2020 = Ajv20202;
+    module.exports = exports$1 = Ajv20202;
+    module.exports.Ajv2020 = Ajv20202;
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.default = Ajv20202;
+    var validate_1 = require_validate();
+    Object.defineProperty(exports$1, "KeywordCxt", { enumerable: true, get: function() {
+      return validate_1.KeywordCxt;
+    } });
+    var codegen_1 = require_codegen();
+    Object.defineProperty(exports$1, "_", { enumerable: true, get: function() {
+      return codegen_1._;
+    } });
+    Object.defineProperty(exports$1, "str", { enumerable: true, get: function() {
+      return codegen_1.str;
+    } });
+    Object.defineProperty(exports$1, "stringify", { enumerable: true, get: function() {
+      return codegen_1.stringify;
+    } });
+    Object.defineProperty(exports$1, "nil", { enumerable: true, get: function() {
+      return codegen_1.nil;
+    } });
+    Object.defineProperty(exports$1, "Name", { enumerable: true, get: function() {
+      return codegen_1.Name;
+    } });
+    Object.defineProperty(exports$1, "CodeGen", { enumerable: true, get: function() {
+      return codegen_1.CodeGen;
+    } });
+    var validation_error_1 = require_validation_error();
+    Object.defineProperty(exports$1, "ValidationError", { enumerable: true, get: function() {
+      return validation_error_1.default;
+    } });
+    var ref_error_1 = require_ref_error();
+    Object.defineProperty(exports$1, "MissingRefError", { enumerable: true, get: function() {
+      return ref_error_1.default;
+    } });
+  }
+});
+
 // src/step-machine/reducer.ts
 function applyStepResult(flow, state, stepName, stepResult) {
   const stepConfig = flow.steps[stepName];
@@ -10071,9 +10878,11 @@ var MemoryJournal = class {
     return this.buffer.length;
   }
 };
+
+// src/continuous-event-graph/reactive.ts
 function computeDataHash(data) {
   const json = stableStringify(data);
-  return crypto$1.createHash("sha256").update(json).digest("hex").slice(0, 16);
+  return fnv1a64Hex(json);
 }
 function stableStringify(value) {
   if (value === null || value === void 0 || typeof value !== "object") {
@@ -10086,13 +10895,49 @@ 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 {
@@ -10702,13 +11547,11 @@ function createNoopHandler(getResolve, staticData) {
 var live_cards_schema_default = {
   $schema: "http://json-schema.org/draft-07/schema#",
   $id: "https://nsreehari.github.io/boards/live-cards.schema.json",
-  title: "LiveCards Node Schema",
-  description: "Schema for Card and ExternalSource nodes in the LiveCards Board/Canvas engine",
   definitions: {
     bind_ref: {
-      description: "A state path reference, e.g. 'state.raw_quotes' or 'requires.upstream'",
+      description: "A card data path reference, e.g. 'card_data.raw_quotes' or 'requires.upstream'",
       type: "string",
-      pattern: "^(state|requires|computed_values)\\."
+      pattern: "^(card_data|requires|fetched_sources|computed_values)(\\.|$)"
     },
     bind_or_literal: {
       description: "A literal value or a bind reference object",
@@ -10777,7 +11620,7 @@ var live_cards_schema_default = {
           ]
         },
         input: {
-          description: "state.path, literal, array of inputs, or nested compute_expr",
+          description: "card_data.path, literal, array of inputs, or nested compute_expr",
           oneOf: [
             { type: "string" },
             { type: "number" },
@@ -10813,18 +11656,18 @@ var live_cards_schema_default = {
         required: ["bindTo", "src"],
         properties: {
           bindTo: { type: "string", description: "Token name published downstream" },
-          src: { type: "string", description: "Path to read value from (state.*, requires.*, computed_values.*)" }
+          src: { type: "string", description: "Path to read value from (card_data.*, requires.*, fetched_sources.*, computed_values.*)" }
         }
       },
-      description: "Explicit bindings exposing computed/state values downstream as named tokens"
+      description: "Explicit bindings exposing computed or card_data values downstream as named tokens"
     },
     compute_step: {
-      description: "A single ordered compute step: reads state.*/requires.*/computed_values.*, writes to computed_values[bindTo]",
+      description: "A single ordered compute step: reads card_data.*/requires.*/computed_values.*, writes to computed_values[bindTo]",
       type: "object",
       required: ["bindTo", "expr"],
       properties: {
         bindTo: { type: "string", description: "Key in computed_values to write result" },
-        expr: { type: "string", description: "JSONata expression evaluated against { state, requires, sources, computed_values }" }
+        expr: { type: "string", description: "JSONata expression evaluated against { card_data, requires, fetched_sources, computed_values }" }
       }
     },
     source_def: {
@@ -10833,7 +11676,7 @@ var live_cards_schema_default = {
       required: ["bindTo"],
       additionalProperties: true,
       properties: {
-        bindTo: { type: "string", description: "Key under sources.* available in compute expressions" },
+        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)." },
@@ -10861,19 +11704,17 @@ var live_cards_schema_default = {
             "text",
             "markdown",
             "custom",
-            "file-upload",
-            "chat",
             "actions"
           ]
         },
         label: { type: "string", description: "Heading above this element" },
         className: { type: "string", description: "Bootstrap grid class, e.g. 'col-12 col-md-6'" },
-        visible: { type: "string", description: "state path \u2014 element shown only if truthy" },
+        visible: { type: "string", description: "card_data/requires/fetched_sources/computed_values path \u2014 element shown only if truthy" },
         data: {
           type: "object",
           properties: {
-            bind: { $ref: "#/definitions/bind_ref", description: "state path to read data from" },
-            writeTo: { $ref: "#/definitions/bind_ref", description: "state path for user input (form, filter, todo, notes)" },
+            bind: { $ref: "#/definitions/bind_ref", description: "card_data/requires/fetched_sources/computed_values path to read data from" },
+            writeTo: { $ref: "#/definitions/bind_ref", description: "card_data path for user input (form, filter, todo, notes)" },
             columns: { type: "array", items: { type: "string" }, description: "table: visible columns" },
             maxRows: { type: "integer", description: "table/list: max rows to display" },
             sortable: { type: "boolean", default: true, description: "table: enable click-to-sort" },
@@ -10906,7 +11747,7 @@ var live_cards_schema_default = {
                   label: { type: "string" },
                   style: { type: "string", description: "Bootstrap button variant, e.g. 'success', 'outline-danger'" },
                   size: { type: "string", default: "sm" },
-                  disabled: { oneOf: [{ type: "boolean" }, { type: "string", description: "state path \u2014 truthy = disabled" }] }
+                  disabled: { oneOf: [{ type: "boolean" }, { type: "string", description: "card_data/requires/fetched_sources/computed_values path \u2014 truthy = disabled" }] }
                 }
               }
             }
@@ -10966,14 +11807,39 @@ var live_cards_schema_default = {
     provides: { $ref: "#/definitions/provides" },
     meta: { $ref: "#/definitions/meta" },
     view: { $ref: "#/definitions/view" },
-    state: {
+    card_data: {
       type: "object",
-      additionalProperties: true,
+      description: "Authored card data supplied in the card definition",
       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
+          }
+        }
+      },
+      additionalProperties: true
     },
     sources: {
       type: "array",
@@ -10982,7 +11848,7 @@ var live_cards_schema_default = {
     },
     compute: {
       type: "array",
-      description: "Ordered array of compute steps. Each reads state.*/requires.*/sources.*/computed_values.* and writes to ephemeral computed_values[bindTo].",
+      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" }
     }
   }
@@ -10991,6 +11857,57 @@ var live_cards_schema_default = {
 // src/card-compute/schema-validator.ts
 var import_ajv3 = __toESM(require_ajv());
 var _compiled3 = null;
+var NAMESPACE_REFERENCE_RE = /\b(card_data|requires|fetched_sources|computed_values|sources)\b/g;
+var ROOT_PATH_NAMESPACE_RE = /^\s*(card_data|requires|fetched_sources|computed_values|sources)(\.|$)/;
+function referencedNamespaces(expression) {
+  const namespaces = /* @__PURE__ */ new Set();
+  let match;
+  NAMESPACE_REFERENCE_RE.lastIndex = 0;
+  while ((match = NAMESPACE_REFERENCE_RE.exec(expression)) !== null) {
+    namespaces.add(match[1]);
+  }
+  return namespaces;
+}
+function parseRootPathNamespace(pathValue) {
+  const match = ROOT_PATH_NAMESPACE_RE.exec(pathValue);
+  return match ? match[1] : null;
+}
+function validateJsonataExprWithNamespaces(expr, path, allowedNamespaces, errors) {
+  try {
+    jsonata2__default.default(expr);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    errors.push(`${path}: invalid JSONata expression (${message})`);
+    return;
+  }
+  const usedNamespaces = referencedNamespaces(expr);
+  for (const namespace of usedNamespaces) {
+    if (!allowedNamespaces.has(namespace)) {
+      errors.push(`${path}: disallowed namespace "${namespace}" in expression`);
+    }
+  }
+}
+function walkViewPathReferences(value, path, errors) {
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => {
+      walkViewPathReferences(entry, `${path}/${index}`, errors);
+    });
+    return;
+  }
+  if (typeof value === "string") {
+    const rootNamespace = parseRootPathNamespace(value);
+    if (!rootNamespace) return;
+    if (!(/* @__PURE__ */ new Set(["card_data", "requires", "fetched_sources", "computed_values"])).has(rootNamespace)) {
+      errors.push(`${path}: disallowed namespace "${rootNamespace}" in view reference`);
+    }
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+  const record = value;
+  for (const [key, next2] of Object.entries(record)) {
+    walkViewPathReferences(next2, `${path}/${key}`, errors);
+  }
+}
 function getValidator3() {
   if (_compiled3) return _compiled3;
   const ajv = new import_ajv3.default({ allErrors: true });
@@ -11008,6 +11925,42 @@ function validateLiveCardSchema(node) {
   });
   return { ok: false, errors };
 }
+function validateLiveCardRuntimeExpressions(node) {
+  const errors = [];
+  if (!node || typeof node !== "object" || Array.isArray(node)) {
+    return { ok: true, errors: [] };
+  }
+  const asRecord = node;
+  const compute = asRecord.compute;
+  if (Array.isArray(compute)) {
+    compute.forEach((step, i) => {
+      if (!step || typeof step !== "object" || Array.isArray(step)) return;
+      const expr = step.expr;
+      if (typeof expr !== "string" || expr.trim().length === 0) return;
+      validateJsonataExprWithNamespaces(
+        expr,
+        `/compute/${i}/expr`,
+        /* @__PURE__ */ new Set(["card_data", "requires", "fetched_sources", "computed_values"]),
+        errors
+      );
+    });
+  }
+  const view = asRecord.view;
+  if (view && typeof view === "object" && !Array.isArray(view)) {
+    walkViewPathReferences(view, "/view", errors);
+  }
+  return { ok: errors.length === 0, errors };
+}
+function validateLiveCard(node) {
+  return validateLiveCardDefinition(node);
+}
+function validateLiveCardDefinition(node) {
+  const schema = validateLiveCardSchema(node);
+  if (!schema.ok) return schema;
+  const runtime = validateLiveCardRuntimeExpressions(node);
+  if (!runtime.ok) return { ok: false, errors: runtime.errors };
+  return { ok: true, errors: [] };
+}
 
 // src/card-compute/index.ts
 function deepGet(obj, path) {
@@ -11031,18 +11984,18 @@ function deepSet(obj, path, value) {
 }
 async function run(node, options) {
   if (!node?.compute?.length) return node;
-  if (!node.state) node.state = {};
+  if (!node.card_data) node.card_data = {};
   node.computed_values = {};
   node._sourcesData = options?.sourcesData ?? {};
   const ctx = {
-    state: node.state,
+    card_data: node.card_data,
     requires: node.requires ?? {},
-    sources: node._sourcesData,
+    fetched_sources: node._sourcesData,
     computed_values: node.computed_values
   };
   for (const step of node.compute) {
     try {
-      const val = await jsonata__default.default(step.expr).evaluate(ctx);
+      const val = await jsonata2__default.default(step.expr).evaluate(ctx);
       deepSet(node.computed_values, step.bindTo, val);
       ctx.computed_values = node.computed_values;
     } catch (err) {
@@ -11053,16 +12006,16 @@ async function run(node, options) {
 }
 async function evalExpr(expr, node) {
   const ctx = {
-    state: node.state ?? {},
+    card_data: node.card_data ?? {},
     requires: node.requires ?? {},
-    sources: node._sourcesData ?? {},
+    fetched_sources: node._sourcesData ?? {},
     computed_values: node.computed_values ?? {}
   };
-  return jsonata__default.default(expr).evaluate(ctx);
+  return jsonata2__default.default(expr).evaluate(ctx);
 }
 function resolve(node, path) {
-  if (path.startsWith("sources.")) {
-    return deepGet(node._sourcesData ?? {}, path.slice("sources.".length));
+  if (path.startsWith("fetched_sources.")) {
+    return deepGet(node._sourcesData ?? {}, path.slice("fetched_sources.".length));
   }
   return deepGet(node, path);
 }
@@ -11082,8 +12035,7 @@ var VALID_ELEMENT_KINDS = /* @__PURE__ */ new Set([
   "markdown",
   "custom"
 ]);
-var VALID_STATUSES = /* @__PURE__ */ new Set(["fresh", "stale", "loading", "error"]);
-var ALLOWED_KEYS = /* @__PURE__ */ new Set(["id", "meta", "requires", "provides", "view", "state", "compute", "sources"]);
+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)) {
@@ -11094,13 +12046,8 @@ function validateNode(node) {
   for (const key of Object.keys(n)) {
     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)) {
@@ -11189,11 +12136,21 @@ function validateNode(node) {
   }
   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
+  validate: validateNode,
+  enrichSources
 };
 
 // src/continuous-event-graph/live-cards-bridge.ts
@@ -11229,7 +12186,7 @@ function liveCardsToReactiveGraph(input, options = {}) {
   const allTokens = /* @__PURE__ */ new Set();
   const tokenToCardId = /* @__PURE__ */ new Map();
   for (const card of cards) {
-    for (const binding of card.provides ?? [{ bindTo: card.id, src: `state.${card.id}` }]) {
+    for (const binding of card.provides ?? [{ bindTo: card.id, src: "card_data" }]) {
       allTokens.add(binding.bindTo);
       tokenToCardId.set(binding.bindTo, card.id);
     }
@@ -11243,7 +12200,7 @@ function liveCardsToReactiveGraph(input, options = {}) {
     }
     tasks[card.id] = {
       requires: requires.length > 0 ? requires : void 0,
-      provides: (card.provides ?? [{ bindTo: card.id, src: `state.${card.id}` }]).map((p) => p.bindTo),
+      provides: (card.provides ?? [{ bindTo: card.id, src: "card_data" }]).map((p) => p.bindTo),
       taskHandlers: [card.id],
       description: card.meta?.title ?? card.id
     };
@@ -11295,9 +12252,9 @@ 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";
   };
 }
@@ -11320,7 +12277,7 @@ function buildCardHandler(card, cardHandlers, sharedState, _cardMap, tokenToCard
     }
     const computeNode = {
       id: card.id,
-      state: { ...card.state },
+      card_data: { ...card.card_data },
       requires: requiresData,
       compute: card.compute
     };
@@ -11332,15 +12289,252 @@ function buildCardHandler(card, cardHandlers, sharedState, _cardMap, tokenToCard
         resultData[bindTo] = CardCompute.resolve(computeNode, src);
       }
     } else {
-      resultData = { ...computeNode.state, ...computeNode.computed_values };
+      resultData = { ...computeNode.card_data, ...computeNode.computed_values };
     }
-    const resultState = { ...computeNode.state, ...computeNode.computed_values };
+    const resultState = { ...computeNode.card_data, ...computeNode.computed_values };
     sharedState.set(card.id, resultState);
     getResolve()(input.callbackToken, resultData);
     return "task-initiated";
   };
 }
 
+// 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 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
 var DEFAULT_THRESHOLD = 0.5;
 var DEFAULT_SYSTEM_PROMPT = `You are a workflow completion analyzer. Given a graph of tasks with their current states, evidence, and inference hints, determine which tasks appear to be completed based on the available evidence.
@@ -11592,6 +12786,190 @@ function createHttpAdapter(opts) {
   };
 }
 
+// schema/board-status.schema.json
+var board_status_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://yaml-flow.dev/schema/board-status.schema.json",
+  title: "Board Status Object",
+  type: "object",
+  additionalProperties: false,
+  required: ["schema_version", "meta", "summary", "cards"],
+  properties: {
+    schema_version: {
+      type: "string",
+      const: "v1"
+    },
+    meta: {
+      type: "object",
+      additionalProperties: false,
+      required: ["board"],
+      properties: {
+        board: {
+          type: "object",
+          additionalProperties: false,
+          required: ["path"],
+          properties: {
+            path: { type: "string" }
+          }
+        }
+      }
+    },
+    summary: {
+      type: "object",
+      additionalProperties: false,
+      required: ["card_count", "completed", "eligible", "pending", "blocked", "unresolved"],
+      properties: {
+        card_count: { type: "integer", minimum: 0 },
+        completed: { type: "integer", minimum: 0 },
+        eligible: { type: "integer", minimum: 0 },
+        pending: { type: "integer", minimum: 0 },
+        blocked: { type: "integer", minimum: 0 },
+        unresolved: { type: "integer", minimum: 0 },
+        failed: { type: "integer", minimum: 0 },
+        in_progress: { type: "integer", minimum: 0 },
+        orphan_cards: { type: "integer", minimum: 0 },
+        topology: {
+          type: "object",
+          additionalProperties: false,
+          required: ["edge_count", "max_fan_out_card", "max_fan_out"],
+          properties: {
+            edge_count: { type: "integer", minimum: 0 },
+            max_fan_out_card: { type: ["string", "null"] },
+            max_fan_out: { type: "integer", minimum: 0 }
+          }
+        }
+      }
+    },
+    cards: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: [
+          "name",
+          "status",
+          "requires",
+          "requires_satisfied",
+          "requires_missing",
+          "provides_declared",
+          "provides_runtime",
+          "blocked_by",
+          "unblocks",
+          "runtime"
+        ],
+        properties: {
+          name: { type: "string" },
+          status: { type: "string" },
+          error: {
+            type: "object",
+            additionalProperties: false,
+            required: ["message"],
+            properties: {
+              message: { type: "string" },
+              code: { type: "string" },
+              at: { type: ["string", "null"] },
+              source: { type: "string" }
+            }
+          },
+          requires: { type: "array", items: { type: "string" } },
+          requires_satisfied: { type: "array", items: { type: "string" } },
+          requires_missing: { type: "array", items: { type: "string" } },
+          provides_declared: { type: "array", items: { type: "string" } },
+          provides_runtime: { type: "array", items: { type: "string" } },
+          blocked_by: { type: "array", items: { type: "string" } },
+          unblocks: { type: "array", items: { type: "string" } },
+          runtime: {
+            type: "object",
+            additionalProperties: false,
+            required: [
+              "attempt_count",
+              "restart_count",
+              "in_progress_since",
+              "last_transition_at",
+              "last_completed_at",
+              "last_restarted_at",
+              "status_age_ms"
+            ],
+            properties: {
+              attempt_count: { type: "integer", minimum: 0 },
+              restart_count: { type: "integer", minimum: 0 },
+              in_progress_since: { type: ["string", "null"] },
+              last_transition_at: { type: ["string", "null"] },
+              last_completed_at: { type: ["string", "null"] },
+              last_restarted_at: { type: ["string", "null"] },
+              status_age_ms: { type: ["integer", "null"], minimum: 0 }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+// schema/card-runtime.schema.json
+var card_runtime_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://yaml-flow.dev/schema/card-runtime.schema.json",
+  title: "Card Runtime Computed Artifact",
+  description: "Published per-card runtime artifact written to runtime-out/cards/<card-id>.computed.json. Contains only values produced by the compute step.",
+  type: "object",
+  required: ["schema_version", "card_id", "computed_values"],
+  additionalProperties: false,
+  properties: {
+    schema_version: {
+      type: "string",
+      const: "v1",
+      description: "Artifact schema version."
+    },
+    card_id: {
+      type: "string",
+      description: "The ID of the card this artifact belongs to."
+    },
+    computed_values: {
+      type: "object",
+      description: "Key/value map of outputs produced by the card's JSONata compute steps.",
+      additionalProperties: true
+    }
+  }
+};
+
+// src/runtime-artifacts/schema-validator.ts
+var import__ = __toESM(require__());
+var boardStatusValidator = null;
+var cardRuntimeValidator = null;
+function createAjv() {
+  const ajv = new import__.default({ allErrors: true, strict: false });
+  addFormats__default.default(ajv);
+  return ajv;
+}
+function toValidationResult(validate) {
+  const errors = (validate.errors ?? []).map((error) => {
+    const instancePath = error.instancePath || "/";
+    return `${instancePath}: ${error.message ?? "unknown error"}`;
+  });
+  return { ok: false, errors };
+}
+function getBoardStatusValidator() {
+  if (boardStatusValidator) return boardStatusValidator;
+  boardStatusValidator = createAjv().compile(board_status_schema_default);
+  return boardStatusValidator;
+}
+function getCardRuntimeValidator() {
+  if (cardRuntimeValidator) return cardRuntimeValidator;
+  cardRuntimeValidator = createAjv().compile(card_runtime_schema_default);
+  return cardRuntimeValidator;
+}
+function validateBoardStatusSchema(statusObject) {
+  const validate = getBoardStatusValidator();
+  if (validate(statusObject)) return { ok: true, errors: [] };
+  return toValidationResult(validate);
+}
+function validateCardRuntimeSchema(cardRuntimeObject) {
+  const validate = getCardRuntimeValidator();
+  if (validate(cardRuntimeObject)) return { ok: true, errors: [] };
+  return toValidationResult(validate);
+}
+
 exports.COMPLETION_STRATEGIES = COMPLETION_STRATEGIES;
 exports.CONFLICT_STRATEGIES = CONFLICT_STRATEGIES;
 exports.CardCompute = CardCompute;
@@ -11620,6 +12998,7 @@ exports.buildInferencePrompt = buildInferencePrompt;
 exports.checkCircuitBreaker = checkCircuitBreaker;
 exports.computeAvailableOutputs = computeAvailableOutputs;
 exports.computeStepInput = computeStepInput;
+exports.createBoardLiveGraphRuntime = createBoardLiveGraphRuntime;
 exports.createCallbackHandler = createCallbackHandler;
 exports.createCliAdapter = createCliAdapter;
 exports.createDefaultGraphEngineStore = createDefaultGraphEngineStore;
@@ -11681,10 +13060,15 @@ exports.resolveVariables = resolveVariables;
 exports.restore = restore;
 exports.schedule = schedule;
 exports.snapshot = snapshot;
+exports.validateBoardStatusSchema = validateBoardStatusSchema;
+exports.validateCardRuntimeSchema = validateCardRuntimeSchema;
 exports.validateFlowSchema = validateFlowSchema;
 exports.validateGraph = validateGraph;
 exports.validateGraphConfig = validateGraphConfig;
 exports.validateGraphSchema = validateGraphSchema;
+exports.validateLiveCard = validateLiveCard;
+exports.validateLiveCardDefinition = validateLiveCardDefinition;
+exports.validateLiveCardRuntimeExpressions = validateLiveCardRuntimeExpressions;
 exports.validateLiveCardSchema = validateLiveCardSchema;
 exports.validateLiveGraph = validateLiveGraph;
 exports.validateReactiveGraph = validateReactiveGraph;