yaml-flow 4.0.0 → 5.1.0

package/dist/index.js

@@ -1,7 +1,6 @@
 import addFormats from 'ajv-formats';
-import { createHash } from 'crypto';
 import { exec, execFile } from 'child_process';
-import jsonata from 'jsonata';
+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];
@@ -10064,9 +10871,11 @@ var MemoryJournal = class {
     return this.buffer.length;
   }
 };
+
+// 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,13 +10888,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 {
@@ -10695,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 '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",
@@ -10770,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" },
@@ -10806,18 +11649,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: {
@@ -10826,7 +11669,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)." },
@@ -10854,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" },
@@ -10899,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" }] }
                 }
               }
             }
@@ -10959,14 +11800,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",
@@ -10975,7 +11841,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" }
     }
   }
@@ -10984,6 +11850,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(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 });
@@ -11001,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) {
@@ -11024,18 +11977,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(step.expr).evaluate(ctx);
+      const val = await jsonata2(step.expr).evaluate(ctx);
       deepSet(node.computed_values, step.bindTo, val);
       ctx.computed_values = node.computed_values;
     } catch (err) {
@@ -11046,16 +11999,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(expr).evaluate(ctx);
+  return jsonata2(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);
 }
@@ -11075,8 +12028,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)) {
@@ -11087,13 +12039,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)) {
@@ -11182,11 +12129,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
@@ -11222,7 +12179,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);
     }
@@ -11236,7 +12193,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
     };
@@ -11288,9 +12245,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";
   };
 }
@@ -11313,7 +12270,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
     };
@@ -11325,15 +12282,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.
@@ -11585,6 +12779,190 @@ function createHttpAdapter(opts) {
   };
 }
 
-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, 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