Standardize on using "kind" to distinguish sub-varieties of a type.

runtime/vm/service/service.md

 # Dart VM Service Protocol 0.0
 
 This document describes _version 0.0_ of the Dart VM Service Protocol.
 This protocol is used to communicate with a running Dart Virtual
 Machine.
 
 To use the Service Protocol, start the VM with the *--observe* flag.
 The VM will start a webserver which services protocol requests via WebSocket.
 It is possible to make HTTP (non-WebSocket) requests,
 but this does not allow access to VM _events_ and is not documented
@@ skipping 34 matching lines @@
         - [BoundField](#boundfield)
         - [BoundVariable](#boundvariable)
         - [Breakpoint](#breakpoint)
         - [Class](#class)
         - [ClassList](#classlist)
         - [Code](#code)
         - [CodeKind](#codekind)
         - [Double](#double)
         - [Error](#error)
         - [Event](#event)
-        - [EventType](#eventtype)
+        - [EventKind](#eventkind)
         - [Field](#field)
         - [Flag](#flag)
         - [FlagList](#flaglist)
         - [Frame](#frame)
         - [Function](#function)
         - [Instance](#instance)
         - [Int](#int)
         - [Isolate](#isolate)
         - [Library](#library)
         - [List](#list)
         - [ListElement](#listelement)
         - [Message](#message)
         - [Null](#null)
         - [Object](#object)
         - [Sentinel](#sentinel)
-        - [SentinelType](#sentineltype)
+        - [SentinelKind](#sentinelkind)
         - [Script](#script)
         - [Stack](#stack)
         - [StepOption](#stepoption)
         - [String](#string)
         - [Success](#success)
         - [Type](#type)
         - [TypeArguments](#typearguments)
         - [Response](#response)
         - [Version](#version)
         - [VM](#vm)
@@ skipping 103 matching lines @@
 access to events pertaining to isolate births, deaths, and name changes.  See [streamListen](#streamlisten)
 for a list of the well-known stream ids and their associated events.
 
 Events arrive asynchronously over the WebSocket and always have the
 _streamId_ and _event_ properties:
 
 ```
 {
   "event": {
     "type": "Event",
-    "eventType": "IsolateExit",
+    "kind": "IsolateExit",
     "isolate": {
       "type": "@Isolate",
       "id": "isolates/33",
       "number": "51048743613",
       "name": "worker-isolate"
     }
   }
   "streamId": "Isolate"
 }
 ```
@@ skipping 709 matching lines @@
 - The program has encountered an unhandled exception
 - The program has encountered a syntax error (or another Dart language error)
 - The program has encountered an unhandled erroneous condition in native code
 - The program has been terminated
 
 ### Event
 
 ```
 class Event extends Response {
   // What kind of event is this?
-  EventType eventType;
+  EventKind kind;
 
   // The isolate with which this event is associated.
   @Isolate isolate;
 
   // The breakpoint associated with this event, if applicable.
   //
-  // This is provided for the events:
+  // This is provided for the event kinds:
   //   PauseBreakpoint
   //   BreakpointAdded
   //   BreakpointRemoved
   //   BreakpointResolved
   Breakpoint breakpoint [optional];
 
   // The top stack frame associated with this event, if applicable.
   //
-  // This is provided for the events:
+  // This is provided for the event kinds:
   //   PauseBreakpoint
   //   PauseInterrupted
   //   PauseException
   //
   // For the Resume event, the top frame is provided at
   // all times except for the initial resume event that is delivered
   // when an isolate begins execution.
   Frame topFrame [optional];
 
   // The exception associated with this event, if this is a
   // PauseException event.
   @Instance exception [optional];
 }
 ```
 
 An _Event_ is an asynchronous notification from the VM.  It is delivered
 only when the client has subscribed to an event stream using the
 [streamListen](#streamListen) RPC.
 
 For more information, see [events](#events).
 
-### EventType
+### EventKind
 
 ```
-enum EventType {
+enum EventKind {
   // Notification that a new isolate has started.
   IsolateStart,
 
   // Notification that an isolate has exited.
   IsolateExit,
 
   // Notification that isolate identifying information has changed.
   // Currently used to notify of changes to the isolate debugging name
   // via <code>setName</code>.
   IsolateUpdate,
@@ skipping 23 matching lines @@
   BreakpointResolved,
 
   // A breakpoint has been removed.
   BreakpointRemoved,
 
   // A garbage collection event.
   GC
 }
 ```
 
+Adding new values to _EventKind_ is considered a backwards compatible
+change.  Clients should ignore unrecognized events.
+
 ### Field
 
 ```
 class @Field extends @Object {
   // The name of this field.
   string name;
 
   // The owner of this field, which can be either a Library or a
   // Class.
   @Object owner;
@@ skipping 389 matching lines @@
 }
 ```
 
 An _Object_ is a  persistent object that is owned by some isolate.
 
 ### Sentinel
 
 ```
 class Sentinel extends Response {
   // What kind of sentinel is this?
-  SentinelType sentinelType;
+  SentinelKind kind;
 
   // A reasonable string representation of this sentinel.
   string valueAsString;
 }
 ```
 
 A _Sentinel_ is used to indicate that the normal response is not available.
 
 We use a _Sentinel_ instead of an [error](#errors) for these cases because
 they do not represent a problematic condition.  They are normal.
 
-### SentinelType
+### SentinelKind
 
 ```
-enum SentinelType {
+enum SentinelKind {
   // Indicates that the object referred to has been collected by the GC.
   Collected,
 
   // Indicates that an object id has expired.
   Expired,
 
   // Indicates that a variable or field has not been initialized.
   NotInitialized,
 
   // Indicates that a variable or field is in the process of being initialized.
   BeingInitialized,
 
   // Indicates that a variable has been eliminated by the optimizing compiler.
-  OptimizedOut
+  OptimizedOut,
+
+  // Reserved for future use.
+  Free,
 }
 ```
 
-A _SentinelType_ is used to distinguish different kinds of _Sentinel_ objects.
+A _SentinelKind_ is used to distinguish different kinds of _Sentinel_ objects.
+
+Adding new values to _SentinelKind_ is considered a backwards
+compatible change.  Clients must handle this gracefully.
 
 ### Script
 
 ```
 class @Script extends @Object {
   // The uri from which this script was loaded.
   string uri;
 }
 ```
 
@@ skipping 213 matching lines @@
   // A list of isolates running in the VM.
   @Isolate[] isolates
 }
 ```
 
 ## Revision History
 
 version | comments
 ------- | --------
 0.0 | draft