@decaf-ts/integrations 0.3.7 → 0.3.9

package/lib/esm/graph/engine/snapshots/index.js

@@ -0,0 +1,7 @@
+/**
+ * @module integrations/graph/snapshots
+ * @summary Graph execution snapshot mapping.
+ * @description Re-exports the snapshot patch mapper.
+ */
+export * from "./GraphExecutionSnapshotMapper.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvZW5naW5lL3NuYXBzaG90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsa0RBQStDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaC9zbmFwc2hvdHNcbiAqIEBzdW1tYXJ5IEdyYXBoIGV4ZWN1dGlvbiBzbmFwc2hvdCBtYXBwaW5nLlxuICogQGRlc2NyaXB0aW9uIFJlLWV4cG9ydHMgdGhlIHNuYXBzaG90IHBhdGNoIG1hcHBlci5cbiAqL1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhFeGVjdXRpb25TbmFwc2hvdE1hcHBlclwiO1xuIl19

package/lib/esm/graph/engine/store/GraphCachedValue.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhDYWNoZWRWYWx1ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9ncmFwaC9lbmdpbmUvc3RvcmUvR3JhcGhDYWNoZWRWYWx1ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaC9zdG9yZS9HcmFwaENhY2hlZFZhbHVlXG4gKiBAc3VtbWFyeSBBIGNhY2hlZCBncmFwaCB2YWx1ZSB3aXRoIHBpbm5pbmcgbWV0YWRhdGEuXG4gKiBAZGVzY3JpcHRpb24gUmVwcmVzZW50cyBhIG5vZGUncyBvdXRwdXQgdGhhdCBoYXMgYmVlbiBjYWNoZWQgKGFuZCBvcHRpb25hbGx5IHBpbm5lZCkgaW4gdGhlIHZhbHVlIHN0b3JlLlxuICovXG5pbXBvcnQgdHlwZSB7IEdyYXBoRXhlY3V0aW9uVmFsdWVzIH0gZnJvbSBcIi4uL3R5cGVzXCI7XG5pbXBvcnQgdHlwZSB7IEdyYXBoVmFsdWVLZXkgfSBmcm9tIFwiLi9HcmFwaFZhbHVlS2V5XCI7XG5cbi8qKlxuICogQSB2YWx1ZSBzdG9yZWQgaW4gdGhlIGNhY2hlLCBpbmNsdWRpbmcgdGhlIG91dHB1dHMsIHBpbm5pbmcgc3RhdGUsIGFuZFxuICogdGltZXN0YW1wcyBmb3IgVFRMLWJhc2VkIGV4cGlyeS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBHcmFwaENhY2hlZFZhbHVlIHtcbiAga2V5OiBHcmFwaFZhbHVlS2V5O1xuICBvdXRwdXRzOiBHcmFwaEV4ZWN1dGlvblZhbHVlcztcbiAgcGlubmVkOiBib29sZWFuO1xuICBjcmVhdGVkQXQ6IHN0cmluZztcbiAgdXBkYXRlZEF0OiBzdHJpbmc7XG4gIGV4cGlyZXNBdD86IHN0cmluZztcbiAgbWV0YWRhdGE/OiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPjtcbn1cbiJdfQ==

package/lib/esm/graph/engine/store/GraphValueKey.js

