yaml-flow 4.0.0 → 5.0.0

package/dist/card-compute/index.d.cts

@@ -20,6 +20,17 @@
  * Returns the same `ValidationResult` shape as `CardCompute.validate()`.
  */
 declare function validateLiveCardSchema(node: unknown): ValidationResult;
+/**
+ * Validate JSONata expressions in compute[] by compiling with the same parser used at runtime.
+ */
+declare function validateLiveCardRuntimeExpressions(node: unknown): ValidationResult;
+declare function validateLiveCard(node: unknown): ValidationResult;
+/**
+ * Full validation for live card definitions:
+ * 1) JSON Schema structure/contract checks
+ * 2) Runtime JSONata parser compatibility checks for compute expressions
+ */
+declare function validateLiveCardDefinition(node: unknown): ValidationResult;
 
 /**
  * card-compute — JSONata-powered compute engine for LiveCards nodes.
@@ -33,10 +44,10 @@ declare function validateLiveCardSchema(node: unknown): ValidationResult;
  *
  * const node = {
  *   id: 'sales',
- *   state: { data: [{ revenue: 100 }, { revenue: 200 }] },
+ *   card_data: { data: [{ revenue: 100 }, { revenue: 200 }] },
  *   compute: [
- *     { bindTo: 'total', expr: '$sum(state.data.revenue)' },
- *     { bindTo: 'avg',   expr: '$average(state.data.revenue)' },
+ *     { bindTo: 'total', expr: '$sum(card_data.data.revenue)' },
+ *     { bindTo: 'avg',   expr: '$average(card_data.data.revenue)' },
  *   ],
  * };
  * await CardCompute.run(node);
@@ -44,10 +55,10 @@ declare function validateLiveCardSchema(node: unknown): ValidationResult;
  * // node.computed_values.avg   === 150
  * ```
  *
- * Expressions are evaluated against { state, requires, computed_values }.
+ * Expressions are evaluated against { card_data, requires, fetched_sources, computed_values }.
  * computed_values is ephemeral — never persisted to disk.
  */
