vscode-debug.log

<- launchResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 2,
  command: 'launch',
  success: true
}
new connection 1
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'started', threadId: 1 }
}
<- initializedEvent
InitializedEvent { seq: 0, type: 'event', event: 'initialized' }
-> setBreakpointsRequest
{
  command: 'setBreakpoints',
  arguments: {
    source: {
      name: 'OrganisationController.php',
      path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
    },
    lines: [ 334 ],
    breakpoints: [ { line: 334 } ],
    sourceModified: false
  },
  type: 'request',
  seq: 3
}
<- setBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 3,
  command: 'setBreakpoints',
  success: true,
  body: {
    breakpoints: [
      {
        verified: false,
        line: 334,
        source: {
          name: 'OrganisationController.php',
          path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
        },
        id: 1
      }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: { reason: 'changed', breakpoint: { id: 1, verified: false } }
}
-> setFunctionBreakpointsRequest
{
  command: 'setFunctionBreakpoints',
  arguments: { breakpoints: [] },
  type: 'request',
  seq: 4
}
<- setFunctionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 4,
  command: 'setFunctionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> setExceptionBreakpointsRequest
{
  command: 'setExceptionBreakpoints',
  arguments: { filters: [] },
  type: 'request',
  seq: 5
}
<- setExceptionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 5,
  command: 'setExceptionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> configurationDoneRequest
{ command: 'configurationDone', type: 'request', seq: 6 }
-> threadsRequest
{ command: 'threads', type: 'request', seq: 7 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 7,
  command: 'threads',
  success: true,
  body: { threads: [ Thread { id: 1, name: 'Request 1 (11:31:34 AM)' } ] }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: {
    reason: 'changed',
    breakpoint: { id: 1, verified: true, line: 335 }
  }
}
new connection 2
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'started', threadId: 2 }
}
<- initializedEvent
InitializedEvent { seq: 0, type: 'event', event: 'initialized' }
-> setBreakpointsRequest
{
  command: 'setBreakpoints',
  arguments: {
    source: {
      name: 'OrganisationController.php',
      path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
    },
    lines: [ 334 ],
    breakpoints: [ { line: 334 } ],
    sourceModified: false
  },
  type: 'request',
  seq: 8
}
<- setBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 8,
  command: 'setBreakpoints',
  success: true,
  body: {
    breakpoints: [
      {
        verified: false,
        line: 334,
        source: {
          name: 'OrganisationController.php',
          path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
        },
        id: 2
      }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: { reason: 'changed', breakpoint: { id: 2, verified: false } }
}
-> setFunctionBreakpointsRequest
{
  command: 'setFunctionBreakpoints',
  arguments: { breakpoints: [] },
  type: 'request',
  seq: 9
}
<- setFunctionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 9,
  command: 'setFunctionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> setExceptionBreakpointsRequest
{
  command: 'setExceptionBreakpoints',
  arguments: { filters: [] },
  type: 'request',
  seq: 10
}
<- setExceptionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 10,
  command: 'setExceptionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> configurationDoneRequest
{ command: 'configurationDone', type: 'request', seq: 11 }
-> threadsRequest
{ command: 'threads', type: 'request', seq: 12 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 12,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 1, name: 'Request 1 (11:31:34 AM)' },
      Thread { id: 2, name: 'Request 2 (11:31:36 AM)' }
    ]
  }
}
<- configurationDoneResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 6,
  command: 'configurationDone',
  success: true
}
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'exited', threadId: 1 }
}
-> threadsRequest
{ command: 'threads', type: 'request', seq: 13 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 13,
  command: 'threads',
  success: true,
  body: { threads: [ Thread { id: 2, name: 'Request 2 (11:31:36 AM)' } ] }
}
new connection 3
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'started', threadId: 3 }
}
<- initializedEvent
InitializedEvent { seq: 0, type: 'event', event: 'initialized' }
-> setBreakpointsRequest
{
  command: 'setBreakpoints',
  arguments: {
    source: {
      name: 'OrganisationController.php',
      path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
    },
    lines: [ 334 ],
    breakpoints: [ { line: 334 } ],
    sourceModified: false
  },
  type: 'request',
  seq: 14
}
<- setBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 14,
  command: 'setBreakpoints',
  success: true,
  body: {
    breakpoints: [
      {
        verified: false,
        line: 334,
        source: {
          name: 'OrganisationController.php',
          path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
        },
        id: 3
      }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: { reason: 'changed', breakpoint: { id: 3, verified: false } }
}
-> setFunctionBreakpointsRequest
{
  command: 'setFunctionBreakpoints',
  arguments: { breakpoints: [] },
  type: 'request',
  seq: 15
}
<- setFunctionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 15,
  command: 'setFunctionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> setExceptionBreakpointsRequest
{
  command: 'setExceptionBreakpoints',
  arguments: { filters: [] },
  type: 'request',
  seq: 16
}
<- setExceptionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 16,
  command: 'setExceptionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> configurationDoneRequest
{ command: 'configurationDone', type: 'request', seq: 17 }
-> threadsRequest
{ command: 'threads', type: 'request', seq: 18 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 18,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 2, name: 'Request 2 (11:31:36 AM)' },
      Thread { id: 3, name: 'Request 3 (11:31:36 AM)' }
    ]
  }
}
new connection 4
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'started', threadId: 4 }
}
<- initializedEvent
InitializedEvent { seq: 0, type: 'event', event: 'initialized' }
-> setBreakpointsRequest
{
  command: 'setBreakpoints',
  arguments: {
    source: {
      name: 'OrganisationController.php',
      path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
    },
    lines: [ 334 ],
    breakpoints: [ { line: 334 } ],
    sourceModified: false
  },
  type: 'request',
  seq: 19
}
<- setBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 19,
  command: 'setBreakpoints',
  success: true,
  body: {
    breakpoints: [
      {
        verified: false,
        line: 334,
        source: {
          name: 'OrganisationController.php',
          path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
        },
        id: 4
      }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: { reason: 'changed', breakpoint: { id: 4, verified: false } }
}
-> setFunctionBreakpointsRequest
{
  command: 'setFunctionBreakpoints',
  arguments: { breakpoints: [] },
  type: 'request',
  seq: 20
}
<- setFunctionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 20,
  command: 'setFunctionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> setExceptionBreakpointsRequest
{
  command: 'setExceptionBreakpoints',
  arguments: { filters: [] },
  type: 'request',
  seq: 21
}
<- setExceptionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 21,
  command: 'setExceptionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> configurationDoneRequest
{ command: 'configurationDone', type: 'request', seq: 22 }
-> threadsRequest
{ command: 'threads', type: 'request', seq: 23 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 23,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 2, name: 'Request 2 (11:31:36 AM)' },
      Thread { id: 3, name: 'Request 3 (11:31:36 AM)' },
      Thread { id: 4, name: 'Request 4 (11:31:37 AM)' }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: {
    reason: 'changed',
    breakpoint: { id: 2, verified: true, line: 335 }
  }
}
<- configurationDoneResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 11,
  command: 'configurationDone',
  success: true
}
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'exited', threadId: 2 }
}
-> threadsRequest
{ command: 'threads', type: 'request', seq: 24 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 24,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 3, name: 'Request 3 (11:31:36 AM)' },
      Thread { id: 4, name: 'Request 4 (11:31:37 AM)' }
    ]
  }
}
new connection 5
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'started', threadId: 5 }
}
<- initializedEvent
InitializedEvent { seq: 0, type: 'event', event: 'initialized' }
-> setBreakpointsRequest
{
  command: 'setBreakpoints',
  arguments: {
    source: {
      name: 'OrganisationController.php',
      path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
    },
    lines: [ 334 ],
    breakpoints: [ { line: 334 } ],
    sourceModified: false
  },
  type: 'request',
  seq: 25
}
<- setBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 25,
  command: 'setBreakpoints',
  success: true,
  body: {
    breakpoints: [
      {
        verified: false,
        line: 334,
        source: {
          name: 'OrganisationController.php',
          path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
        },
        id: 5
      }
    ]
  }
}
-> setFunctionBreakpointsRequest
{
  command: 'setFunctionBreakpoints',
  arguments: { breakpoints: [] },
  type: 'request',
  seq: 26
}
<- setFunctionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 26,
  command: 'setFunctionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: { reason: 'changed', breakpoint: { id: 5, verified: false } }
}
-> setExceptionBreakpointsRequest
{
  command: 'setExceptionBreakpoints',
  arguments: { filters: [] },
  type: 'request',
  seq: 27
}
<- setExceptionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 27,
  command: 'setExceptionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> configurationDoneRequest
{ command: 'configurationDone', type: 'request', seq: 28 }
new connection 6
-> threadsRequest
{ command: 'threads', type: 'request', seq: 29 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 29,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 3, name: 'Request 3 (11:31:36 AM)' },
      Thread { id: 4, name: 'Request 4 (11:31:37 AM)' },
      Thread { id: 5, name: 'Request 5 (11:31:38 AM)' },
      Thread { id: 6, name: 'Request 6 (11:31:38 AM)' }
    ]
  }
}
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'started', threadId: 6 }
}
<- initializedEvent
InitializedEvent { seq: 0, type: 'event', event: 'initialized' }
-> setBreakpointsRequest
{
  command: 'setBreakpoints',
  arguments: {
    source: {
      name: 'OrganisationController.php',
      path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
    },
    lines: [ 334 ],
    breakpoints: [ { line: 334 } ],
    sourceModified: false
  },
  type: 'request',
  seq: 30
}
<- setBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 30,
  command: 'setBreakpoints',
  success: true,
  body: {
    breakpoints: [
      {
        verified: false,
        line: 334,
        source: {
          name: 'OrganisationController.php',
          path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
        },
        id: 6
      }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: { reason: 'changed', breakpoint: { id: 6, verified: false } }
}
-> setFunctionBreakpointsRequest
{
  command: 'setFunctionBreakpoints',
  arguments: { breakpoints: [] },
  type: 'request',
  seq: 31
}
<- setFunctionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 31,
  command: 'setFunctionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> setExceptionBreakpointsRequest
{
  command: 'setExceptionBreakpoints',
  arguments: { filters: [] },
  type: 'request',
  seq: 32
}
<- setExceptionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 32,
  command: 'setExceptionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> configurationDoneRequest
{ command: 'configurationDone', type: 'request', seq: 33 }
-> threadsRequest
{ command: 'threads', type: 'request', seq: 34 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 34,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 3, name: 'Request 3 (11:31:36 AM)' },
      Thread { id: 4, name: 'Request 4 (11:31:37 AM)' },
      Thread { id: 5, name: 'Request 5 (11:31:38 AM)' },
      Thread { id: 6, name: 'Request 6 (11:31:38 AM)' }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: {
    reason: 'changed',
    breakpoint: { id: 3, verified: true, line: 335 }
  }
}
new connection 7
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'started', threadId: 7 }
}
<- initializedEvent
InitializedEvent { seq: 0, type: 'event', event: 'initialized' }
-> setBreakpointsRequest
{
  command: 'setBreakpoints',
  arguments: {
    source: {
      name: 'OrganisationController.php',
      path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
    },
    lines: [ 334 ],
    breakpoints: [ { line: 334 } ],
    sourceModified: false
  },
  type: 'request',
  seq: 35
}
<- setBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 35,
  command: 'setBreakpoints',
  success: true,
  body: {
    breakpoints: [
      {
        verified: false,
        line: 334,
        source: {
          name: 'OrganisationController.php',
          path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
        },
        id: 7
      }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: { reason: 'changed', breakpoint: { id: 7, verified: false } }
}
-> setFunctionBreakpointsRequest
{
  command: 'setFunctionBreakpoints',
  arguments: { breakpoints: [] },
  type: 'request',
  seq: 36
}
<- setFunctionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 36,
  command: 'setFunctionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> setExceptionBreakpointsRequest
{
  command: 'setExceptionBreakpoints',
  arguments: { filters: [] },
  type: 'request',
  seq: 37
}
<- setExceptionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 37,
  command: 'setExceptionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> configurationDoneRequest
{ command: 'configurationDone', type: 'request', seq: 38 }
-> threadsRequest
{ command: 'threads', type: 'request', seq: 39 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 39,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 3, name: 'Request 3 (11:31:36 AM)' },
      Thread { id: 4, name: 'Request 4 (11:31:37 AM)' },
      Thread { id: 5, name: 'Request 5 (11:31:38 AM)' },
      Thread { id: 6, name: 'Request 6 (11:31:38 AM)' },
      Thread { id: 7, name: 'Request 7 (11:31:38 AM)' }
    ]
  }
}
<- configurationDoneResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 17,
  command: 'configurationDone',
  success: true
}
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'exited', threadId: 3 }
}
-> threadsRequest
{ command: 'threads', type: 'request', seq: 40 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 40,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 4, name: 'Request 4 (11:31:37 AM)' },
      Thread { id: 5, name: 'Request 5 (11:31:38 AM)' },
      Thread { id: 6, name: 'Request 6 (11:31:38 AM)' },
      Thread { id: 7, name: 'Request 7 (11:31:38 AM)' }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: {
    reason: 'changed',
    breakpoint: { id: 4, verified: true, line: 335 }
  }
}
new connection 8
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'started', threadId: 8 }
}
<- initializedEvent
InitializedEvent { seq: 0, type: 'event', event: 'initialized' }
-> setBreakpointsRequest
{
  command: 'setBreakpoints',
  arguments: {
    source: {
      name: 'OrganisationController.php',
      path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
    },
    lines: [ 334 ],
    breakpoints: [ { line: 334 } ],
    sourceModified: false
  },
  type: 'request',
  seq: 41
}
<- setBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 41,
  command: 'setBreakpoints',
  success: true,
  body: {
    breakpoints: [
      {
        verified: false,
        line: 334,
        source: {
          name: 'OrganisationController.php',
          path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
        },
        id: 8
      }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: { reason: 'changed', breakpoint: { id: 8, verified: false } }
}
-> setFunctionBreakpointsRequest
{
  command: 'setFunctionBreakpoints',
  arguments: { breakpoints: [] },
  type: 'request',
  seq: 42
}
<- setFunctionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 42,
  command: 'setFunctionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> setExceptionBreakpointsRequest
{
  command: 'setExceptionBreakpoints',
  arguments: { filters: [] },
  type: 'request',
  seq: 43
}
<- setExceptionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 43,
  command: 'setExceptionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> configurationDoneRequest
{ command: 'configurationDone', type: 'request', seq: 44 }
-> threadsRequest
{ command: 'threads', type: 'request', seq: 45 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 45,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 4, name: 'Request 4 (11:31:37 AM)' },
      Thread { id: 5, name: 'Request 5 (11:31:38 AM)' },
      Thread { id: 6, name: 'Request 6 (11:31:38 AM)' },
      Thread { id: 7, name: 'Request 7 (11:31:38 AM)' },
      Thread { id: 8, name: 'Request 8 (11:31:39 AM)' }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: {
    reason: 'changed',
    breakpoint: { id: 7, verified: true, line: 335 }
  }
}
new connection 9
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'started', threadId: 9 }
}
<- initializedEvent
InitializedEvent { seq: 0, type: 'event', event: 'initialized' }
-> setBreakpointsRequest
{
  command: 'setBreakpoints',
  arguments: {
    source: {
      name: 'OrganisationController.php',
      path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
    },
    lines: [ 334 ],
    breakpoints: [ { line: 334 } ],
    sourceModified: false
  },
  type: 'request',
  seq: 46
}
<- setBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 46,
  command: 'setBreakpoints',
  success: true,
  body: {
    breakpoints: [
      {
        verified: false,
        line: 334,
        source: {
          name: 'OrganisationController.php',
          path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
        },
        id: 9
      }
    ]
  }
}
-> setFunctionBreakpointsRequest
{
  command: 'setFunctionBreakpoints',
  arguments: { breakpoints: [] },
  type: 'request',
  seq: 47
}
<- setFunctionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 47,
  command: 'setFunctionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> setExceptionBreakpointsRequest
{
  command: 'setExceptionBreakpoints',
  arguments: { filters: [] },
  type: 'request',
  seq: 48
}
<- setExceptionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 48,
  command: 'setExceptionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> configurationDoneRequest
{ command: 'configurationDone', type: 'request', seq: 49 }
-> threadsRequest
{ command: 'threads', type: 'request', seq: 50 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 50,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 4, name: 'Request 4 (11:31:37 AM)' },
      Thread { id: 5, name: 'Request 5 (11:31:38 AM)' },
      Thread { id: 6, name: 'Request 6 (11:31:38 AM)' },
      Thread { id: 7, name: 'Request 7 (11:31:38 AM)' },
      Thread { id: 8, name: 'Request 8 (11:31:39 AM)' },
      Thread { id: 9, name: 'Request 9 (11:31:40 AM)' }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: { reason: 'changed', breakpoint: { id: 9, verified: false } }
}
new connection 10
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'started', threadId: 10 }
}
<- initializedEvent
InitializedEvent { seq: 0, type: 'event', event: 'initialized' }
-> setBreakpointsRequest
{
  command: 'setBreakpoints',
  arguments: {
    source: {
      name: 'OrganisationController.php',
      path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
    },
    lines: [ 334 ],
    breakpoints: [ { line: 334 } ],
    sourceModified: false
  },
  type: 'request',
  seq: 51
}
<- setBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 51,
  command: 'setBreakpoints',
  success: true,
  body: {
    breakpoints: [
      {
        verified: false,
        line: 334,
        source: {
          name: 'OrganisationController.php',
          path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
        },
        id: 10
      }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: { reason: 'changed', breakpoint: { id: 10, verified: false } }
}
-> setFunctionBreakpointsRequest
{
  command: 'setFunctionBreakpoints',
  arguments: { breakpoints: [] },
  type: 'request',
  seq: 52
}
<- setFunctionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 52,
  command: 'setFunctionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> setExceptionBreakpointsRequest
{
  command: 'setExceptionBreakpoints',
  arguments: { filters: [] },
  type: 'request',
  seq: 53
}
<- setExceptionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 53,
  command: 'setExceptionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> configurationDoneRequest
{ command: 'configurationDone', type: 'request', seq: 54 }
-> threadsRequest
{ command: 'threads', type: 'request', seq: 55 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 55,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 4, name: 'Request 4 (11:31:37 AM)' },
      Thread { id: 5, name: 'Request 5 (11:31:38 AM)' },
      Thread { id: 6, name: 'Request 6 (11:31:38 AM)' },
      Thread { id: 7, name: 'Request 7 (11:31:38 AM)' },
      Thread { id: 8, name: 'Request 8 (11:31:39 AM)' },
      Thread { id: 9, name: 'Request 9 (11:31:40 AM)' },
      Thread { id: 10, name: 'Request 10 (11:31:41 AM)' }
    ]
  }
}
<- configurationDoneResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 22,
  command: 'configurationDone',
  success: true
}
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'exited', threadId: 4 }
}
-> threadsRequest
{ command: 'threads', type: 'request', seq: 56 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 56,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 5, name: 'Request 5 (11:31:38 AM)' },
      Thread { id: 6, name: 'Request 6 (11:31:38 AM)' },
      Thread { id: 7, name: 'Request 7 (11:31:38 AM)' },
      Thread { id: 8, name: 'Request 8 (11:31:39 AM)' },
      Thread { id: 9, name: 'Request 9 (11:31:40 AM)' },
      Thread { id: 10, name: 'Request 10 (11:31:41 AM)' }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: {
    reason: 'changed',
    breakpoint: { id: 6, verified: true, line: 335 }
  }
}
new connection 11
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'started', threadId: 11 }
}
<- initializedEvent
InitializedEvent { seq: 0, type: 'event', event: 'initialized' }
-> setBreakpointsRequest
{
  command: 'setBreakpoints',
  arguments: {
    source: {
      name: 'OrganisationController.php',
      path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
    },
    lines: [ 334 ],
    breakpoints: [ { line: 334 } ],
    sourceModified: false
  },
  type: 'request',
  seq: 57
}
<- setBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 57,
  command: 'setBreakpoints',
  success: true,
  body: {
    breakpoints: [
      {
        verified: false,
        line: 334,
        source: {
          name: 'OrganisationController.php',
          path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
        },
        id: 11
      }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: { reason: 'changed', breakpoint: { id: 11, verified: false } }
}
-> setFunctionBreakpointsRequest
{
  command: 'setFunctionBreakpoints',
  arguments: { breakpoints: [] },
  type: 'request',
  seq: 58
}
<- setFunctionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 58,
  command: 'setFunctionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> setExceptionBreakpointsRequest
{
  command: 'setExceptionBreakpoints',
  arguments: { filters: [] },
  type: 'request',
  seq: 59
}
<- setExceptionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 59,
  command: 'setExceptionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> configurationDoneRequest
{ command: 'configurationDone', type: 'request', seq: 60 }
-> threadsRequest
{ command: 'threads', type: 'request', seq: 61 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 61,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 5, name: 'Request 5 (11:31:38 AM)' },
      Thread { id: 6, name: 'Request 6 (11:31:38 AM)' },
      Thread { id: 7, name: 'Request 7 (11:31:38 AM)' },
      Thread { id: 8, name: 'Request 8 (11:31:39 AM)' },
      Thread { id: 9, name: 'Request 9 (11:31:40 AM)' },
      Thread { id: 10, name: 'Request 10 (11:31:41 AM)' },
      Thread { id: 11, name: 'Request 11 (11:31:42 AM)' }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: {
    reason: 'changed',
    breakpoint: { id: 5, verified: true, line: 335 }
  }
}
<- configurationDoneResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 38,
  command: 'configurationDone',
  success: true
}
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'exited', threadId: 7 }
}
-> threadsRequest
{ command: 'threads', type: 'request', seq: 62 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 62,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 5, name: 'Request 5 (11:31:38 AM)' },
      Thread { id: 6, name: 'Request 6 (11:31:38 AM)' },
      Thread { id: 8, name: 'Request 8 (11:31:39 AM)' },
      Thread { id: 9, name: 'Request 9 (11:31:40 AM)' },
      Thread { id: 10, name: 'Request 10 (11:31:41 AM)' },
      Thread { id: 11, name: 'Request 11 (11:31:42 AM)' }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: {
    reason: 'changed',
    breakpoint: { id: 10, verified: true, line: 335 }
  }
}
new connection 12
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'started', threadId: 12 }
}
<- initializedEvent
InitializedEvent { seq: 0, type: 'event', event: 'initialized' }
-> setBreakpointsRequest
{
  command: 'setBreakpoints',
  arguments: {
    source: {
      name: 'OrganisationController.php',
      path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
    },
    lines: [ 334 ],
    breakpoints: [ { line: 334 } ],
    sourceModified: false
  },
  type: 'request',
  seq: 63
}
<- setBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 63,
  command: 'setBreakpoints',
  success: true,
  body: {
    breakpoints: [
      {
        verified: false,
        line: 334,
        source: {
          name: 'OrganisationController.php',
          path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
        },
        id: 12
      }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: { reason: 'changed', breakpoint: { id: 12, verified: false } }
}
-> setFunctionBreakpointsRequest
{
  command: 'setFunctionBreakpoints',
  arguments: { breakpoints: [] },
  type: 'request',
  seq: 64
}
<- setFunctionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 64,
  command: 'setFunctionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> setExceptionBreakpointsRequest
{
  command: 'setExceptionBreakpoints',
  arguments: { filters: [] },
  type: 'request',
  seq: 65
}
<- setExceptionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 65,
  command: 'setExceptionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> configurationDoneRequest
{ command: 'configurationDone', type: 'request', seq: 66 }
-> threadsRequest
{ command: 'threads', type: 'request', seq: 67 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 67,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 5, name: 'Request 5 (11:31:38 AM)' },
      Thread { id: 6, name: 'Request 6 (11:31:38 AM)' },
      Thread { id: 8, name: 'Request 8 (11:31:39 AM)' },
      Thread { id: 9, name: 'Request 9 (11:31:40 AM)' },
      Thread { id: 10, name: 'Request 10 (11:31:41 AM)' },
      Thread { id: 11, name: 'Request 11 (11:31:42 AM)' },
      Thread { id: 12, name: 'Request 12 (11:31:43 AM)' }
    ]
  }
}
<- configurationDoneResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 33,
  command: 'configurationDone',
  success: true
}
-> threadsRequest
{ command: 'threads', type: 'request', seq: 68 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 68,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 5, name: 'Request 5 (11:31:38 AM)' },
      Thread { id: 6, name: 'Request 6 (11:31:38 AM)' },
      Thread { id: 8, name: 'Request 8 (11:31:39 AM)' },
      Thread { id: 9, name: 'Request 9 (11:31:40 AM)' },
      Thread { id: 10, name: 'Request 10 (11:31:41 AM)' },
      Thread { id: 11, name: 'Request 11 (11:31:42 AM)' },
      Thread { id: 12, name: 'Request 12 (11:31:43 AM)' }
    ]
  }
}
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'exited', threadId: 6 }
}
<- configurationDoneResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 28,
  command: 'configurationDone',
  success: true
}
-> threadsRequest
{ command: 'threads', type: 'request', seq: 69 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 69,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 5, name: 'Request 5 (11:31:38 AM)' },
      Thread { id: 8, name: 'Request 8 (11:31:39 AM)' },
      Thread { id: 9, name: 'Request 9 (11:31:40 AM)' },
      Thread { id: 10, name: 'Request 10 (11:31:41 AM)' },
      Thread { id: 11, name: 'Request 11 (11:31:42 AM)' },
      Thread { id: 12, name: 'Request 12 (11:31:43 AM)' }
    ]
  }
}
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'exited', threadId: 5 }
}
<- configurationDoneResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 54,
  command: 'configurationDone',
  success: true
}
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'exited', threadId: 10 }
}
-> threadsRequest
{ command: 'threads', type: 'request', seq: 70 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 70,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 8, name: 'Request 8 (11:31:39 AM)' },
      Thread { id: 9, name: 'Request 9 (11:31:40 AM)' },
      Thread { id: 11, name: 'Request 11 (11:31:42 AM)' },
      Thread { id: 12, name: 'Request 12 (11:31:43 AM)' }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: {
    reason: 'changed',
    breakpoint: { id: 8, verified: true, line: 335 }
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: {
    reason: 'changed',
    breakpoint: { id: 11, verified: true, line: 335 }
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: {
    reason: 'changed',
    breakpoint: { id: 9, verified: true, line: 335 }
  }
}
<- configurationDoneResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 44,
  command: 'configurationDone',
  success: true
}
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'exited', threadId: 8 }
}
-> threadsRequest
{ command: 'threads', type: 'request', seq: 71 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 71,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 9, name: 'Request 9 (11:31:40 AM)' },
      Thread { id: 11, name: 'Request 11 (11:31:42 AM)' },
      Thread { id: 12, name: 'Request 12 (11:31:43 AM)' }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: {
    reason: 'changed',
    breakpoint: { id: 12, verified: true, line: 335 }
  }
}
<- configurationDoneResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 60,
  command: 'configurationDone',
  success: true
}
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'exited', threadId: 11 }
}
-> threadsRequest
{ command: 'threads', type: 'request', seq: 72 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 72,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 9, name: 'Request 9 (11:31:40 AM)' },
      Thread { id: 12, name: 'Request 12 (11:31:43 AM)' }
    ]
  }
}
<- configurationDoneResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 49,
  command: 'configurationDone',
  success: true
}
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'exited', threadId: 9 }
}
-> threadsRequest
{ command: 'threads', type: 'request', seq: 73 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 73,
  command: 'threads',
  success: true,
  body: { threads: [ Thread { id: 12, name: 'Request 12 (11:31:43 AM)' } ] }
}
new connection 13
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'started', threadId: 13 }
}
<- initializedEvent
InitializedEvent { seq: 0, type: 'event', event: 'initialized' }
-> setBreakpointsRequest
{
  command: 'setBreakpoints',
  arguments: {
    source: {
      name: 'OrganisationController.php',
      path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
    },
    lines: [ 334 ],
    breakpoints: [ { line: 334 } ],
    sourceModified: false
  },
  type: 'request',
  seq: 74
}
<- setBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 74,
  command: 'setBreakpoints',
  success: true,
  body: {
    breakpoints: [
      {
        verified: false,
        line: 334,
        source: {
          name: 'OrganisationController.php',
          path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
        },
        id: 13
      }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: { reason: 'changed', breakpoint: { id: 13, verified: false } }
}
-> setFunctionBreakpointsRequest
{
  command: 'setFunctionBreakpoints',
  arguments: { breakpoints: [] },
  type: 'request',
  seq: 75
}
<- setFunctionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 75,
  command: 'setFunctionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> setExceptionBreakpointsRequest
{
  command: 'setExceptionBreakpoints',
  arguments: { filters: [] },
  type: 'request',
  seq: 76
}
<- setExceptionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 76,
  command: 'setExceptionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> configurationDoneRequest
{ command: 'configurationDone', type: 'request', seq: 77 }
-> threadsRequest
{ command: 'threads', type: 'request', seq: 78 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 78,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 12, name: 'Request 12 (11:31:43 AM)' },
      Thread { id: 13, name: 'Request 13 (11:31:46 AM)' }
    ]
  }
}
new connection 14
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'started', threadId: 14 }
}
<- initializedEvent
InitializedEvent { seq: 0, type: 'event', event: 'initialized' }
-> setBreakpointsRequest
{
  command: 'setBreakpoints',
  arguments: {
    source: {
      name: 'OrganisationController.php',
      path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
    },
    lines: [ 334 ],
    breakpoints: [ { line: 334 } ],
    sourceModified: false
  },
  type: 'request',
  seq: 79
}
<- setBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 79,
  command: 'setBreakpoints',
  success: true,
  body: {
    breakpoints: [
      {
        verified: false,
        line: 334,
        source: {
          name: 'OrganisationController.php',
          path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
        },
        id: 14
      }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: { reason: 'changed', breakpoint: { id: 14, verified: false } }
}
new connection 15
-> setFunctionBreakpointsRequest
{
  command: 'setFunctionBreakpoints',
  arguments: { breakpoints: [] },
  type: 'request',
  seq: 80
}
<- setFunctionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 80,
  command: 'setFunctionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> setExceptionBreakpointsRequest
{
  command: 'setExceptionBreakpoints',
  arguments: { filters: [] },
  type: 'request',
  seq: 81
}
<- setExceptionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 81,
  command: 'setExceptionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> configurationDoneRequest
{ command: 'configurationDone', type: 'request', seq: 82 }
-> threadsRequest
{ command: 'threads', type: 'request', seq: 83 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 83,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 12, name: 'Request 12 (11:31:43 AM)' },
      Thread { id: 13, name: 'Request 13 (11:31:46 AM)' },
      Thread { id: 14, name: 'Request 14 (11:31:47 AM)' },
      Thread { id: 15, name: 'Request 15 (11:31:47 AM)' }
    ]
  }
}
<- configurationDoneResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 66,
  command: 'configurationDone',
  success: true
}
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'exited', threadId: 12 }
}
-> threadsRequest
{ command: 'threads', type: 'request', seq: 84 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 84,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 13, name: 'Request 13 (11:31:46 AM)' },
      Thread { id: 14, name: 'Request 14 (11:31:47 AM)' },
      Thread { id: 15, name: 'Request 15 (11:31:47 AM)' }
    ]
  }
}
new connection 16
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'started', threadId: 16 }
}
<- initializedEvent
InitializedEvent { seq: 0, type: 'event', event: 'initialized' }
-> setBreakpointsRequest
{
  command: 'setBreakpoints',
  arguments: {
    source: {
      name: 'OrganisationController.php',
      path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
    },
    lines: [ 334 ],
    breakpoints: [ { line: 334 } ],
    sourceModified: false
  },
  type: 'request',
  seq: 85
}
<- setBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 85,
  command: 'setBreakpoints',
  success: true,
  body: {
    breakpoints: [
      {
        verified: false,
        line: 334,
        source: {
          name: 'OrganisationController.php',
          path: '/Users/nickjanssen/Documents/wordpress/visuade_app/wp-content/plugins/flux-app/includes/Controllers/OrganisationController.php'
        },
        id: 15
      }
    ]
  }
}
<- breakpointEvent
BreakpointEvent {
  seq: 0,
  type: 'event',
  event: 'breakpoint',
  body: { reason: 'changed', breakpoint: { id: 15, verified: false } }
}
-> setFunctionBreakpointsRequest
{
  command: 'setFunctionBreakpoints',
  arguments: { breakpoints: [] },
  type: 'request',
  seq: 86
}
<- setFunctionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 86,
  command: 'setFunctionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> setExceptionBreakpointsRequest
{
  command: 'setExceptionBreakpoints',
  arguments: { filters: [] },
  type: 'request',
  seq: 87
}
<- setExceptionBreakpointsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 87,
  command: 'setExceptionBreakpoints',
  success: true,
  body: { breakpoints: [] }
}
-> configurationDoneRequest
{ command: 'configurationDone', type: 'request', seq: 88 }
-> threadsRequest
{ command: 'threads', type: 'request', seq: 89 }
<- threadsResponse
Response {
  seq: 0,
  type: 'response',
  request_seq: 89,
  command: 'threads',
  success: true,
  body: {
    threads: [
      Thread { id: 13, name: 'Request 13 (11:31:46 AM)' },
      Thread { id: 14, name: 'Request 14 (11:31:47 AM)' },
      Thread { id: 15, name: 'Request 15 (11:31:47 AM)' },
      Thread { id: 16, name: 'Request 16 (11:31:47 AM)' }
    ]
  }
}
<- outputEvent
OutputEvent {
  seq: 0,
  type: 'event',
  event: 'output',
  body: { category: 'stderr', output: 'command is not available\n' }
}
command is not available
<- outputEvent
OutputEvent {
  seq: 0,
  type: 'event',
  event: 'output',
  body: { category: 'console', output: 'connection 15 closed\n' }
}
connection 15 closed
<- continuedEvent
ContinuedEvent {
  seq: 0,
  type: 'event',
  event: 'continued',
  body: { threadId: 15, allThreadsContinued: false }
}
<- threadEvent
ThreadEvent {
  seq: 0,
  type: 'event',
  event: 'thread',
  body: { reason: 'exited', threadId: 15 }
}