@cqa-lib/cqa-ui 1.1.556 → 1.1.557-delta.8

package/esm2020/lib/execution-screen/api-step/api-step.component.mjs

@@ -161,6 +161,12 @@ export class ApiStepComponent extends BaseStepComponent {
         }
     }
     formatJson(obj) {
+        // If the caller already passed a pre-formatted string (e.g. a GraphQL query with
+        // embedded newlines), render it as-is. Running JSON.stringify on it would wrap
+        // the value in quotes and escape every `\n` into a literal `\n`, which is what
+        // shows up as a single-line blob in the Request Body panel.
+        if (typeof obj === 'string')
+            return obj;
         return JSON.stringify(obj, null, 2);
     }
     getPassedAssertions() {
@@ -962,4 +968,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImpor
             }], jsonPathCopied: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-step.component.js","sourceRoot":"","sources":["../../../../../../src/lib/execution-screen/api-step/api-step.component.ts","../../../../../../src/lib/execution-screen/api-step/api-step.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnInit, OnChanges, OnDestroy, Output, SimpleChanges, DoCheck } from '@angular/core';\nimport { ApiStepConfig, ApiAssertion, SubStep, StepStatus, TimingBreakdown, FailureDetails, SelfHealAnalysisData, SelfHealAction, ExecutionStepConfig, SelfHealActionEvent, AddStepMenuOption, DEFAULT_ADD_STEP_MENU_OPTIONS, StepMoreMenuOption, DEFAULT_STEP_MORE_MENU_OPTIONS } from '../execution-step.models';\nimport { BaseStepComponent } from '../base-step.component';\nimport { makeCurrentBaselineEvent, uploadBaselineEvent } from '../visual-comparison/visual-comparison.component';\n\n@Component({\n  selector: 'cqa-api-step',\n  templateUrl: './api-step.component.html',\n  styleUrls: [],\n  host: { class: 'cqa-ui-root cqa-w-full' }\n})\nexport class ApiStepComponent extends BaseStepComponent implements OnInit, OnChanges, OnDestroy, DoCheck {\n  // Individual inputs\n  @Input() id!: string;\n  @Input() testStepResultId!: string;\n  @Input() stepNumber!: string;\n  @Input() title!: string;\n  @Input() status!: StepStatus;\n  @Input() duration!: number;\n  @Input() timingBreakdown?: TimingBreakdown;\n  @Input() expanded?: boolean;\n  @Input() method!: string;\n  @Input() endpoint!: string;\n  @Input() statusCode!: number;\n  @Input() responseTime!: number;\n  @Input() requestBody?: any;\n  @Input() responseBody?: any;\n  @Input() requestHeaders?: any;\n  @Input() responseHeaders?: any;\n  @Input() assertions?: ApiAssertion[];\n  @Input() initialActions?: SubStep[];\n  @Input() isDebug?: boolean = false;\n  @Input() canEditSteps?: boolean = true;\n  @Input() debugPointSet?: boolean = false;\n  @Input() parentSkipped?: boolean = false;\n  @Output() debugPointChange = new EventEmitter<boolean>();\n  @Output() editStep = new EventEmitter<void>();\n  @Output() addStepOptionSelect = new EventEmitter<AddStepMenuOption>();\n  @Output() stepMoreOptionSelect = new EventEmitter<StepMoreMenuOption>();\n  @Input() addStepMenuOptions: AddStepMenuOption[] = DEFAULT_ADD_STEP_MENU_OPTIONS;\n  @Input() stepMoreMenuOptions: StepMoreMenuOption[] = DEFAULT_STEP_MORE_MENU_OPTIONS;\n  @Input() failureDetails?: FailureDetails;\n  @Input() reasoning?: string[];\n  @Input() confidence?: string;\n  @Input() stepDeleted?: boolean;\n  @Input() isUploadingBaseline = {};\n  @Input() isMakingCurrentBaseline = {};\n  @Input() isLive: boolean = false;\n  @Input() selfHealAnalysis?: SelfHealAnalysisData;\n  @Input() getSelfHealLoadingStatesHandler?: () => { isLoadingAccept: { [key: string]: boolean }; isLoadingModifyAccept: { [key: string]: boolean } };\n  @Input() onStepClickHandler?: (step: ExecutionStepConfig, event?: Event) => void;\n  @Input() onJsonPathCopiedHandler?: (event: { path: string; source: 'requestBody' | 'responseBody' | 'requestHeaders' | 'responseHeaders' }) => void;\n  @Input() jumpToTimestampHandler?: (timestamp: number, testStepId?: number | string) => void;\n  @Input() step?: any;\n  get stepBadges(): ('skipped' | 'edited' | 'added' | 'removed')[] {\n    const badge = this.step?.stepBadge;\n    if (!badge) return [];\n    return Array.isArray(badge) ? badge : [badge];\n  }\n\n  get isSkipped(): boolean {\n    return this.stepBadges.includes('skipped');\n  }\n\n  get isStepDeleted(): boolean {\n    return this.stepBadges.includes('removed');\n  }\n\n  @Output() makeCurrentBaseline = new EventEmitter<makeCurrentBaselineEvent>();\n  @Output() uploadBaseline = new EventEmitter<uploadBaselineEvent>();\n  @Output() analyze = new EventEmitter<void>();\n  @Output() viewFullLogs = new EventEmitter<void>();\n  @Output() selfHealAction = new EventEmitter<SelfHealActionEvent>();\n  @Output() jsonPathCopied = new EventEmitter<{ path: string; source: 'requestBody' | 'responseBody' | 'requestHeaders' | 'responseHeaders' }>();\n\n  showFailedStepDetails: boolean = false;\n\n  /** Show debug icon only when this step has no child steps (leaf step: always show when isDebug). */\n  get showDebugIcon(): boolean {\n    return this.isDebug === true;\n  }\n\n  /** Per-step filtered three-dot menu options (e.g. hide Duplicate/Delete for step-group children). */\n  get effectiveStepMoreMenuOptions(): StepMoreMenuOption[] {\n    const base = this.stepMoreMenuOptions || [];\n    const stepRef: any = this.step;\n    if (!stepRef) return base;\n\n    const isGroupChild = !!stepRef.isStepGroupChildren;\n    // When step.stepMoreMenuOptions is truthy OR step is a step-group child, hide mutating items\n    const suppressMutating = !!stepRef.stepMoreMenuOptions || isGroupChild;\n    if (!suppressMutating) return base;\n\n    return base.filter(opt => opt.id !== 'duplicate' && opt.id !== 'delete');\n  }\n\n  // Config property for base class - built from individual inputs in ngOnInit\n  override config!: ApiStepConfig;\n\n  private previousStatus?: StepStatus;\n  private userManuallyClosed: boolean = false;\n  showRequestSummaryCopied: boolean = false;\n\n  // Processed initial actions for live mode WAIT_FOR_LOCATOR countdown grouping\n  processedInitialActions: any[] = [];\n  private lastProcessedIndex: number = 0;\n  private waitLocatorGroupEntry: any | null = null;\n  private countdownIntervalId: any = null;\n\n  // AI_AUTO_HEAL grouping: show loading until AI_AUTO_HEAL_SUCCESS or AI_AUTO_HEAL_FAILED\n  private aiAutoHealGroupEntry: any | null = null;\n\n  // Processed initial actions for run result screen (filter and split AI_AUTO_HEAL_SUCCESS/FAILED)\n  processedInitialActionsForRunResult: any[] = [];\n  private requestSummaryCopiedTimeout?: any;\n  showRequestHeadersCopied: boolean = false;\n  private requestHeadersCopiedTimeout?: any;\n  showResponseHeadersCopied: boolean = false;\n  private responseHeadersCopiedTimeout?: any;\n  showRequestBodyCopied: boolean = false;\n  private requestBodyCopiedTimeout?: any;\n  showResponseBodyCopied: boolean = false;\n  private responseBodyCopiedTimeout?: any;\n\n  override ngOnInit(): void {\n    // Build config from individual inputs\n    this.updateConfig();\n\n    super.ngOnInit();\n    \n    // Ensure isExpanded is set correctly after super.ngOnInit()\n    if (this.expanded !== undefined) {\n      this.isExpanded = this.expanded;\n    }\n\n    // Initialize live initial actions processing for WAIT_FOR_LOCATOR grouping\n    if (this.isLive && this.initialActions && this.initialActions.length > 0) {\n      this.processLiveInitialActions();\n    } else if (!this.isLive && this.initialActions && this.initialActions.length > 0) {\n      // Process for run result screen: filter and split AI_AUTO_HEAL_SUCCESS/FAILED\n      this.processInitialActionsForRunResult();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if(this.isLive) {\n      // Update config when any relevant input changes\n      if (changes['status'] || changes['duration'] || changes['expanded'] ||\n          changes['statusCode'] || changes['responseTime'] || changes['assertions'] ||\n          changes['initialActions'] || changes['requestBody'] || changes['responseBody'] ||\n          changes['requestHeaders'] || changes['responseHeaders'] || changes['timingBreakdown'] ||\n          changes['stepNumber']) {\n        this.updateConfig();\n      }\n      \n      // Update expanded state if changed\n      if (changes['expanded'] && this.expanded !== undefined) {\n        this.isExpanded = this.expanded;\n      }\n\n      // Update initialActions array when new ones are added\n      if (changes['initialActions']) {\n        const previousActionsCount = changes['initialActions'].previousValue?.length || 0;\n        const currentActionsCount = (this.initialActions || []).length;\n        \n        // Process live initial actions\n        if (this.isLive) {\n          this.processLiveInitialActions();\n        } else {\n          this.processInitialActionsForRunResult();\n        }\n        \n        // Auto-expand if step is running and new initialActions are added (logs coming in)\n        if (!changes['initialActions'].firstChange && \n            this.status === 'running' && \n            currentActionsCount > previousActionsCount &&\n            this.hasSubSteps && \n            !this.isExpanded && \n            !this.userManuallyClosed) {\n          this.autoExpand();\n        }\n      }\n\n      // Handle status changes - auto-expand when step starts executing\n      if (changes['status'] && !changes['status'].firstChange) {\n        const newStatus = changes['status'].currentValue;\n        const oldStatus = changes['status'].previousValue;\n        \n        // Auto-expand when status changes to 'running' and has subSteps (or will have soon)\n        if (newStatus === 'running' && oldStatus !== 'running' && !this.userManuallyClosed) {\n          // Expand immediately if already has subSteps, or wait for them\n          if (this.hasSubSteps) {\n            this.autoExpand();\n          }\n        }\n        \n        this.previousStatus = newStatus;\n      }\n    }\n\n    if (changes['stepDeleted'] && this.config) {\n      this.config.stepDeleted = changes['stepDeleted'].currentValue;\n    }\n  }\n\n  getStatusBadgeClass(): string {\n    if (this.config.statusCode >= 200 && this.config.statusCode < 300) {\n      return 'cqa-bg-green-100 cqa-text-green-800';\n    } else if (this.config.statusCode >= 400 && this.config.statusCode < 500) {\n      return 'cqa-bg-orange-100 cqa-text-orange-800';\n    } else {\n      return 'cqa-bg-red-100 cqa-text-red-800';\n    }\n  }\n\n  formatJson(obj: any): string {\n    return JSON.stringify(obj, null, 2);\n  }\n\n  getPassedAssertions(): number {\n    return this.config.assertions?.filter(a => a.status === 'passed').length || 0;\n  }\n\n  getFailedAssertions(): number {\n    return this.config.assertions?.filter(a => a.status === 'failed').length || 0;\n  }\n\n  copyToClipboard(text: string): void {\n    navigator.clipboard.writeText(text).then(() => {\n      console.log('Copied to clipboard:', text);\n    }).catch(err => {\n      console.error('Failed to copy to clipboard:', err);\n      // Call the handler if copy fails\n      if (this.onJsonPathCopiedHandler) {\n        console.log('Calling onJsonPathCopiedHandler from copyToClipboard');\n        try {\n          this.onJsonPathCopiedHandler({ path: text, source: 'responseBody' });\n        } catch (handlerError) {\n          console.error('Error in onJsonPathCopiedHandler:', handlerError);\n        }\n      }\n    });\n  }\n\n  copyRequestBody(): void {\n    if (this.requestBody) {\n      const formattedJson = this.formatJson(this.requestBody);\n      navigator.clipboard.writeText(formattedJson).then(() => {\n        // Show \"Copied\" tooltip\n        this.showRequestBodyCopied = true;\n        \n        // Clear any existing timeout\n        if (this.requestBodyCopiedTimeout) {\n          clearTimeout(this.requestBodyCopiedTimeout);\n        }\n        \n        // Hide tooltip after 2 seconds\n        this.requestBodyCopiedTimeout = setTimeout(() => {\n          this.showRequestBodyCopied = false;\n        }, 2000);\n      }).catch(err => {\n        console.error('Failed to copy request body:', err);\n      });\n    }\n  }\n\n  copyResponseBody(): void {\n    if (this.responseBody) {\n      const formattedJson = this.formatJson(this.responseBody);\n      navigator.clipboard.writeText(formattedJson).then(() => {\n        // Show \"Copied\" tooltip\n        this.showResponseBodyCopied = true;\n        \n        // Clear any existing timeout\n        if (this.responseBodyCopiedTimeout) {\n          clearTimeout(this.responseBodyCopiedTimeout);\n        }\n        \n        // Hide tooltip after 2 seconds\n        this.responseBodyCopiedTimeout = setTimeout(() => {\n          this.showResponseBodyCopied = false;\n        }, 2000);\n      }).catch(err => {\n        console.error('Failed to copy response body:', err);\n      });\n    }\n  }\n\n  copyRequestHeaders(): void {\n    if (this.requestHeaders) {\n      const formattedJson = this.formatJson(this.requestHeaders);\n      navigator.clipboard.writeText(formattedJson).then(() => {\n        // Show \"Copied\" tooltip\n        this.showRequestHeadersCopied = true;\n        \n        // Clear any existing timeout\n        if (this.requestHeadersCopiedTimeout) {\n          clearTimeout(this.requestHeadersCopiedTimeout);\n        }\n        \n        // Hide tooltip after 2 seconds\n        this.requestHeadersCopiedTimeout = setTimeout(() => {\n          this.showRequestHeadersCopied = false;\n        }, 2000);\n      }).catch(err => {\n        console.error('Failed to copy request headers:', err);\n      });\n    }\n  }\n\n  copyResponseHeaders(): void {\n    if (this.responseHeaders) {\n      const formattedJson = this.formatJson(this.responseHeaders);\n      navigator.clipboard.writeText(formattedJson).then(() => {\n        // Show \"Copied\" tooltip\n        this.showResponseHeadersCopied = true;\n        \n        // Clear any existing timeout\n        if (this.responseHeadersCopiedTimeout) {\n          clearTimeout(this.responseHeadersCopiedTimeout);\n        }\n        \n        // Hide tooltip after 2 seconds\n        this.responseHeadersCopiedTimeout = setTimeout(() => {\n          this.showResponseHeadersCopied = false;\n        }, 2000);\n      }).catch(err => {\n        console.error('Failed to copy response headers:', err);\n      });\n    }\n  }\n\n  /**\n   * Walks jsonData and builds a map from each line number (in the output of\n   * JSON.stringify(jsonData, null, 2)) to the segment path that line represents.\n   * Segments are strings for object keys and numbers for array indices.\n   */\n  private buildLinePathMap(obj: any): Map<number, Array<string | number>> {\n    const map = new Map<number, Array<string | number>>();\n    const state = { line: 0 };\n\n    const walk = (value: any, path: Array<string | number>): void => {\n      if (Array.isArray(value)) {\n        if (value.length === 0) return;\n        for (let i = 0; i < value.length; i++) {\n          state.line += 1; // newline before element\n          const elementPath = [...path, i];\n          map.set(state.line, elementPath);\n          walk(value[i], elementPath);\n        }\n        state.line += 1; // newline before closing ]\n        return;\n      }\n      if (value && typeof value === 'object') {\n        const keys = Object.keys(value);\n        if (keys.length === 0) return;\n        for (const key of keys) {\n          state.line += 1; // newline before \"key\":\n          const keyPath = [...path, key];\n          map.set(state.line, keyPath);\n          walk(value[key], keyPath);\n        }\n        state.line += 1; // newline before closing }\n        return;\n      }\n      // primitive — no additional lines\n    };\n\n    // Root line (line 0) is the opening { or [ or primitive.\n    walk(obj, []);\n    return map;\n  }\n\n  /**\n   * Extracts JSON path from the clicked position in a formatted JSON string.\n   * Returns an array of segments (string keys or numeric array indices), or null.\n   */\n  private getJsonPathFromClick(event: MouseEvent, jsonData: any, prefix: string = ''): Array<string | number> | null {\n    const target = event.target as HTMLElement;\n    if (!target || jsonData == null) return null;\n\n    const preElement = target.closest('pre');\n    if (!preElement) return null;\n\n    // Create a range at the click position\n    let range: Range | null = null;\n    if (document.caretRangeFromPoint) {\n      range = document.caretRangeFromPoint(event.clientX, event.clientY);\n    }\n\n    if (!range) {\n      // Fallback for browsers that don't support caretRangeFromPoint\n      const selection = window.getSelection();\n      if (selection && selection.rangeCount > 0) {\n        range = selection.getRangeAt(0);\n      } else {\n        return null;\n      }\n    }\n\n    // Get the text content up to the click position\n    const preRange = document.createRange();\n    preRange.selectNodeContents(preElement);\n    preRange.setEnd(range.startContainer, range.startOffset);\n    const textBeforeClick = preRange.toString();\n\n    // Count newlines to find which line we're on\n    const lineIndex = (textBeforeClick.match(/\\n/g) || []).length;\n\n    const linePathMap = this.buildLinePathMap(jsonData);\n\n    // Exact match first; otherwise fall back to the nearest preceding mapped line\n    // (handles clicks on closing brackets or blank columns).\n    let segments = linePathMap.get(lineIndex);\n    if (!segments) {\n      for (let i = lineIndex - 1; i >= 0; i--) {\n        const candidate = linePathMap.get(i);\n        if (candidate) {\n          segments = candidate;\n          break;\n        }\n      }\n    }\n    if (!segments || segments.length === 0) return null;\n\n    return prefix ? [prefix, ...segments] : [...segments];\n  }\n\n  private formatSegmentsPath(segments: Array<string | number>): string {\n    return segments.reduce<string>((acc, seg) => {\n      if (typeof seg === 'number') return `${acc}[${seg}]`;\n      return acc ? `${acc}.${seg}` : String(seg);\n    }, '');\n  }\n\n  private normalizeJsonPath(segments: Array<string | number>, prefix: string): string {\n    if (!segments || segments.length === 0) return '';\n\n    if (!prefix || segments.length < 2) {\n      return this.formatSegmentsPath(segments);\n    }\n\n    const [, ...rest] = segments;\n\n    if (prefix === 'requestHeaders' || prefix === 'responseHeaders') {\n      return rest.length ? `headers${this.formatSegmentsPath(rest).startsWith('[') ? '' : '.'}${this.formatSegmentsPath(rest)}` : 'headers';\n    }\n\n    if (prefix === 'requestBody' || prefix === 'responseBody') {\n      return rest.length ? `body${this.formatSegmentsPath(rest).startsWith('[') ? '' : '.'}${this.formatSegmentsPath(rest)}` : 'body';\n    }\n\n    return this.formatSegmentsPath(segments);\n  }\n\n  /**\n   * Copy JSON path on double-click\n   */\n  copyJsonPath(event: MouseEvent, jsonData: any, prefix: string = ''): void {\n    if (!jsonData) return;\n\n    const segments = this.getJsonPathFromClick(event, jsonData, prefix);\n    if (segments && segments.length > 0) {\n      const source = prefix as 'requestBody' | 'responseBody' | 'requestHeaders' | 'responseHeaders';\n      const normalizedPath = this.normalizeJsonPath(segments, prefix);\n      navigator.clipboard.writeText(normalizedPath).then(() => {\n        console.log('Copied to clipboard:', normalizedPath);\n        // Call the handler on every double-click (even on success, for now showing error as per requirement)\n        if (this.onJsonPathCopiedHandler) {\n          console.log('Calling onJsonPathCopiedHandler on success with:', { path: normalizedPath, source });\n          try {\n            this.onJsonPathCopiedHandler({ path: normalizedPath, source });\n          } catch (handlerError) {\n            console.error('Error in onJsonPathCopiedHandler:', handlerError);\n          }\n        }\n        // Emit event with the copied path and source\n        this.jsonPathCopied.emit({ path: normalizedPath, source });\n      }).catch(err => {\n        console.error('Failed to copy to clipboard:', err);\n        // Call the handler if copy fails\n        if (this.onJsonPathCopiedHandler) {\n          console.log('Calling onJsonPathCopiedHandler on failure with:', { path: normalizedPath, source });\n          try {\n            this.onJsonPathCopiedHandler({ path: normalizedPath, source });\n          } catch (handlerError) {\n            console.error('Error in onJsonPathCopiedHandler:', handlerError);\n          }\n        }\n        // Also emit the event for backward compatibility\n        this.jsonPathCopied.emit({ path: normalizedPath, source });\n      });\n    } else {\n      // Fallback: if we can't determine the path, copy the whole JSON\n      const formattedJson = this.formatJson(jsonData);\n      this.copyToClipboard(formattedJson);\n    }\n  }\n\n  copyRequestSummary(): void {\n    const summary: Record<string, unknown> = {\n      method: this.config?.method,\n      endpoint: this.config?.endpoint\n    };\n    if (this.config?.statusCode != null) summary['statusCode'] = this.config.statusCode;\n    if (this.config?.responseTime != null) summary['responseTime'] = this.config.responseTime;\n    const summaryText = this.formatJson(summary);\n\n    navigator.clipboard.writeText(summaryText).then(() => {\n      // Show \"Copied\" tooltip\n      this.showRequestSummaryCopied = true;\n\n      // Clear any existing timeout\n      if (this.requestSummaryCopiedTimeout) {\n        clearTimeout(this.requestSummaryCopiedTimeout);\n      }\n\n      // Hide tooltip after 2 seconds\n      this.requestSummaryCopiedTimeout = setTimeout(() => {\n        this.showRequestSummaryCopied = false;\n      }, 2000);\n    }).catch(err => {\n      console.error('Failed to copy request summary:', err);\n    });\n  }\n\n  onViewMoreFailedStepClick(expanded: boolean): void {\n    this.showFailedStepDetails = expanded;\n  }\n\n  getSubStepsForFailedStep(): SubStep[] {\n    return this.initialActions || [];\n  }\n\n  onMakeCurrentBaseline(event: makeCurrentBaselineEvent): void {\n    this.makeCurrentBaseline.emit(event);\n  }\n\n  onUploadBaseline(event: uploadBaselineEvent): void {\n    this.uploadBaseline.emit(event);\n  }\n\n  onAnalyze(): void {\n    this.analyze.emit();\n  }\n\n  onViewFullLogs(): void {\n    this.viewFullLogs.emit();\n  }\n\n  onSelfHealAction(event: SelfHealActionEvent): void {\n    this.selfHealAction.emit(event);\n  }\n\n  get showViewMoreButton(): boolean {\n    return this.isExpanded && Boolean(this.failureDetails) &&\n      (\n        (Boolean(this.failureDetails?.expected || this.failureDetails?.actual)) ||\n        (Boolean(this.failureDetails?.screenshots?.current || this.failureDetails?.screenshots?.baseline || this.failureDetails?.screenshots?.difference)\n          || Boolean(this.failureDetails?.logs?.length)) || \n        (Boolean(this.failureDetails?.aiFixApplied && (this.failureDetails?.aiFixMessage || this.confidence || this.reasoning?.length)))\n      )\n  }\n\n  onDebugPointClick(event: Event): void {\n    event.preventDefault();\n    event.stopPropagation();\n    this.debugPointChange.emit(!this.debugPointSet);\n  }\n\n  onEditStep(event: Event): void {\n    event.preventDefault();\n    event.stopPropagation();\n    this.editStep.emit();\n  }\n\n  onAddStepOptionSelect(option: AddStepMenuOption, event: Event): void {\n    event.preventDefault();\n    this.addStepOptionSelect.emit(option);\n  }\n\n  onStepMoreOptionSelect(option: StepMoreMenuOption, event: Event): void {\n    event.preventDefault();\n    this.stepMoreOptionSelect.emit(option);\n  }\n\n  toggleHeader(event?: Event): void {\n    if (event) {\n      event.preventDefault();\n      event.stopPropagation();\n    }\n    this.toggle();\n    if(!this.isExpanded){\n      this.showFailedStepDetails = false;\n    }\n    if (this.onStepClickHandler) {\n      const stepToPass = this.step || this.config;\n      if (stepToPass) {\n        this.onStepClickHandler(stepToPass, event);\n      }\n    }\n  }\n\n  override toggle(): void {\n    const wasExpanded = this.isExpanded;\n    super.toggle();\n\n    // Track manual closure by user\n    if (wasExpanded && !this.isExpanded) {\n      this.userManuallyClosed = true;\n    } else if (!wasExpanded && this.isExpanded) {\n      this.userManuallyClosed = false;\n    }\n\n    // Ensure expanded state is synced with config\n    if (this.config) {\n      this.config.expanded = this.isExpanded;\n    }\n  }\n\n  private autoExpand(): void {\n    if (!this.isExpanded && this.hasSubSteps) {\n      this.isExpanded = true;\n      this.userManuallyClosed = false;\n      this.toggleExpanded.emit(true);\n    }\n  }\n\n  get hasSubSteps(): boolean {\n    return this.initialActions !== undefined && this.initialActions.length > 0;\n  }\n\n  private updateConfig(): void {\n    // Build or update config from individual inputs\n    this.config = {\n      id: this.id,\n      testStepId: this.step?.testStepId || undefined,\n      testStepResultId: this.testStepResultId,\n      stepNumber: this.stepNumber,\n      title: this.title,\n      status: this.status,\n      duration: this.duration,\n      displayType: 'api',\n      method: this.method,\n      endpoint: this.endpoint,\n      statusCode: this.statusCode,\n      responseTime: this.responseTime,\n      requestBody: this.requestBody,\n      responseBody: this.responseBody,\n      requestHeaders: this.requestHeaders,\n      responseHeaders: this.responseHeaders,\n      assertions: this.assertions,\n      initialActions: this.initialActions,\n      stepDeleted: this.stepDeleted,\n      timingBreakdown: this.timingBreakdown,\n      expanded: this.expanded,\n    } as ApiStepConfig;\n  }\n\n  ngDoCheck(): void {\n    if (!this.isLive) return;\n    const currentLength = (this.initialActions || []).length;\n    if (currentLength !== this.lastProcessedIndex) {\n      this.processLiveInitialActions();\n    }\n  }\n\n  ngOnDestroy(): void {\n    // Clean up timeouts to prevent memory leaks\n    if (this.requestSummaryCopiedTimeout) {\n      clearTimeout(this.requestSummaryCopiedTimeout);\n    }\n    if (this.requestHeadersCopiedTimeout) {\n      clearTimeout(this.requestHeadersCopiedTimeout);\n    }\n    if (this.responseHeadersCopiedTimeout) {\n      clearTimeout(this.responseHeadersCopiedTimeout);\n    }\n    if (this.requestBodyCopiedTimeout) {\n      clearTimeout(this.requestBodyCopiedTimeout);\n    }\n    if (this.responseBodyCopiedTimeout) {\n      clearTimeout(this.responseBodyCopiedTimeout);\n    }\n    this.clearCountdownTimer();\n  }\n\n  private processLiveInitialActions(): void {\n    const allInitialActions = (this.initialActions || []) as any[];\n\n    // Reset if initialActions were cleared or replaced with fewer entries\n    if (allInitialActions.length < this.lastProcessedIndex) {\n      this.resetLiveProcessing();\n    }\n\n    for (let i = this.lastProcessedIndex; i < allInitialActions.length; i++) {\n      const action = allInitialActions[i];\n      const uiType: string = action?.uiType || action?.type || '';\n      const status: string = (action?.status || '').toLowerCase();\n\n      if (uiType === 'WAIT_FOR_LOCATOR') {\n        // Create a single grouped entry with a countdown; absorbs FIND_LOCATOR and LOCATOR_FOUND\n        const timeoutSeconds = typeof action.value === 'number'\n          ? action.value\n          : (action.value ? parseFloat(action.value) : 30);\n\n        this.clearCountdownTimer();\n\n        this.waitLocatorGroupEntry = {\n          ...action,\n          remainingSeconds: timeoutSeconds,\n          status: 'running'\n        };\n        this.addDurationToWaitLocatorGroupEntry(action);\n        this.processedInitialActions.push(this.waitLocatorGroupEntry);\n\n        // Tick down every second\n        this.countdownIntervalId = setInterval(() => {\n          if (this.waitLocatorGroupEntry) {\n            this.waitLocatorGroupEntry.remainingSeconds = Math.max(0, this.waitLocatorGroupEntry.remainingSeconds - 1);\n            if (this.waitLocatorGroupEntry.remainingSeconds <= 0) {\n              this.waitLocatorGroupEntry.status = 'failed';\n              this.waitLocatorGroupEntry.remainingSeconds = null;\n              this.clearCountdownTimer();\n              this.waitLocatorGroupEntry = null;\n            }\n          }\n        }, 1000);\n\n      } else if (uiType === 'FIND_LOCATOR') {\n        if (status === 'failed' || status === 'failure') {\n          // Abort countdown, replace group entry with this failed log\n          if (this.waitLocatorGroupEntry) {\n            this.processedInitialActions = this.processedInitialActions.filter(entry => entry !== this.waitLocatorGroupEntry);\n            this.clearCountdownTimer();\n            this.waitLocatorGroupEntry = null;\n          }\n          this.processedInitialActions.push({ ...action, status: 'failed' });\n        } else if (this.waitLocatorGroupEntry) {\n          // Update the single group entry's text so the user sees progress\n          const newText = action.description || action.text || action.title;\n          if (newText) this.waitLocatorGroupEntry.description = newText;\n          this.addDurationToWaitLocatorGroupEntry(action);\n        } else {\n          // No active group – push FIND_LOCATOR normally once countdown is cleared\n          this.processedInitialActions.push({ ...action });\n        }\n\n      } else if (uiType === 'LOCATOR_FOUND') {\n\n        if (status === 'failed' || status === 'failure') {\n          // Abort countdown, replace group entry with this failed log\n          if (this.waitLocatorGroupEntry) {\n            this.processedInitialActions = this.processedInitialActions.filter(entry => entry !== this.waitLocatorGroupEntry);\n            this.clearCountdownTimer();\n            this.waitLocatorGroupEntry = null;\n          }\n          this.processedInitialActions.push({ ...action, status: 'failed' });\n        } else {\n          // Sequence complete – update group entry to show LOCATOR_FOUND text as success\n          if (this.waitLocatorGroupEntry) {\n            const newText = action.description || action.text || action.title;\n            if (newText) this.waitLocatorGroupEntry.description = newText;\n            this.waitLocatorGroupEntry.status = 'success';\n            this.addDurationToWaitLocatorGroupEntry(action);\n            this.waitLocatorGroupEntry.remainingSeconds = null;\n            this.clearCountdownTimer();\n            this.waitLocatorGroupEntry = null;\n          } else {\n            // No active group – push LOCATOR_FOUND normally\n            this.processedInitialActions.push({ ...action });\n          }\n        }\n\n      } else if (uiType === 'AI_AUTO_HEAL') {\n        // If a WAIT_FOR_LOCATOR countdown is active, complete it as failed before starting AI auto-heal\n        if (this.waitLocatorGroupEntry) {\n          this.waitLocatorGroupEntry.status = 'failed';\n          this.waitLocatorGroupEntry.remainingSeconds = null;\n          this.clearCountdownTimer();\n          this.waitLocatorGroupEntry = null;\n        }\n\n        // Add single loading entry; will be replaced by AI_AUTO_HEAL_SUCCESS or AI_AUTO_HEAL_FAILED\n        this.aiAutoHealGroupEntry = {\n          ...action,\n          description: action.description || action.text || 'AI auto-heal started',\n          status: 'running',\n          uiType: 'AI_AUTO_HEAL'\n        };\n        this.processedInitialActions.push(this.aiAutoHealGroupEntry);\n\n      } else if (uiType === 'AI_AUTO_HEAL_SUCCESS' || uiType === 'AI_AUTO_HEAL_FAILED') {\n        // If a WAIT_FOR_LOCATOR countdown is active, complete it as failed before handling AI auto-heal result\n        if (this.waitLocatorGroupEntry) {\n          this.waitLocatorGroupEntry.status = 'failed';\n          this.waitLocatorGroupEntry.remainingSeconds = null;\n          this.clearCountdownTimer();\n          this.waitLocatorGroupEntry = null;\n        }\n\n        // Remove loading entry and add TWO separate entries: value and reasoning (like AI_ANSWER)\n        if (this.aiAutoHealGroupEntry) {\n          this.processedInitialActions = this.processedInitialActions.filter(entry => entry !== this.aiAutoHealGroupEntry);\n          this.aiAutoHealGroupEntry = null;\n        }\n        const isSuccess = uiType === 'AI_AUTO_HEAL_SUCCESS';\n        const value = action.value ?? action.text ?? '';\n        const reasoning = action.reasoning ?? action.Reasoning ?? '';\n        const baseDuration = action.duration || 0;\n        const finalStatus = isSuccess ? 'success' : 'failed';\n\n        // First entry: value/description\n        const valueDescription = action.text || action.description || (isSuccess\n          ? `AI auto-heal completed successfully`\n          : `AI auto-heal failed`);\n        this.processedInitialActions.push({\n          ...action,\n          description: valueDescription,\n          value: value,\n          reasoning: null,\n          status: finalStatus,\n          uiType: 'AI_AUTO_HEAL_VALUE',\n          type: 'AI_AUTO_HEAL_VALUE',\n          duration: baseDuration,\n          isAiAutoHealResult: true\n        });\n\n        // Second entry: reasoning (only if present)\n        if (reasoning) {\n          this.processedInitialActions.push({\n            ...action,\n            description: reasoning,\n            value: null,\n            reasoning: reasoning,\n            status: finalStatus,\n            uiType: 'AI_AUTO_HEAL_REASONING',\n            type: 'AI_AUTO_HEAL_REASONING',\n            duration: baseDuration,\n            isAiAutoHealResult: true\n          });\n        }\n\n      } else {\n        // Any failed log while a countdown is active – resolve it as failed\n        if ((status === 'failed' || status === 'failure') && this.waitLocatorGroupEntry) {\n          this.waitLocatorGroupEntry.status = 'failed';\n          this.waitLocatorGroupEntry.remainingSeconds = null;\n          this.clearCountdownTimer();\n          this.waitLocatorGroupEntry = null;\n        }\n        this.processedInitialActions.push(action);\n      }\n    }\n\n    this.lastProcessedIndex = allInitialActions.length;\n  }\n\n  private resetLiveProcessing(): void {\n    this.clearCountdownTimer();\n    this.processedInitialActions = [];\n    this.lastProcessedIndex = 0;\n    this.waitLocatorGroupEntry = null;\n    this.aiAutoHealGroupEntry = null;\n  }\n\n  private clearCountdownTimer(): void {\n    if (this.countdownIntervalId !== null) {\n      clearInterval(this.countdownIntervalId);\n      this.countdownIntervalId = null;\n    }\n  }\n\n  private addDurationToWaitLocatorGroupEntry(action: any): void {\n    if (!this.waitLocatorGroupEntry) {\n      return;\n    }\n\n    const rawDuration = action?.duration;\n    let delta = 0;\n    if (typeof rawDuration === 'number') {\n      delta = rawDuration;\n    } else if (typeof rawDuration === 'string' && rawDuration.trim() !== '') {\n      const parsed = parseFloat(rawDuration);\n      delta = Number.isFinite(parsed) ? parsed : 0;\n    }\n\n    if (delta <= 0) {\n      return;\n    }\n\n    const currentRaw = this.waitLocatorGroupEntry.duration;\n    let current = 0;\n    if (typeof currentRaw === 'number') {\n      current = currentRaw;\n    } else if (typeof currentRaw === 'string' && currentRaw.trim() !== '') {\n      const parsedCurrent = parseFloat(currentRaw);\n      current = Number.isFinite(parsedCurrent) ? parsedCurrent : 0;\n    }\n\n    this.waitLocatorGroupEntry.duration = current + delta;\n  }\n\n  onJumpToTimestamp(event: Event): void {\n    event.stopPropagation();\n    if (this.jumpToTimestampHandler && this.step?.executedResult?.video_start_time !== undefined && this.step?.executedResult?.video_start_time !== null) {\n      const timestamp = typeof this.step.executedResult.video_start_time === 'number' \n        ? this.step.executedResult.video_start_time \n        : Number(this.step.executedResult.video_start_time);\n      const testStepId = this.step?.testStepId;\n      if (isFinite(timestamp) && timestamp >= 0) {\n        this.jumpToTimestampHandler(timestamp, testStepId);\n      }\n    }\n  }\n\n  private processInitialActionsForRunResult(): void {\n    const allInitialActions = (this.initialActions || []) as any[];\n    this.processedInitialActionsForRunResult = [];\n\n    for (const action of allInitialActions) {\n      const uiType: string = action?.uiType || action?.type || '';\n\n      // Split AI_AUTO_HEAL_SUCCESS/FAILED into two entries\n      if (uiType === 'AI_AUTO_HEAL_SUCCESS' || uiType === 'AI_AUTO_HEAL_FAILED') {\n        const isSuccess = uiType === 'AI_AUTO_HEAL_SUCCESS';\n        const value = action.value ?? action.text ?? '';\n        const reasoning = action.reasoning ?? action.Reasoning ?? '';\n        const baseDuration = action.duration || 0;\n        const finalStatus = isSuccess ? 'success' : 'failed';\n\n        // First entry: value/description\n        const valueDescription = (isSuccess\n          ? `AI auto-heal completed successfully`\n          : `AI auto-heal failed`);\n        this.processedInitialActionsForRunResult.push({\n          ...action,\n          description: valueDescription,\n          value: value,\n          reasoning: null,\n          status: finalStatus,\n          uiType: 'AI_AUTO_HEAL_VALUE',\n          type: 'AI_AUTO_HEAL_VALUE',\n          duration: baseDuration,\n          isAiAutoHealResult: true\n        });\n\n        // Second entry: reasoning (only if present)\n        if (reasoning) {\n          this.processedInitialActionsForRunResult.push({\n            ...action,\n            description: reasoning,\n            value: null,\n            reasoning: reasoning,\n            status: finalStatus,\n            uiType: 'AI_AUTO_HEAL_REASONING',\n            type: 'AI_AUTO_HEAL_REASONING',\n            duration: baseDuration,\n            isAiAutoHealResult: true\n          });\n        }\n      } else {\n        const status = (action?.status ?? '').toString().toLowerCase();\n        const isFailed = status === 'failed' || status === 'failure';\n        const isLocatorStep = uiType === 'WAIT_FOR_LOCATOR' || uiType === 'FIND_LOCATOR' || uiType === 'LOCATOR_FOUND';\n        if (isLocatorStep && isFailed) {\n          const baseDesc = action?.description ?? action?.text ?? action?.title ?? '';\n          const notFoundSuffix = ' - Element not found';\n          this.processedInitialActionsForRunResult.push({\n            ...action,\n            description: (baseDesc ? baseDesc + notFoundSuffix : notFoundSuffix.trim())\n          });\n        } else {\n          this.processedInitialActionsForRunResult.push(action);\n        }\n      }\n    }\n  }\n\n}\n","<div class=\"cqa-font-inter cqa-w-full\" [class.cqa-opacity-50]=\"isDebug && isSkipped && !parentSkipped\" [style.background-color]=\"!isDebug ? null : status.toLowerCase() === 'paused' ? '#FFF9E9' : status.toLowerCase() === 'failed' ? '#FEF2F2' : null\" (click)=\"$event.stopPropagation()\">\n  <!-- Header -->\n  <div\n    class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-p-2 cqa-cursor-pointer\"\n    (click)=\"toggleHeader($event)\">\n    <div *ngIf=\"showDebugIcon\" class=\"cqa-flex cqa-items-center cqa-justify-center\"\n      [matTooltip]=\"status.toLowerCase() === 'running' ? 'Breakpoint cannot be set on a running step' : (isStepDeleted ? 'Breakpoint cannot be set on deleted steps' : ((!!parentSkipped && !step?.debugPointDisabled) ? 'Breakpoint cannot be set on a running step' : (!!step?.debugPointDisabled ? 'Breakpoint cannot be set on skipped steps' : '')))\"\n      matTooltipPosition=\"right\">\n      <button type=\"button\" class=\"cqa-p-0 cqa-border-0 cqa-bg-transparent cqa-rounded-full cqa-transition-opacity focus:cqa-outline-none\"\n        [ngClass]=\"status.toLowerCase() === 'running' || !!step?.debugPointDisabled || !!parentSkipped || isStepDeleted ? 'cqa-cursor-not-allowed cqa-opacity-40 cqa-pointer-events-none' : 'cqa-cursor-pointer hover:cqa-opacity-80'\"\n        [disabled]=\"status.toLowerCase() === 'running' || !!step?.debugPointDisabled || !!parentSkipped || isStepDeleted\"\n        (click)=\"onDebugPointClick($event)\" [attr.aria-label]=\"debugPointSet ? 'Remove debug point' : 'Set debug point'\">\n        <svg *ngIf=\"debugPointSet\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n          <circle cx=\"7\" cy=\"7\" r=\"6\" [attr.fill]=\"!!step?.debugPointDisabled || !!parentSkipped || isStepDeleted ? '#9E9E9E' : '#C63535'\"/>\n        </svg>\n        <svg *ngIf=\"!debugPointSet\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n          <circle cx=\"7\" cy=\"7\" r=\"6\" [attr.stroke]=\"!!step?.debugPointDisabled || !!parentSkipped || isStepDeleted ? '#9E9E9E' : '#C63535'\" stroke-width=\"1.5\" fill=\"none\"/>\n        </svg>\n      </button>\n    </div>\n    <!-- Status Icon -->\n    \n    <div *ngIf=\"status.toLowerCase() === 'success'\" ><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10.9005 4.99999C11.1289 6.12064 10.9662 7.28571 10.4395 8.30089C9.91279 9.31608 9.054 10.12 8.00631 10.5787C6.95862 11.0373 5.78536 11.1229 4.6822 10.8212C3.57904 10.5195 2.61265 9.84869 1.94419 8.92071C1.27573 7.99272 0.945611 6.86361 1.00888 5.72169C1.07215 4.57976 1.52499 3.49404 2.29188 2.64558C3.05876 1.79712 4.09334 1.23721 5.22308 1.05922C6.35282 0.881233 7.50944 1.09592 8.50005 1.66749\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 5.5L6 7L11 2\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n    <div *ngIf=\"status.toLowerCase() === 'failure' || status.toLowerCase() === 'failed'\"><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#DC2626\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M7.5 4.5L4.5 7.5\" stroke=\"#DC2626\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 4.5L7.5 7.5\" stroke=\"#DC2626\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n    <div *ngIf=\"status.toLowerCase() === 'pending'\"><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M6 3V6L8 7\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n    <div *ngIf=\"status.toLowerCase() === 'running'\"><svg class=\"cqa-animate-spin cqa-text-[#3B82F6]\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><circle cx=\"6\" cy=\"6\" r=\"5\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" opacity=\"0.25\"/><path d=\"M6 1A5 5 0 0 1 11 6\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" stroke-linecap=\"round\"/></svg></div>\n    <div *ngIf=\"status.toLowerCase() === 'skipped'\"><svg xmlns=\"http://www.w3.org/2000/svg\" height=\"12px\" viewBox=\"0 -960 960 960\" width=\"12px\" fill=\"#1f1f1f\"><path d=\"M660-240v-480h80v480h-80Zm-440 0v-480l360 240-360 240Zm80-240Zm0 90 136-90-136-90v180Z\"/></svg></div>\n    <div *ngIf=\"status.toLowerCase() === 'paused'\"><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M8.5 2H7.5C7.22386 2 7 2.22386 7 2.5V9.5C7 9.77614 7.22386 10 7.5 10H8.5C8.77614 10 9 9.77614 9 9.5V2.5C9 2.22386 8.77614 2 8.5 2Z\" stroke=\"#E17100\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 2H3.5C3.22386 2 3 2.22386 3 2.5V9.5C3 9.77614 3.22386 10 3.5 10H4.5C4.77614 10 5 9.77614 5 9.5V2.5C5 2.22386 4.77614 2 4.5 2Z\" stroke=\"#E17100\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n    <!-- API Icon -->\n    <div><svg width=\"20\" height=\"16\" viewBox=\"0 0 20 16\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"20\" height=\"16\" rx=\"4\" fill=\"#EDE9FE\"/><path d=\"M8 6.5L9.5 8L8 9.5M10.5 9.5H12M6.5 12H13.5C13.7652 12 14.0196 11.8946 14.2071 11.7071C14.3946 11.5196 14.5 11.2652 14.5 11V5C14.5 4.73478 14.3946 4.48043 14.2071 4.29289C14.0196 4.10536 13.7652 4 13.5 4H6.5C6.23478 4 5.98043 4.10536 5.79289 4.29289C5.60536 4.48043 5.5 4.73478 5.5 5V11C5.5 11.2652 5.60536 11.5196 5.79289 11.7071C5.98043 11.8946 6.23478 12 6.5 12Z\" stroke=\"#7F22FE\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n\n    <!-- Step Number and Title -->\n    <div class=\"cqa-flex-1 cqa-flex cqa-items-center cqa-gap-3 cqa-font-inter\">\n      <span class=\"cqa-font-semibold cqa-text-[#334155] cqa-text-[14px] cqa-leading-[18px]\" style=\"word-break: break-word;\">\n        {{ config?.stepNumber }}. <span [innerHTML]=\"config.title\"></span>\n      </span>\n      <span class=\"cqa-px-1.5 cqa-rounded-full cqa-font-medium cqa-text-[#7008E7] cqa-bg-[#EDE9FE] cqa-text-[10px] cqa-leading-[15px]\">\n        API\n      </span>\n      <span class=\"cqa-px-1.5 cqa-rounded-full cqa-font-medium cqa-text-[#008236] cqa-bg-[#DCFCE7] cqa-text-[10px] cqa-leading-[15px]\">\n        {{ config.method }}\n      </span>\n      <span *ngIf=\"config.stepDeleted\" class=\"cqa-px-1.5 cqa-py-[2px] cqa-rounded-[4px] cqa-text-[10px] cqa-leading-[12px] cqa-font-medium cqa-text-[#B42318] cqa-bg-[#FEF3F2] cqa-border cqa-border-[#FEE4E2]\">\n        Deleted\n      </span>\n    </div>\n\n    <div class=\"cqa-flex cqa-items-center cqa-gap-1 cqa-font-inter\">\n      <!-- Step Change Badges (debug only) -->\n      <ng-container *ngIf=\"isDebug\">\n        <ng-container *ngFor=\"let badge of stepBadges\">\n        <cqa-badge\n          *ngIf=\"badge === 'skipped'\"\n          label=\"Skipped\"\n          size=\"small\"\n          [textColor]=\"'#4A5565'\"\n          [borderColor]=\"'#99A1AF'\"\n          [backgroundColor]=\"'#FFFFFF'\">\n        </cqa-badge>\n        <cqa-badge\n          *ngIf=\"badge === 'edited'\"\n          label=\"Edited\"\n          size=\"small\"\n          [textColor]=\"'#FBBF24'\"\n          [borderColor]=\"'#FDDF92'\"\n          [backgroundColor]=\"'#FFF9E9'\">\n        </cqa-badge>\n        <cqa-badge\n          *ngIf=\"badge === 'added'\"\n          label=\"Added\"\n          size=\"small\"\n          [textColor]=\"'#0DBD7D'\"\n          [borderColor]=\"'#5ED3A8'\"\n          [backgroundColor]=\"'#CFF2E5'\">\n        </cqa-badge>\n        <cqa-badge\n          *ngIf=\"badge === 'removed'\"\n          label=\"Removed\"\n          size=\"small\"\n          [textColor]=\"'#EE3F3F'\"\n          [borderColor]=\"'#F47F7F'\"\n          [backgroundColor]=\"'#FCD9D9'\">\n        </cqa-badge>\n        </ng-container>\n      </ng-container>\n      <span *ngIf=\"selfHealAnalysis\" class=\"cqa-px-1.5 cqa-rounded-full cqa-font-medium cqa-text-[#097E53] cqa-bg-[#CFF2E5] cqa-text-[10px] cqa-leading-[15px] cqa-min-w-max cqa-flex cqa-items-center cqa-gap-[6px]\">\n        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"9\" height=\"9\" viewBox=\"0 0 9 9\" fill=\"none\">\n          <path d=\"M4.50941 0C4.56489 0.0227384 4.58859 0.0782652 4.61131 0.129846C4.62269 0.1599 4.63314 0.190117 4.64329 0.220575C4.64726 0.232247 4.65123 0.243918 4.65532 0.255943C4.70806 0.413005 4.75504 0.571748 4.80229 0.73038C4.81297 0.76619 4.82369 0.801987 4.83442 0.837783C4.88905 1.02004 4.94327 1.2024 4.99719 1.38484C5.00476 1.41047 5.01234 1.43609 5.01992 1.46171C5.04128 1.53395 5.06262 1.60619 5.08383 1.67847C5.12867 1.8312 5.17473 1.98347 5.22378 2.13501C5.22807 2.14827 5.23236 2.16152 5.23677 2.17518C5.3642 2.565 5.54482 2.91437 5.8409 3.21196C5.84823 3.2197 5.85556 3.22744 5.86312 3.23541C5.9895 3.36437 6.15169 3.46771 6.3138 3.55111C6.32206 3.55542 6.33031 3.55974 6.33882 3.56419C6.81587 3.80925 7.38951 3.91704 7.90619 4.0605C8.1326 4.1234 8.3583 4.18829 8.58317 4.25603C8.59897 4.26079 8.61478 4.26554 8.63058 4.27028C8.67784 4.28445 8.725 4.29887 8.77211 4.31347C8.7831 4.31679 8.79408 4.32011 8.80539 4.32353C8.87029 4.34406 8.93239 4.36829 8.98566 4.41027C9.00191 4.44418 9.00191 4.44418 8.99748 4.4781C8.94564 4.52736 8.8942 4.55046 8.82578 4.573C8.816 4.57632 8.80622 4.57965 8.79614 4.58308C8.68061 4.62183 8.56351 4.65575 8.44626 4.68935C8.4222 4.6963 8.39814 4.70326 8.37408 4.71021C8.22571 4.75301 8.07708 4.7949 7.92829 4.83632C7.73232 4.89088 7.53663 4.94634 7.34113 5.00243C7.3091 5.01162 7.27706 5.02078 7.24501 5.02991C7.07671 5.07786 6.90923 5.12753 6.74314 5.18208C6.72937 5.18659 6.71559 5.1911 6.70139 5.19574C6.14511 5.38082 5.7211 5.72609 5.45571 6.23099C5.31263 6.51475 5.22823 6.82161 5.14214 7.12447C5.11884 7.20619 5.09409 7.28745 5.06905 7.36869C5.0494 7.43261 5.0302 7.49663 5.01149 7.56081C5.00926 7.56844 5.00703 7.57608 5.00473 7.58395C4.99394 7.62094 4.98319 7.65793 4.97252 7.69495C4.94519 7.78879 4.91578 7.88187 4.88555 7.97489C4.83191 8.14021 4.7831 8.30674 4.73459 8.4735C4.66144 8.72457 4.66144 8.72457 4.61997 8.84527C4.61721 8.85337 4.61446 8.86147 4.61163 8.86982C4.59649 8.91278 4.58092 8.95233 4.55226 8.9887C4.50867 8.99788 4.50867 8.99788 4.46951 9C4.42473 8.93759 4.39508 8.87711 4.37133 8.80508C4.36787 8.79487 4.36441 8.78466 4.36085 8.77415C4.31684 8.64248 4.27751 8.50946 4.23817 8.37646C4.22916 8.34604 4.22011 8.31564 4.21105 8.28524C4.1436 8.05863 4.07725 7.83174 4.01101 7.60481C3.73507 6.48224 3.73507 6.48224 3.039 5.57466C3.02784 5.56596 3.01669 5.55726 3.00519 5.5483C2.54913 5.19902 1.94834 5.06969 1.39815 4.91813C1.26207 4.88062 1.12605 4.84293 0.990032 4.80523C0.978138 4.80193 0.978138 4.80193 0.966003 4.79857C0.769811 4.74417 0.573674 4.68963 0.378224 4.63283C0.369956 4.63045 0.361688 4.62806 0.353169 4.62561C0.0528989 4.53883 0.0528989 4.53883 0.000646537 4.4781C-0.000831261 4.45054 -0.000831261 4.45054 0.0124689 4.42157C0.0670835 4.3704 0.120077 4.34848 0.19216 4.32619C0.202597 4.32284 0.213034 4.31948 0.223787 4.31603C0.255753 4.30582 0.287788 4.29584 0.319851 4.28592C0.329001 4.28305 0.338151 4.28017 0.347578 4.27722C0.412285 4.25693 0.477225 4.2374 0.542259 4.21809C0.55824 4.21332 0.55824 4.21332 0.574544 4.20846C0.852269 4.12587 1.13181 4.049 1.41126 3.97196C1.6195 3.91455 1.82738 3.85618 2.0346 3.79548C2.04413 3.79271 2.05365 3.78993 2.06346 3.78707C2.5435 3.64696 3.01278 3.44816 3.32274 3.0537C3.32738 3.04785 3.33202 3.042 3.3368 3.03597C3.68197 2.59815 3.81658 2.06572 3.96695 1.54621C4.01643 1.37534 4.06649 1.20464 4.11673 1.03399C4.13064 0.986733 4.14453 0.939471 4.15836 0.892194C4.21394 0.702289 4.27035 0.512642 4.33 0.323864C4.33558 0.306186 4.34114 0.288501 4.34666 0.270807C4.43017 0.00398761 4.43017 0.00398761 4.50941 0Z\" fill=\"#0DBD7D\"/>\n          <path d=\"M7.23597 0.554859C7.29024 0.613599 7.30109 0.682631 7.31799 0.757638C7.37436 0.993269 7.43929 1.20993 7.66467 1.34681C7.80371 1.42035 7.96944 1.45381 8.1235 1.48541C8.18854 1.49902 8.24348 1.51709 8.29924 1.55321C8.31181 1.57229 8.31181 1.57229 8.31107 1.60549C8.29814 1.64588 8.28678 1.6589 8.25269 1.68533C8.21543 1.69726 8.21543 1.69726 8.17068 1.70653C8.15375 1.71025 8.13683 1.714 8.11992 1.71779C8.11086 1.7198 8.10181 1.72181 8.09247 1.72388C7.81696 1.78482 7.81696 1.78482 7.57882 1.92273C7.57108 1.92869 7.56333 1.93466 7.55536 1.9408C7.38516 2.08431 7.34916 2.32303 7.29793 2.52301C7.29499 2.53399 7.29206 2.54497 7.28903 2.55629C7.28649 2.56601 7.28395 2.57573 7.28133 2.58575C7.27028 2.61544 7.25881 2.63479 7.23597 2.65754C7.17234 2.66527 7.17234 2.66527 7.14139 2.65754C7.09216 2.62106 7.08114 2.5795 7.06828 2.52365C7.06613 2.51501 7.06398 2.50636 7.06176 2.49745C7.05489 2.46983 7.04824 2.44217 7.04164 2.41449C6.98979 2.19897 6.93126 1.98751 6.72451 1.86118C6.56293 1.77501 6.36646 1.73426 6.18587 1.70136C6.13637 1.69151 6.10802 1.67911 6.07738 1.64012C6.07073 1.60055 6.07073 1.60055 6.07738 1.56098C6.12447 1.51437 6.17402 1.50299 6.23772 1.48891C6.25778 1.48416 6.27784 1.47938 6.29789 1.47456C6.30825 1.47209 6.31861 1.46962 6.32929 1.46707C6.38212 1.45407 6.43443 1.43949 6.48673 1.42462C6.49623 1.42198 6.50573 1.41935 6.51552 1.41663C6.62182 1.38624 6.71356 1.34737 6.79854 1.27836C6.80647 1.27213 6.81439 1.26589 6.82255 1.25946C6.9548 1.14565 6.99974 0.974674 7.04053 0.815134C7.04364 0.803022 7.04675 0.79091 7.04995 0.778432C7.05614 0.754101 7.06222 0.729743 7.06817 0.705359C7.07243 0.688394 7.07243 0.688394 7.07678 0.671086C7.07927 0.660951 7.08175 0.650816 7.08431 0.640373C7.09521 0.608108 7.10952 0.582772 7.12957 0.554859C7.1681 0.536435 7.19515 0.544764 7.23597 0.554859Z\" fill=\"#075F3F\"/>\n          <path d=\"M1.79545 6.2471C1.80951 6.24719 1.80951 6.24719 1.82386 6.24729C1.92477 6.25022 1.99304 6.28115 2.06736 6.34601C2.15384 6.43533 2.19377 6.53611 2.1915 6.6565C2.18178 6.75412 2.12158 6.83935 2.04773 6.90533C1.96081 6.97242 1.87313 6.99459 1.76206 6.99149C1.66841 6.98107 1.5803 6.93852 1.51393 6.87451C1.43138 6.76681 1.40725 6.66803 1.41935 6.53537C1.44433 6.43092 1.51637 6.34613 1.6085 6.28666C1.67251 6.25564 1.72399 6.24652 1.79545 6.2471Z\" fill=\"#0DBD7D\"/>\n          </svg>\n        Self-healed\n      </span>\n      <div class=\"cqa-flex cqa-items-center cqa-gap-1 cqa-rounded-[4px] cqa-py-0.5 cqa-px-1 cqa-bg-[#6366F11A] cqa-ml-1 cqa-cursor-pointer hover:cqa-opacity-80 cqa-transition-opacity\" \n           *ngIf=\"step?.executedResult?.video_start_time\" \n           [matTooltip]=\"'Jump to video time'\" \n           matTooltipPosition=\"below\"\n           (click)=\"onJumpToTimestamp($event)\">\n        <mat-icon class=\"cqa-text-[#636363] !cqa-text-[10px] !cqa-w-[10px] !cqa-h-[10px]\">\n          play_arrow\n        </mat-icon>\n        <span class=\"cqa-text-[8px] cqa-leading-[12px] cqa-font-normal cqa-text-[#636363]\">\n          {{ formatDurationClock(step?.executedResult?.video_start_time || 0) }}\n        </span>\n      </div>\n      <div *ngIf=\"isDebug && canEditSteps\" class=\"cqa-flex cqa-items-center cqa-gap-0.5 cqa-text-[#9CA3AF]\" (click)=\"$event.stopPropagation()\">\n        <button *ngIf=\"!step?.isStepGroupChildren\" type=\"button\" class=\"cqa-p-0 cqa-border-0 cqa-bg-transparent cqa-cursor-pointer hover:cqa-opacity-80 cqa-transition-opacity focus:cqa-outline-none\" aria-label=\"Edit\" (click)=\"onEditStep($event)\">\n          <mat-icon class=\"!cqa-text-[14px] !cqa-w-[14px] !cqa-h-[14px]\">edit</mat-icon>\n        </button>\n        <button *ngIf=\"!step?.isStepGroupChildren\" type=\"button\" class=\"cqa-p-0 cqa-border-0 cqa-bg-transparent cqa-cursor-pointer hover:cqa-opacity-80 cqa-transition-opacity focus:cqa-outline-none\" aria-label=\"Add\" [matMenuTriggerFor]=\"addStepMenu\">\n          <mat-icon class=\"!cqa-text-[14px] !cqa-w-[14px] !cqa-h-[14px]\">add</mat-icon>\n        </button>\n        <mat-menu #addStepMenu=\"matMenu\" class=\"cqa-add-step-menu\" xPosition=\"before\" yPosition=\"below\">\n          <button mat-menu-item *ngFor=\"let opt of addStepMenuOptions\" (click)=\"onAddStepOptionSelect(opt, $event)\">\n            {{ opt.label }}\n          </button>\n        </mat-menu>\n        <button *ngIf=\"effectiveStepMoreMenuOptions.length\" type=\"button\" class=\"cqa-p-0 cqa-border-0 cqa-bg-transparent cqa-cursor-pointer hover:cqa-opacity-80 cqa-transition-opacity focus:cqa-outline-none\" aria-label=\"More options\" [matMenuTriggerFor]=\"stepMoreMenu\">\n          <mat-icon class=\"!cqa-text-[14px] !cqa-w-[14px] !cqa-h-[14px]\">more_vert</mat-icon>\n        </button>\n        <mat-menu #stepMoreMenu=\"matMenu\" class=\"cqa-step-more-menu\" xPosition=\"before\" yPosition=\"below\">\n          <button mat-menu-item *ngFor=\"let opt of effectiveStepMoreMenuOptions\" (click)=\"onStepMoreOptionSelect(opt, $event)\">{{ opt.label }}</button>\n        </mat-menu>\n      </div>\n      <span class=\"cqa-text-[12px] cqa-leading-[15px] cqa-font-medium cqa-text-[#9CA3AF]\">\n        {{ formatDuration(config.duration) }}\n      </span>\n      <svg [class.cqa-rotate-180]=\"isExpanded\" class=\"cqa-transition-transform\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M3.5 5L7 8.5L10.5 5\" stroke=\"#9CA3AF\" stroke-width=\"0.833333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n    </div>\n  </div>\n\n  <!-- Expanded Content -->\n  <div *ngIf=\"isExpanded\">\n    <!-- Initial Actions (show when we have raw or processed actions; in live mode processedInitialActions is populated from initialActions via ngDoCheck) -->\n    <div *ngIf=\"(config.initialActions && config.initialActions.length > 0) || (isLive && processedInitialActions.length > 0)\" class=\"cqa-flex cqa-flex-col cqa-gap-1 cqa-ml-9\">\n      <!-- Single loop: render all entries in chronological order -->\n      <ng-container *ngFor=\"let action of (isLive ? processedInitialActions : processedInitialActionsForRunResult)\">\n        <!-- AI_AUTO_HEAL_SUCCESS/FAILED: render with ai-agent-step style (both live and run result screens) -->\n        <cqa-ai-logs-with-reasoning\n          *ngIf=\"$any(action).isAiAutoHealResult\"\n          [status]=\"action.status\"\n          [text]=\"$any(action).text || action?.value\"\n          [description]=\"$any(action).description || action?.text || action?.value\"\n          [reasoning]=\"$any(action).reasoning || action?.reasoning\"\n          [duration]=\"action.duration\">\n        </cqa-ai-logs-with-reasoning>\n\n        <!-- Regular initial actions -->\n        <div\n          *ngIf=\"!$any(action).isAiAutoHealResult\"\n          class=\"cqa-flex cqa-items-center cqa-gap-3 cqa-py-[5.5px] cqa-px-3\">\n          \n          <div *ngIf=\"action?.status?.toLowerCase() === 'success' || action?.status?.toLowerCase() === 'passed'\" >\n            <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10.9005 4.99999C11.1289 6.12064 10.9662 7.28571 10.4395 8.30089C9.91279 9.31608 9.054 10.12 8.00631 10.5787C6.95862 11.0373 5.78536 11.1229 4.6822 10.8212C3.57904 10.5195 2.61265 9.84869 1.94419 8.92071C1.27573 7.99272 0.945611 6.86361 1.00888 5.72169C1.07215 4.57976 1.52499 3.49404 2.29188 2.64558C3.05876 1.79712 4.09334 1.23721 5.22308 1.05922C6.35282 0.881233 7.50944 1.09592 8.50005 1.66749\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 5.5L6 7L11 2\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n          </div>\n          <!-- Failure -->\n          <div *ngIf=\"action?.status?.toLowerCase() === 'failure' || action?.status?.toLowerCase() === 'failed'\">\n            <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#DC2626\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M7.5 4.5L4.5 7.5\" stroke=\"#DC2626\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 4.5L7.5 7.5\" stroke=\"#DC2626\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n          </div>\n          <!-- Pending -->\n          <div *ngIf=\"action?.status?.toLowerCase() === 'pending'\">\n            <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M6 3V6L8 7\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n          </div>\n          <!-- Running - Show spinner (also used for active WAIT_FOR_LOCATOR countdown in live mode) -->\n          <div *ngIf=\"action?.status?.toLowerCase() === 'running'\">\n            <svg class=\"cqa-animate-spin cqa-text-[#3B82F6]\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n              <circle cx=\"6\" cy=\"6\" r=\"5\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" opacity=\"0.25\"/>\n              <path d=\"M6 1A5 5 0 0 1 11 6\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" stroke-linecap=\"round\"/>\n            </svg>\n          </div>\n\n          <!-- Action Description -->\n          <span class=\"cqa-flex-1 cqa-text-[13px] cqa-leading-[15px] cqa-text-[#364153]\" style=\"white-space: pre-line; word-break: break-word;\">\n            {{ $any(action).description || $any(action).text }}\n            <!-- Countdown for active WAIT_FOR_LOCATOR in live mode -->\n            <span *ngIf=\"isLive && $any(action).remainingSeconds != null\" class=\"cqa-text-[#F97316] cqa-font-medium cqa-ml-1\">({{ $any(action).remainingSeconds }}s remaining)</span>\n          </span>\n\n          <!-- Action Duration -->\n          <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-metadata-key\">\n            {{ formatDuration(action.duration) }}\n          </span>\n        </div>\n      </ng-container>\n    </div>\n\n    <!-- Request Summary Card -->\n    <div *ngIf=\"!isLive\" class=\"cqa-bg-[#FFFEF9] cqa-mt-1.5 cqa-ml-9 cqa-mr-6 cqa-p-4\" style=\"border-top: 1px solid #E4E4E4;\">\n      \n      <div class=\"cqa-bg-[#FCFCFC] cqa-rounded-lg cqa-p-3\" style=\"border: 1px solid #EDE9FE\">\n        <div class=\"cqa-flex cqa-items-center cqa-justify-between cqa-mb-3 cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#636363]\">\n          <span>Request Summary</span>\n          <div class=\"cqa-relative\">\n            <button (click)=\"copyRequestSummary()\" class=\"cqa-flex cqa-items-center cqa-gap-1 p-0\">\n              <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 4H5C4.44772 4 4 4.44772 4 5V10C4 10.5523 4.44772 11 5 11H10C10.5523 11 11 10.5523 11 10V5C11 4.44772 10.5523 4 10 4Z\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M2 8C1.45 8 1 7.55 1 7V2C1 1.45 1.45 1 2 1H7C7.55 1 8 1.45 8 2\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n              Copy\n            </button>\n            <!-- Copied Tooltip -->\n            <div \n              *ngIf=\"showRequestSummaryCopied\" \n              class=\"cqa-absolute cqa-right-0 cqa-top-full cqa-mt-1 cqa-px-2 cqa-py-1 cqa-bg-[#0B0B0B] cqa-text-white cqa-text-[10px] cqa-rounded cqa-whitespace-nowrap cqa-z-50 cqa-shadow-lg\"\n              style=\"animation: fadeInOut 0.2s ease-in-out;\">\n              Copied!\n            </div>\n          </div>\n        </div>\n        <div class=\"cqa-flex cqa-items-center cqa-justify-between cqa-gap-3 cqa-cursor-pointer\" (dblclick)=\"copyRequestSummary()\">\n          <div class=\"cqa-flex cqa-items-center cqa-gap-2\">\n            <span class=\"cqa-px-1 cqa-py-[2px] cqa-rounded cqa-font-medium cqa-text-[#008236] cqa-bg-[#DCFCE7] cqa-text-[10px] cqa-leading-[15px]\">\n              {{ config.method }}\n            </span>\n            <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#0B0B0B]\">{{ config.endpoint }}</span>\n          </div>\n          <div class=\"cqa-flex cqa-items-center cqa-gap-3\">\n            <span *ngIf=\"config?.statusCode === 200 || config?.statusCode === 201\" class=\"cqa-flex cqa-items-center cqa-gap-1.5 cqa-px-1 cqa-py-[2px] cqa-rounded cqa-font-medium cqa-text-[#00A63E] cqa-bg-[#DCFCE7] cqa-text-[10px] cqa-leading-[15px]\">\n              <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 3L4.5 8.5L2 6\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"></path></svg>\n              {{ config.statusCode }}\n            </span>\n            <span *ngIf=\"config?.statusCode && config?.statusCode !== 200 && config?.statusCode !== 201\" class=\"cqa-flex cqa-items-center cqa-gap-1.5 cqa-px-1 cqa-py-[2px] cqa-rounded cqa-font-medium cqa-text-[#E7000B] cqa-bg-[#FFE2E2] cqa-text-[10px] cqa-leading-[15px]\">\n              <svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10.5 3.5L3.5 10.5\" stroke=\"#E7000B\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M3.5 3.5L10.5 10.5\" stroke=\"#E7000B\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n              {{ config.statusCode }}\n            </span>\n            <div class=\"cqa-flex cqa-items-center cqa-gap-1.5 cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#636363]\" *ngIf=\"config?.responseTime\">\n              <svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6.99999 12.8334C10.2217 12.8334 12.8333 10.2217 12.8333 7.00008C12.8333 3.77842 10.2217 1.16675 6.99999 1.16675C3.77833 1.16675 1.16666 3.77842 1.16666 7.00008C1.16666 10.2217 3.77833 12.8334 6.99999 12.8334Z\" stroke=\"#636363\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M7 3.5V7L9.33333 8.16667\" stroke=\"#636363\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n              <span>{{ config.responseTime }}ms</span>\n            </div>\n          </div>\n        </div>\n      </div>\n\n      <!-- Request/Response Headers -->\n      <div class=\"cqa-grid cqa-grid-cols-2 cqa-gap-3 cqa-mt-4\" *ngIf=\"config?.requestHeaders || config?.responseHeaders\">\n        <!-- Request Headers -->\n        <div class=\"cqa-bg-[#FCFCFC] cqa-rounded-lg cqa-p-3 cqa-flex cqa-flex-col\" style=\"border: 1px solid #EDE9FE\">\n          <div class=\"cqa-flex cqa-items-center cqa-justify-between cqa-gap-2 cqa-mb-2\">\n            <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#636363]\">Request Headers</span>\n            <div class=\"cqa-relative\">\n              <button (click)=\"copyRequestHeaders()\">\n                <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 4H5C4.44772 4 4 4.44772 4 5V10C4 10.5523 4.44772 11 5 11H10C10.5523 11 11 10.5523 11 10V5C11 4.44772 10.5523 4 10 4Z\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M2 8C1.45 8 1 7.55 1 7V2C1 1.45 1.45 1 2 1H7C7.55 1 8 1.45 8 2\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n              </button>\n              <!-- Copied Tooltip -->\n              <div \n                *ngIf=\"showRequestHeadersCopied\" \n                class=\"cqa-absolute cqa-right-0 cqa-top-full cqa-mt-1 cqa-px-2 cqa-py-1 cqa-bg-[#0B0B0B] cqa-text-white cqa-text-[10px] cqa-rounded cqa-whitespace-nowrap cqa-z-50 cqa-shadow-lg\"\n                style=\"animation: fadeInOut 0.2s ease-in-out;\">\n                Copied\n              </div>\n            </div>\n          </div>\n          <pre *ngIf=\"config.requestHeaders\" class=\"cqa-h-full cqa-text-[12px] cqa-text-[#0B0B0B] cqa-bg-[#F8F8F8] cqa-p-2 cqa-m-0 cqa-rounded cqa-overflow-auto cqa-max-h-[114px] cqa-cursor-pointer\" style=\"scrollbar-width: thin;\" (dblclick)=\"copyJsonPath($event, config.requestHeaders, 'requestHeaders')\">{{ formatJson(config.requestHeaders) }}</pre>\n        </div>\n\n        <!-- Response Headers -->\n        <div class=\"cqa-bg-[#FCFCFC] cqa-rounded-lg cqa-p-3 cqa-flex cqa-flex-col\" style=\"border: 1px solid #EDE9FE\">\n          <div class=\"cqa-flex cqa-items-center cqa-justify-between cqa-mb-2\">\n            <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#636363]\">Response Headers</span>\n            <div class=\"cqa-relative\">\n              <button (click)=\"copyResponseHeaders()\">\n                <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 4H5C4.44772 4 4 4.44772 4 5V10C4 10.5523 4.44772 11 5 11H10C10.5523 11 11 10.5523 11 10V5C11 4.44772 10.5523 4 10 4Z\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M2 8C1.45 8 1 7.55 1 7V2C1 1.45 1.45 1 2 1H7C7.55 1 8 1.45 8 2\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n              </button>\n              <!-- Copied Tooltip -->\n              <div \n                *ngIf=\"showResponseHeadersCopied\" \n                class=\"cqa-absolute cqa-right-0 cqa-top-full cqa-mt-1 cqa-px-2 cqa-py-1 cqa-bg-[#0B0B0B] cqa-text-white cqa-text-[10px] cqa-rounded cqa-whitespace-nowrap cqa-z-50 cqa-shadow-lg\"\n                style=\"animation: fadeInOut 0.2s ease-in-out;\">\n                Copied\n              </div>\n            </div>\n          </div>\n          <pre *ngIf=\"config.responseHeaders\" [ngClass]=\"{'cqa-bg-[#FEF2F2] cqa-text-[#C10007]': config.statusCode >= 400}\" class=\"cqa-h-full cqa-text-[12px] cqa-p-2 cqa-m-0 cqa-rounded cqa-overflow-auto cqa-max-h-[114px] cqa-cursor-pointer\" style=\"scrollbar-width: thin;\" (dblclick)=\"copyJsonPath($event, config.responseHeaders, 'responseHeaders')\">{{ formatJson(config.responseHeaders) }}</pre>\n        </div>\n      </div>\n\n      <!-- Request/Response Bodies -->\n      <div class=\"cqa-grid cqa-grid-cols-2 cqa-gap-3 cqa-mt-4\" *ngIf=\"config?.requestBody || config?.responseBody\">\n        <!-- Request Body -->\n        <div class=\"cqa-bg-[#FCFCFC] cqa-rounded-lg cqa-p-3 cqa-flex cqa-flex-col\" style=\"border: 1px solid #EDE9FE\">\n          <div class=\"cqa-flex cqa-items-center cqa-justify-between cqa-gap-2 cqa-mb-2\">\n            <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#636363]\">Request Body</span>\n            <div class=\"cqa-relative\">\n              <button (click)=\"copyRequestBody()\">\n                <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 4H5C4.44772 4 4 4.44772 4 5V10C4 10.5523 4.44772 11 5 11H10C10.5523 11 11 10.5523 11 10V5C11 4.44772 10.5523 4 10 4Z\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M2 8C1.45 8 1 7.55 1 7V2C1 1.45 1.45 1 2 1H7C7.55 1 8 1.45 8 2\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n              </button>\n              <!-- Copied Tooltip -->\n              <div \n                *ngIf=\"showRequestBodyCopied\" \n                class=\"cqa-absolute cqa-right-0 cqa-top-full cqa-mt-1 cqa-px-2 cqa-py-1 cqa-bg-[#0B0B0B] cqa-text-white cqa-text-[10px] cqa-rounded cqa-whitespace-nowrap cqa-z-50 cqa-shadow-lg\"\n                style=\"animation: fadeInOut 0.2s ease-in-out;\">\n                Copied\n              </div>\n            </div>\n          </div>\n          <pre *ngIf=\"config.requestBody\" class=\"cqa-h-full cqa-text-[12px] cqa-text-[#0B0B0B] cqa-bg-[#F8F8F8] cqa-p-2 cqa-m-0 cqa-rounded cqa-overflow-auto cqa-max-h-[114px] cqa-cursor-pointer\" style=\"scrollbar-width: thin;\" (dblclick)=\"copyJsonPath($event, config.requestBody, 'requestBody')\">{{ formatJson(config.requestBody) }}</pre>\n        </div>\n\n        <!-- Response Body -->\n        <div class=\"cqa-bg-[#FCFCFC] cqa-rounded-lg cqa-p-3 cqa-flex cqa-flex-col\" style=\"border: 1px solid #EDE9FE\">\n          <div class=\"cqa-flex cqa-items-center cqa-justify-between cqa-mb-2\">\n            <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#636363]\">Response Body</span>\n            <div class=\"cqa-relative\">\n              <button (click)=\"copyResponseBody()\">\n                <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 4H5C4.44772 4 4 4.44772 4 5V10C4 10.5523 4.44772 11 5 11H10C10.5523 11 11 10.5523 11 10V5C11 4.44772 10.5523 4 10 4Z\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M2 8C1.45 8 1 7.55 1 7V2C1 1.45 1.45 1 2 1H7C7.55 1 8 1.45 8 2\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n              </button>\n              <!-- Copied Tooltip -->\n              <div \n                *ngIf=\"showResponseBodyCopied\" \n                class=\"cqa-absolute cqa-right-0 cqa-top-full cqa-mt-1 cqa-px-2 cqa-py-1 cqa-bg-[#0B0B0B] cqa-text-white cqa-text-[10px] cqa-rounded cqa-whitespace-nowrap cqa-z-50 cqa-shadow-lg\"\n                style=\"animation: fadeInOut 0.2s ease-in-out;\">\n                Copied\n              </div>\n            </div>\n          </div>\n          <pre *ngIf=\"config.responseBody\" [ngClass]=\"{'cqa-bg-[#FEF2F2] cqa-text-[#C10007]': config.statusCode >= 400}\" class=\"cqa-h-full cqa-text-[12px] cqa-p-2 cqa-m-0 cqa-rounded cqa-overflow-auto cqa-max-h-[114px] cqa-cursor-pointer\" style=\"scrollbar-width: thin;\" (dblclick)=\"copyJsonPath($event, config.responseBody, 'responseBody')\">{{ formatJson(config.responseBody) }}</pre>\n        </div>\n      </div>\n\n      <!-- Assertions -->\n      <div *ngIf=\"config.assertions && config.assertions.length > 0\" class=\"cqa-bg-[#FCFCFC] cqa-rounded-lg cqa-p-3 cqa-flex cqa-flex-col cqa-mt-4\" style=\"border: 1px solid #EDE9FE\">\n        <div class=\"cqa-flex cqa-items-center cqa-justify-between cqa-gap-2 cqa-mb-3\">\n          <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#636363]\">Assertions</span>\n          <div class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-text-[10px] cqa-leading-[15px] cqa-font-medium\">\n            <span class=\"cqa-flex cqa-items-center cqa-gap-1 cqa-text-[#00A63E]\">\n              <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 3L4.5 8.5L2 6\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n              {{ getPassedAssertions() }} passed\n            </span>\n            <span class=\"cqa-flex cqa-items-center cqa-gap-1 cqa-text-[#E7000B]\">\n              <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M9 3L3 9\" stroke=\"#E7000B\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M3 3L9 9\" stroke=\"#E7000B\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n              {{ getFailedAssertions() }} failed\n            </span>\n          </div>\n        </div>\n        <div class=\"cqa-flex cqa-flex-col cqa-gap-2\">\n          <div\n            *ngFor=\"let assertion of config.assertions\"\n            class=\"cqa-flex cqa-justify-between cqa-gap-2 cqa-flex-wrap cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#636363] cqa-px-3 cqa-py-1 cqa-rounded-md cqa-items-center\"\n            [ngStyle]=\"{\n                'background-color': assertion.status === 'passed' ? '#ECFDF3' : '#FEF2F2',\n                'border': assertion.status === 'passed'\n                  ? '1px solid #A7F3D0'\n                  : '1px solid #FFC9C9'\n            }\"\n          >\n            <div class=\"cqa-flex-1 cqa-flex cqa-items-center cqa-gap-2\">\n              <div>\n                <!-- Passed -->\n                <ng-container *ngIf=\"assertion.status === 'passed'; else failedIcon\">\n                  <svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"20\" height=\"20\" rx=\"10\" fill=\"#DCFCE7\"/><path d=\"M14 7L8.5 12.5L6 10\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n                </ng-container>\n                \n                <!-- Failed -->\n                <ng-template #failedIcon>\n                  <svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"20\" height=\"20\" rx=\"10\" fill=\"#FFE2E2\"/><path d=\"M13 7L7 13\" stroke=\"#E7000B\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M7 7L13 13\" stroke=\"#E7000B\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n                </ng-template>\n              </div>\n              <div class=\"cqa-text-[12px] cqa-leading-[15px]\" \n                [ngClass]=\"{\n                  'cqa-text-[#9F0712]': assertion.status !== 'passed',\n                  'cqa-text-[#016630]': assertion.status === 'passed'\n                }\"\n              >\n                {{ assertion.description }}\n              </div>\n            </div>\n            <div class=\"cqa-flex cqa-items-center cqa-gap-4 cqa-max-w-[200px]\">\n              <div>\n                <span>Expected:</span>\n                <span style=\"word-break: break-word;\" [ngClass]=\"assertion.status === 'passed' ? 'cqa-text-[#008236]' : 'cqa-text-[#0B0B0B]'\">\n                  {{ assertion.expected }}\n                </span>\n              </div>\n              <div>\n                <span>Actual:</span>\n                <span style=\"word-break: break-word;\" [ngClass]=\"assertion.status === 'passed' ? 'cqa-text-green-600' : 'cqa-text-[#E7000B]'\">\n                  {{ assertion.actual }}\n                </span>\n              </div>\n            </div>\n          </div>\n        </div>\n      </div>\n    </div>\n\n      <!-- Self Heal Analysis -->\n    <cqa-self-heal-analysis \n      *ngIf=\"selfHealAnalysis\" \n      [id]=\"step?.testStepId\"\n      [originalLocator]=\"selfHealAnalysis.originalLocator\"\n      [healedLocator]=\"selfHealAnalysis.healedLocator\"\n      [confidence]=\"selfHealAnalysis.confidence\"\n      [healMethod]=\"selfHealAnalysis.healMethod\"\n      [isLoadingAccept]=\"getSelfHealLoadingStatesHandler ? getSelfHealLoadingStatesHandler().isLoadingAccept?.[step?.testStepId] : false\"\n      [isLoadingModifyAccept]=\"getSelfHealLoadingStatesHandler ? getSelfHealLoadingStatesHandler().isLoadingModifyAccept?.[step?.testStepId] : false\"\n      (action)=\"onSelfHealAction($event)\">\n    </cqa-self-heal-analysis>\n\n    <!-- Timing Breakdown -->\n    <div *ngIf=\"config.timingBreakdown\" class=\"cqa-flex cqa-items-center cqa-justify-end cqa-gap-5 cqa-pt-1.5 cqa-px-4 cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#9CA3AF]\">\n      <div class=\"cqa-flex cqa-items-center cqa-gap-2\">\n        <div><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M6 3V6L8 7\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n        <span>Timing breakdown</span>\n      </div>\n      <span class=\"cqa-text-dialog-muted cqa-flex cqa-items-center cqa-gap-3\">\n        <div>\n          App <span class=\"cqa-text-gray-700\">{{ formatDuration(config.timingBreakdown.app) }}</span>\n        </div>\n        <div><svg width=\"1\" height=\"11\" viewBox=\"0 0 1 11\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M-3.8147e-06 10.32V-7.15256e-07H0.959996V10.32H-3.8147e-06Z\" fill=\"#E5E7EB\"/></svg></div>\n        <div>\n          Tool <span class=\"cqa-text-gray-700\">{{ formatDuration(config.timingBreakdown.tool) }}</span>\n        </div>\n      </span>\n    </div>\n  </div>\n\n  <!-- View More Failed Step Button - shown when expanded and failure details exist -->\n  <div *ngIf=\"showViewMoreButton\" class=\"cqa-mt-2 cqa-px-4\">\n    <cqa-view-more-failed-step-button\n      [timingBreakdown]=\"timingBreakdown\"\n      [subSteps]=\"getSubStepsForFailedStep()\"\n      [failureDetails]=\"failureDetails\"\n      [isExpanded]=\"showFailedStepDetails\"\n      (viewMoreClick)=\"onViewMoreFailedStepClick($event)\">\n    </cqa-view-more-failed-step-button>\n  </div>\n\n  <!-- Updated Failed Step Component - shown when button is clicked -->\n  <div *ngIf=\"showViewMoreButton && showFailedStepDetails && failureDetails\" class=\"cqa-mt-2 cqa-px-4\">\n    <cqa-updated-failed-step\n      [testStepResultId]=\"testStepResultId\"\n      [timingBreakdown]=\"timingBreakdown\"\n      [expanded]=\"true\"\n      [subSteps]=\"getSubStepsForFailedStep()\"\n      [failureDetails]=\"failureDetails\"\n      [reasoning]=\"reasoning\"\n      [confidence]=\"confidence\"\n      [isUploadingBaseline]=\"isUploadingBaseline\"\n      [isMakingCurrentBaseline]=\"isMakingCurrentBaseline\"\n      [isLive]=\"isLive\"\n      (makeCurrentBaseline)=\"onMakeCurrentBaseline($event)\"\n      (uploadBaseline)=\"onUploadBaseline($event)\"\n      (analyze)=\"onAnalyze()\"\n      (viewFullLogs)=\"onViewFullLogs()\">\n    </cqa-updated-failed-step>\n  </div>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-step.component.js","sourceRoot":"","sources":["../../../../../../src/lib/execution-screen/api-step/api-step.component.ts","../../../../../../src/lib/execution-screen/api-step/api-step.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnInit, OnChanges, OnDestroy, Output, SimpleChanges, DoCheck } from '@angular/core';\nimport { ApiStepConfig, ApiAssertion, SubStep, StepStatus, TimingBreakdown, FailureDetails, SelfHealAnalysisData, SelfHealAction, ExecutionStepConfig, SelfHealActionEvent, AddStepMenuOption, DEFAULT_ADD_STEP_MENU_OPTIONS, StepMoreMenuOption, DEFAULT_STEP_MORE_MENU_OPTIONS } from '../execution-step.models';\nimport { BaseStepComponent } from '../base-step.component';\nimport { makeCurrentBaselineEvent, uploadBaselineEvent } from '../visual-comparison/visual-comparison.component';\n\n@Component({\n  selector: 'cqa-api-step',\n  templateUrl: './api-step.component.html',\n  styleUrls: [],\n  host: { class: 'cqa-ui-root cqa-w-full' }\n})\nexport class ApiStepComponent extends BaseStepComponent implements OnInit, OnChanges, OnDestroy, DoCheck {\n  // Individual inputs\n  @Input() id!: string;\n  @Input() testStepResultId!: string;\n  @Input() stepNumber!: string;\n  @Input() title!: string;\n  @Input() status!: StepStatus;\n  @Input() duration!: number;\n  @Input() timingBreakdown?: TimingBreakdown;\n  @Input() expanded?: boolean;\n  @Input() method!: string;\n  @Input() endpoint!: string;\n  @Input() statusCode!: number;\n  @Input() responseTime!: number;\n  @Input() requestBody?: any;\n  @Input() responseBody?: any;\n  @Input() requestHeaders?: any;\n  @Input() responseHeaders?: any;\n  @Input() assertions?: ApiAssertion[];\n  @Input() initialActions?: SubStep[];\n  @Input() isDebug?: boolean = false;\n  @Input() canEditSteps?: boolean = true;\n  @Input() debugPointSet?: boolean = false;\n  @Input() parentSkipped?: boolean = false;\n  @Output() debugPointChange = new EventEmitter<boolean>();\n  @Output() editStep = new EventEmitter<void>();\n  @Output() addStepOptionSelect = new EventEmitter<AddStepMenuOption>();\n  @Output() stepMoreOptionSelect = new EventEmitter<StepMoreMenuOption>();\n  @Input() addStepMenuOptions: AddStepMenuOption[] = DEFAULT_ADD_STEP_MENU_OPTIONS;\n  @Input() stepMoreMenuOptions: StepMoreMenuOption[] = DEFAULT_STEP_MORE_MENU_OPTIONS;\n  @Input() failureDetails?: FailureDetails;\n  @Input() reasoning?: string[];\n  @Input() confidence?: string;\n  @Input() stepDeleted?: boolean;\n  @Input() isUploadingBaseline = {};\n  @Input() isMakingCurrentBaseline = {};\n  @Input() isLive: boolean = false;\n  @Input() selfHealAnalysis?: SelfHealAnalysisData;\n  @Input() getSelfHealLoadingStatesHandler?: () => { isLoadingAccept: { [key: string]: boolean }; isLoadingModifyAccept: { [key: string]: boolean } };\n  @Input() onStepClickHandler?: (step: ExecutionStepConfig, event?: Event) => void;\n  @Input() onJsonPathCopiedHandler?: (event: { path: string; source: 'requestBody' | 'responseBody' | 'requestHeaders' | 'responseHeaders' }) => void;\n  @Input() jumpToTimestampHandler?: (timestamp: number, testStepId?: number | string) => void;\n  @Input() step?: any;\n  get stepBadges(): ('skipped' | 'edited' | 'added' | 'removed')[] {\n    const badge = this.step?.stepBadge;\n    if (!badge) return [];\n    return Array.isArray(badge) ? badge : [badge];\n  }\n\n  get isSkipped(): boolean {\n    return this.stepBadges.includes('skipped');\n  }\n\n  get isStepDeleted(): boolean {\n    return this.stepBadges.includes('removed');\n  }\n\n  @Output() makeCurrentBaseline = new EventEmitter<makeCurrentBaselineEvent>();\n  @Output() uploadBaseline = new EventEmitter<uploadBaselineEvent>();\n  @Output() analyze = new EventEmitter<void>();\n  @Output() viewFullLogs = new EventEmitter<void>();\n  @Output() selfHealAction = new EventEmitter<SelfHealActionEvent>();\n  @Output() jsonPathCopied = new EventEmitter<{ path: string; source: 'requestBody' | 'responseBody' | 'requestHeaders' | 'responseHeaders' }>();\n\n  showFailedStepDetails: boolean = false;\n\n  /** Show debug icon only when this step has no child steps (leaf step: always show when isDebug). */\n  get showDebugIcon(): boolean {\n    return this.isDebug === true;\n  }\n\n  /** Per-step filtered three-dot menu options (e.g. hide Duplicate/Delete for step-group children). */\n  get effectiveStepMoreMenuOptions(): StepMoreMenuOption[] {\n    const base = this.stepMoreMenuOptions || [];\n    const stepRef: any = this.step;\n    if (!stepRef) return base;\n\n    const isGroupChild = !!stepRef.isStepGroupChildren;\n    // When step.stepMoreMenuOptions is truthy OR step is a step-group child, hide mutating items\n    const suppressMutating = !!stepRef.stepMoreMenuOptions || isGroupChild;\n    if (!suppressMutating) return base;\n\n    return base.filter(opt => opt.id !== 'duplicate' && opt.id !== 'delete');\n  }\n\n  // Config property for base class - built from individual inputs in ngOnInit\n  override config!: ApiStepConfig;\n\n  private previousStatus?: StepStatus;\n  private userManuallyClosed: boolean = false;\n  showRequestSummaryCopied: boolean = false;\n\n  // Processed initial actions for live mode WAIT_FOR_LOCATOR countdown grouping\n  processedInitialActions: any[] = [];\n  private lastProcessedIndex: number = 0;\n  private waitLocatorGroupEntry: any | null = null;\n  private countdownIntervalId: any = null;\n\n  // AI_AUTO_HEAL grouping: show loading until AI_AUTO_HEAL_SUCCESS or AI_AUTO_HEAL_FAILED\n  private aiAutoHealGroupEntry: any | null = null;\n\n  // Processed initial actions for run result screen (filter and split AI_AUTO_HEAL_SUCCESS/FAILED)\n  processedInitialActionsForRunResult: any[] = [];\n  private requestSummaryCopiedTimeout?: any;\n  showRequestHeadersCopied: boolean = false;\n  private requestHeadersCopiedTimeout?: any;\n  showResponseHeadersCopied: boolean = false;\n  private responseHeadersCopiedTimeout?: any;\n  showRequestBodyCopied: boolean = false;\n  private requestBodyCopiedTimeout?: any;\n  showResponseBodyCopied: boolean = false;\n  private responseBodyCopiedTimeout?: any;\n\n  override ngOnInit(): void {\n    // Build config from individual inputs\n    this.updateConfig();\n\n    super.ngOnInit();\n    \n    // Ensure isExpanded is set correctly after super.ngOnInit()\n    if (this.expanded !== undefined) {\n      this.isExpanded = this.expanded;\n    }\n\n    // Initialize live initial actions processing for WAIT_FOR_LOCATOR grouping\n    if (this.isLive && this.initialActions && this.initialActions.length > 0) {\n      this.processLiveInitialActions();\n    } else if (!this.isLive && this.initialActions && this.initialActions.length > 0) {\n      // Process for run result screen: filter and split AI_AUTO_HEAL_SUCCESS/FAILED\n      this.processInitialActionsForRunResult();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if(this.isLive) {\n      // Update config when any relevant input changes\n      if (changes['status'] || changes['duration'] || changes['expanded'] ||\n          changes['statusCode'] || changes['responseTime'] || changes['assertions'] ||\n          changes['initialActions'] || changes['requestBody'] || changes['responseBody'] ||\n          changes['requestHeaders'] || changes['responseHeaders'] || changes['timingBreakdown'] ||\n          changes['stepNumber']) {\n        this.updateConfig();\n      }\n      \n      // Update expanded state if changed\n      if (changes['expanded'] && this.expanded !== undefined) {\n        this.isExpanded = this.expanded;\n      }\n\n      // Update initialActions array when new ones are added\n      if (changes['initialActions']) {\n        const previousActionsCount = changes['initialActions'].previousValue?.length || 0;\n        const currentActionsCount = (this.initialActions || []).length;\n        \n        // Process live initial actions\n        if (this.isLive) {\n          this.processLiveInitialActions();\n        } else {\n          this.processInitialActionsForRunResult();\n        }\n        \n        // Auto-expand if step is running and new initialActions are added (logs coming in)\n        if (!changes['initialActions'].firstChange && \n            this.status === 'running' && \n            currentActionsCount > previousActionsCount &&\n            this.hasSubSteps && \n            !this.isExpanded && \n            !this.userManuallyClosed) {\n          this.autoExpand();\n        }\n      }\n\n      // Handle status changes - auto-expand when step starts executing\n      if (changes['status'] && !changes['status'].firstChange) {\n        const newStatus = changes['status'].currentValue;\n        const oldStatus = changes['status'].previousValue;\n        \n        // Auto-expand when status changes to 'running' and has subSteps (or will have soon)\n        if (newStatus === 'running' && oldStatus !== 'running' && !this.userManuallyClosed) {\n          // Expand immediately if already has subSteps, or wait for them\n          if (this.hasSubSteps) {\n            this.autoExpand();\n          }\n        }\n        \n        this.previousStatus = newStatus;\n      }\n    }\n\n    if (changes['stepDeleted'] && this.config) {\n      this.config.stepDeleted = changes['stepDeleted'].currentValue;\n    }\n  }\n\n  getStatusBadgeClass(): string {\n    if (this.config.statusCode >= 200 && this.config.statusCode < 300) {\n      return 'cqa-bg-green-100 cqa-text-green-800';\n    } else if (this.config.statusCode >= 400 && this.config.statusCode < 500) {\n      return 'cqa-bg-orange-100 cqa-text-orange-800';\n    } else {\n      return 'cqa-bg-red-100 cqa-text-red-800';\n    }\n  }\n\n  formatJson(obj: any): string {\n    // If the caller already passed a pre-formatted string (e.g. a GraphQL query with\n    // embedded newlines), render it as-is. Running JSON.stringify on it would wrap\n    // the value in quotes and escape every `\\n` into a literal `\\n`, which is what\n    // shows up as a single-line blob in the Request Body panel.\n    if (typeof obj === 'string') return obj;\n    return JSON.stringify(obj, null, 2);\n  }\n\n  getPassedAssertions(): number {\n    return this.config.assertions?.filter(a => a.status === 'passed').length || 0;\n  }\n\n  getFailedAssertions(): number {\n    return this.config.assertions?.filter(a => a.status === 'failed').length || 0;\n  }\n\n  copyToClipboard(text: string): void {\n    navigator.clipboard.writeText(text).then(() => {\n      console.log('Copied to clipboard:', text);\n    }).catch(err => {\n      console.error('Failed to copy to clipboard:', err);\n      // Call the handler if copy fails\n      if (this.onJsonPathCopiedHandler) {\n        console.log('Calling onJsonPathCopiedHandler from copyToClipboard');\n        try {\n          this.onJsonPathCopiedHandler({ path: text, source: 'responseBody' });\n        } catch (handlerError) {\n          console.error('Error in onJsonPathCopiedHandler:', handlerError);\n        }\n      }\n    });\n  }\n\n  copyRequestBody(): void {\n    if (this.requestBody) {\n      const formattedJson = this.formatJson(this.requestBody);\n      navigator.clipboard.writeText(formattedJson).then(() => {\n        // Show \"Copied\" tooltip\n        this.showRequestBodyCopied = true;\n        \n        // Clear any existing timeout\n        if (this.requestBodyCopiedTimeout) {\n          clearTimeout(this.requestBodyCopiedTimeout);\n        }\n        \n        // Hide tooltip after 2 seconds\n        this.requestBodyCopiedTimeout = setTimeout(() => {\n          this.showRequestBodyCopied = false;\n        }, 2000);\n      }).catch(err => {\n        console.error('Failed to copy request body:', err);\n      });\n    }\n  }\n\n  copyResponseBody(): void {\n    if (this.responseBody) {\n      const formattedJson = this.formatJson(this.responseBody);\n      navigator.clipboard.writeText(formattedJson).then(() => {\n        // Show \"Copied\" tooltip\n        this.showResponseBodyCopied = true;\n        \n        // Clear any existing timeout\n        if (this.responseBodyCopiedTimeout) {\n          clearTimeout(this.responseBodyCopiedTimeout);\n        }\n        \n        // Hide tooltip after 2 seconds\n        this.responseBodyCopiedTimeout = setTimeout(() => {\n          this.showResponseBodyCopied = false;\n        }, 2000);\n      }).catch(err => {\n        console.error('Failed to copy response body:', err);\n      });\n    }\n  }\n\n  copyRequestHeaders(): void {\n    if (this.requestHeaders) {\n      const formattedJson = this.formatJson(this.requestHeaders);\n      navigator.clipboard.writeText(formattedJson).then(() => {\n        // Show \"Copied\" tooltip\n        this.showRequestHeadersCopied = true;\n        \n        // Clear any existing timeout\n        if (this.requestHeadersCopiedTimeout) {\n          clearTimeout(this.requestHeadersCopiedTimeout);\n        }\n        \n        // Hide tooltip after 2 seconds\n        this.requestHeadersCopiedTimeout = setTimeout(() => {\n          this.showRequestHeadersCopied = false;\n        }, 2000);\n      }).catch(err => {\n        console.error('Failed to copy request headers:', err);\n      });\n    }\n  }\n\n  copyResponseHeaders(): void {\n    if (this.responseHeaders) {\n      const formattedJson = this.formatJson(this.responseHeaders);\n      navigator.clipboard.writeText(formattedJson).then(() => {\n        // Show \"Copied\" tooltip\n        this.showResponseHeadersCopied = true;\n        \n        // Clear any existing timeout\n        if (this.responseHeadersCopiedTimeout) {\n          clearTimeout(this.responseHeadersCopiedTimeout);\n        }\n        \n        // Hide tooltip after 2 seconds\n        this.responseHeadersCopiedTimeout = setTimeout(() => {\n          this.showResponseHeadersCopied = false;\n        }, 2000);\n      }).catch(err => {\n        console.error('Failed to copy response headers:', err);\n      });\n    }\n  }\n\n  /**\n   * Walks jsonData and builds a map from each line number (in the output of\n   * JSON.stringify(jsonData, null, 2)) to the segment path that line represents.\n   * Segments are strings for object keys and numbers for array indices.\n   */\n  private buildLinePathMap(obj: any): Map<number, Array<string | number>> {\n    const map = new Map<number, Array<string | number>>();\n    const state = { line: 0 };\n\n    const walk = (value: any, path: Array<string | number>): void => {\n      if (Array.isArray(value)) {\n        if (value.length === 0) return;\n        for (let i = 0; i < value.length; i++) {\n          state.line += 1; // newline before element\n          const elementPath = [...path, i];\n          map.set(state.line, elementPath);\n          walk(value[i], elementPath);\n        }\n        state.line += 1; // newline before closing ]\n        return;\n      }\n      if (value && typeof value === 'object') {\n        const keys = Object.keys(value);\n        if (keys.length === 0) return;\n        for (const key of keys) {\n          state.line += 1; // newline before \"key\":\n          const keyPath = [...path, key];\n          map.set(state.line, keyPath);\n          walk(value[key], keyPath);\n        }\n        state.line += 1; // newline before closing }\n        return;\n      }\n      // primitive — no additional lines\n    };\n\n    // Root line (line 0) is the opening { or [ or primitive.\n    walk(obj, []);\n    return map;\n  }\n\n  /**\n   * Extracts JSON path from the clicked position in a formatted JSON string.\n   * Returns an array of segments (string keys or numeric array indices), or null.\n   */\n  private getJsonPathFromClick(event: MouseEvent, jsonData: any, prefix: string = ''): Array<string | number> | null {\n    const target = event.target as HTMLElement;\n    if (!target || jsonData == null) return null;\n\n    const preElement = target.closest('pre');\n    if (!preElement) return null;\n\n    // Create a range at the click position\n    let range: Range | null = null;\n    if (document.caretRangeFromPoint) {\n      range = document.caretRangeFromPoint(event.clientX, event.clientY);\n    }\n\n    if (!range) {\n      // Fallback for browsers that don't support caretRangeFromPoint\n      const selection = window.getSelection();\n      if (selection && selection.rangeCount > 0) {\n        range = selection.getRangeAt(0);\n      } else {\n        return null;\n      }\n    }\n\n    // Get the text content up to the click position\n    const preRange = document.createRange();\n    preRange.selectNodeContents(preElement);\n    preRange.setEnd(range.startContainer, range.startOffset);\n    const textBeforeClick = preRange.toString();\n\n    // Count newlines to find which line we're on\n    const lineIndex = (textBeforeClick.match(/\\n/g) || []).length;\n\n    const linePathMap = this.buildLinePathMap(jsonData);\n\n    // Exact match first; otherwise fall back to the nearest preceding mapped line\n    // (handles clicks on closing brackets or blank columns).\n    let segments = linePathMap.get(lineIndex);\n    if (!segments) {\n      for (let i = lineIndex - 1; i >= 0; i--) {\n        const candidate = linePathMap.get(i);\n        if (candidate) {\n          segments = candidate;\n          break;\n        }\n      }\n    }\n    if (!segments || segments.length === 0) return null;\n\n    return prefix ? [prefix, ...segments] : [...segments];\n  }\n\n  private formatSegmentsPath(segments: Array<string | number>): string {\n    return segments.reduce<string>((acc, seg) => {\n      if (typeof seg === 'number') return `${acc}[${seg}]`;\n      return acc ? `${acc}.${seg}` : String(seg);\n    }, '');\n  }\n\n  private normalizeJsonPath(segments: Array<string | number>, prefix: string): string {\n    if (!segments || segments.length === 0) return '';\n\n    if (!prefix || segments.length < 2) {\n      return this.formatSegmentsPath(segments);\n    }\n\n    const [, ...rest] = segments;\n\n    if (prefix === 'requestHeaders' || prefix === 'responseHeaders') {\n      return rest.length ? `headers${this.formatSegmentsPath(rest).startsWith('[') ? '' : '.'}${this.formatSegmentsPath(rest)}` : 'headers';\n    }\n\n    if (prefix === 'requestBody' || prefix === 'responseBody') {\n      return rest.length ? `body${this.formatSegmentsPath(rest).startsWith('[') ? '' : '.'}${this.formatSegmentsPath(rest)}` : 'body';\n    }\n\n    return this.formatSegmentsPath(segments);\n  }\n\n  /**\n   * Copy JSON path on double-click\n   */\n  copyJsonPath(event: MouseEvent, jsonData: any, prefix: string = ''): void {\n    if (!jsonData) return;\n\n    const segments = this.getJsonPathFromClick(event, jsonData, prefix);\n    if (segments && segments.length > 0) {\n      const source = prefix as 'requestBody' | 'responseBody' | 'requestHeaders' | 'responseHeaders';\n      const normalizedPath = this.normalizeJsonPath(segments, prefix);\n      navigator.clipboard.writeText(normalizedPath).then(() => {\n        console.log('Copied to clipboard:', normalizedPath);\n        // Call the handler on every double-click (even on success, for now showing error as per requirement)\n        if (this.onJsonPathCopiedHandler) {\n          console.log('Calling onJsonPathCopiedHandler on success with:', { path: normalizedPath, source });\n          try {\n            this.onJsonPathCopiedHandler({ path: normalizedPath, source });\n          } catch (handlerError) {\n            console.error('Error in onJsonPathCopiedHandler:', handlerError);\n          }\n        }\n        // Emit event with the copied path and source\n        this.jsonPathCopied.emit({ path: normalizedPath, source });\n      }).catch(err => {\n        console.error('Failed to copy to clipboard:', err);\n        // Call the handler if copy fails\n        if (this.onJsonPathCopiedHandler) {\n          console.log('Calling onJsonPathCopiedHandler on failure with:', { path: normalizedPath, source });\n          try {\n            this.onJsonPathCopiedHandler({ path: normalizedPath, source });\n          } catch (handlerError) {\n            console.error('Error in onJsonPathCopiedHandler:', handlerError);\n          }\n        }\n        // Also emit the event for backward compatibility\n        this.jsonPathCopied.emit({ path: normalizedPath, source });\n      });\n    } else {\n      // Fallback: if we can't determine the path, copy the whole JSON\n      const formattedJson = this.formatJson(jsonData);\n      this.copyToClipboard(formattedJson);\n    }\n  }\n\n  copyRequestSummary(): void {\n    const summary: Record<string, unknown> = {\n      method: this.config?.method,\n      endpoint: this.config?.endpoint\n    };\n    if (this.config?.statusCode != null) summary['statusCode'] = this.config.statusCode;\n    if (this.config?.responseTime != null) summary['responseTime'] = this.config.responseTime;\n    const summaryText = this.formatJson(summary);\n\n    navigator.clipboard.writeText(summaryText).then(() => {\n      // Show \"Copied\" tooltip\n      this.showRequestSummaryCopied = true;\n\n      // Clear any existing timeout\n      if (this.requestSummaryCopiedTimeout) {\n        clearTimeout(this.requestSummaryCopiedTimeout);\n      }\n\n      // Hide tooltip after 2 seconds\n      this.requestSummaryCopiedTimeout = setTimeout(() => {\n        this.showRequestSummaryCopied = false;\n      }, 2000);\n    }).catch(err => {\n      console.error('Failed to copy request summary:', err);\n    });\n  }\n\n  onViewMoreFailedStepClick(expanded: boolean): void {\n    this.showFailedStepDetails = expanded;\n  }\n\n  getSubStepsForFailedStep(): SubStep[] {\n    return this.initialActions || [];\n  }\n\n  onMakeCurrentBaseline(event: makeCurrentBaselineEvent): void {\n    this.makeCurrentBaseline.emit(event);\n  }\n\n  onUploadBaseline(event: uploadBaselineEvent): void {\n    this.uploadBaseline.emit(event);\n  }\n\n  onAnalyze(): void {\n    this.analyze.emit();\n  }\n\n  onViewFullLogs(): void {\n    this.viewFullLogs.emit();\n  }\n\n  onSelfHealAction(event: SelfHealActionEvent): void {\n    this.selfHealAction.emit(event);\n  }\n\n  get showViewMoreButton(): boolean {\n    return this.isExpanded && Boolean(this.failureDetails) &&\n      (\n        (Boolean(this.failureDetails?.expected || this.failureDetails?.actual)) ||\n        (Boolean(this.failureDetails?.screenshots?.current || this.failureDetails?.screenshots?.baseline || this.failureDetails?.screenshots?.difference)\n          || Boolean(this.failureDetails?.logs?.length)) || \n        (Boolean(this.failureDetails?.aiFixApplied && (this.failureDetails?.aiFixMessage || this.confidence || this.reasoning?.length)))\n      )\n  }\n\n  onDebugPointClick(event: Event): void {\n    event.preventDefault();\n    event.stopPropagation();\n    this.debugPointChange.emit(!this.debugPointSet);\n  }\n\n  onEditStep(event: Event): void {\n    event.preventDefault();\n    event.stopPropagation();\n    this.editStep.emit();\n  }\n\n  onAddStepOptionSelect(option: AddStepMenuOption, event: Event): void {\n    event.preventDefault();\n    this.addStepOptionSelect.emit(option);\n  }\n\n  onStepMoreOptionSelect(option: StepMoreMenuOption, event: Event): void {\n    event.preventDefault();\n    this.stepMoreOptionSelect.emit(option);\n  }\n\n  toggleHeader(event?: Event): void {\n    if (event) {\n      event.preventDefault();\n      event.stopPropagation();\n    }\n    this.toggle();\n    if(!this.isExpanded){\n      this.showFailedStepDetails = false;\n    }\n    if (this.onStepClickHandler) {\n      const stepToPass = this.step || this.config;\n      if (stepToPass) {\n        this.onStepClickHandler(stepToPass, event);\n      }\n    }\n  }\n\n  override toggle(): void {\n    const wasExpanded = this.isExpanded;\n    super.toggle();\n\n    // Track manual closure by user\n    if (wasExpanded && !this.isExpanded) {\n      this.userManuallyClosed = true;\n    } else if (!wasExpanded && this.isExpanded) {\n      this.userManuallyClosed = false;\n    }\n\n    // Ensure expanded state is synced with config\n    if (this.config) {\n      this.config.expanded = this.isExpanded;\n    }\n  }\n\n  private autoExpand(): void {\n    if (!this.isExpanded && this.hasSubSteps) {\n      this.isExpanded = true;\n      this.userManuallyClosed = false;\n      this.toggleExpanded.emit(true);\n    }\n  }\n\n  get hasSubSteps(): boolean {\n    return this.initialActions !== undefined && this.initialActions.length > 0;\n  }\n\n  private updateConfig(): void {\n    // Build or update config from individual inputs\n    this.config = {\n      id: this.id,\n      testStepId: this.step?.testStepId || undefined,\n      testStepResultId: this.testStepResultId,\n      stepNumber: this.stepNumber,\n      title: this.title,\n      status: this.status,\n      duration: this.duration,\n      displayType: 'api',\n      method: this.method,\n      endpoint: this.endpoint,\n      statusCode: this.statusCode,\n      responseTime: this.responseTime,\n      requestBody: this.requestBody,\n      responseBody: this.responseBody,\n      requestHeaders: this.requestHeaders,\n      responseHeaders: this.responseHeaders,\n      assertions: this.assertions,\n      initialActions: this.initialActions,\n      stepDeleted: this.stepDeleted,\n      timingBreakdown: this.timingBreakdown,\n      expanded: this.expanded,\n    } as ApiStepConfig;\n  }\n\n  ngDoCheck(): void {\n    if (!this.isLive) return;\n    const currentLength = (this.initialActions || []).length;\n    if (currentLength !== this.lastProcessedIndex) {\n      this.processLiveInitialActions();\n    }\n  }\n\n  ngOnDestroy(): void {\n    // Clean up timeouts to prevent memory leaks\n    if (this.requestSummaryCopiedTimeout) {\n      clearTimeout(this.requestSummaryCopiedTimeout);\n    }\n    if (this.requestHeadersCopiedTimeout) {\n      clearTimeout(this.requestHeadersCopiedTimeout);\n    }\n    if (this.responseHeadersCopiedTimeout) {\n      clearTimeout(this.responseHeadersCopiedTimeout);\n    }\n    if (this.requestBodyCopiedTimeout) {\n      clearTimeout(this.requestBodyCopiedTimeout);\n    }\n    if (this.responseBodyCopiedTimeout) {\n      clearTimeout(this.responseBodyCopiedTimeout);\n    }\n    this.clearCountdownTimer();\n  }\n\n  private processLiveInitialActions(): void {\n    const allInitialActions = (this.initialActions || []) as any[];\n\n    // Reset if initialActions were cleared or replaced with fewer entries\n    if (allInitialActions.length < this.lastProcessedIndex) {\n      this.resetLiveProcessing();\n    }\n\n    for (let i = this.lastProcessedIndex; i < allInitialActions.length; i++) {\n      const action = allInitialActions[i];\n      const uiType: string = action?.uiType || action?.type || '';\n      const status: string = (action?.status || '').toLowerCase();\n\n      if (uiType === 'WAIT_FOR_LOCATOR') {\n        // Create a single grouped entry with a countdown; absorbs FIND_LOCATOR and LOCATOR_FOUND\n        const timeoutSeconds = typeof action.value === 'number'\n          ? action.value\n          : (action.value ? parseFloat(action.value) : 30);\n\n        this.clearCountdownTimer();\n\n        this.waitLocatorGroupEntry = {\n          ...action,\n          remainingSeconds: timeoutSeconds,\n          status: 'running'\n        };\n        this.addDurationToWaitLocatorGroupEntry(action);\n        this.processedInitialActions.push(this.waitLocatorGroupEntry);\n\n        // Tick down every second\n        this.countdownIntervalId = setInterval(() => {\n          if (this.waitLocatorGroupEntry) {\n            this.waitLocatorGroupEntry.remainingSeconds = Math.max(0, this.waitLocatorGroupEntry.remainingSeconds - 1);\n            if (this.waitLocatorGroupEntry.remainingSeconds <= 0) {\n              this.waitLocatorGroupEntry.status = 'failed';\n              this.waitLocatorGroupEntry.remainingSeconds = null;\n              this.clearCountdownTimer();\n              this.waitLocatorGroupEntry = null;\n            }\n          }\n        }, 1000);\n\n      } else if (uiType === 'FIND_LOCATOR') {\n        if (status === 'failed' || status === 'failure') {\n          // Abort countdown, replace group entry with this failed log\n          if (this.waitLocatorGroupEntry) {\n            this.processedInitialActions = this.processedInitialActions.filter(entry => entry !== this.waitLocatorGroupEntry);\n            this.clearCountdownTimer();\n            this.waitLocatorGroupEntry = null;\n          }\n          this.processedInitialActions.push({ ...action, status: 'failed' });\n        } else if (this.waitLocatorGroupEntry) {\n          // Update the single group entry's text so the user sees progress\n          const newText = action.description || action.text || action.title;\n          if (newText) this.waitLocatorGroupEntry.description = newText;\n          this.addDurationToWaitLocatorGroupEntry(action);\n        } else {\n          // No active group – push FIND_LOCATOR normally once countdown is cleared\n          this.processedInitialActions.push({ ...action });\n        }\n\n      } else if (uiType === 'LOCATOR_FOUND') {\n\n        if (status === 'failed' || status === 'failure') {\n          // Abort countdown, replace group entry with this failed log\n          if (this.waitLocatorGroupEntry) {\n            this.processedInitialActions = this.processedInitialActions.filter(entry => entry !== this.waitLocatorGroupEntry);\n            this.clearCountdownTimer();\n            this.waitLocatorGroupEntry = null;\n          }\n          this.processedInitialActions.push({ ...action, status: 'failed' });\n        } else {\n          // Sequence complete – update group entry to show LOCATOR_FOUND text as success\n          if (this.waitLocatorGroupEntry) {\n            const newText = action.description || action.text || action.title;\n            if (newText) this.waitLocatorGroupEntry.description = newText;\n            this.waitLocatorGroupEntry.status = 'success';\n            this.addDurationToWaitLocatorGroupEntry(action);\n            this.waitLocatorGroupEntry.remainingSeconds = null;\n            this.clearCountdownTimer();\n            this.waitLocatorGroupEntry = null;\n          } else {\n            // No active group – push LOCATOR_FOUND normally\n            this.processedInitialActions.push({ ...action });\n          }\n        }\n\n      } else if (uiType === 'AI_AUTO_HEAL') {\n        // If a WAIT_FOR_LOCATOR countdown is active, complete it as failed before starting AI auto-heal\n        if (this.waitLocatorGroupEntry) {\n          this.waitLocatorGroupEntry.status = 'failed';\n          this.waitLocatorGroupEntry.remainingSeconds = null;\n          this.clearCountdownTimer();\n          this.waitLocatorGroupEntry = null;\n        }\n\n        // Add single loading entry; will be replaced by AI_AUTO_HEAL_SUCCESS or AI_AUTO_HEAL_FAILED\n        this.aiAutoHealGroupEntry = {\n          ...action,\n          description: action.description || action.text || 'AI auto-heal started',\n          status: 'running',\n          uiType: 'AI_AUTO_HEAL'\n        };\n        this.processedInitialActions.push(this.aiAutoHealGroupEntry);\n\n      } else if (uiType === 'AI_AUTO_HEAL_SUCCESS' || uiType === 'AI_AUTO_HEAL_FAILED') {\n        // If a WAIT_FOR_LOCATOR countdown is active, complete it as failed before handling AI auto-heal result\n        if (this.waitLocatorGroupEntry) {\n          this.waitLocatorGroupEntry.status = 'failed';\n          this.waitLocatorGroupEntry.remainingSeconds = null;\n          this.clearCountdownTimer();\n          this.waitLocatorGroupEntry = null;\n        }\n\n        // Remove loading entry and add TWO separate entries: value and reasoning (like AI_ANSWER)\n        if (this.aiAutoHealGroupEntry) {\n          this.processedInitialActions = this.processedInitialActions.filter(entry => entry !== this.aiAutoHealGroupEntry);\n          this.aiAutoHealGroupEntry = null;\n        }\n        const isSuccess = uiType === 'AI_AUTO_HEAL_SUCCESS';\n        const value = action.value ?? action.text ?? '';\n        const reasoning = action.reasoning ?? action.Reasoning ?? '';\n        const baseDuration = action.duration || 0;\n        const finalStatus = isSuccess ? 'success' : 'failed';\n\n        // First entry: value/description\n        const valueDescription = action.text || action.description || (isSuccess\n          ? `AI auto-heal completed successfully`\n          : `AI auto-heal failed`);\n        this.processedInitialActions.push({\n          ...action,\n          description: valueDescription,\n          value: value,\n          reasoning: null,\n          status: finalStatus,\n          uiType: 'AI_AUTO_HEAL_VALUE',\n          type: 'AI_AUTO_HEAL_VALUE',\n          duration: baseDuration,\n          isAiAutoHealResult: true\n        });\n\n        // Second entry: reasoning (only if present)\n        if (reasoning) {\n          this.processedInitialActions.push({\n            ...action,\n            description: reasoning,\n            value: null,\n            reasoning: reasoning,\n            status: finalStatus,\n            uiType: 'AI_AUTO_HEAL_REASONING',\n            type: 'AI_AUTO_HEAL_REASONING',\n            duration: baseDuration,\n            isAiAutoHealResult: true\n          });\n        }\n\n      } else {\n        // Any failed log while a countdown is active – resolve it as failed\n        if ((status === 'failed' || status === 'failure') && this.waitLocatorGroupEntry) {\n          this.waitLocatorGroupEntry.status = 'failed';\n          this.waitLocatorGroupEntry.remainingSeconds = null;\n          this.clearCountdownTimer();\n          this.waitLocatorGroupEntry = null;\n        }\n        this.processedInitialActions.push(action);\n      }\n    }\n\n    this.lastProcessedIndex = allInitialActions.length;\n  }\n\n  private resetLiveProcessing(): void {\n    this.clearCountdownTimer();\n    this.processedInitialActions = [];\n    this.lastProcessedIndex = 0;\n    this.waitLocatorGroupEntry = null;\n    this.aiAutoHealGroupEntry = null;\n  }\n\n  private clearCountdownTimer(): void {\n    if (this.countdownIntervalId !== null) {\n      clearInterval(this.countdownIntervalId);\n      this.countdownIntervalId = null;\n    }\n  }\n\n  private addDurationToWaitLocatorGroupEntry(action: any): void {\n    if (!this.waitLocatorGroupEntry) {\n      return;\n    }\n\n    const rawDuration = action?.duration;\n    let delta = 0;\n    if (typeof rawDuration === 'number') {\n      delta = rawDuration;\n    } else if (typeof rawDuration === 'string' && rawDuration.trim() !== '') {\n      const parsed = parseFloat(rawDuration);\n      delta = Number.isFinite(parsed) ? parsed : 0;\n    }\n\n    if (delta <= 0) {\n      return;\n    }\n\n    const currentRaw = this.waitLocatorGroupEntry.duration;\n    let current = 0;\n    if (typeof currentRaw === 'number') {\n      current = currentRaw;\n    } else if (typeof currentRaw === 'string' && currentRaw.trim() !== '') {\n      const parsedCurrent = parseFloat(currentRaw);\n      current = Number.isFinite(parsedCurrent) ? parsedCurrent : 0;\n    }\n\n    this.waitLocatorGroupEntry.duration = current + delta;\n  }\n\n  onJumpToTimestamp(event: Event): void {\n    event.stopPropagation();\n    if (this.jumpToTimestampHandler && this.step?.executedResult?.video_start_time !== undefined && this.step?.executedResult?.video_start_time !== null) {\n      const timestamp = typeof this.step.executedResult.video_start_time === 'number' \n        ? this.step.executedResult.video_start_time \n        : Number(this.step.executedResult.video_start_time);\n      const testStepId = this.step?.testStepId;\n      if (isFinite(timestamp) && timestamp >= 0) {\n        this.jumpToTimestampHandler(timestamp, testStepId);\n      }\n    }\n  }\n\n  private processInitialActionsForRunResult(): void {\n    const allInitialActions = (this.initialActions || []) as any[];\n    this.processedInitialActionsForRunResult = [];\n\n    for (const action of allInitialActions) {\n      const uiType: string = action?.uiType || action?.type || '';\n\n      // Split AI_AUTO_HEAL_SUCCESS/FAILED into two entries\n      if (uiType === 'AI_AUTO_HEAL_SUCCESS' || uiType === 'AI_AUTO_HEAL_FAILED') {\n        const isSuccess = uiType === 'AI_AUTO_HEAL_SUCCESS';\n        const value = action.value ?? action.text ?? '';\n        const reasoning = action.reasoning ?? action.Reasoning ?? '';\n        const baseDuration = action.duration || 0;\n        const finalStatus = isSuccess ? 'success' : 'failed';\n\n        // First entry: value/description\n        const valueDescription = (isSuccess\n          ? `AI auto-heal completed successfully`\n          : `AI auto-heal failed`);\n        this.processedInitialActionsForRunResult.push({\n          ...action,\n          description: valueDescription,\n          value: value,\n          reasoning: null,\n          status: finalStatus,\n          uiType: 'AI_AUTO_HEAL_VALUE',\n          type: 'AI_AUTO_HEAL_VALUE',\n          duration: baseDuration,\n          isAiAutoHealResult: true\n        });\n\n        // Second entry: reasoning (only if present)\n        if (reasoning) {\n          this.processedInitialActionsForRunResult.push({\n            ...action,\n            description: reasoning,\n            value: null,\n            reasoning: reasoning,\n            status: finalStatus,\n            uiType: 'AI_AUTO_HEAL_REASONING',\n            type: 'AI_AUTO_HEAL_REASONING',\n            duration: baseDuration,\n            isAiAutoHealResult: true\n          });\n        }\n      } else {\n        const status = (action?.status ?? '').toString().toLowerCase();\n        const isFailed = status === 'failed' || status === 'failure';\n        const isLocatorStep = uiType === 'WAIT_FOR_LOCATOR' || uiType === 'FIND_LOCATOR' || uiType === 'LOCATOR_FOUND';\n        if (isLocatorStep && isFailed) {\n          const baseDesc = action?.description ?? action?.text ?? action?.title ?? '';\n          const notFoundSuffix = ' - Element not found';\n          this.processedInitialActionsForRunResult.push({\n            ...action,\n            description: (baseDesc ? baseDesc + notFoundSuffix : notFoundSuffix.trim())\n          });\n        } else {\n          this.processedInitialActionsForRunResult.push(action);\n        }\n      }\n    }\n  }\n\n}\n","<div class=\"cqa-font-inter cqa-w-full\" [class.cqa-opacity-50]=\"isDebug && isSkipped && !parentSkipped\" [style.background-color]=\"!isDebug ? null : status.toLowerCase() === 'paused' ? '#FFF9E9' : status.toLowerCase() === 'failed' ? '#FEF2F2' : null\" (click)=\"$event.stopPropagation()\">\n  <!-- Header -->\n  <div\n    class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-p-2 cqa-cursor-pointer\"\n    (click)=\"toggleHeader($event)\">\n    <div *ngIf=\"showDebugIcon\" class=\"cqa-flex cqa-items-center cqa-justify-center\"\n      [matTooltip]=\"status.toLowerCase() === 'running' ? 'Breakpoint cannot be set on a running step' : (isStepDeleted ? 'Breakpoint cannot be set on deleted steps' : ((!!parentSkipped && !step?.debugPointDisabled) ? 'Breakpoint cannot be set on a running step' : (!!step?.debugPointDisabled ? 'Breakpoint cannot be set on skipped steps' : '')))\"\n      matTooltipPosition=\"right\">\n      <button type=\"button\" class=\"cqa-p-0 cqa-border-0 cqa-bg-transparent cqa-rounded-full cqa-transition-opacity focus:cqa-outline-none\"\n        [ngClass]=\"status.toLowerCase() === 'running' || !!step?.debugPointDisabled || !!parentSkipped || isStepDeleted ? 'cqa-cursor-not-allowed cqa-opacity-40 cqa-pointer-events-none' : 'cqa-cursor-pointer hover:cqa-opacity-80'\"\n        [disabled]=\"status.toLowerCase() === 'running' || !!step?.debugPointDisabled || !!parentSkipped || isStepDeleted\"\n        (click)=\"onDebugPointClick($event)\" [attr.aria-label]=\"debugPointSet ? 'Remove debug point' : 'Set debug point'\">\n        <svg *ngIf=\"debugPointSet\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n          <circle cx=\"7\" cy=\"7\" r=\"6\" [attr.fill]=\"!!step?.debugPointDisabled || !!parentSkipped || isStepDeleted ? '#9E9E9E' : '#C63535'\"/>\n        </svg>\n        <svg *ngIf=\"!debugPointSet\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n          <circle cx=\"7\" cy=\"7\" r=\"6\" [attr.stroke]=\"!!step?.debugPointDisabled || !!parentSkipped || isStepDeleted ? '#9E9E9E' : '#C63535'\" stroke-width=\"1.5\" fill=\"none\"/>\n        </svg>\n      </button>\n    </div>\n    <!-- Status Icon -->\n    \n    <div *ngIf=\"status.toLowerCase() === 'success'\" ><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10.9005 4.99999C11.1289 6.12064 10.9662 7.28571 10.4395 8.30089C9.91279 9.31608 9.054 10.12 8.00631 10.5787C6.95862 11.0373 5.78536 11.1229 4.6822 10.8212C3.57904 10.5195 2.61265 9.84869 1.94419 8.92071C1.27573 7.99272 0.945611 6.86361 1.00888 5.72169C1.07215 4.57976 1.52499 3.49404 2.29188 2.64558C3.05876 1.79712 4.09334 1.23721 5.22308 1.05922C6.35282 0.881233 7.50944 1.09592 8.50005 1.66749\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 5.5L6 7L11 2\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n    <div *ngIf=\"status.toLowerCase() === 'failure' || status.toLowerCase() === 'failed'\"><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#DC2626\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M7.5 4.5L4.5 7.5\" stroke=\"#DC2626\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 4.5L7.5 7.5\" stroke=\"#DC2626\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n    <div *ngIf=\"status.toLowerCase() === 'pending'\"><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M6 3V6L8 7\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n    <div *ngIf=\"status.toLowerCase() === 'running'\"><svg class=\"cqa-animate-spin cqa-text-[#3B82F6]\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><circle cx=\"6\" cy=\"6\" r=\"5\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" opacity=\"0.25\"/><path d=\"M6 1A5 5 0 0 1 11 6\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" stroke-linecap=\"round\"/></svg></div>\n    <div *ngIf=\"status.toLowerCase() === 'skipped'\"><svg xmlns=\"http://www.w3.org/2000/svg\" height=\"12px\" viewBox=\"0 -960 960 960\" width=\"12px\" fill=\"#1f1f1f\"><path d=\"M660-240v-480h80v480h-80Zm-440 0v-480l360 240-360 240Zm80-240Zm0 90 136-90-136-90v180Z\"/></svg></div>\n    <div *ngIf=\"status.toLowerCase() === 'paused'\"><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M8.5 2H7.5C7.22386 2 7 2.22386 7 2.5V9.5C7 9.77614 7.22386 10 7.5 10H8.5C8.77614 10 9 9.77614 9 9.5V2.5C9 2.22386 8.77614 2 8.5 2Z\" stroke=\"#E17100\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 2H3.5C3.22386 2 3 2.22386 3 2.5V9.5C3 9.77614 3.22386 10 3.5 10H4.5C4.77614 10 5 9.77614 5 9.5V2.5C5 2.22386 4.77614 2 4.5 2Z\" stroke=\"#E17100\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n    <!-- API Icon -->\n    <div><svg width=\"20\" height=\"16\" viewBox=\"0 0 20 16\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"20\" height=\"16\" rx=\"4\" fill=\"#EDE9FE\"/><path d=\"M8 6.5L9.5 8L8 9.5M10.5 9.5H12M6.5 12H13.5C13.7652 12 14.0196 11.8946 14.2071 11.7071C14.3946 11.5196 14.5 11.2652 14.5 11V5C14.5 4.73478 14.3946 4.48043 14.2071 4.29289C14.0196 4.10536 13.7652 4 13.5 4H6.5C6.23478 4 5.98043 4.10536 5.79289 4.29289C5.60536 4.48043 5.5 4.73478 5.5 5V11C5.5 11.2652 5.60536 11.5196 5.79289 11.7071C5.98043 11.8946 6.23478 12 6.5 12Z\" stroke=\"#7F22FE\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n\n    <!-- Step Number and Title -->\n    <div class=\"cqa-flex-1 cqa-flex cqa-items-center cqa-gap-3 cqa-font-inter\">\n      <span class=\"cqa-font-semibold cqa-text-[#334155] cqa-text-[14px] cqa-leading-[18px]\" style=\"word-break: break-word;\">\n        {{ config?.stepNumber }}. <span [innerHTML]=\"config.title\"></span>\n      </span>\n      <span class=\"cqa-px-1.5 cqa-rounded-full cqa-font-medium cqa-text-[#7008E7] cqa-bg-[#EDE9FE] cqa-text-[10px] cqa-leading-[15px]\">\n        API\n      </span>\n      <span class=\"cqa-px-1.5 cqa-rounded-full cqa-font-medium cqa-text-[#008236] cqa-bg-[#DCFCE7] cqa-text-[10px] cqa-leading-[15px]\">\n        {{ config.method }}\n      </span>\n      <span *ngIf=\"config.stepDeleted\" class=\"cqa-px-1.5 cqa-py-[2px] cqa-rounded-[4px] cqa-text-[10px] cqa-leading-[12px] cqa-font-medium cqa-text-[#B42318] cqa-bg-[#FEF3F2] cqa-border cqa-border-[#FEE4E2]\">\n        Deleted\n      </span>\n    </div>\n\n    <div class=\"cqa-flex cqa-items-center cqa-gap-1 cqa-font-inter\">\n      <!-- Step Change Badges (debug only) -->\n      <ng-container *ngIf=\"isDebug\">\n        <ng-container *ngFor=\"let badge of stepBadges\">\n        <cqa-badge\n          *ngIf=\"badge === 'skipped'\"\n          label=\"Skipped\"\n          size=\"small\"\n          [textColor]=\"'#4A5565'\"\n          [borderColor]=\"'#99A1AF'\"\n          [backgroundColor]=\"'#FFFFFF'\">\n        </cqa-badge>\n        <cqa-badge\n          *ngIf=\"badge === 'edited'\"\n          label=\"Edited\"\n          size=\"small\"\n          [textColor]=\"'#FBBF24'\"\n          [borderColor]=\"'#FDDF92'\"\n          [backgroundColor]=\"'#FFF9E9'\">\n        </cqa-badge>\n        <cqa-badge\n          *ngIf=\"badge === 'added'\"\n          label=\"Added\"\n          size=\"small\"\n          [textColor]=\"'#0DBD7D'\"\n          [borderColor]=\"'#5ED3A8'\"\n          [backgroundColor]=\"'#CFF2E5'\">\n        </cqa-badge>\n        <cqa-badge\n          *ngIf=\"badge === 'removed'\"\n          label=\"Removed\"\n          size=\"small\"\n          [textColor]=\"'#EE3F3F'\"\n          [borderColor]=\"'#F47F7F'\"\n          [backgroundColor]=\"'#FCD9D9'\">\n        </cqa-badge>\n        </ng-container>\n      </ng-container>\n      <span *ngIf=\"selfHealAnalysis\" class=\"cqa-px-1.5 cqa-rounded-full cqa-font-medium cqa-text-[#097E53] cqa-bg-[#CFF2E5] cqa-text-[10px] cqa-leading-[15px] cqa-min-w-max cqa-flex cqa-items-center cqa-gap-[6px]\">\n        <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"9\" height=\"9\" viewBox=\"0 0 9 9\" fill=\"none\">\n          <path d=\"M4.50941 0C4.56489 0.0227384 4.58859 0.0782652 4.61131 0.129846C4.62269 0.1599 4.63314 0.190117 4.64329 0.220575C4.64726 0.232247 4.65123 0.243918 4.65532 0.255943C4.70806 0.413005 4.75504 0.571748 4.80229 0.73038C4.81297 0.76619 4.82369 0.801987 4.83442 0.837783C4.88905 1.02004 4.94327 1.2024 4.99719 1.38484C5.00476 1.41047 5.01234 1.43609 5.01992 1.46171C5.04128 1.53395 5.06262 1.60619 5.08383 1.67847C5.12867 1.8312 5.17473 1.98347 5.22378 2.13501C5.22807 2.14827 5.23236 2.16152 5.23677 2.17518C5.3642 2.565 5.54482 2.91437 5.8409 3.21196C5.84823 3.2197 5.85556 3.22744 5.86312 3.23541C5.9895 3.36437 6.15169 3.46771 6.3138 3.55111C6.32206 3.55542 6.33031 3.55974 6.33882 3.56419C6.81587 3.80925 7.38951 3.91704 7.90619 4.0605C8.1326 4.1234 8.3583 4.18829 8.58317 4.25603C8.59897 4.26079 8.61478 4.26554 8.63058 4.27028C8.67784 4.28445 8.725 4.29887 8.77211 4.31347C8.7831 4.31679 8.79408 4.32011 8.80539 4.32353C8.87029 4.34406 8.93239 4.36829 8.98566 4.41027C9.00191 4.44418 9.00191 4.44418 8.99748 4.4781C8.94564 4.52736 8.8942 4.55046 8.82578 4.573C8.816 4.57632 8.80622 4.57965 8.79614 4.58308C8.68061 4.62183 8.56351 4.65575 8.44626 4.68935C8.4222 4.6963 8.39814 4.70326 8.37408 4.71021C8.22571 4.75301 8.07708 4.7949 7.92829 4.83632C7.73232 4.89088 7.53663 4.94634 7.34113 5.00243C7.3091 5.01162 7.27706 5.02078 7.24501 5.02991C7.07671 5.07786 6.90923 5.12753 6.74314 5.18208C6.72937 5.18659 6.71559 5.1911 6.70139 5.19574C6.14511 5.38082 5.7211 5.72609 5.45571 6.23099C5.31263 6.51475 5.22823 6.82161 5.14214 7.12447C5.11884 7.20619 5.09409 7.28745 5.06905 7.36869C5.0494 7.43261 5.0302 7.49663 5.01149 7.56081C5.00926 7.56844 5.00703 7.57608 5.00473 7.58395C4.99394 7.62094 4.98319 7.65793 4.97252 7.69495C4.94519 7.78879 4.91578 7.88187 4.88555 7.97489C4.83191 8.14021 4.7831 8.30674 4.73459 8.4735C4.66144 8.72457 4.66144 8.72457 4.61997 8.84527C4.61721 8.85337 4.61446 8.86147 4.61163 8.86982C4.59649 8.91278 4.58092 8.95233 4.55226 8.9887C4.50867 8.99788 4.50867 8.99788 4.46951 9C4.42473 8.93759 4.39508 8.87711 4.37133 8.80508C4.36787 8.79487 4.36441 8.78466 4.36085 8.77415C4.31684 8.64248 4.27751 8.50946 4.23817 8.37646C4.22916 8.34604 4.22011 8.31564 4.21105 8.28524C4.1436 8.05863 4.07725 7.83174 4.01101 7.60481C3.73507 6.48224 3.73507 6.48224 3.039 5.57466C3.02784 5.56596 3.01669 5.55726 3.00519 5.5483C2.54913 5.19902 1.94834 5.06969 1.39815 4.91813C1.26207 4.88062 1.12605 4.84293 0.990032 4.80523C0.978138 4.80193 0.978138 4.80193 0.966003 4.79857C0.769811 4.74417 0.573674 4.68963 0.378224 4.63283C0.369956 4.63045 0.361688 4.62806 0.353169 4.62561C0.0528989 4.53883 0.0528989 4.53883 0.000646537 4.4781C-0.000831261 4.45054 -0.000831261 4.45054 0.0124689 4.42157C0.0670835 4.3704 0.120077 4.34848 0.19216 4.32619C0.202597 4.32284 0.213034 4.31948 0.223787 4.31603C0.255753 4.30582 0.287788 4.29584 0.319851 4.28592C0.329001 4.28305 0.338151 4.28017 0.347578 4.27722C0.412285 4.25693 0.477225 4.2374 0.542259 4.21809C0.55824 4.21332 0.55824 4.21332 0.574544 4.20846C0.852269 4.12587 1.13181 4.049 1.41126 3.97196C1.6195 3.91455 1.82738 3.85618 2.0346 3.79548C2.04413 3.79271 2.05365 3.78993 2.06346 3.78707C2.5435 3.64696 3.01278 3.44816 3.32274 3.0537C3.32738 3.04785 3.33202 3.042 3.3368 3.03597C3.68197 2.59815 3.81658 2.06572 3.96695 1.54621C4.01643 1.37534 4.06649 1.20464 4.11673 1.03399C4.13064 0.986733 4.14453 0.939471 4.15836 0.892194C4.21394 0.702289 4.27035 0.512642 4.33 0.323864C4.33558 0.306186 4.34114 0.288501 4.34666 0.270807C4.43017 0.00398761 4.43017 0.00398761 4.50941 0Z\" fill=\"#0DBD7D\"/>\n          <path d=\"M7.23597 0.554859C7.29024 0.613599 7.30109 0.682631 7.31799 0.757638C7.37436 0.993269 7.43929 1.20993 7.66467 1.34681C7.80371 1.42035 7.96944 1.45381 8.1235 1.48541C8.18854 1.49902 8.24348 1.51709 8.29924 1.55321C8.31181 1.57229 8.31181 1.57229 8.31107 1.60549C8.29814 1.64588 8.28678 1.6589 8.25269 1.68533C8.21543 1.69726 8.21543 1.69726 8.17068 1.70653C8.15375 1.71025 8.13683 1.714 8.11992 1.71779C8.11086 1.7198 8.10181 1.72181 8.09247 1.72388C7.81696 1.78482 7.81696 1.78482 7.57882 1.92273C7.57108 1.92869 7.56333 1.93466 7.55536 1.9408C7.38516 2.08431 7.34916 2.32303 7.29793 2.52301C7.29499 2.53399 7.29206 2.54497 7.28903 2.55629C7.28649 2.56601 7.28395 2.57573 7.28133 2.58575C7.27028 2.61544 7.25881 2.63479 7.23597 2.65754C7.17234 2.66527 7.17234 2.66527 7.14139 2.65754C7.09216 2.62106 7.08114 2.5795 7.06828 2.52365C7.06613 2.51501 7.06398 2.50636 7.06176 2.49745C7.05489 2.46983 7.04824 2.44217 7.04164 2.41449C6.98979 2.19897 6.93126 1.98751 6.72451 1.86118C6.56293 1.77501 6.36646 1.73426 6.18587 1.70136C6.13637 1.69151 6.10802 1.67911 6.07738 1.64012C6.07073 1.60055 6.07073 1.60055 6.07738 1.56098C6.12447 1.51437 6.17402 1.50299 6.23772 1.48891C6.25778 1.48416 6.27784 1.47938 6.29789 1.47456C6.30825 1.47209 6.31861 1.46962 6.32929 1.46707C6.38212 1.45407 6.43443 1.43949 6.48673 1.42462C6.49623 1.42198 6.50573 1.41935 6.51552 1.41663C6.62182 1.38624 6.71356 1.34737 6.79854 1.27836C6.80647 1.27213 6.81439 1.26589 6.82255 1.25946C6.9548 1.14565 6.99974 0.974674 7.04053 0.815134C7.04364 0.803022 7.04675 0.79091 7.04995 0.778432C7.05614 0.754101 7.06222 0.729743 7.06817 0.705359C7.07243 0.688394 7.07243 0.688394 7.07678 0.671086C7.07927 0.660951 7.08175 0.650816 7.08431 0.640373C7.09521 0.608108 7.10952 0.582772 7.12957 0.554859C7.1681 0.536435 7.19515 0.544764 7.23597 0.554859Z\" fill=\"#075F3F\"/>\n          <path d=\"M1.79545 6.2471C1.80951 6.24719 1.80951 6.24719 1.82386 6.24729C1.92477 6.25022 1.99304 6.28115 2.06736 6.34601C2.15384 6.43533 2.19377 6.53611 2.1915 6.6565C2.18178 6.75412 2.12158 6.83935 2.04773 6.90533C1.96081 6.97242 1.87313 6.99459 1.76206 6.99149C1.66841 6.98107 1.5803 6.93852 1.51393 6.87451C1.43138 6.76681 1.40725 6.66803 1.41935 6.53537C1.44433 6.43092 1.51637 6.34613 1.6085 6.28666C1.67251 6.25564 1.72399 6.24652 1.79545 6.2471Z\" fill=\"#0DBD7D\"/>\n          </svg>\n        Self-healed\n      </span>\n      <div class=\"cqa-flex cqa-items-center cqa-gap-1 cqa-rounded-[4px] cqa-py-0.5 cqa-px-1 cqa-bg-[#6366F11A] cqa-ml-1 cqa-cursor-pointer hover:cqa-opacity-80 cqa-transition-opacity\" \n           *ngIf=\"step?.executedResult?.video_start_time\" \n           [matTooltip]=\"'Jump to video time'\" \n           matTooltipPosition=\"below\"\n           (click)=\"onJumpToTimestamp($event)\">\n        <mat-icon class=\"cqa-text-[#636363] !cqa-text-[10px] !cqa-w-[10px] !cqa-h-[10px]\">\n          play_arrow\n        </mat-icon>\n        <span class=\"cqa-text-[8px] cqa-leading-[12px] cqa-font-normal cqa-text-[#636363]\">\n          {{ formatDurationClock(step?.executedResult?.video_start_time || 0) }}\n        </span>\n      </div>\n      <div *ngIf=\"isDebug && canEditSteps\" class=\"cqa-flex cqa-items-center cqa-gap-0.5 cqa-text-[#9CA3AF]\" (click)=\"$event.stopPropagation()\">\n        <button *ngIf=\"!step?.isStepGroupChildren\" type=\"button\" class=\"cqa-p-0 cqa-border-0 cqa-bg-transparent cqa-cursor-pointer hover:cqa-opacity-80 cqa-transition-opacity focus:cqa-outline-none\" aria-label=\"Edit\" (click)=\"onEditStep($event)\">\n          <mat-icon class=\"!cqa-text-[14px] !cqa-w-[14px] !cqa-h-[14px]\">edit</mat-icon>\n        </button>\n        <button *ngIf=\"!step?.isStepGroupChildren\" type=\"button\" class=\"cqa-p-0 cqa-border-0 cqa-bg-transparent cqa-cursor-pointer hover:cqa-opacity-80 cqa-transition-opacity focus:cqa-outline-none\" aria-label=\"Add\" [matMenuTriggerFor]=\"addStepMenu\">\n          <mat-icon class=\"!cqa-text-[14px] !cqa-w-[14px] !cqa-h-[14px]\">add</mat-icon>\n        </button>\n        <mat-menu #addStepMenu=\"matMenu\" class=\"cqa-add-step-menu\" xPosition=\"before\" yPosition=\"below\">\n          <button mat-menu-item *ngFor=\"let opt of addStepMenuOptions\" (click)=\"onAddStepOptionSelect(opt, $event)\">\n            {{ opt.label }}\n          </button>\n        </mat-menu>\n        <button *ngIf=\"effectiveStepMoreMenuOptions.length\" type=\"button\" class=\"cqa-p-0 cqa-border-0 cqa-bg-transparent cqa-cursor-pointer hover:cqa-opacity-80 cqa-transition-opacity focus:cqa-outline-none\" aria-label=\"More options\" [matMenuTriggerFor]=\"stepMoreMenu\">\n          <mat-icon class=\"!cqa-text-[14px] !cqa-w-[14px] !cqa-h-[14px]\">more_vert</mat-icon>\n        </button>\n        <mat-menu #stepMoreMenu=\"matMenu\" class=\"cqa-step-more-menu\" xPosition=\"before\" yPosition=\"below\">\n          <button mat-menu-item *ngFor=\"let opt of effectiveStepMoreMenuOptions\" (click)=\"onStepMoreOptionSelect(opt, $event)\">{{ opt.label }}</button>\n        </mat-menu>\n      </div>\n      <span class=\"cqa-text-[12px] cqa-leading-[15px] cqa-font-medium cqa-text-[#9CA3AF]\">\n        {{ formatDuration(config.duration) }}\n      </span>\n      <svg [class.cqa-rotate-180]=\"isExpanded\" class=\"cqa-transition-transform\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M3.5 5L7 8.5L10.5 5\" stroke=\"#9CA3AF\" stroke-width=\"0.833333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n    </div>\n  </div>\n\n  <!-- Expanded Content -->\n  <div *ngIf=\"isExpanded\">\n    <!-- Initial Actions (show when we have raw or processed actions; in live mode processedInitialActions is populated from initialActions via ngDoCheck) -->\n    <div *ngIf=\"(config.initialActions && config.initialActions.length > 0) || (isLive && processedInitialActions.length > 0)\" class=\"cqa-flex cqa-flex-col cqa-gap-1 cqa-ml-9\">\n      <!-- Single loop: render all entries in chronological order -->\n      <ng-container *ngFor=\"let action of (isLive ? processedInitialActions : processedInitialActionsForRunResult)\">\n        <!-- AI_AUTO_HEAL_SUCCESS/FAILED: render with ai-agent-step style (both live and run result screens) -->\n        <cqa-ai-logs-with-reasoning\n          *ngIf=\"$any(action).isAiAutoHealResult\"\n          [status]=\"action.status\"\n          [text]=\"$any(action).text || action?.value\"\n          [description]=\"$any(action).description || action?.text || action?.value\"\n          [reasoning]=\"$any(action).reasoning || action?.reasoning\"\n          [duration]=\"action.duration\">\n        </cqa-ai-logs-with-reasoning>\n\n        <!-- Regular initial actions -->\n        <div\n          *ngIf=\"!$any(action).isAiAutoHealResult\"\n          class=\"cqa-flex cqa-items-center cqa-gap-3 cqa-py-[5.5px] cqa-px-3\">\n          \n          <div *ngIf=\"action?.status?.toLowerCase() === 'success' || action?.status?.toLowerCase() === 'passed'\" >\n            <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10.9005 4.99999C11.1289 6.12064 10.9662 7.28571 10.4395 8.30089C9.91279 9.31608 9.054 10.12 8.00631 10.5787C6.95862 11.0373 5.78536 11.1229 4.6822 10.8212C3.57904 10.5195 2.61265 9.84869 1.94419 8.92071C1.27573 7.99272 0.945611 6.86361 1.00888 5.72169C1.07215 4.57976 1.52499 3.49404 2.29188 2.64558C3.05876 1.79712 4.09334 1.23721 5.22308 1.05922C6.35282 0.881233 7.50944 1.09592 8.50005 1.66749\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 5.5L6 7L11 2\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n          </div>\n          <!-- Failure -->\n          <div *ngIf=\"action?.status?.toLowerCase() === 'failure' || action?.status?.toLowerCase() === 'failed'\">\n            <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#DC2626\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M7.5 4.5L4.5 7.5\" stroke=\"#DC2626\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 4.5L7.5 7.5\" stroke=\"#DC2626\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n          </div>\n          <!-- Pending -->\n          <div *ngIf=\"action?.status?.toLowerCase() === 'pending'\">\n            <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M6 3V6L8 7\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n          </div>\n          <!-- Running - Show spinner (also used for active WAIT_FOR_LOCATOR countdown in live mode) -->\n          <div *ngIf=\"action?.status?.toLowerCase() === 'running'\">\n            <svg class=\"cqa-animate-spin cqa-text-[#3B82F6]\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n              <circle cx=\"6\" cy=\"6\" r=\"5\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" opacity=\"0.25\"/>\n              <path d=\"M6 1A5 5 0 0 1 11 6\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" stroke-linecap=\"round\"/>\n            </svg>\n          </div>\n\n          <!-- Action Description -->\n          <span class=\"cqa-flex-1 cqa-text-[13px] cqa-leading-[15px] cqa-text-[#364153]\" style=\"white-space: pre-line; word-break: break-word;\">\n            {{ $any(action).description || $any(action).text }}\n            <!-- Countdown for active WAIT_FOR_LOCATOR in live mode -->\n            <span *ngIf=\"isLive && $any(action).remainingSeconds != null\" class=\"cqa-text-[#F97316] cqa-font-medium cqa-ml-1\">({{ $any(action).remainingSeconds }}s remaining)</span>\n          </span>\n\n          <!-- Action Duration -->\n          <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-metadata-key\">\n            {{ formatDuration(action.duration) }}\n          </span>\n        </div>\n      </ng-container>\n    </div>\n\n    <!-- Request Summary Card -->\n    <div *ngIf=\"!isLive\" class=\"cqa-bg-[#FFFEF9] cqa-mt-1.5 cqa-ml-9 cqa-mr-6 cqa-p-4\" style=\"border-top: 1px solid #E4E4E4;\">\n      \n      <div class=\"cqa-bg-[#FCFCFC] cqa-rounded-lg cqa-p-3\" style=\"border: 1px solid #EDE9FE\">\n        <div class=\"cqa-flex cqa-items-center cqa-justify-between cqa-mb-3 cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#636363]\">\n          <span>Request Summary</span>\n          <div class=\"cqa-relative\">\n            <button (click)=\"copyRequestSummary()\" class=\"cqa-flex cqa-items-center cqa-gap-1 p-0\">\n              <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 4H5C4.44772 4 4 4.44772 4 5V10C4 10.5523 4.44772 11 5 11H10C10.5523 11 11 10.5523 11 10V5C11 4.44772 10.5523 4 10 4Z\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M2 8C1.45 8 1 7.55 1 7V2C1 1.45 1.45 1 2 1H7C7.55 1 8 1.45 8 2\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n              Copy\n            </button>\n            <!-- Copied Tooltip -->\n            <div \n              *ngIf=\"showRequestSummaryCopied\" \n              class=\"cqa-absolute cqa-right-0 cqa-top-full cqa-mt-1 cqa-px-2 cqa-py-1 cqa-bg-[#0B0B0B] cqa-text-white cqa-text-[10px] cqa-rounded cqa-whitespace-nowrap cqa-z-50 cqa-shadow-lg\"\n              style=\"animation: fadeInOut 0.2s ease-in-out;\">\n              Copied!\n            </div>\n          </div>\n        </div>\n        <div class=\"cqa-flex cqa-items-center cqa-justify-between cqa-gap-3 cqa-cursor-pointer\" (dblclick)=\"copyRequestSummary()\">\n          <div class=\"cqa-flex cqa-items-center cqa-gap-2\">\n            <span class=\"cqa-px-1 cqa-py-[2px] cqa-rounded cqa-font-medium cqa-text-[#008236] cqa-bg-[#DCFCE7] cqa-text-[10px] cqa-leading-[15px]\">\n              {{ config.method }}\n            </span>\n            <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#0B0B0B]\">{{ config.endpoint }}</span>\n          </div>\n          <div class=\"cqa-flex cqa-items-center cqa-gap-3\">\n            <span *ngIf=\"config?.statusCode === 200 || config?.statusCode === 201\" class=\"cqa-flex cqa-items-center cqa-gap-1.5 cqa-px-1 cqa-py-[2px] cqa-rounded cqa-font-medium cqa-text-[#00A63E] cqa-bg-[#DCFCE7] cqa-text-[10px] cqa-leading-[15px]\">\n              <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 3L4.5 8.5L2 6\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"></path></svg>\n              {{ config.statusCode }}\n            </span>\n            <span *ngIf=\"config?.statusCode && config?.statusCode !== 200 && config?.statusCode !== 201\" class=\"cqa-flex cqa-items-center cqa-gap-1.5 cqa-px-1 cqa-py-[2px] cqa-rounded cqa-font-medium cqa-text-[#E7000B] cqa-bg-[#FFE2E2] cqa-text-[10px] cqa-leading-[15px]\">\n              <svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10.5 3.5L3.5 10.5\" stroke=\"#E7000B\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M3.5 3.5L10.5 10.5\" stroke=\"#E7000B\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n              {{ config.statusCode }}\n            </span>\n            <div class=\"cqa-flex cqa-items-center cqa-gap-1.5 cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#636363]\" *ngIf=\"config?.responseTime\">\n              <svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6.99999 12.8334C10.2217 12.8334 12.8333 10.2217 12.8333 7.00008C12.8333 3.77842 10.2217 1.16675 6.99999 1.16675C3.77833 1.16675 1.16666 3.77842 1.16666 7.00008C1.16666 10.2217 3.77833 12.8334 6.99999 12.8334Z\" stroke=\"#636363\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M7 3.5V7L9.33333 8.16667\" stroke=\"#636363\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n              <span>{{ config.responseTime }}ms</span>\n            </div>\n          </div>\n        </div>\n      </div>\n\n      <!-- Request/Response Headers -->\n      <div class=\"cqa-grid cqa-grid-cols-2 cqa-gap-3 cqa-mt-4\" *ngIf=\"config?.requestHeaders || config?.responseHeaders\">\n        <!-- Request Headers -->\n        <div class=\"cqa-bg-[#FCFCFC] cqa-rounded-lg cqa-p-3 cqa-flex cqa-flex-col\" style=\"border: 1px solid #EDE9FE\">\n          <div class=\"cqa-flex cqa-items-center cqa-justify-between cqa-gap-2 cqa-mb-2\">\n            <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#636363]\">Request Headers</span>\n            <div class=\"cqa-relative\">\n              <button (click)=\"copyRequestHeaders()\">\n                <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 4H5C4.44772 4 4 4.44772 4 5V10C4 10.5523 4.44772 11 5 11H10C10.5523 11 11 10.5523 11 10V5C11 4.44772 10.5523 4 10 4Z\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M2 8C1.45 8 1 7.55 1 7V2C1 1.45 1.45 1 2 1H7C7.55 1 8 1.45 8 2\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n              </button>\n              <!-- Copied Tooltip -->\n              <div \n                *ngIf=\"showRequestHeadersCopied\" \n                class=\"cqa-absolute cqa-right-0 cqa-top-full cqa-mt-1 cqa-px-2 cqa-py-1 cqa-bg-[#0B0B0B] cqa-text-white cqa-text-[10px] cqa-rounded cqa-whitespace-nowrap cqa-z-50 cqa-shadow-lg\"\n                style=\"animation: fadeInOut 0.2s ease-in-out;\">\n                Copied\n              </div>\n            </div>\n          </div>\n          <pre *ngIf=\"config.requestHeaders\" class=\"cqa-h-full cqa-text-[12px] cqa-text-[#0B0B0B] cqa-bg-[#F8F8F8] cqa-p-2 cqa-m-0 cqa-rounded cqa-overflow-auto cqa-max-h-[114px] cqa-cursor-pointer\" style=\"scrollbar-width: thin;\" (dblclick)=\"copyJsonPath($event, config.requestHeaders, 'requestHeaders')\">{{ formatJson(config.requestHeaders) }}</pre>\n        </div>\n\n        <!-- Response Headers -->\n        <div class=\"cqa-bg-[#FCFCFC] cqa-rounded-lg cqa-p-3 cqa-flex cqa-flex-col\" style=\"border: 1px solid #EDE9FE\">\n          <div class=\"cqa-flex cqa-items-center cqa-justify-between cqa-mb-2\">\n            <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#636363]\">Response Headers</span>\n            <div class=\"cqa-relative\">\n              <button (click)=\"copyResponseHeaders()\">\n                <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 4H5C4.44772 4 4 4.44772 4 5V10C4 10.5523 4.44772 11 5 11H10C10.5523 11 11 10.5523 11 10V5C11 4.44772 10.5523 4 10 4Z\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M2 8C1.45 8 1 7.55 1 7V2C1 1.45 1.45 1 2 1H7C7.55 1 8 1.45 8 2\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n              </button>\n              <!-- Copied Tooltip -->\n              <div \n                *ngIf=\"showResponseHeadersCopied\" \n                class=\"cqa-absolute cqa-right-0 cqa-top-full cqa-mt-1 cqa-px-2 cqa-py-1 cqa-bg-[#0B0B0B] cqa-text-white cqa-text-[10px] cqa-rounded cqa-whitespace-nowrap cqa-z-50 cqa-shadow-lg\"\n                style=\"animation: fadeInOut 0.2s ease-in-out;\">\n                Copied\n              </div>\n            </div>\n          </div>\n          <pre *ngIf=\"config.responseHeaders\" [ngClass]=\"{'cqa-bg-[#FEF2F2] cqa-text-[#C10007]': config.statusCode >= 400}\" class=\"cqa-h-full cqa-text-[12px] cqa-p-2 cqa-m-0 cqa-rounded cqa-overflow-auto cqa-max-h-[114px] cqa-cursor-pointer\" style=\"scrollbar-width: thin;\" (dblclick)=\"copyJsonPath($event, config.responseHeaders, 'responseHeaders')\">{{ formatJson(config.responseHeaders) }}</pre>\n        </div>\n      </div>\n\n      <!-- Request/Response Bodies -->\n      <div class=\"cqa-grid cqa-grid-cols-2 cqa-gap-3 cqa-mt-4\" *ngIf=\"config?.requestBody || config?.responseBody\">\n        <!-- Request Body -->\n        <div class=\"cqa-bg-[#FCFCFC] cqa-rounded-lg cqa-p-3 cqa-flex cqa-flex-col\" style=\"border: 1px solid #EDE9FE\">\n          <div class=\"cqa-flex cqa-items-center cqa-justify-between cqa-gap-2 cqa-mb-2\">\n            <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#636363]\">Request Body</span>\n            <div class=\"cqa-relative\">\n              <button (click)=\"copyRequestBody()\">\n                <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 4H5C4.44772 4 4 4.44772 4 5V10C4 10.5523 4.44772 11 5 11H10C10.5523 11 11 10.5523 11 10V5C11 4.44772 10.5523 4 10 4Z\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M2 8C1.45 8 1 7.55 1 7V2C1 1.45 1.45 1 2 1H7C7.55 1 8 1.45 8 2\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n              </button>\n              <!-- Copied Tooltip -->\n              <div \n                *ngIf=\"showRequestBodyCopied\" \n                class=\"cqa-absolute cqa-right-0 cqa-top-full cqa-mt-1 cqa-px-2 cqa-py-1 cqa-bg-[#0B0B0B] cqa-text-white cqa-text-[10px] cqa-rounded cqa-whitespace-nowrap cqa-z-50 cqa-shadow-lg\"\n                style=\"animation: fadeInOut 0.2s ease-in-out;\">\n                Copied\n              </div>\n            </div>\n          </div>\n          <pre *ngIf=\"config.requestBody\" class=\"cqa-h-full cqa-text-[12px] cqa-text-[#0B0B0B] cqa-bg-[#F8F8F8] cqa-p-2 cqa-m-0 cqa-rounded cqa-overflow-auto cqa-max-h-[114px] cqa-cursor-pointer\" style=\"scrollbar-width: thin;\" (dblclick)=\"copyJsonPath($event, config.requestBody, 'requestBody')\">{{ formatJson(config.requestBody) }}</pre>\n        </div>\n\n        <!-- Response Body -->\n        <div class=\"cqa-bg-[#FCFCFC] cqa-rounded-lg cqa-p-3 cqa-flex cqa-flex-col\" style=\"border: 1px solid #EDE9FE\">\n          <div class=\"cqa-flex cqa-items-center cqa-justify-between cqa-mb-2\">\n            <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#636363]\">Response Body</span>\n            <div class=\"cqa-relative\">\n              <button (click)=\"copyResponseBody()\">\n                <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 4H5C4.44772 4 4 4.44772 4 5V10C4 10.5523 4.44772 11 5 11H10C10.5523 11 11 10.5523 11 10V5C11 4.44772 10.5523 4 10 4Z\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M2 8C1.45 8 1 7.55 1 7V2C1 1.45 1.45 1 2 1H7C7.55 1 8 1.45 8 2\" stroke=\"#636363\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n              </button>\n              <!-- Copied Tooltip -->\n              <div \n                *ngIf=\"showResponseBodyCopied\" \n                class=\"cqa-absolute cqa-right-0 cqa-top-full cqa-mt-1 cqa-px-2 cqa-py-1 cqa-bg-[#0B0B0B] cqa-text-white cqa-text-[10px] cqa-rounded cqa-whitespace-nowrap cqa-z-50 cqa-shadow-lg\"\n                style=\"animation: fadeInOut 0.2s ease-in-out;\">\n                Copied\n              </div>\n            </div>\n          </div>\n          <pre *ngIf=\"config.responseBody\" [ngClass]=\"{'cqa-bg-[#FEF2F2] cqa-text-[#C10007]': config.statusCode >= 400}\" class=\"cqa-h-full cqa-text-[12px] cqa-p-2 cqa-m-0 cqa-rounded cqa-overflow-auto cqa-max-h-[114px] cqa-cursor-pointer\" style=\"scrollbar-width: thin;\" (dblclick)=\"copyJsonPath($event, config.responseBody, 'responseBody')\">{{ formatJson(config.responseBody) }}</pre>\n        </div>\n      </div>\n\n      <!-- Assertions -->\n      <div *ngIf=\"config.assertions && config.assertions.length > 0\" class=\"cqa-bg-[#FCFCFC] cqa-rounded-lg cqa-p-3 cqa-flex cqa-flex-col cqa-mt-4\" style=\"border: 1px solid #EDE9FE\">\n        <div class=\"cqa-flex cqa-items-center cqa-justify-between cqa-gap-2 cqa-mb-3\">\n          <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#636363]\">Assertions</span>\n          <div class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-text-[10px] cqa-leading-[15px] cqa-font-medium\">\n            <span class=\"cqa-flex cqa-items-center cqa-gap-1 cqa-text-[#00A63E]\">\n              <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 3L4.5 8.5L2 6\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n              {{ getPassedAssertions() }} passed\n            </span>\n            <span class=\"cqa-flex cqa-items-center cqa-gap-1 cqa-text-[#E7000B]\">\n              <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M9 3L3 9\" stroke=\"#E7000B\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M3 3L9 9\" stroke=\"#E7000B\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n              {{ getFailedAssertions() }} failed\n            </span>\n          </div>\n        </div>\n        <div class=\"cqa-flex cqa-flex-col cqa-gap-2\">\n          <div\n            *ngFor=\"let assertion of config.assertions\"\n            class=\"cqa-flex cqa-justify-between cqa-gap-2 cqa-flex-wrap cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#636363] cqa-px-3 cqa-py-1 cqa-rounded-md cqa-items-center\"\n            [ngStyle]=\"{\n                'background-color': assertion.status === 'passed' ? '#ECFDF3' : '#FEF2F2',\n                'border': assertion.status === 'passed'\n                  ? '1px solid #A7F3D0'\n                  : '1px solid #FFC9C9'\n            }\"\n          >\n            <div class=\"cqa-flex-1 cqa-flex cqa-items-center cqa-gap-2\">\n              <div>\n                <!-- Passed -->\n                <ng-container *ngIf=\"assertion.status === 'passed'; else failedIcon\">\n                  <svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"20\" height=\"20\" rx=\"10\" fill=\"#DCFCE7\"/><path d=\"M14 7L8.5 12.5L6 10\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n                </ng-container>\n                \n                <!-- Failed -->\n                <ng-template #failedIcon>\n                  <svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"20\" height=\"20\" rx=\"10\" fill=\"#FFE2E2\"/><path d=\"M13 7L7 13\" stroke=\"#E7000B\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M7 7L13 13\" stroke=\"#E7000B\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n                </ng-template>\n              </div>\n              <div class=\"cqa-text-[12px] cqa-leading-[15px]\" \n                [ngClass]=\"{\n                  'cqa-text-[#9F0712]': assertion.status !== 'passed',\n                  'cqa-text-[#016630]': assertion.status === 'passed'\n                }\"\n              >\n                {{ assertion.description }}\n              </div>\n            </div>\n            <div class=\"cqa-flex cqa-items-center cqa-gap-4 cqa-max-w-[200px]\">\n              <div>\n                <span>Expected:</span>\n                <span style=\"word-break: break-word;\" [ngClass]=\"assertion.status === 'passed' ? 'cqa-text-[#008236]' : 'cqa-text-[#0B0B0B]'\">\n                  {{ assertion.expected }}\n                </span>\n              </div>\n              <div>\n                <span>Actual:</span>\n                <span style=\"word-break: break-word;\" [ngClass]=\"assertion.status === 'passed' ? 'cqa-text-green-600' : 'cqa-text-[#E7000B]'\">\n                  {{ assertion.actual }}\n                </span>\n              </div>\n            </div>\n          </div>\n        </div>\n      </div>\n    </div>\n\n      <!-- Self Heal Analysis -->\n    <cqa-self-heal-analysis \n      *ngIf=\"selfHealAnalysis\" \n      [id]=\"step?.testStepId\"\n      [originalLocator]=\"selfHealAnalysis.originalLocator\"\n      [healedLocator]=\"selfHealAnalysis.healedLocator\"\n      [confidence]=\"selfHealAnalysis.confidence\"\n      [healMethod]=\"selfHealAnalysis.healMethod\"\n      [isLoadingAccept]=\"getSelfHealLoadingStatesHandler ? getSelfHealLoadingStatesHandler().isLoadingAccept?.[step?.testStepId] : false\"\n      [isLoadingModifyAccept]=\"getSelfHealLoadingStatesHandler ? getSelfHealLoadingStatesHandler().isLoadingModifyAccept?.[step?.testStepId] : false\"\n      (action)=\"onSelfHealAction($event)\">\n    </cqa-self-heal-analysis>\n\n    <!-- Timing Breakdown -->\n    <div *ngIf=\"config.timingBreakdown\" class=\"cqa-flex cqa-items-center cqa-justify-end cqa-gap-5 cqa-pt-1.5 cqa-px-4 cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#9CA3AF]\">\n      <div class=\"cqa-flex cqa-items-center cqa-gap-2\">\n        <div><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M6 3V6L8 7\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n        <span>Timing breakdown</span>\n      </div>\n      <span class=\"cqa-text-dialog-muted cqa-flex cqa-items-center cqa-gap-3\">\n        <div>\n          App <span class=\"cqa-text-gray-700\">{{ formatDuration(config.timingBreakdown.app) }}</span>\n        </div>\n        <div><svg width=\"1\" height=\"11\" viewBox=\"0 0 1 11\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M-3.8147e-06 10.32V-7.15256e-07H0.959996V10.32H-3.8147e-06Z\" fill=\"#E5E7EB\"/></svg></div>\n        <div>\n          Tool <span class=\"cqa-text-gray-700\">{{ formatDuration(config.timingBreakdown.tool) }}</span>\n        </div>\n      </span>\n    </div>\n  </div>\n\n  <!-- View More Failed Step Button - shown when expanded and failure details exist -->\n  <div *ngIf=\"showViewMoreButton\" class=\"cqa-mt-2 cqa-px-4\">\n    <cqa-view-more-failed-step-button\n      [timingBreakdown]=\"timingBreakdown\"\n      [subSteps]=\"getSubStepsForFailedStep()\"\n      [failureDetails]=\"failureDetails\"\n      [isExpanded]=\"showFailedStepDetails\"\n      (viewMoreClick)=\"onViewMoreFailedStepClick($event)\">\n    </cqa-view-more-failed-step-button>\n  </div>\n\n  <!-- Updated Failed Step Component - shown when button is clicked -->\n  <div *ngIf=\"showViewMoreButton && showFailedStepDetails && failureDetails\" class=\"cqa-mt-2 cqa-px-4\">\n    <cqa-updated-failed-step\n      [testStepResultId]=\"testStepResultId\"\n      [timingBreakdown]=\"timingBreakdown\"\n      [expanded]=\"true\"\n      [subSteps]=\"getSubStepsForFailedStep()\"\n      [failureDetails]=\"failureDetails\"\n      [reasoning]=\"reasoning\"\n      [confidence]=\"confidence\"\n      [isUploadingBaseline]=\"isUploadingBaseline\"\n      [isMakingCurrentBaseline]=\"isMakingCurrentBaseline\"\n      [isLive]=\"isLive\"\n      (makeCurrentBaseline)=\"onMakeCurrentBaseline($event)\"\n      (uploadBaseline)=\"onUploadBaseline($event)\"\n      (analyze)=\"onAnalyze()\"\n      (viewFullLogs)=\"onViewFullLogs()\">\n    </cqa-updated-failed-step>\n  </div>\n</div>\n"]}