@invect/core 0.0.1

package/dist/services/react-flow-renderer.service.cjs

@@ -0,0 +1,236 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_errors_types = require("../types/common/errors.types.cjs");
+const require_base = require("../types/base.cjs");
+const require_action_registry = require("../actions/action-registry.cjs");
+const require_flow_executions_schema = require("../types/schemas/flow/flow-executions.schema.cjs");
+require("../types/schemas/index.cjs");
+let _invect_layouts = require("@invect/layouts");
+//#region src/services/react-flow-renderer.service.ts
+/**
+* Service for rendering flow data in React Flow compatible format
+* Transforms Invect flow definitions into React Flow compatible nodes and edges
+*/
+var ReactFlowRendererService = class ReactFlowRendererService {
+	initialized = false;
+	constructor(logger, flowsService, flowVersionsService, flowRunsService, nodeExecutionsService) {
+		this.logger = logger;
+		this.flowsService = flowsService;
+		this.flowVersionsService = flowVersionsService;
+		this.flowRunsService = flowRunsService;
+		this.nodeExecutionsService = nodeExecutionsService;
+	}
+	/**
+	* Initialize the service
+	*/
+	async initialize() {
+		if (this.initialized) {
+			this.logger.debug("React Flow renderer service already initialized");
+			return;
+		}
+		try {
+			this.initialized = true;
+			this.logger.info("React Flow renderer service initialized successfully");
+		} catch (error) {
+			this.logger.error("Failed to initialize React Flow renderer service", { error });
+			throw new require_errors_types.DatabaseError("Failed to initialize React Flow renderer service", { error });
+		}
+	}
+	/**
+	* Transform flow version and execution data to React Flow format
+	*/
+	async renderToReactFlow(flowId, options) {
+		this.logger.debug("renderToReactFlow called with arguments:", JSON.stringify({
+			flowId,
+			options
+		}, null, 2));
+		const validatedParams = require_flow_executions_schema.FlowIdParamsSchema.parse({ flowId });
+		const flowVersion = await this.flowVersionsService.getFlowVersion(validatedParams.flowId, options?.version || "latest");
+		if (!flowVersion) throw new require_errors_types.DatabaseError(`Flow version not found for flow ${flowId}`);
+		const flow = await this.flowsService.getFlowById(validatedParams.flowId);
+		let flowRun;
+		let nodeExecutions;
+		if (options?.flowRunId) {
+			flowRun = await this.flowRunsService.getRunById(options.flowRunId);
+			nodeExecutions = await this.nodeExecutionsService.listNodeExecutionsByFlowRunId(options.flowRunId);
+		}
+		return this.transformToReactFlowData(flowVersion, flow.name, flow.description, flow.isActive, flowRun, nodeExecutions);
+	}
+	/**
+	* Internal method to transform data to React Flow format
+	*/
+	async transformToReactFlowData(flowVersion, flowName, flowDescription, isActive = true, flowRun, nodeExecutions) {
+		this.logger.debug("Rendering flow to React Flow format", {
+			flowId: flowVersion.flowId,
+			flowVersion: flowVersion.version,
+			flowRunId: flowRun?.id,
+			nodeExecutionsCount: nodeExecutions?.length || 0
+		});
+		const executionStatusMap = this.createExecutionStatusMap(nodeExecutions);
+		let nodes = this.transformNodes(flowVersion, executionStatusMap);
+		const edges = this.transformEdges(flowVersion, executionStatusMap);
+		nodes = await this.applyElkLayoutToNodes(nodes, edges);
+		return {
+			nodes,
+			edges,
+			version: flowVersion,
+			name: flowName,
+			description: flowDescription,
+			isActive,
+			executionStatus: executionStatusMap
+		};
+	}
+	/**
+	* Create execution status map from node executions
+	*/
+	createExecutionStatusMap(nodeExecutions) {
+		const statusMap = /* @__PURE__ */ new Map();
+		if (nodeExecutions) nodeExecutions.forEach((execution) => {
+			statusMap.set(execution.nodeId, {
+				status: execution.status,
+				error: execution.error,
+				output: execution.outputs
+			});
+		});
+		return statusMap;
+	}
+	/**
+	* Transform flow nodes to React Flow format
+	*/
+	transformNodes(flowVersion, executionStatusMap) {
+		const nodes = [];
+		const definition = flowVersion.invectDefinition;
+		if (!definition?.nodes) return nodes;
+		const actionRegistry = require_action_registry.getGlobalActionRegistry();
+		definition.nodes.forEach((node) => {
+			const executionStatus = executionStatusMap.get(node.id);
+			const action = actionRegistry.get(node.type);
+			const displayName = this.getDisplayName(node, action);
+			const referenceId = this.getReferenceId(node, displayName);
+			const nodeData = {
+				id: node.id,
+				type: node.type,
+				display_name: displayName,
+				reference_id: referenceId,
+				description: action?.description,
+				icon: action?.provider.icon,
+				status: this.mapExecutionStatusToNodeStatus(executionStatus?.status),
+				executionStatus: executionStatus?.status,
+				executionError: executionStatus?.error,
+				executionOutput: executionStatus?.output,
+				params: node.params,
+				inputs: void 0,
+				outputs: executionStatus?.output?.data,
+				...node.params || {},
+				...node.mapper ? { mapper: node.mapper } : {}
+			};
+			const transformedNode = {
+				id: node.id,
+				type: node.type,
+				position: node.position || {
+					x: 0,
+					y: 0
+				},
+				data: nodeData,
+				width: 200,
+				height: 60
+			};
+			nodes.push(transformedNode);
+		});
+		return nodes;
+	}
+	/**
+	* Get display name for a node, with fallbacks
+	*/
+	getDisplayName(node, action) {
+		if (node.label && typeof node.label === "string") return node.label;
+		if (action?.name) return action.name;
+		return node.type.replace(/[._]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+	}
+	static MAX_REFERENCE_ID_LENGTH = 22;
+	/**
+	* Get or generate a reference_id for a node (snake_case, alphanumeric only)
+	* Truncates to MAX_REFERENCE_ID_LENGTH while preserving any increment suffix
+	*/
+	getReferenceId(node, displayName) {
+		if (node.referenceId && typeof node.referenceId === "string") return node.referenceId;
+		const baseId = displayName.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim().replace(/\s+/g, "_");
+		return this.truncateReferenceId(baseId);
+	}
+	/**
+	* Truncate a reference ID to max length while preserving any numeric suffix
+	*/
+	truncateReferenceId(refId, suffix) {
+		const maxLen = ReactFlowRendererService.MAX_REFERENCE_ID_LENGTH;
+		if (refId.length <= maxLen) return refId;
+		if (suffix) {
+			const suffixWithUnderscore = `_${suffix}`;
+			const availableForBase = maxLen - suffixWithUnderscore.length;
+			if (availableForBase <= 0) return refId.substring(0, maxLen);
+			return refId.substring(0, availableForBase) + suffixWithUnderscore;
+		}
+		return refId.substring(0, maxLen);
+	}
+	/**
+	* Transform flow edges to React Flow format
+	*/
+	transformEdges(flowVersion, executionStatusMap) {
+		const edges = [];
+		const definition = flowVersion.invectDefinition;
+		if (!definition?.edges || !definition?.nodes) return edges;
+		const nodeTypeMap = /* @__PURE__ */ new Map();
+		definition.nodes.forEach((node) => {
+			nodeTypeMap.set(node.id, node.type);
+		});
+		definition.edges.forEach((edge) => {
+			const sourceNodeStatus = executionStatusMap.get(edge.source);
+			const targetNodeStatus = executionStatusMap.get(edge.target);
+			const isConnectedToSkippedNode = sourceNodeStatus?.status === require_base.NodeExecutionStatus.SKIPPED || targetNodeStatus?.status === require_base.NodeExecutionStatus.SKIPPED;
+			const transformedEdge = {
+				id: edge.id,
+				source: edge.source,
+				target: edge.target,
+				sourceHandle: edge.sourceHandle || "output",
+				targetHandle: edge.targetHandle || "input",
+				animated: edge.animated || false,
+				data: {
+					type: isConnectedToSkippedNode ? "skipped" : "default",
+					animated: edge.animated || false,
+					highlighted: false,
+					selected: false,
+					sourceNodeStatus: sourceNodeStatus?.status,
+					targetNodeStatus: targetNodeStatus?.status
+				}
+			};
+			edges.push(transformedEdge);
+		});
+		return edges;
+	}
+	/**
+	* Map execution status to node visual status
+	*/
+	mapExecutionStatusToNodeStatus(executionStatus) {
+		if (!executionStatus) return "idle";
+		switch (executionStatus) {
+			case require_base.NodeExecutionStatus.PENDING:
+			case require_base.NodeExecutionStatus.RUNNING: return "running";
+			case require_base.NodeExecutionStatus.SUCCESS: return "completed";
+			case require_base.NodeExecutionStatus.FAILED: return "error";
+			case require_base.NodeExecutionStatus.SKIPPED: return "skipped";
+			case require_base.NodeExecutionStatus.BATCH_SUBMITTED: return "running";
+			default: return "idle";
+		}
+	}
+	/**
+	* Apply ELK left-to-right layout to nodes
+	* Uses elkjs layered algorithm for better edge crossing minimization
+	*
+	* Note: ELK is async because elkjs uses web workers internally
+	*/
+	async applyElkLayoutToNodes(nodes, edges) {
+		return (0, _invect_layouts.applyElkLayout)(nodes, edges);
+	}
+};
+//#endregion
+exports.ReactFlowRendererService = ReactFlowRendererService;
+
+//# sourceMappingURL=react-flow-renderer.service.cjs.map

package/dist/services/react-flow-renderer.service.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-flow-renderer.service.cjs","names":["DatabaseError","getGlobalActionRegistry","NodeExecutionStatus"],"sources":["../../src/services/react-flow-renderer.service.ts"],"sourcesContent":["import { FlowVersion } from '../database';\nimport { FlowRun } from './flow-runs/flow-runs.model';\nimport { NodeExecution } from './node-executions/node-executions.model';\nimport { NodeExecutionStatus } from '../types/base';\nimport { Logger } from '../types/schemas';\nimport { DatabaseError } from '../types/common/errors.types';\nimport { FlowEdge, FlowNodeDefinitions } from './flow-versions/schemas-fresh';\nimport type { NodeOutput, NodeInputData } from '../types/node-io-types';\nimport { getGlobalActionRegistry } from '../actions/action-registry';\nimport { applyElkLayout } from '@invect/layouts';\nimport { FlowsService } from './flows/flows.service';\nimport { FlowVersionsService } from './flow-versions/flow-versions.service';\nimport { FlowRunsService } from './flow-runs/flow-runs.service';\nimport { NodeExecutionService } from './node-executions/node-execution.service';\nimport * as Schemas from '../types/schemas';\n\n// Position interface matching existing schema\nexport interface Position {\n  x: number;\n  y: number;\n}\n\n// Node visual status for React Flow rendering\nexport type NodeVisualStatus = 'idle' | 'running' | 'completed' | 'error' | 'skipped';\n\n// Layout will be handled on the frontend\n\n// Node execution status for rendering\nexport interface NodeExecutionStatusInfo {\n  status: NodeExecutionStatus;\n  error?: string;\n  output?: NodeOutput;\n}\n\n// Base React Flow node data interface\nexport interface ReactFlowNodeData extends Record<string, unknown> {\n  id: string;\n  type: string;\n  display_name: string;\n  reference_id: string; // snake_case unique identifier for input mapping\n  description?: string;\n  icon?: string;\n  status: NodeVisualStatus;\n  executionStatus?: NodeExecutionStatus;\n  executionError?: string;\n  executionOutput?: NodeOutput;\n  // Node configuration parameters (dynamic based on node definition)\n  params?: Record<string, unknown>;\n  // Runtime inputs (what the node receives during execution)\n  inputs?: NodeInputData;\n  // Runtime outputs (what the node produces during execution)\n  outputs?: NodeOutput['data'];\n}\n\n// React Flow compatible node interface with strong typing\nexport interface ReactFlowNode<T extends string = string> {\n  id: string;\n  type: T;\n  position: Position;\n  data: ReactFlowNodeData;\n  width?: number;\n  height?: number;\n  measured?: { width: number; height: number };\n  dragHandle?: string;\n}\n\n// React Flow compatible edge interface\nexport interface ReactFlowEdge {\n  id: string;\n  source: string;\n  target: string;\n  sourceHandle?: string;\n  targetHandle?: string;\n  animated?: boolean;\n  data?: {\n    type: 'default' | 'skipped';\n    animated: boolean;\n    highlighted: boolean;\n    selected: boolean;\n    sourceNodeStatus?: NodeExecutionStatus;\n    targetNodeStatus?: NodeExecutionStatus;\n  };\n}\n\n// Complete React Flow data response\nexport interface ReactFlowData {\n  nodes: ReactFlowNode[];\n  edges: ReactFlowEdge[];\n  version: FlowVersion;\n  name: string;\n  description?: string;\n  isActive: boolean;\n  executionStatus?: Map<string, NodeExecutionStatusInfo>;\n}\n\n// Strongly typed React Flow data for specific node types\nexport interface TypedReactFlowData<T extends string = string> {\n  nodes: ReactFlowNode<T>[];\n  edges: ReactFlowEdge[];\n  version: FlowVersion;\n  name: string;\n  description?: string;\n  executionStatus?: Map<string, NodeExecutionStatusInfo>;\n}\n\n/**\n * Service for rendering flow data in React Flow compatible format\n * Transforms Invect flow definitions into React Flow compatible nodes and edges\n */\nexport class ReactFlowRendererService {\n  private initialized = false;\n\n  constructor(\n    private readonly logger: Logger,\n    private readonly flowsService: FlowsService,\n    private readonly flowVersionsService: FlowVersionsService,\n    private readonly flowRunsService: FlowRunsService,\n    private readonly nodeExecutionsService: NodeExecutionService,\n  ) {}\n\n  /**\n   * Initialize the service\n   */\n  async initialize(): Promise<void> {\n    if (this.initialized) {\n      this.logger.debug('React Flow renderer service already initialized');\n      return;\n    }\n\n    try {\n      this.initialized = true;\n      this.logger.info('React Flow renderer service initialized successfully');\n    } catch (error) {\n      this.logger.error('Failed to initialize React Flow renderer service', { error });\n      throw new DatabaseError('Failed to initialize React Flow renderer service', { error });\n    }\n  }\n\n  /**\n   * Transform flow version and execution data to React Flow format\n   */\n  async renderToReactFlow(\n    flowId: string,\n    options?: { version?: string | number | 'latest'; flowRunId?: string },\n  ): Promise<ReactFlowData> {\n    this.logger.debug(\n      'renderToReactFlow called with arguments:',\n      JSON.stringify({ flowId, options }, null, 2),\n    );\n\n    const validatedParams = Schemas.flow.FlowIdParamsSchema.parse({ flowId });\n\n    // Get flow version\n    const flowVersion = await this.flowVersionsService.getFlowVersion(\n      validatedParams.flowId,\n      options?.version || 'latest',\n    );\n\n    if (!flowVersion) {\n      throw new DatabaseError(`Flow version not found for flow ${flowId}`);\n    }\n\n    // Get flow details for name/description\n    const flow = await this.flowsService.getFlowById(validatedParams.flowId);\n\n    // Get execution data if flowRunId provided\n    let flowRun: FlowRun | undefined;\n    let nodeExecutions: NodeExecution[] | undefined;\n\n    if (options?.flowRunId) {\n      flowRun = await this.flowRunsService.getRunById(options.flowRunId);\n      nodeExecutions = await this.nodeExecutionsService.listNodeExecutionsByFlowRunId(\n        options.flowRunId,\n      );\n    }\n\n    return this.transformToReactFlowData(\n      flowVersion,\n      flow.name,\n      flow.description,\n      flow.isActive,\n      flowRun,\n      nodeExecutions,\n    );\n  }\n\n  /**\n   * Internal method to transform data to React Flow format\n   */\n  private async transformToReactFlowData(\n    flowVersion: FlowVersion,\n    flowName: string,\n    flowDescription?: string,\n    isActive: boolean = true,\n    flowRun?: FlowRun,\n    nodeExecutions?: NodeExecution[],\n  ): Promise<ReactFlowData> {\n    this.logger.debug('Rendering flow to React Flow format', {\n      flowId: flowVersion.flowId,\n      flowVersion: flowVersion.version,\n      flowRunId: flowRun?.id,\n      nodeExecutionsCount: nodeExecutions?.length || 0,\n    });\n\n    // Create execution status map\n    const executionStatusMap = this.createExecutionStatusMap(nodeExecutions);\n\n    // Transform nodes and edges\n    let nodes = this.transformNodes(flowVersion, executionStatusMap);\n    const edges = this.transformEdges(flowVersion, executionStatusMap);\n\n    // Apply ELK left-to-right layout by default (using elkjs layered algorithm)\n    nodes = await this.applyElkLayoutToNodes(nodes, edges);\n\n    return {\n      nodes,\n      edges,\n      version: flowVersion,\n      name: flowName,\n      description: flowDescription,\n      isActive,\n      executionStatus: executionStatusMap,\n    };\n  }\n\n  /**\n   * Create execution status map from node executions\n   */\n  private createExecutionStatusMap(\n    nodeExecutions?: NodeExecution[],\n  ): Map<string, NodeExecutionStatusInfo> {\n    const statusMap = new Map<string, NodeExecutionStatusInfo>();\n\n    if (nodeExecutions) {\n      nodeExecutions.forEach((execution) => {\n        statusMap.set(execution.nodeId, {\n          status: execution.status,\n          error: execution.error,\n          output: execution.outputs,\n        });\n      });\n    }\n\n    return statusMap;\n  }\n\n  /**\n   * Transform flow nodes to React Flow format\n   */\n  private transformNodes(\n    flowVersion: FlowVersion,\n    executionStatusMap: Map<string, NodeExecutionStatusInfo>,\n  ): ReactFlowNode[] {\n    const nodes: ReactFlowNode[] = [];\n\n    const definition = flowVersion.invectDefinition;\n    if (!definition?.nodes) {\n      return nodes;\n    }\n\n    const actionRegistry = getGlobalActionRegistry();\n\n    definition.nodes.forEach((node: FlowNodeDefinitions) => {\n      const executionStatus = executionStatusMap.get(node.id);\n      const action = actionRegistry.get(node.type);\n\n      const displayName = this.getDisplayName(node, action);\n      const referenceId = this.getReferenceId(\n        node as FlowNodeDefinitions & { referenceId?: string },\n        displayName,\n      );\n\n      // Create strongly typed node data\n      const nodeData: ReactFlowNodeData = {\n        id: node.id,\n        type: node.type,\n        display_name: displayName,\n        reference_id: referenceId,\n        description: action?.description,\n        icon: action?.provider.icon,\n        status: this.mapExecutionStatusToNodeStatus(executionStatus?.status),\n        executionStatus: executionStatus?.status,\n        executionError: executionStatus?.error,\n        executionOutput: executionStatus?.output,\n        params: node.params,\n        // Runtime data will be populated during execution\n        inputs: undefined, // Could be populated from execution context if available\n        outputs: executionStatus?.output?.data,\n        // Flatten params to top level for component access\n        ...(node.params || {}),\n        // Data mapper config (top-level node field)\n        ...(node.mapper ? { mapper: node.mapper } : {}),\n      };\n\n      const transformedNode: ReactFlowNode = {\n        id: node.id,\n        type: node.type,\n        position: node.position || { x: 0, y: 0 },\n        data: nodeData,\n        width: 200,\n        height: 60,\n      };\n\n      nodes.push(transformedNode);\n    });\n\n    return nodes;\n  }\n\n  /**\n   * Get display name for a node, with fallbacks\n   */\n  private getDisplayName(node: FlowNodeDefinitions, action: { name: string } | undefined): string {\n    // First priority: user-defined label on the node itself\n    if (node.label && typeof node.label === 'string') {\n      return node.label;\n    }\n\n    // Second priority: action registry name\n    if (action?.name) {\n      return action.name;\n    }\n\n    // Fallback: humanise the node type string (e.g. \"core.javascript\" → \"Core Javascript\")\n    return node.type.replace(/[._]/g, ' ').replace(/\\b\\w/g, (c) => c.toUpperCase());\n  }\n\n  private static readonly MAX_REFERENCE_ID_LENGTH = 22;\n\n  /**\n   * Get or generate a reference_id for a node (snake_case, alphanumeric only)\n   * Truncates to MAX_REFERENCE_ID_LENGTH while preserving any increment suffix\n   */\n  private getReferenceId(\n    node: FlowNodeDefinitions & { referenceId?: string },\n    displayName: string,\n  ): string {\n    // Use existing referenceId if present (already truncated when saved)\n    if (node.referenceId && typeof node.referenceId === 'string') {\n      return node.referenceId;\n    }\n\n    // Generate from display name: lowercase, alphanumeric + underscores only\n    const baseId = displayName\n      .toLowerCase()\n      .replace(/[^a-z0-9\\s]/g, '') // Remove non-alphanumeric chars except spaces\n      .trim()\n      .replace(/\\s+/g, '_'); // Replace spaces with underscores\n\n    // Truncate to max length\n    return this.truncateReferenceId(baseId);\n  }\n\n  /**\n   * Truncate a reference ID to max length while preserving any numeric suffix\n   */\n  private truncateReferenceId(refId: string, suffix?: string): string {\n    const maxLen = ReactFlowRendererService.MAX_REFERENCE_ID_LENGTH;\n\n    if (refId.length <= maxLen) {\n      return refId;\n    }\n\n    if (suffix) {\n      const suffixWithUnderscore = `_${suffix}`;\n      const availableForBase = maxLen - suffixWithUnderscore.length;\n      if (availableForBase <= 0) {\n        return refId.substring(0, maxLen);\n      }\n      return refId.substring(0, availableForBase) + suffixWithUnderscore;\n    }\n\n    return refId.substring(0, maxLen);\n  }\n\n  /**\n   * Transform flow edges to React Flow format\n   */\n  private transformEdges(\n    flowVersion: FlowVersion,\n    executionStatusMap: Map<string, NodeExecutionStatusInfo>,\n  ): ReactFlowEdge[] {\n    const edges: ReactFlowEdge[] = [];\n\n    const definition = flowVersion.invectDefinition;\n    if (!definition?.edges || !definition?.nodes) {\n      return edges;\n    }\n\n    // Create a map of node IDs to their types for handle validation\n    const nodeTypeMap = new Map<string, string>();\n    definition.nodes.forEach((node: FlowNodeDefinitions) => {\n      nodeTypeMap.set(node.id, node.type);\n    });\n\n    definition.edges.forEach((edge: FlowEdge & { animated?: boolean }) => {\n      const sourceNodeStatus = executionStatusMap.get(edge.source);\n      const targetNodeStatus = executionStatusMap.get(edge.target);\n\n      // Check if either node is skipped\n      const isConnectedToSkippedNode =\n        sourceNodeStatus?.status === NodeExecutionStatus.SKIPPED ||\n        targetNodeStatus?.status === NodeExecutionStatus.SKIPPED;\n\n      // Pass through source/target handles from the stored edge definition\n      // These are needed by React Flow to connect edges to the correct handles\n      // Default to \"output\"/\"input\" if not specified (standard single-handle nodes)\n      const transformedEdge: ReactFlowEdge = {\n        id: edge.id,\n        source: edge.source,\n        target: edge.target,\n        sourceHandle: edge.sourceHandle || 'output',\n        targetHandle: edge.targetHandle || 'input',\n        animated: edge.animated || false,\n        data: {\n          type: isConnectedToSkippedNode ? 'skipped' : 'default',\n          animated: edge.animated || false,\n          highlighted: false,\n          selected: false,\n          sourceNodeStatus: sourceNodeStatus?.status,\n          targetNodeStatus: targetNodeStatus?.status,\n        },\n      };\n\n      edges.push(transformedEdge);\n    });\n\n    return edges;\n  }\n\n  /**\n   * Map execution status to node visual status\n   */\n  private mapExecutionStatusToNodeStatus(executionStatus?: NodeExecutionStatus): NodeVisualStatus {\n    if (!executionStatus) {\n      return 'idle';\n    }\n\n    switch (executionStatus) {\n      case NodeExecutionStatus.PENDING:\n      case NodeExecutionStatus.RUNNING:\n        return 'running';\n      case NodeExecutionStatus.SUCCESS:\n        return 'completed';\n      case NodeExecutionStatus.FAILED:\n        return 'error';\n      case NodeExecutionStatus.SKIPPED:\n        return 'skipped';\n      case NodeExecutionStatus.BATCH_SUBMITTED:\n        return 'running'; // Treat batch submitted as running\n      default:\n        return 'idle';\n    }\n  }\n\n  /**\n   * Apply ELK left-to-right layout to nodes\n   * Uses elkjs layered algorithm for better edge crossing minimization\n   *\n   * Note: ELK is async because elkjs uses web workers internally\n   */\n  private async applyElkLayoutToNodes(\n    nodes: ReactFlowNode[],\n    edges: ReactFlowEdge[],\n  ): Promise<ReactFlowNode[]> {\n    return applyElkLayout(nodes, edges);\n  }\n}\n"],"mappings":";;;;;;;;;;;;AA6GA,IAAa,2BAAb,MAAa,yBAAyB;CACpC,cAAsB;CAEtB,YACE,QACA,cACA,qBACA,iBACA,uBACA;AALiB,OAAA,SAAA;AACA,OAAA,eAAA;AACA,OAAA,sBAAA;AACA,OAAA,kBAAA;AACA,OAAA,wBAAA;;;;;CAMnB,MAAM,aAA4B;AAChC,MAAI,KAAK,aAAa;AACpB,QAAK,OAAO,MAAM,kDAAkD;AACpE;;AAGF,MAAI;AACF,QAAK,cAAc;AACnB,QAAK,OAAO,KAAK,uDAAuD;WACjE,OAAO;AACd,QAAK,OAAO,MAAM,oDAAoD,EAAE,OAAO,CAAC;AAChF,SAAM,IAAIA,qBAAAA,cAAc,oDAAoD,EAAE,OAAO,CAAC;;;;;;CAO1F,MAAM,kBACJ,QACA,SACwB;AACxB,OAAK,OAAO,MACV,4CACA,KAAK,UAAU;GAAE;GAAQ;GAAS,EAAE,MAAM,EAAE,CAC7C;EAED,MAAM,kBAAA,+BAAA,mBAAkD,MAAM,EAAE,QAAQ,CAAC;EAGzE,MAAM,cAAc,MAAM,KAAK,oBAAoB,eACjD,gBAAgB,QAChB,SAAS,WAAW,SACrB;AAED,MAAI,CAAC,YACH,OAAM,IAAIA,qBAAAA,cAAc,mCAAmC,SAAS;EAItE,MAAM,OAAO,MAAM,KAAK,aAAa,YAAY,gBAAgB,OAAO;EAGxE,IAAI;EACJ,IAAI;AAEJ,MAAI,SAAS,WAAW;AACtB,aAAU,MAAM,KAAK,gBAAgB,WAAW,QAAQ,UAAU;AAClE,oBAAiB,MAAM,KAAK,sBAAsB,8BAChD,QAAQ,UACT;;AAGH,SAAO,KAAK,yBACV,aACA,KAAK,MACL,KAAK,aACL,KAAK,UACL,SACA,eACD;;;;;CAMH,MAAc,yBACZ,aACA,UACA,iBACA,WAAoB,MACpB,SACA,gBACwB;AACxB,OAAK,OAAO,MAAM,uCAAuC;GACvD,QAAQ,YAAY;GACpB,aAAa,YAAY;GACzB,WAAW,SAAS;GACpB,qBAAqB,gBAAgB,UAAU;GAChD,CAAC;EAGF,MAAM,qBAAqB,KAAK,yBAAyB,eAAe;EAGxE,IAAI,QAAQ,KAAK,eAAe,aAAa,mBAAmB;EAChE,MAAM,QAAQ,KAAK,eAAe,aAAa,mBAAmB;AAGlE,UAAQ,MAAM,KAAK,sBAAsB,OAAO,MAAM;AAEtD,SAAO;GACL;GACA;GACA,SAAS;GACT,MAAM;GACN,aAAa;GACb;GACA,iBAAiB;GAClB;;;;;CAMH,yBACE,gBACsC;EACtC,MAAM,4BAAY,IAAI,KAAsC;AAE5D,MAAI,eACF,gBAAe,SAAS,cAAc;AACpC,aAAU,IAAI,UAAU,QAAQ;IAC9B,QAAQ,UAAU;IAClB,OAAO,UAAU;IACjB,QAAQ,UAAU;IACnB,CAAC;IACF;AAGJ,SAAO;;;;;CAMT,eACE,aACA,oBACiB;EACjB,MAAM,QAAyB,EAAE;EAEjC,MAAM,aAAa,YAAY;AAC/B,MAAI,CAAC,YAAY,MACf,QAAO;EAGT,MAAM,iBAAiBC,wBAAAA,yBAAyB;AAEhD,aAAW,MAAM,SAAS,SAA8B;GACtD,MAAM,kBAAkB,mBAAmB,IAAI,KAAK,GAAG;GACvD,MAAM,SAAS,eAAe,IAAI,KAAK,KAAK;GAE5C,MAAM,cAAc,KAAK,eAAe,MAAM,OAAO;GACrD,MAAM,cAAc,KAAK,eACvB,MACA,YACD;GAGD,MAAM,WAA8B;IAClC,IAAI,KAAK;IACT,MAAM,KAAK;IACX,cAAc;IACd,cAAc;IACd,aAAa,QAAQ;IACrB,MAAM,QAAQ,SAAS;IACvB,QAAQ,KAAK,+BAA+B,iBAAiB,OAAO;IACpE,iBAAiB,iBAAiB;IAClC,gBAAgB,iBAAiB;IACjC,iBAAiB,iBAAiB;IAClC,QAAQ,KAAK;IAEb,QAAQ,KAAA;IACR,SAAS,iBAAiB,QAAQ;IAElC,GAAI,KAAK,UAAU,EAAE;IAErB,GAAI,KAAK,SAAS,EAAE,QAAQ,KAAK,QAAQ,GAAG,EAAE;IAC/C;GAED,MAAM,kBAAiC;IACrC,IAAI,KAAK;IACT,MAAM,KAAK;IACX,UAAU,KAAK,YAAY;KAAE,GAAG;KAAG,GAAG;KAAG;IACzC,MAAM;IACN,OAAO;IACP,QAAQ;IACT;AAED,SAAM,KAAK,gBAAgB;IAC3B;AAEF,SAAO;;;;;CAMT,eAAuB,MAA2B,QAA8C;AAE9F,MAAI,KAAK,SAAS,OAAO,KAAK,UAAU,SACtC,QAAO,KAAK;AAId,MAAI,QAAQ,KACV,QAAO,OAAO;AAIhB,SAAO,KAAK,KAAK,QAAQ,SAAS,IAAI,CAAC,QAAQ,UAAU,MAAM,EAAE,aAAa,CAAC;;CAGjF,OAAwB,0BAA0B;;;;;CAMlD,eACE,MACA,aACQ;AAER,MAAI,KAAK,eAAe,OAAO,KAAK,gBAAgB,SAClD,QAAO,KAAK;EAId,MAAM,SAAS,YACZ,aAAa,CACb,QAAQ,gBAAgB,GAAG,CAC3B,MAAM,CACN,QAAQ,QAAQ,IAAI;AAGvB,SAAO,KAAK,oBAAoB,OAAO;;;;;CAMzC,oBAA4B,OAAe,QAAyB;EAClE,MAAM,SAAS,yBAAyB;AAExC,MAAI,MAAM,UAAU,OAClB,QAAO;AAGT,MAAI,QAAQ;GACV,MAAM,uBAAuB,IAAI;GACjC,MAAM,mBAAmB,SAAS,qBAAqB;AACvD,OAAI,oBAAoB,EACtB,QAAO,MAAM,UAAU,GAAG,OAAO;AAEnC,UAAO,MAAM,UAAU,GAAG,iBAAiB,GAAG;;AAGhD,SAAO,MAAM,UAAU,GAAG,OAAO;;;;;CAMnC,eACE,aACA,oBACiB;EACjB,MAAM,QAAyB,EAAE;EAEjC,MAAM,aAAa,YAAY;AAC/B,MAAI,CAAC,YAAY,SAAS,CAAC,YAAY,MACrC,QAAO;EAIT,MAAM,8BAAc,IAAI,KAAqB;AAC7C,aAAW,MAAM,SAAS,SAA8B;AACtD,eAAY,IAAI,KAAK,IAAI,KAAK,KAAK;IACnC;AAEF,aAAW,MAAM,SAAS,SAA4C;GACpE,MAAM,mBAAmB,mBAAmB,IAAI,KAAK,OAAO;GAC5D,MAAM,mBAAmB,mBAAmB,IAAI,KAAK,OAAO;GAG5D,MAAM,2BACJ,kBAAkB,WAAWC,aAAAA,oBAAoB,WACjD,kBAAkB,WAAWA,aAAAA,oBAAoB;GAKnD,MAAM,kBAAiC;IACrC,IAAI,KAAK;IACT,QAAQ,KAAK;IACb,QAAQ,KAAK;IACb,cAAc,KAAK,gBAAgB;IACnC,cAAc,KAAK,gBAAgB;IACnC,UAAU,KAAK,YAAY;IAC3B,MAAM;KACJ,MAAM,2BAA2B,YAAY;KAC7C,UAAU,KAAK,YAAY;KAC3B,aAAa;KACb,UAAU;KACV,kBAAkB,kBAAkB;KACpC,kBAAkB,kBAAkB;KACrC;IACF;AAED,SAAM,KAAK,gBAAgB;IAC3B;AAEF,SAAO;;;;;CAMT,+BAAuC,iBAAyD;AAC9F,MAAI,CAAC,gBACH,QAAO;AAGT,UAAQ,iBAAR;GACE,KAAKA,aAAAA,oBAAoB;GACzB,KAAKA,aAAAA,oBAAoB,QACvB,QAAO;GACT,KAAKA,aAAAA,oBAAoB,QACvB,QAAO;GACT,KAAKA,aAAAA,oBAAoB,OACvB,QAAO;GACT,KAAKA,aAAAA,oBAAoB,QACvB,QAAO;GACT,KAAKA,aAAAA,oBAAoB,gBACvB,QAAO;GACT,QACE,QAAO;;;;;;;;;CAUb,MAAc,sBACZ,OACA,OAC0B;AAC1B,UAAA,GAAA,gBAAA,gBAAsB,OAAO,MAAM"}

package/dist/services/react-flow-renderer.service.d.cts

@@ -0,0 +1,149 @@
+import { NodeExecutionStatus } from "../types/base.cjs";
+import { Logger } from "../types/schemas-fresh/invect-config.cjs";
+import { NodeInputData, NodeOutput } from "../types/node-io-types.cjs";
+import { FlowVersion } from "../database/schema-sqlite.cjs";
+import { FlowsService } from "./flows/flows.service.cjs";
+import { FlowVersionsService } from "./flow-versions/flow-versions.service.cjs";
+import { FlowRunsService } from "./flow-runs/flow-runs.service.cjs";
+import { NodeExecutionService } from "./node-executions/node-execution.service.cjs";
+
+//#region src/services/react-flow-renderer.service.d.ts
+interface Position {
+  x: number;
+  y: number;
+}
+type NodeVisualStatus = 'idle' | 'running' | 'completed' | 'error' | 'skipped';
+interface NodeExecutionStatusInfo {
+  status: NodeExecutionStatus;
+  error?: string;
+  output?: NodeOutput;
+}
+interface ReactFlowNodeData extends Record<string, unknown> {
+  id: string;
+  type: string;
+  display_name: string;
+  reference_id: string;
+  description?: string;
+  icon?: string;
+  status: NodeVisualStatus;
+  executionStatus?: NodeExecutionStatus;
+  executionError?: string;
+  executionOutput?: NodeOutput;
+  params?: Record<string, unknown>;
+  inputs?: NodeInputData;
+  outputs?: NodeOutput['data'];
+}
+interface ReactFlowNode<T extends string = string> {
+  id: string;
+  type: T;
+  position: Position;
+  data: ReactFlowNodeData;
+  width?: number;
+  height?: number;
+  measured?: {
+    width: number;
+    height: number;
+  };
+  dragHandle?: string;
+}
+interface ReactFlowEdge {
+  id: string;
+  source: string;
+  target: string;
+  sourceHandle?: string;
+  targetHandle?: string;
+  animated?: boolean;
+  data?: {
+    type: 'default' | 'skipped';
+    animated: boolean;
+    highlighted: boolean;
+    selected: boolean;
+    sourceNodeStatus?: NodeExecutionStatus;
+    targetNodeStatus?: NodeExecutionStatus;
+  };
+}
+interface ReactFlowData {
+  nodes: ReactFlowNode[];
+  edges: ReactFlowEdge[];
+  version: FlowVersion;
+  name: string;
+  description?: string;
+  isActive: boolean;
+  executionStatus?: Map<string, NodeExecutionStatusInfo>;
+}
+interface TypedReactFlowData<T extends string = string> {
+  nodes: ReactFlowNode<T>[];
+  edges: ReactFlowEdge[];
+  version: FlowVersion;
+  name: string;
+  description?: string;
+  executionStatus?: Map<string, NodeExecutionStatusInfo>;
+}
+/**
+ * Service for rendering flow data in React Flow compatible format
+ * Transforms Invect flow definitions into React Flow compatible nodes and edges
+ */
+declare class ReactFlowRendererService {
+  private readonly logger;
+  private readonly flowsService;
+  private readonly flowVersionsService;
+  private readonly flowRunsService;
+  private readonly nodeExecutionsService;
+  private initialized;
+  constructor(logger: Logger, flowsService: FlowsService, flowVersionsService: FlowVersionsService, flowRunsService: FlowRunsService, nodeExecutionsService: NodeExecutionService);
+  /**
+   * Initialize the service
+   */
+  initialize(): Promise<void>;
+  /**
+   * Transform flow version and execution data to React Flow format
+   */
+  renderToReactFlow(flowId: string, options?: {
+    version?: string | number | 'latest';
+    flowRunId?: string;
+  }): Promise<ReactFlowData>;
+  /**
+   * Internal method to transform data to React Flow format
+   */
+  private transformToReactFlowData;
+  /**
+   * Create execution status map from node executions
+   */
+  private createExecutionStatusMap;
+  /**
+   * Transform flow nodes to React Flow format
+   */
+  private transformNodes;
+  /**
+   * Get display name for a node, with fallbacks
+   */
+  private getDisplayName;
+  private static readonly MAX_REFERENCE_ID_LENGTH;
+  /**
+   * Get or generate a reference_id for a node (snake_case, alphanumeric only)
+   * Truncates to MAX_REFERENCE_ID_LENGTH while preserving any increment suffix
+   */
+  private getReferenceId;
+  /**
+   * Truncate a reference ID to max length while preserving any numeric suffix
+   */
+  private truncateReferenceId;
+  /**
+   * Transform flow edges to React Flow format
+   */
+  private transformEdges;
+  /**
+   * Map execution status to node visual status
+   */
+  private mapExecutionStatusToNodeStatus;
+  /**
+   * Apply ELK left-to-right layout to nodes
+   * Uses elkjs layered algorithm for better edge crossing minimization
+   *
+   * Note: ELK is async because elkjs uses web workers internally
+   */
+  private applyElkLayoutToNodes;
+}
+//#endregion
+export { NodeExecutionStatusInfo, NodeVisualStatus, Position, ReactFlowData, ReactFlowEdge, ReactFlowNode, ReactFlowNodeData, ReactFlowRendererService, TypedReactFlowData };
+//# sourceMappingURL=react-flow-renderer.service.d.cts.map

package/dist/services/react-flow-renderer.service.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-flow-renderer.service.d.cts","names":[],"sources":["../../src/services/react-flow-renderer.service.ts"],"mappings":";;;;;;;;;;UAiBiB,QAAA;EACf,CAAA;EACA,CAAA;AAAA;AAAA,KAIU,gBAAA;AAAA,UAKK,uBAAA;EACf,MAAA,EAAQ,mBAAA;EACR,KAAA;EACA,MAAA,GAAS,UAAA;AAAA;AAAA,UAIM,iBAAA,SAA0B,MAAA;EACzC,EAAA;EACA,IAAA;EACA,YAAA;EACA,YAAA;EACA,WAAA;EACA,IAAA;EACA,MAAA,EAAQ,gBAAA;EACR,eAAA,GAAkB,mBAAA;EAClB,cAAA;EACA,eAAA,GAAkB,UAAA;EAElB,MAAA,GAAS,MAAA;EAET,MAAA,GAAS,aAAA;EAET,OAAA,GAAU,UAAA;AAAA;AAAA,UAIK,aAAA;EACf,EAAA;EACA,IAAA,EAAM,CAAA;EACN,QAAA,EAAU,QAAA;EACV,IAAA,EAAM,iBAAA;EACN,KAAA;EACA,MAAA;EACA,QAAA;IAAa,KAAA;IAAe,MAAA;EAAA;EAC5B,UAAA;AAAA;AAAA,UAIe,aAAA;EACf,EAAA;EACA,MAAA;EACA,MAAA;EACA,YAAA;EACA,YAAA;EACA,QAAA;EACA,IAAA;IACE,IAAA;IACA,QAAA;IACA,WAAA;IACA,QAAA;IACA,gBAAA,GAAmB,mBAAA;IACnB,gBAAA,GAAmB,mBAAA;EAAA;AAAA;AAAA,UAKN,aAAA;EACf,KAAA,EAAO,aAAA;EACP,KAAA,EAAO,aAAA;EACP,OAAA,EAAS,WAAA;EACT,IAAA;EACA,WAAA;EACA,QAAA;EACA,eAAA,GAAkB,GAAA,SAAY,uBAAA;AAAA;AAAA,UAIf,kBAAA;EACf,KAAA,EAAO,aAAA,CAAc,CAAA;EACrB,KAAA,EAAO,aAAA;EACP,OAAA,EAAS,WAAA;EACT,IAAA;EACA,WAAA;EACA,eAAA,GAAkB,GAAA,SAAY,uBAAA;AAAA;;;;;cAOnB,wBAAA;EAAA,iBAIQ,MAAA;EAAA,iBACA,YAAA;EAAA,iBACA,mBAAA;EAAA,iBACA,eAAA;EAAA,iBACA,qBAAA;EAAA,QAPX,WAAA;cAGW,MAAA,EAAQ,MAAA,EACR,YAAA,EAAc,YAAA,EACd,mBAAA,EAAqB,mBAAA,EACrB,eAAA,EAAiB,eAAA,EACjB,qBAAA,EAAuB,oBAAA;EAlDd;;;EAwDtB,UAAA,CAAA,GAAc,OAAA;EAtDpB;;;EAwEM,iBAAA,CACJ,MAAA,UACA,OAAA;IAAY,OAAA;IAAsC,SAAA;EAAA,IACjD,OAAA,CAAQ,aAAA;EApET;;;EAAA,QAiHY,wBAAA;EA9GO;;;EAAA,QAqJb,wBAAA;EApJgC;AAK1C;;EAL0C,QAyKhC,cAAA;EAnKD;;;EAAA,QAkOC,cAAA;EAAA,wBAegB,uBAAA;EA3OH;;;;EAAA,QAiPb,cAAA;EAtPD;;;EAAA,QA6QC,mBAAA;EA1QR;;;EAAA,QAgSQ,cAAA;EA9RsB;;;EAAA,QAqVtB,8BAAA;EAjVyB;;;;;;EAAA,QA6WnB,qBAAA;AAAA"}

package/dist/services/react-flow-renderer.service.d.ts

@@ -0,0 +1,149 @@
+import { NodeExecutionStatus } from "../types/base.js";
+import { Logger } from "../types/schemas-fresh/invect-config.js";
+import { NodeInputData, NodeOutput } from "../types/node-io-types.js";
+import { FlowVersion } from "../database/schema-sqlite.js";
+import { FlowsService } from "./flows/flows.service.js";
+import { FlowVersionsService } from "./flow-versions/flow-versions.service.js";
+import { FlowRunsService } from "./flow-runs/flow-runs.service.js";
+import { NodeExecutionService } from "./node-executions/node-execution.service.js";
+
+//#region src/services/react-flow-renderer.service.d.ts
+interface Position {
+  x: number;
+  y: number;
+}
+type NodeVisualStatus = 'idle' | 'running' | 'completed' | 'error' | 'skipped';
+interface NodeExecutionStatusInfo {
+  status: NodeExecutionStatus;
+  error?: string;
+  output?: NodeOutput;
+}
+interface ReactFlowNodeData extends Record<string, unknown> {
+  id: string;
+  type: string;
+  display_name: string;
+  reference_id: string;
+  description?: string;
+  icon?: string;
+  status: NodeVisualStatus;
+  executionStatus?: NodeExecutionStatus;
+  executionError?: string;
+  executionOutput?: NodeOutput;
+  params?: Record<string, unknown>;
+  inputs?: NodeInputData;
+  outputs?: NodeOutput['data'];
+}
+interface ReactFlowNode<T extends string = string> {
+  id: string;
+  type: T;
+  position: Position;
+  data: ReactFlowNodeData;
+  width?: number;
+  height?: number;
+  measured?: {
+    width: number;
+    height: number;
+  };
+  dragHandle?: string;
+}
+interface ReactFlowEdge {
+  id: string;
+  source: string;
+  target: string;
+  sourceHandle?: string;
+  targetHandle?: string;
+  animated?: boolean;
+  data?: {
+    type: 'default' | 'skipped';
+    animated: boolean;
+    highlighted: boolean;
+    selected: boolean;
+    sourceNodeStatus?: NodeExecutionStatus;
+    targetNodeStatus?: NodeExecutionStatus;
+  };
+}
+interface ReactFlowData {
+  nodes: ReactFlowNode[];
+  edges: ReactFlowEdge[];
+  version: FlowVersion;
+  name: string;
+  description?: string;
+  isActive: boolean;
+  executionStatus?: Map<string, NodeExecutionStatusInfo>;
+}
+interface TypedReactFlowData<T extends string = string> {
+  nodes: ReactFlowNode<T>[];
+  edges: ReactFlowEdge[];
+  version: FlowVersion;
+  name: string;
+  description?: string;
+  executionStatus?: Map<string, NodeExecutionStatusInfo>;
+}
+/**
+ * Service for rendering flow data in React Flow compatible format
+ * Transforms Invect flow definitions into React Flow compatible nodes and edges
+ */
+declare class ReactFlowRendererService {
+  private readonly logger;
+  private readonly flowsService;
+  private readonly flowVersionsService;
+  private readonly flowRunsService;
+  private readonly nodeExecutionsService;
+  private initialized;
+  constructor(logger: Logger, flowsService: FlowsService, flowVersionsService: FlowVersionsService, flowRunsService: FlowRunsService, nodeExecutionsService: NodeExecutionService);
+  /**
+   * Initialize the service
+   */
+  initialize(): Promise<void>;
+  /**
+   * Transform flow version and execution data to React Flow format
+   */
+  renderToReactFlow(flowId: string, options?: {
+    version?: string | number | 'latest';
+    flowRunId?: string;
+  }): Promise<ReactFlowData>;
+  /**
+   * Internal method to transform data to React Flow format
+   */
+  private transformToReactFlowData;
+  /**
+   * Create execution status map from node executions
+   */
+  private createExecutionStatusMap;
+  /**
+   * Transform flow nodes to React Flow format
+   */
+  private transformNodes;
+  /**
+   * Get display name for a node, with fallbacks
+   */
+  private getDisplayName;
+  private static readonly MAX_REFERENCE_ID_LENGTH;
+  /**
+   * Get or generate a reference_id for a node (snake_case, alphanumeric only)
+   * Truncates to MAX_REFERENCE_ID_LENGTH while preserving any increment suffix
+   */
+  private getReferenceId;
+  /**
+   * Truncate a reference ID to max length while preserving any numeric suffix
+   */
+  private truncateReferenceId;
+  /**
+   * Transform flow edges to React Flow format
+   */
+  private transformEdges;
+  /**
+   * Map execution status to node visual status
+   */
+  private mapExecutionStatusToNodeStatus;
+  /**
+   * Apply ELK left-to-right layout to nodes
+   * Uses elkjs layered algorithm for better edge crossing minimization
+   *
+   * Note: ELK is async because elkjs uses web workers internally
+   */
+  private applyElkLayoutToNodes;
+}
+//#endregion
+export { NodeExecutionStatusInfo, NodeVisualStatus, Position, ReactFlowData, ReactFlowEdge, ReactFlowNode, ReactFlowNodeData, ReactFlowRendererService, TypedReactFlowData };
+//# sourceMappingURL=react-flow-renderer.service.d.ts.map

package/dist/services/react-flow-renderer.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-flow-renderer.service.d.ts","names":[],"sources":["../../src/services/react-flow-renderer.service.ts"],"mappings":";;;;;;;;;;UAiBiB,QAAA;EACf,CAAA;EACA,CAAA;AAAA;AAAA,KAIU,gBAAA;AAAA,UAKK,uBAAA;EACf,MAAA,EAAQ,mBAAA;EACR,KAAA;EACA,MAAA,GAAS,UAAA;AAAA;AAAA,UAIM,iBAAA,SAA0B,MAAA;EACzC,EAAA;EACA,IAAA;EACA,YAAA;EACA,YAAA;EACA,WAAA;EACA,IAAA;EACA,MAAA,EAAQ,gBAAA;EACR,eAAA,GAAkB,mBAAA;EAClB,cAAA;EACA,eAAA,GAAkB,UAAA;EAElB,MAAA,GAAS,MAAA;EAET,MAAA,GAAS,aAAA;EAET,OAAA,GAAU,UAAA;AAAA;AAAA,UAIK,aAAA;EACf,EAAA;EACA,IAAA,EAAM,CAAA;EACN,QAAA,EAAU,QAAA;EACV,IAAA,EAAM,iBAAA;EACN,KAAA;EACA,MAAA;EACA,QAAA;IAAa,KAAA;IAAe,MAAA;EAAA;EAC5B,UAAA;AAAA;AAAA,UAIe,aAAA;EACf,EAAA;EACA,MAAA;EACA,MAAA;EACA,YAAA;EACA,YAAA;EACA,QAAA;EACA,IAAA;IACE,IAAA;IACA,QAAA;IACA,WAAA;IACA,QAAA;IACA,gBAAA,GAAmB,mBAAA;IACnB,gBAAA,GAAmB,mBAAA;EAAA;AAAA;AAAA,UAKN,aAAA;EACf,KAAA,EAAO,aAAA;EACP,KAAA,EAAO,aAAA;EACP,OAAA,EAAS,WAAA;EACT,IAAA;EACA,WAAA;EACA,QAAA;EACA,eAAA,GAAkB,GAAA,SAAY,uBAAA;AAAA;AAAA,UAIf,kBAAA;EACf,KAAA,EAAO,aAAA,CAAc,CAAA;EACrB,KAAA,EAAO,aAAA;EACP,OAAA,EAAS,WAAA;EACT,IAAA;EACA,WAAA;EACA,eAAA,GAAkB,GAAA,SAAY,uBAAA;AAAA;;;;;cAOnB,wBAAA;EAAA,iBAIQ,MAAA;EAAA,iBACA,YAAA;EAAA,iBACA,mBAAA;EAAA,iBACA,eAAA;EAAA,iBACA,qBAAA;EAAA,QAPX,WAAA;cAGW,MAAA,EAAQ,MAAA,EACR,YAAA,EAAc,YAAA,EACd,mBAAA,EAAqB,mBAAA,EACrB,eAAA,EAAiB,eAAA,EACjB,qBAAA,EAAuB,oBAAA;EAlD3B;;;EAwDT,UAAA,CAAA,GAAc,OAAA;EAvDpB;;;EAyEM,iBAAA,CACJ,MAAA,UACA,OAAA;IAAY,OAAA;IAAsC,SAAA;EAAA,IACjD,OAAA,CAAQ,aAAA;EArET;;;EAAA,QAkHY,wBAAA;EA9GZ;;;EAAA,QAqJM,wBAAA;EApJgC;;AAK1C;EAL0C,QAyKhC,cAAA;;;;UA+DA,cAAA;EAAA,wBAegB,uBAAA;EA3ON;;;;EAAA,QAiPV,cAAA;EAtPR;;;EAAA,QA6QQ,mBAAA;EA3QR;;;EAAA,QAiSQ,cAAA;EA9RU;;;EAAA,QAqVV,8BAAA;EAjVO;;;;;;EAAA,QA6WD,qBAAA;AAAA"}