@@ -0,0 +1,7 @@
+/**
+ * @module integrations/graph/store/GraphValueKey
+ * @summary Stable key for cached graph values.
+ * @description Identifies a cached value in the store by workflow, node, fingerprint, and optional namespace/version.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhWYWx1ZUtleS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9ncmFwaC9lbmdpbmUvc3RvcmUvR3JhcGhWYWx1ZUtleS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaC9zdG9yZS9HcmFwaFZhbHVlS2V5XG4gKiBAc3VtbWFyeSBTdGFibGUga2V5IGZvciBjYWNoZWQgZ3JhcGggdmFsdWVzLlxuICogQGRlc2NyaXB0aW9uIElkZW50aWZpZXMgYSBjYWNoZWQgdmFsdWUgaW4gdGhlIHN0b3JlIGJ5IHdvcmtmbG93LCBub2RlLCBmaW5nZXJwcmludCwgYW5kIG9wdGlvbmFsIG5hbWVzcGFjZS92ZXJzaW9uLlxuICovXG5cbi8qKlxuICogS2V5IHVzZWQgdG8gcmVhZC93cml0ZSBjYWNoZWQgdmFsdWVzIGluIGEge0BsaW5rIEdyYXBoVmFsdWVTdG9yZUFkYXB0ZXJ9LlxuICpcbiAqIFRoZSBgZmluZ2VycHJpbnRgIG11c3QgY2hhbmdlIHdoZW4gbWVhbmluZ2Z1bCBpbnB1dHMgb3IgZGVwZW5kZW5jaWVzIGNoYW5nZVxuICogc28gc3RhbGUgdmFsdWVzIGFyZSBuZXZlciBhY2NpZGVudGFsbHkgcmV1c2VkLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEdyYXBoVmFsdWVLZXkge1xuICB3b3JrZmxvd0lkOiBzdHJpbmc7XG4gIG5vZGVJZDogc3RyaW5nO1xuICBmaW5nZXJwcmludDogc3RyaW5nO1xuICBuYW1lc3BhY2U/OiBzdHJpbmc7XG4gIHZlcnNpb24/OiBzdHJpbmc7XG59XG4iXX0=

package/lib/esm/graph/engine/store/GraphValueStore.js

@@ -0,0 +1,71 @@
+/**
+ * @module integrations/graph/store/GraphValueStore
+ * @summary Runtime value store wrapping a persistent adapter.
+ * @description Holds runtime values for the current execution in memory and delegates cached/pinned values to a {@link GraphValueStoreAdapter}.
+ */
+import { GRAPH_WORKFLOW_BOUNDARY } from "./../constants.js";
+/**
+ * Manages values during a single graph execution.
+ *
+ * Runtime values (workflow inputs, node outputs, workflow outputs) are kept in
+ * an in-memory map. Persistent cache and pinning operations are delegated to
+ * the configured {@link GraphValueStoreAdapter}.
+ */
+export class GraphValueStore {
+    /**
+     * @param adapter - The persistent adapter for cached/pinned values.
+     */
+    constructor(adapter) {
+        this.adapter = adapter;
+        this.runtimeValues = new Map();
+    }
+    /** Seeds the workflow input values. */
+    seedWorkflowInputs(inputs) {
+        this.runtimeValues.set(GRAPH_WORKFLOW_BOUNDARY, { ...inputs });
+    }
+    /** Stores the outputs produced by a node. */
+    setNodeOutputs(nodeId, outputs) {
+        this.runtimeValues.set(nodeId, { ...outputs });
+    }
+    /** Reads a single port value from a node's stored outputs. */
+    getPort(nodeId, port) {
+        return this.runtimeValues.get(nodeId)?.[port];
+    }
+    /** Returns whether a node has a value for the given port. */
+    hasPort(nodeId, port) {
+        return Object.prototype.hasOwnProperty.call(this.runtimeValues.get(nodeId) ?? {}, port);
+    }
+    /** Sets a single workflow output port value. */
+    setWorkflowOutput(port, value) {
+        const current = this.runtimeValues.get(GRAPH_WORKFLOW_BOUNDARY) ?? {};
+        current[port] = value;
+        this.runtimeValues.set(GRAPH_WORKFLOW_BOUNDARY, current);
+    }
+    /** Returns all workflow-level values (inputs merged with outputs). */
+    getWorkflowValues() {
+        return {
+            ...(this.runtimeValues.get(GRAPH_WORKFLOW_BOUNDARY) ?? {}),
+        };
+    }
+    /** Reads a cached value from the adapter. */
+    async readCached(key) {
+        return this.adapter.read(key);
+    }
+    /** Writes a cached value through the adapter. */
+    async writeCached(key, value) {
+        await this.adapter.write(key, value);
+    }
+    /** Deletes a cached value through the adapter. */
+    async deleteCached(key) {
+        await this.adapter.delete(key);
+    }
+    /** Returns a snapshot of all runtime values. */
+    snapshot() {
+        return Object.fromEntries(this.runtimeValues.entries());
+    }
+    /** Returns the underlying adapter (used by the pinning service). */
+    getAdapter() {
+        return this.adapter;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/graph/engine/store/GraphValueStoreAdapter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/graph/engine/store/InMemoryGraphValueStoreAdapter.js

@@ -0,0 +1,64 @@
+/**
+ * In-memory implementation of {@link GraphValueStoreAdapter}.
+ *
+ * Values are keyed by a serialized string combining namespace, workflowId,
+ * nodeId, version, and fingerprint.
+ */
+export class InMemoryGraphValueStoreAdapter {
+    constructor() {
+        this.values = new Map();
+    }
+    /** @inheritDoc */
+    async read(key) {
+        return this.values.get(this.serializeKey(key));
+    }
+    /** @inheritDoc */
+    async write(key, value) {
+        this.values.set(this.serializeKey(key), value);
+    }
+    /** @inheritDoc */
+    async delete(key) {
+        this.values.delete(this.serializeKey(key));
+    }
+    /** @inheritDoc */
+    async has(key) {
+        return this.values.has(this.serializeKey(key));
+    }
+    /** @inheritDoc */
+    async list(prefix) {
+        const results = [];
+        for (const value of this.values.values()) {
+            const k = value.key;
+            if (prefix.workflowId !== undefined &&
+                k.workflowId !== prefix.workflowId)
+                continue;
+            if (prefix.nodeId !== undefined && k.nodeId !== prefix.nodeId)
+                continue;
+            if (prefix.namespace !== undefined &&
+                k.namespace !== prefix.namespace)
+                continue;
+            if (prefix.version !== undefined && k.version !== prefix.version)
+                continue;
+            results.push(value);
+        }
+        return results;
+    }
+    /** @inheritDoc */
+    async clearRun(runId) {
+        void runId;
+        this.values.clear();
+    }
+    /**
+     * Serializes a key into a stable string used as the Map key.
+     */
+    serializeKey(key) {
+        return [
+            key.namespace ?? "default",
+            key.workflowId,
+            key.nodeId,
+            key.version ?? "default",
+            key.fingerprint,
+        ].join(":");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/graph/engine/store/index.js

@@ -0,0 +1,11 @@
+/**
+ * @module integrations/graph/store
+ * @summary Graph value store, adapter, and key types.
+ * @description Re-exports the value store adapter interface, in-memory default, key/cached-value types, and the runtime store wrapper.
+ */
+export * from "./GraphValueKey.js";
+export * from "./GraphCachedValue.js";
+export * from "./GraphValueStoreAdapter.js";
+export * from "./InMemoryGraphValueStoreAdapter.js";
+export * from "./GraphValueStore.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvZW5naW5lL3N0b3JlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxtQ0FBZ0M7QUFDaEMsc0NBQW1DO0FBQ25DLDRDQUF5QztBQUN6QyxvREFBaUQ7QUFDakQscUNBQWtDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaC9zdG9yZVxuICogQHN1bW1hcnkgR3JhcGggdmFsdWUgc3RvcmUsIGFkYXB0ZXIsIGFuZCBrZXkgdHlwZXMuXG4gKiBAZGVzY3JpcHRpb24gUmUtZXhwb3J0cyB0aGUgdmFsdWUgc3RvcmUgYWRhcHRlciBpbnRlcmZhY2UsIGluLW1lbW9yeSBkZWZhdWx0LCBrZXkvY2FjaGVkLXZhbHVlIHR5cGVzLCBhbmQgdGhlIHJ1bnRpbWUgc3RvcmUgd3JhcHBlci5cbiAqL1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhWYWx1ZUtleVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhDYWNoZWRWYWx1ZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhWYWx1ZVN0b3JlQWRhcHRlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vSW5NZW1vcnlHcmFwaFZhbHVlU3RvcmVBZGFwdGVyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaFZhbHVlU3RvcmVcIjtcbiJdfQ==

package/lib/esm/graph/engine/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/graph/engine/types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * @module integrations/graph/engine/types\n * @summary Graph execution engine core types.\n * @description Engine-private type aliases and interfaces. Frontend-safe\n * types (`ExprValue`, `ConditionExpression`, `CodeCondition`,\n * `SwitchCaseCondition`, `SwitchCase`, `SwitchNodeMetadata`,\n * `NodeMetadataChange`) live in `../shared/types`; engine modules import\n * shared symbols from there and engine-private symbols from here.\n */\nimport type {\n  GraphNodeDefinition,\n  GraphWorkflowDefinition,\n} from \"@decaf-ts/ui-decorators/graph\";\n\nimport type {\n  GraphExecutionEventType,\n  GraphExecutionStatus,\n} from \"../shared/constants\";\n\n/**\n * Unique identifier for a single graph execution run.\n */\nexport type GraphRunId = string;\n\n/**\n * Identifier for a workflow definition.\n */\nexport type GraphWorkflowId = string;\n\n/**\n * Identifier for a node within a workflow.\n */\nexport type GraphNodeId = string;\n\n/**\n * Name of a port on a node or workflow boundary.\n */\nexport type GraphPortName = string;\n\n/**\n * A bag of named values exchanged between nodes and the workflow boundary.\n */\nexport type GraphExecutionValues = Record<string, unknown>;\n\n/**\n * Options that influence a single execution of a workflow.\n */\nexport interface GraphExecutionOptions {\n  runId?: GraphRunId;\n  parentRunId?: GraphRunId;\n  workflowId?: GraphWorkflowId;\n  path?: string[];\n  concurrency?: number;\n  failFast?: boolean;\n  validateInputs?: boolean;\n  validateOutputs?: boolean;\n  maxLoopIterations?: number;\n  maxForeachIterations?: number;\n  usePinnedValues?: boolean;\n  writeThroughCache?: boolean;\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * Serialized error payload included in execution events and results.\n */\nexport interface GraphExecutionErrorPayload {\n  name: string;\n  message: string;\n  stack?: string;\n  code?: string;\n  details?: unknown;\n}\n\n/**\n * A single event emitted during graph execution.\n */\nexport interface GraphExecutionEvent {\n  id: string;\n  sequence: number;\n  runId: GraphRunId;\n  parentRunId?: GraphRunId;\n  workflowId: GraphWorkflowId;\n  type: GraphExecutionEventType;\n  timestamp: Date;\n\n  nodeId?: GraphNodeId;\n  edgeId?: string;\n  port?: GraphPortName;\n  iteration?: number;\n  path: string[];\n\n  status?: GraphExecutionStatus;\n  payload?: unknown;\n  error?: GraphExecutionErrorPayload;\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * Result of executing a single node.\n */\nexport interface GraphNodeExecutionResult {\n  nodeId: GraphNodeId;\n  status: GraphExecutionStatus;\n  inputs: GraphExecutionValues;\n  outputs?: GraphExecutionValues;\n  error?: GraphExecutionErrorPayload;\n  startedAt: Date;\n  finishedAt?: Date;\n  fromCache?: boolean;\n  pinned?: boolean;\n  events: GraphExecutionEvent[];\n}\n\n/**\n * Result of executing an entire workflow.\n */\nexport interface GraphExecutionResult {\n  runId: GraphRunId;\n  parentRunId?: GraphRunId;\n  workflowId: GraphWorkflowId;\n  status: GraphExecutionStatus;\n  workflow: GraphWorkflowDefinition;\n  inputs: GraphExecutionValues;\n  outputs: GraphExecutionValues;\n  nodeResults: Record<GraphNodeId, GraphNodeExecutionResult>;\n  events: GraphExecutionEvent[];\n  startedAt: Date;\n  finishedAt?: Date;\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * Options used to construct a {@link GraphExecutionContext}.\n */\nexport interface GraphExecutionContextOptions {\n  runId: GraphRunId;\n  parentRunId?: GraphRunId;\n  workflow: GraphWorkflowDefinition;\n  node: GraphNodeDefinition;\n  path: string[];\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * Metadata describing a loop node's behaviour.\n */\nexport interface GraphLoopMetadata {\n  body: GraphWorkflowDefinition | unknown;\n  maxIterations?: number;\n  timeoutMs?: number;\n  condition?: GraphConditionDefinition;\n  concurrency?: number;\n  inputPort?: string;\n  outputPort?: string;\n  itemPort?: string;\n  resultPort?: string;\n  statePort?: string;\n}\n\n/**\n * Definition of a condition evaluated by the loop condition evaluator.\n *\n * When the condition object carries an `op` field (see {@link ConditionExpression}),\n * the {@link GraphConditionEvaluator} dispatches to the {@link ConditionExpressionEvaluator}\n * instead of the built-in `type`-based switch.\n */\nexport interface GraphConditionDefinition {\n  type:\n    | \"truthy\"\n    | \"falsy\"\n    | \"equals\"\n    | \"notEquals\"\n    | \"greaterThan\"\n    | \"greaterThanOrEqual\"\n    | \"lessThan\"\n    | \"lessThanOrEqual\"\n    | \"exists\"\n    | \"custom\";\n  left?: string;\n  right?: unknown;\n  evaluator?: string;\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * Pinning metadata attached to a node via `@pinnable()`.\n */\nexport interface GraphPinningMetadata {\n  enabled: boolean;\n  ttlMs?: number;\n  strategy: \"manual\" | \"automatic\" | \"disabled\";\n  includeDependencies: boolean;\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * Options for pinning a node after a completed run.\n */\nexport interface GraphPinNodeOptions {\n  workflow: GraphWorkflowDefinition;\n  plan: unknown;\n  result: GraphExecutionResult;\n  nodeId: string;\n  includeDependencies?: boolean;\n  namespace?: string;\n}\n\n/**\n * Options for unpinning a node.\n */\nexport interface GraphUnpinNodeOptions {\n  workflow: GraphWorkflowDefinition;\n  nodeId: string;\n  fingerprint: string;\n  namespace?: string;\n}\n\n/**\n * A patch applied to a graph workflow snapshot after execution.\n */\nexport interface GraphExecutionSnapshotPatch {\n  runId: string;\n  status: GraphExecutionStatus;\n  nodes: Record<\n    string,\n    {\n      status: GraphExecutionStatus;\n      startedAt?: string;\n      finishedAt?: string;\n      error?: GraphExecutionErrorPayload;\n      outputs?: Record<string, unknown>;\n      fromCache?: boolean;\n      pinned?: boolean;\n    }\n  >;\n  edges: Record<\n    string,\n    {\n      status: GraphExecutionStatus;\n      lastValue?: unknown;\n      updatedAt: string;\n    }\n  >;\n  outputs: Record<string, unknown>;\n  events: GraphExecutionEvent[];\n}\n"]}

package/lib/esm/graph/engine/validation/GraphDefinitionValidator.js

@@ -0,0 +1,28 @@
+import { GraphInputError } from "./../errors/GraphInputError.js";
+import { GraphExecutionPlanner } from "./../planning/GraphExecutionPlanner.js";
+/**
+ * Validates a {@link GraphWorkflowDefinition} before execution.
+ */
+export class GraphDefinitionValidator {
+    constructor(planner) {
+        this.planner = planner ?? new GraphExecutionPlanner();
+    }
+    /**
+     * Validates the workflow definition.
+     *
+     * @throws {GraphInputError} when the workflow has no name or invalid structure.
+     * @throws {GraphCycleError} when the workflow contains an unsupported cycle.
+     */
+    validate(workflow) {
+        if (!workflow.name) {
+            throw new GraphInputError("Workflow must have a name");
+        }
+        const nodeIds = new Set((workflow.nodes ?? []).map((n) => n.id));
+        if (nodeIds.size !== (workflow.nodes ?? []).length) {
+            throw new GraphInputError("Workflow node IDs must be unique");
+        }
+        // The planner performs full topology validation (endpoints, ports, cycles)
+        this.planner.plan(workflow);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/graph/engine/validation/GraphPortSchemaResolver.js

@@ -0,0 +1,53 @@
+/**
+ * Resolves a {@link GraphPortDefinition} to a Zod schema (or a lightweight
+ * validation function when Zod is not available).
+ *
+ * This implementation uses primitive type mapping. When the port's `model`
+ * field or underlying Decaf metadata references a `Model` class, consumers
+ * should use `modelToZod` from `@decaf-ts/as-zod` to build the schema.
+ */
+export class GraphPortSchemaResolver {
+    /**
+     * Resolves a single port to a schema descriptor.
+     *
+     * @returns A descriptor with the port name, a `validate` function, and
+     * optional Zod schema reference.
+     */
+    resolve(port) {
+        const validate = this.createValidator(port);
+        return { name: port.name, required: port.required, validate };
+    }
+    /**
+     * Resolves multiple ports into a map of name -> descriptor.
+     */
+    resolveAll(ports) {
+        const result = {};
+        for (const port of ports) {
+            result[port.name] = this.resolve(port);
+        }
+        return result;
+    }
+    /**
+     * Creates a validation function based on the port's type.
+     */
+    createValidator(port) {
+        const type = (port.type ?? port.designType ?? "").toLowerCase();
+        switch (type) {
+            case "string":
+                return (v) => typeof v === "string";
+            case "number":
+                return (v) => typeof v === "number";
+            case "boolean":
+                return (v) => typeof v === "boolean";
+            case "date":
+                return (v) => v instanceof Date || (typeof v === "string" && !isNaN(Date.parse(v)));
+            case "array":
+                return (v) => Array.isArray(v);
+            case "bigint":
+                return (v) => typeof v === "bigint";
+            default:
+                return () => true;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/graph/engine/validation/GraphValueValidator.js

@@ -0,0 +1,47 @@
+import { GraphInputError } from "./../errors/GraphInputError.js";
+/**
+ * Validates runtime values against port definitions.
+ */
+export class GraphValueValidator {
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    /** Validates workflow-level input values. */
+    validateWorkflowInputs(workflow, values) {
+        this.validatePorts(workflow.inputs, values, "workflow input");
+    }
+    /** Validates workflow-level output values. */
+    validateWorkflowOutputs(workflow, values) {
+        this.validatePorts(workflow.outputs, values, "workflow output");
+    }
+    /** Validates a node's input values. */
+    validateNodeInputs(node, values) {
+        const inputPorts = (node.ports ?? []).filter((p) => p.direction === "input");
+        this.validatePorts(inputPorts, values, `node '${node.name}' input`);
+    }
+    /** Validates a node's output values. */
+    validateNodeOutputs(node, values) {
+        const outputPorts = (node.ports ?? []).filter((p) => p.direction === "output");
+        this.validatePorts(outputPorts, values, `node '${node.name}' output`);
+    }
+    /**
+     * Validates values against a set of port definitions.
+     */
+    validatePorts(ports, values, context) {
+        if (!ports)
+            return;
+        for (const port of ports) {
+            const has = Object.prototype.hasOwnProperty.call(values, port.name);
+            if (port.required && !has) {
+                throw new GraphInputError(`Missing required ${context} port '${port.name}'`);
+            }
+            if (has) {
+                const descriptor = this.resolver.resolve(port);
+                if (!descriptor.validate(values[port.name])) {
+                    throw new GraphInputError(`Invalid value for ${context} port '${port.name}'`);
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/graph/engine/validation/index.js

@@ -0,0 +1,9 @@
+/**
+ * @module integrations/graph/validation
+ * @summary Graph validation utilities.
+ * @description Re-exports the definition validator, port schema resolver, and value validator.
+ */
+export * from "./GraphDefinitionValidator.js";
+export * from "./GraphPortSchemaResolver.js";
+export * from "./GraphValueValidator.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvZW5naW5lL3ZhbGlkYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUNILDhDQUEyQztBQUMzQyw2Q0FBMEM7QUFDMUMseUNBQXNDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaC92YWxpZGF0aW9uXG4gKiBAc3VtbWFyeSBHcmFwaCB2YWxpZGF0aW9uIHV0aWxpdGllcy5cbiAqIEBkZXNjcmlwdGlvbiBSZS1leHBvcnRzIHRoZSBkZWZpbml0aW9uIHZhbGlkYXRvciwgcG9ydCBzY2hlbWEgcmVzb2x2ZXIsIGFuZCB2YWx1ZSB2YWxpZGF0b3IuXG4gKi9cbmV4cG9ydCAqIGZyb20gXCIuL0dyYXBoRGVmaW5pdGlvblZhbGlkYXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhQb3J0U2NoZW1hUmVzb2x2ZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0dyYXBoVmFsdWVWYWxpZGF0b3JcIjtcbiJdfQ==

package/lib/esm/graph/index.js

@@ -1,62 +1,12 @@
 /**
  * @module integrations/graph
- * @summary Decaf Graph Execution Engine.
- * @description Reference interpreter for Decaf graph workflows. Executes workflows declared with `@decaf-ts/ui-decorators/graph`, emits events through Decaf's Observable pipeline, supports structured loops, configurable value stores, and pinnable/cacheable nodes.
+ * @summary Decaf Graph Execution Engine (backend convenience export).
+ * @description Re-exports `./engine`, which in turn re-exports `./shared`
+ * (frontend-safe declarations) plus all engine modules. Backend consumers
+ * import from `@decaf-ts/integrations/graph` and get a single unified surface.
+ *
+ * Frontend bundles MUST import from `@decaf-ts/integrations/graph/shared`
+ * instead to avoid pulling in the execution engine.
  */
-export * from "./constants.js";
-export * from "./types.js";
-export * from "./decorators.js";
-export * from "./errors/GraphExecutionError.js";
-export * from "./errors/GraphCycleError.js";
-export * from "./errors/GraphInputError.js";
-export * from "./errors/GraphLoopLimitError.js";
-export * from "./errors/GraphPinningError.js";
-export * from "./errors/GraphPortError.js";
-export * from "./errors/GraphStoreError.js";
-export * from "./errors/GraphTopologyError.js";
-export * from "./events/GraphExecutionEvent.js";
-export * from "./events/GraphExecutionObserver.js";
-export * from "./events/GraphExecutionEventEmitter.js";
-export * from "./events/GraphExecutionEventFactory.js";
-export * from "./execution/GraphExecutionContext.js";
-export * from "./execution/GraphNodeExecutor.js";
-export * from "./execution/GraphExecutionFrame.js";
-export * from "./execution/GraphExecutionResult.js";
-export * from "./execution/GraphExecutionEngine.js";
-export * from "./execution/CodeSandboxEvaluator.js";
-export * from "./execution/SwitchGraphNodeExecutor.js";
-export * from "./registry/GraphNodeExecutorRegistry.js";
-export * from "./registry/GraphNodeExecutorResolver.js";
-export * from "./store/GraphValueKey.js";
-export * from "./store/GraphCachedValue.js";
-export * from "./store/GraphValueStoreAdapter.js";
-export * from "./store/InMemoryGraphValueStoreAdapter.js";
-export * from "./store/GraphValueStore.js";
-export * from "./planning/GraphExecutionPlanNode.js";
-export * from "./planning/GraphExecutionPlanEdge.js";
-export * from "./planning/GraphExecutionPlanLayer.js";
-export * from "./planning/GraphExecutionPlan.js";
-export * from "./planning/GraphRelationResolver.js";
-export * from "./planning/GraphExecutionPlanner.js";
-export * from "./planning/GraphTopology.js";
-// Validation (TASK-215)
-export * from "./validation/GraphDefinitionValidator.js";
-export * from "./validation/GraphPortSchemaResolver.js";
-export * from "./validation/GraphValueValidator.js";
-// Loops (TASK-216)
-export * from "./loops/GraphConditionEvaluator.js";
-export * from "./loops/ConditionExpressionEvaluator.js";
-export * from "./loops/GraphLoopExecutionContext.js";
-export * from "./loops/ForeachGraphNodeExecutor.js";
-export * from "./loops/WhileGraphNodeExecutor.js";
-export * from "./loops/UntilGraphNodeExecutor.js";
-// Pinning (TASK-217/218)
-export * from "./pinning/GraphPinningMetadata.js";
-export * from "./pinning/GraphPinningPolicy.js";
-export * from "./pinning/GraphPinningDependencyResolver.js";
-export * from "./pinning/GraphPinningService.js";
-// Snapshots (TASK-219)
-export * from "./snapshots/GraphExecutionSnapshotMapper.js";
-// Production node kind declarations (TASK-228 / §22.2)
-export * from "./nodes/index.js";
-//# sourceMappingURL=data:application/json;base64,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
+export * from "./engine/index.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZ3JhcGgvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7OztHQVNHO0FBQ0gsa0NBQXlCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaFxuICogQHN1bW1hcnkgRGVjYWYgR3JhcGggRXhlY3V0aW9uIEVuZ2luZSAoYmFja2VuZCBjb252ZW5pZW5jZSBleHBvcnQpLlxuICogQGRlc2NyaXB0aW9uIFJlLWV4cG9ydHMgYC4vZW5naW5lYCwgd2hpY2ggaW4gdHVybiByZS1leHBvcnRzIGAuL3NoYXJlZGBcbiAqIChmcm9udGVuZC1zYWZlIGRlY2xhcmF0aW9ucykgcGx1cyBhbGwgZW5naW5lIG1vZHVsZXMuIEJhY2tlbmQgY29uc3VtZXJzXG4gKiBpbXBvcnQgZnJvbSBgQGRlY2FmLXRzL2ludGVncmF0aW9ucy9ncmFwaGAgYW5kIGdldCBhIHNpbmdsZSB1bmlmaWVkIHN1cmZhY2UuXG4gKlxuICogRnJvbnRlbmQgYnVuZGxlcyBNVVNUIGltcG9ydCBmcm9tIGBAZGVjYWYtdHMvaW50ZWdyYXRpb25zL2dyYXBoL3NoYXJlZGBcbiAqIGluc3RlYWQgdG8gYXZvaWQgcHVsbGluZyBpbiB0aGUgZXhlY3V0aW9uIGVuZ2luZS5cbiAqL1xuZXhwb3J0ICogZnJvbSBcIi4vZW5naW5lXCI7XG4iXX0=

package/lib/esm/graph/shared/constants.js

@@ -0,0 +1,56 @@
+/**
+ * @module integrations/graph/shared/constants
+ * @summary Frontend-safe graph constants and enums.
+ * @description Constants and enumerations that are safe to import from a
+ * frontend bundle (no engine runtime dependency). The execution-status and
+ * event-type enums live here because the frontend renders status badges and
+ * event timelines and must not pull in the execution engine.
+ */
+/**
+ * Execution status for a workflow or individual node.
+ */
+export var GraphExecutionStatus;
+(function (GraphExecutionStatus) {
+    GraphExecutionStatus["PENDING"] = "pending";
+    GraphExecutionStatus["PLANNING"] = "planning";
+    GraphExecutionStatus["RUNNING"] = "running";
+    GraphExecutionStatus["SUCCEEDED"] = "succeeded";
+    GraphExecutionStatus["FAILED"] = "failed";
+    GraphExecutionStatus["SKIPPED"] = "skipped";
+    GraphExecutionStatus["CANCELLED"] = "cancelled";
+    GraphExecutionStatus["CACHED"] = "cached";
+})(GraphExecutionStatus || (GraphExecutionStatus = {}));
+/**
+ * Event types emitted through the graph execution observer pipeline.
+ */
+export var GraphExecutionEventType;
+(function (GraphExecutionEventType) {
+    GraphExecutionEventType["WORKFLOW_STARTED"] = "workflow.started";
+    GraphExecutionEventType["WORKFLOW_PLANNED"] = "workflow.planned";
+    GraphExecutionEventType["WORKFLOW_COMPLETED"] = "workflow.completed";
+    GraphExecutionEventType["WORKFLOW_FAILED"] = "workflow.failed";
+    GraphExecutionEventType["WORKFLOW_CANCELLED"] = "workflow.cancelled";
+    GraphExecutionEventType["NODE_QUEUED"] = "node.queued";
+    GraphExecutionEventType["NODE_STARTED"] = "node.started";
+    GraphExecutionEventType["NODE_OUTPUT"] = "node.output";
+    GraphExecutionEventType["NODE_COMPLETED"] = "node.completed";
+    GraphExecutionEventType["NODE_FAILED"] = "node.failed";
+    GraphExecutionEventType["NODE_SKIPPED"] = "node.skipped";
+    GraphExecutionEventType["NODE_CACHE_HIT"] = "node.cacheHit";
+    GraphExecutionEventType["NODE_PINNED"] = "node.pinned";
+    GraphExecutionEventType["NODE_UNPINNED"] = "node.unpinned";
+    GraphExecutionEventType["EDGE_VALUE_ROUTED"] = "edge.valueRouted";
+    GraphExecutionEventType["LOOP_STARTED"] = "loop.started";
+    GraphExecutionEventType["LOOP_ITERATION_STARTED"] = "loop.iteration.started";
+    GraphExecutionEventType["LOOP_ITERATION_COMPLETED"] = "loop.iteration.completed";
+    GraphExecutionEventType["LOOP_CONDITION_EVALUATED"] = "loop.condition.evaluated";
+    GraphExecutionEventType["LOOP_COMPLETED"] = "loop.completed";
+    GraphExecutionEventType["LOOP_LIMIT_REACHED"] = "loop.limitReached";
+    GraphExecutionEventType["VALIDATION_STARTED"] = "validation.started";
+    GraphExecutionEventType["VALIDATION_FAILED"] = "validation.failed";
+    GraphExecutionEventType["VALIDATION_COMPLETED"] = "validation.completed";
+    GraphExecutionEventType["STORE_READ"] = "store.read";
+    GraphExecutionEventType["STORE_WRITE"] = "store.write";
+    GraphExecutionEventType["STORE_DELETE"] = "store.delete";
+})(GraphExecutionEventType || (GraphExecutionEventType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2dyYXBoL3NoYXJlZC9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7R0FPRztBQUVIOztHQUVHO0FBQ0gsTUFBTSxDQUFOLElBQVksb0JBU1g7QUFURCxXQUFZLG9CQUFvQjtJQUM5QiwyQ0FBbUIsQ0FBQTtJQUNuQiw2Q0FBcUIsQ0FBQTtJQUNyQiwyQ0FBbUIsQ0FBQTtJQUNuQiwrQ0FBdUIsQ0FBQTtJQUN2Qix5Q0FBaUIsQ0FBQTtJQUNqQiwyQ0FBbUIsQ0FBQTtJQUNuQiwrQ0FBdUIsQ0FBQTtJQUN2Qix5Q0FBaUIsQ0FBQTtBQUNuQixDQUFDLEVBVFcsb0JBQW9CLEtBQXBCLG9CQUFvQixRQVMvQjtBQUVEOztHQUVHO0FBQ0gsTUFBTSxDQUFOLElBQVksdUJBaUNYO0FBakNELFdBQVksdUJBQXVCO0lBQ2pDLGdFQUFxQyxDQUFBO0lBQ3JDLGdFQUFxQyxDQUFBO0lBQ3JDLG9FQUF5QyxDQUFBO0lBQ3pDLDhEQUFtQyxDQUFBO0lBQ25DLG9FQUF5QyxDQUFBO0lBRXpDLHNEQUEyQixDQUFBO0lBQzNCLHdEQUE2QixDQUFBO0lBQzdCLHNEQUEyQixDQUFBO0lBQzNCLDREQUFpQyxDQUFBO0lBQ2pDLHNEQUEyQixDQUFBO0lBQzNCLHdEQUE2QixDQUFBO0lBQzdCLDJEQUFnQyxDQUFBO0lBQ2hDLHNEQUEyQixDQUFBO0lBQzNCLDBEQUErQixDQUFBO0lBRS9CLGlFQUFzQyxDQUFBO0lBRXRDLHdEQUE2QixDQUFBO0lBQzdCLDRFQUFpRCxDQUFBO0lBQ2pELGdGQUFxRCxDQUFBO0lBQ3JELGdGQUFxRCxDQUFBO0lBQ3JELDREQUFpQyxDQUFBO0lBQ2pDLG1FQUF3QyxDQUFBO0lBRXhDLG9FQUF5QyxDQUFBO0lBQ3pDLGtFQUF1QyxDQUFBO0lBQ3ZDLHdFQUE2QyxDQUFBO0lBRTdDLG9EQUF5QixDQUFBO0lBQ3pCLHNEQUEyQixDQUFBO0lBQzNCLHdEQUE2QixDQUFBO0FBQy9CLENBQUMsRUFqQ1csdUJBQXVCLEtBQXZCLHVCQUF1QixRQWlDbEMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBtb2R1bGUgaW50ZWdyYXRpb25zL2dyYXBoL3NoYXJlZC9jb25zdGFudHNcbiAqIEBzdW1tYXJ5IEZyb250ZW5kLXNhZmUgZ3JhcGggY29uc3RhbnRzIGFuZCBlbnVtcy5cbiAqIEBkZXNjcmlwdGlvbiBDb25zdGFudHMgYW5kIGVudW1lcmF0aW9ucyB0aGF0IGFyZSBzYWZlIHRvIGltcG9ydCBmcm9tIGFcbiAqIGZyb250ZW5kIGJ1bmRsZSAobm8gZW5naW5lIHJ1bnRpbWUgZGVwZW5kZW5jeSkuIFRoZSBleGVjdXRpb24tc3RhdHVzIGFuZFxuICogZXZlbnQtdHlwZSBlbnVtcyBsaXZlIGhlcmUgYmVjYXVzZSB0aGUgZnJvbnRlbmQgcmVuZGVycyBzdGF0dXMgYmFkZ2VzIGFuZFxuICogZXZlbnQgdGltZWxpbmVzIGFuZCBtdXN0IG5vdCBwdWxsIGluIHRoZSBleGVjdXRpb24gZW5naW5lLlxuICovXG5cbi8qKlxuICogRXhlY3V0aW9uIHN0YXR1cyBmb3IgYSB3b3JrZmxvdyBvciBpbmRpdmlkdWFsIG5vZGUuXG4gKi9cbmV4cG9ydCBlbnVtIEdyYXBoRXhlY3V0aW9uU3RhdHVzIHtcbiAgUEVORElORyA9IFwicGVuZGluZ1wiLFxuICBQTEFOTklORyA9IFwicGxhbm5pbmdcIixcbiAgUlVOTklORyA9IFwicnVubmluZ1wiLFxuICBTVUNDRUVERUQgPSBcInN1Y2NlZWRlZFwiLFxuICBGQUlMRUQgPSBcImZhaWxlZFwiLFxuICBTS0lQUEVEID0gXCJza2lwcGVkXCIsXG4gIENBTkNFTExFRCA9IFwiY2FuY2VsbGVkXCIsXG4gIENBQ0hFRCA9IFwiY2FjaGVkXCIsXG59XG5cbi8qKlxuICogRXZlbnQgdHlwZXMgZW1pdHRlZCB0aHJvdWdoIHRoZSBncmFwaCBleGVjdXRpb24gb2JzZXJ2ZXIgcGlwZWxpbmUuXG4gKi9cbmV4cG9ydCBlbnVtIEdyYXBoRXhlY3V0aW9uRXZlbnRUeXBlIHtcbiAgV09SS0ZMT1dfU1RBUlRFRCA9IFwid29ya2Zsb3cuc3RhcnRlZFwiLFxuICBXT1JLRkxPV19QTEFOTkVEID0gXCJ3b3JrZmxvdy5wbGFubmVkXCIsXG4gIFdPUktGTE9XX0NPTVBMRVRFRCA9IFwid29ya2Zsb3cuY29tcGxldGVkXCIsXG4gIFdPUktGTE9XX0ZBSUxFRCA9IFwid29ya2Zsb3cuZmFpbGVkXCIsXG4gIFdPUktGTE9XX0NBTkNFTExFRCA9IFwid29ya2Zsb3cuY2FuY2VsbGVkXCIsXG5cbiAgTk9ERV9RVUVVRUQgPSBcIm5vZGUucXVldWVkXCIsXG4gIE5PREVfU1RBUlRFRCA9IFwibm9kZS5zdGFydGVkXCIsXG4gIE5PREVfT1VUUFVUID0gXCJub2RlLm91dHB1dFwiLFxuICBOT0RFX0NPTVBMRVRFRCA9IFwibm9kZS5jb21wbGV0ZWRcIixcbiAgTk9ERV9GQUlMRUQgPSBcIm5vZGUuZmFpbGVkXCIsXG4gIE5PREVfU0tJUFBFRCA9IFwibm9kZS5za2lwcGVkXCIsXG4gIE5PREVfQ0FDSEVfSElUID0gXCJub2RlLmNhY2hlSGl0XCIsXG4gIE5PREVfUElOTkVEID0gXCJub2RlLnBpbm5lZFwiLFxuICBOT0RFX1VOUElOTkVEID0gXCJub2RlLnVucGlubmVkXCIsXG5cbiAgRURHRV9WQUxVRV9ST1VURUQgPSBcImVkZ2UudmFsdWVSb3V0ZWRcIixcblxuICBMT09QX1NUQVJURUQgPSBcImxvb3Auc3RhcnRlZFwiLFxuICBMT09QX0lURVJBVElPTl9TVEFSVEVEID0gXCJsb29wLml0ZXJhdGlvbi5zdGFydGVkXCIsXG4gIExPT1BfSVRFUkFUSU9OX0NPTVBMRVRFRCA9IFwibG9vcC5pdGVyYXRpb24uY29tcGxldGVkXCIsXG4gIExPT1BfQ09ORElUSU9OX0VWQUxVQVRFRCA9IFwibG9vcC5jb25kaXRpb24uZXZhbHVhdGVkXCIsXG4gIExPT1BfQ09NUExFVEVEID0gXCJsb29wLmNvbXBsZXRlZFwiLFxuICBMT09QX0xJTUlUX1JFQUNIRUQgPSBcImxvb3AubGltaXRSZWFjaGVkXCIsXG5cbiAgVkFMSURBVElPTl9TVEFSVEVEID0gXCJ2YWxpZGF0aW9uLnN0YXJ0ZWRcIixcbiAgVkFMSURBVElPTl9GQUlMRUQgPSBcInZhbGlkYXRpb24uZmFpbGVkXCIsXG4gIFZBTElEQVRJT05fQ09NUExFVEVEID0gXCJ2YWxpZGF0aW9uLmNvbXBsZXRlZFwiLFxuXG4gIFNUT1JFX1JFQUQgPSBcInN0b3JlLnJlYWRcIixcbiAgU1RPUkVfV1JJVEUgPSBcInN0b3JlLndyaXRlXCIsXG4gIFNUT1JFX0RFTEVURSA9IFwic3RvcmUuZGVsZXRlXCIsXG59XG4iXX0=

package/lib/esm/graph/shared/index.js

@@ -0,0 +1,19 @@
+/**
+ * @module integrations/graph/shared
+ * @summary Frontend-safe graph declarations.
+ * @description Subpath export for frontend bundles. Re-exports the node kind
+ * declarations, shared types, and shared constants — no engine runtime
+ * dependency. Also re-exports `Metadata` from `@decaf-ts/ui-decorators` so
+ * consumers get the `Metadata.nodes()` / `Metadata.workflows()` accessors
+ * (attached via the graph overrides side-effect import).
+ *
+ * Importing anything from this module triggers the `ui-decorators/graph`
+ * overrides side-effect, which attaches `nodes()` / `workflows()` to the
+ * `Metadata` class.
+ */
+import "@decaf-ts/ui-decorators/graph";
+export { Metadata } from "@decaf-ts/decoration";
+export * from "./constants.js";
+export * from "./types.js";
+export * from "./nodes/index.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZ3JhcGgvc2hhcmVkL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7R0FZRztBQUNILE9BQU8sK0JBQStCLENBQUM7QUFFdkMsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ2hELCtCQUE0QjtBQUM1QiwyQkFBd0I7QUFDeEIsaUNBQXdCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIGludGVncmF0aW9ucy9ncmFwaC9zaGFyZWRcbiAqIEBzdW1tYXJ5IEZyb250ZW5kLXNhZmUgZ3JhcGggZGVjbGFyYXRpb25zLlxuICogQGRlc2NyaXB0aW9uIFN1YnBhdGggZXhwb3J0IGZvciBmcm9udGVuZCBidW5kbGVzLiBSZS1leHBvcnRzIHRoZSBub2RlIGtpbmRcbiAqIGRlY2xhcmF0aW9ucywgc2hhcmVkIHR5cGVzLCBhbmQgc2hhcmVkIGNvbnN0YW50cyDigJQgbm8gZW5naW5lIHJ1bnRpbWVcbiAqIGRlcGVuZGVuY3kuIEFsc28gcmUtZXhwb3J0cyBgTWV0YWRhdGFgIGZyb20gYEBkZWNhZi10cy91aS1kZWNvcmF0b3JzYCBzb1xuICogY29uc3VtZXJzIGdldCB0aGUgYE1ldGFkYXRhLm5vZGVzKClgIC8gYE1ldGFkYXRhLndvcmtmbG93cygpYCBhY2Nlc3NvcnNcbiAqIChhdHRhY2hlZCB2aWEgdGhlIGdyYXBoIG92ZXJyaWRlcyBzaWRlLWVmZmVjdCBpbXBvcnQpLlxuICpcbiAqIEltcG9ydGluZyBhbnl0aGluZyBmcm9tIHRoaXMgbW9kdWxlIHRyaWdnZXJzIHRoZSBgdWktZGVjb3JhdG9ycy9ncmFwaGBcbiAqIG92ZXJyaWRlcyBzaWRlLWVmZmVjdCwgd2hpY2ggYXR0YWNoZXMgYG5vZGVzKClgIC8gYHdvcmtmbG93cygpYCB0byB0aGVcbiAqIGBNZXRhZGF0YWAgY2xhc3MuXG4gKi9cbmltcG9ydCBcIkBkZWNhZi10cy91aS1kZWNvcmF0b3JzL2dyYXBoXCI7XG5cbmV4cG9ydCB7IE1ldGFkYXRhIH0gZnJvbSBcIkBkZWNhZi10cy9kZWNvcmF0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9ub2Rlc1wiO1xuIl19