-/** A source definition: cli writes to outputFile; bindTo names the sources.* key in compute context. */
+/** A source definition: cli writes to outputFile; bindTo names the fetched_sources.* key in compute context. */
 interface ComputeSource {
     bindTo: string;
     outputFile?: string;
@@ -58,7 +69,7 @@ interface ComputeSource {
 }
 /** Options for CardCompute.run() */
 interface RunOptions {
-    /** Pre-loaded sources data map (keyed by bindTo). Use in browser or when caller loads files. */
+    /** Pre-loaded source results map (keyed by bindTo). Use in browser or when caller loads files. */
     sourcesData?: Record<string, unknown>;
 }
 /** A single compute step: bindTo names the computed_values key; expr is a JSONata expression. */
@@ -69,7 +80,7 @@ interface ComputeStep {
 /** Minimal node shape expected by CardCompute. */
 interface ComputeNode {
     id?: string;
-    state?: Record<string, unknown>;
+    card_data?: Record<string, unknown>;
     requires?: Record<string, unknown>;
     sources?: ComputeSource[];
     compute?: ComputeStep[];
@@ -80,18 +91,18 @@ interface ComputeNode {
 }
 /**
  * Run all compute steps on a node.
- * Each step's expr is evaluated against { state, requires, sources, computed_values }.
+ * Each step's expr is evaluated against { card_data, requires, fetched_sources, computed_values }.
  * Results are written to node.computed_values[bindTo].
  * computed_values and _sourcesData are reset on each call — ephemeral, never persisted.
  *
- * @param options.sourcesData  Pre-loaded map of { [bindTo]: data } for sources namespace.
+ * @param options.sourcesData  Pre-loaded map of { [bindTo]: data } for fetched_sources namespace.
  *   In Node/CLI: loaded from outputFiles by the caller (card-handler).
  *   In browser:  passed in by the caller (e.g. from fetch results).
  */
 declare function run(node: ComputeNode, options?: RunOptions): Promise<ComputeNode>;
 /**
  * Evaluate a single JSONata expression against a node's context.
- * Context is { state, requires, sources, computed_values }.
+ * Context is { card_data, requires, fetched_sources, computed_values }.
  */
 declare function evalExpr(expr: string, node: ComputeNode): Promise<unknown>;
 declare function resolve(node: ComputeNode, path: string): unknown;
@@ -101,11 +112,25 @@ interface ValidationResult {
     errors: string[];
 }
 declare function validateNode(node: unknown): ValidationResult;
+/**
+ * Enrich sources with execution context for template interpolation and prompt rendering.
+ * Pure function: no side effects, returns new enriched sources array.
+ *
+ * @param sources - Array of source definitions
+ * @param context - Execution context containing requires, sourcesData, computed_values
+ * @returns New array of sources with _requires, _sourcesData, _computed_values attached
+ */
+declare function enrichSources(sources: any[] | undefined, context: {
+    requires?: Record<string, any>;
+    sourcesData?: Record<string, any>;
+    computed_values?: Record<string, any>;
+}): any[];
 declare const CardCompute: {
     run: typeof run;
     eval: typeof evalExpr;
     resolve: typeof resolve;
     validate: typeof validateNode;
+    enrichSources: typeof enrichSources;
 };
 
-export { CardCompute, type ComputeNode, type ComputeSource, type ComputeStep, type RunOptions, type ValidationResult, CardCompute as default, validateLiveCardSchema };
+export { CardCompute, type ComputeNode, type ComputeSource, type ComputeStep, type RunOptions, type ValidationResult, CardCompute as default, validateLiveCard, validateLiveCardDefinition, validateLiveCardRuntimeExpressions, validateLiveCardSchema };

package/dist/card-compute/index.d.ts

@@ -20,6 +20,17 @@
  * Returns the same `ValidationResult` shape as `CardCompute.validate()`.
  */
 declare function validateLiveCardSchema(node: unknown): ValidationResult;
+/**
+ * Validate JSONata expressions in compute[] by compiling with the same parser used at runtime.
+ */
+declare function validateLiveCardRuntimeExpressions(node: unknown): ValidationResult;
+declare function validateLiveCard(node: unknown): ValidationResult;
+/**
+ * Full validation for live card definitions:
+ * 1) JSON Schema structure/contract checks
+ * 2) Runtime JSONata parser compatibility checks for compute expressions
+ */
+declare function validateLiveCardDefinition(node: unknown): ValidationResult;
 
 /**
  * card-compute — JSONata-powered compute engine for LiveCards nodes.
@@ -33,10 +44,10 @@ declare function validateLiveCardSchema(node: unknown): ValidationResult;
  *
  * const node = {
  *   id: 'sales',
- *   state: { data: [{ revenue: 100 }, { revenue: 200 }] },
+ *   card_data: { data: [{ revenue: 100 }, { revenue: 200 }] },
  *   compute: [
- *     { bindTo: 'total', expr: '$sum(state.data.revenue)' },
- *     { bindTo: 'avg',   expr: '$average(state.data.revenue)' },
+ *     { bindTo: 'total', expr: '$sum(card_data.data.revenue)' },
+ *     { bindTo: 'avg',   expr: '$average(card_data.data.revenue)' },
  *   ],
  * };
  * await CardCompute.run(node);
@@ -44,10 +55,10 @@ declare function validateLiveCardSchema(node: unknown): ValidationResult;
  * // node.computed_values.avg   === 150
  * ```
  *
- * Expressions are evaluated against { state, requires, computed_values }.
+ * Expressions are evaluated against { card_data, requires, fetched_sources, computed_values }.
  * computed_values is ephemeral — never persisted to disk.
  */
-/** A source definition: cli writes to outputFile; bindTo names the sources.* key in compute context. */
+/** A source definition: cli writes to outputFile; bindTo names the fetched_sources.* key in compute context. */
 interface ComputeSource {
     bindTo: string;
     outputFile?: string;
@@ -58,7 +69,7 @@ interface ComputeSource {
 }
 /** Options for CardCompute.run() */
 interface RunOptions {
-    /** Pre-loaded sources data map (keyed by bindTo). Use in browser or when caller loads files. */
+    /** Pre-loaded source results map (keyed by bindTo). Use in browser or when caller loads files. */
     sourcesData?: Record<string, unknown>;
 }
 /** A single compute step: bindTo names the computed_values key; expr is a JSONata expression. */
@@ -69,7 +80,7 @@ interface ComputeStep {
 /** Minimal node shape expected by CardCompute. */
 interface ComputeNode {
     id?: string;
-    state?: Record<string, unknown>;
+    card_data?: Record<string, unknown>;
     requires?: Record<string, unknown>;
     sources?: ComputeSource[];
     compute?: ComputeStep[];
@@ -80,18 +91,18 @@ interface ComputeNode {
 }
 /**
  * Run all compute steps on a node.
- * Each step's expr is evaluated against { state, requires, sources, computed_values }.
+ * Each step's expr is evaluated against { card_data, requires, fetched_sources, computed_values }.
  * Results are written to node.computed_values[bindTo].
  * computed_values and _sourcesData are reset on each call — ephemeral, never persisted.
  *
- * @param options.sourcesData  Pre-loaded map of { [bindTo]: data } for sources namespace.
+ * @param options.sourcesData  Pre-loaded map of { [bindTo]: data } for fetched_sources namespace.
  *   In Node/CLI: loaded from outputFiles by the caller (card-handler).
  *   In browser:  passed in by the caller (e.g. from fetch results).
  */
 declare function run(node: ComputeNode, options?: RunOptions): Promise<ComputeNode>;
 /**
  * Evaluate a single JSONata expression against a node's context.
- * Context is { state, requires, sources, computed_values }.
+ * Context is { card_data, requires, fetched_sources, computed_values }.
  */
 declare function evalExpr(expr: string, node: ComputeNode): Promise<unknown>;
 declare function resolve(node: ComputeNode, path: string): unknown;
@@ -101,11 +112,25 @@ interface ValidationResult {
     errors: string[];
 }
 declare function validateNode(node: unknown): ValidationResult;
+/**
+ * Enrich sources with execution context for template interpolation and prompt rendering.
+ * Pure function: no side effects, returns new enriched sources array.
+ *
+ * @param sources - Array of source definitions
+ * @param context - Execution context containing requires, sourcesData, computed_values
+ * @returns New array of sources with _requires, _sourcesData, _computed_values attached
+ */
+declare function enrichSources(sources: any[] | undefined, context: {
+    requires?: Record<string, any>;
+    sourcesData?: Record<string, any>;
+    computed_values?: Record<string, any>;
+}): any[];
 declare const CardCompute: {
     run: typeof run;
     eval: typeof evalExpr;
     resolve: typeof resolve;
     validate: typeof validateNode;
+    enrichSources: typeof enrichSources;
 };
 
-export { CardCompute, type ComputeNode, type ComputeSource, type ComputeStep, type RunOptions, type ValidationResult, CardCompute as default, validateLiveCardSchema };
+export { CardCompute, type ComputeNode, type ComputeSource, type ComputeStep, type RunOptions, type ValidationResult, CardCompute as default, validateLiveCard, validateLiveCardDefinition, validateLiveCardRuntimeExpressions, validateLiveCardSchema };

package/dist/card-compute/index.js

@@ -1,4 +1,4 @@
-import jsonata from 'jsonata';
+import jsonata2 from 'jsonata';
 import addFormats from 'ajv-formats';
 
 var __create = Object.create;
@@ -6416,13 +6416,11 @@ var require_ajv = __commonJS({
 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",
@@ -6491,7 +6489,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" },
@@ -6527,18 +6525,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: {
@@ -6547,7 +6545,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)." },
@@ -6575,19 +6573,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" },
@@ -6620,7 +6616,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" }] }
                 }
               }
             }
@@ -6680,14 +6676,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",
@@ -6696,7 +6717,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" }
     }
   }
@@ -6705,6 +6726,57 @@ var live_cards_schema_default = {
 // src/card-compute/schema-validator.ts
 var import_ajv = __toESM(require_ajv());
 var _compiled = 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, next] of Object.entries(record)) {
+    walkViewPathReferences(next, `${path}/${key}`, errors);
+  }
+}
 function getValidator() {
   if (_compiled) return _compiled;
   const ajv = new import_ajv.default({ allErrors: true });
@@ -6722,6 +6794,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) {
@@ -6745,18 +6853,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) {
@@ -6767,16 +6875,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);
 }
@@ -6796,8 +6904,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)) {
@@ -6808,13 +6915,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)) {
@@ -6903,14 +7005,24 @@ 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
 };
 var card_compute_default = CardCompute;
 
-export { CardCompute, card_compute_default as default, validateLiveCardSchema };
+export { CardCompute, card_compute_default as default, validateLiveCard, validateLiveCardDefinition, validateLiveCardRuntimeExpressions, validateLiveCardSchema };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map