diff --git a/garnet/bin/sysmgr/config/services.config b/garnet/bin/sysmgr/config/services.config
index 3c4258f..f482356 100644
--- a/garnet/bin/sysmgr/config/services.config
+++ b/garnet/bin/sysmgr/config/services.config
@@ -59,6 +59,7 @@
     "fuchsia.ui.input.InputDeviceRegistry": "fuchsia-pkg://fuchsia.com/root_presenter#meta/root_presenter.cmx",
     "fuchsia.ui.policy.Presenter": "fuchsia-pkg://fuchsia.com/root_presenter#meta/root_presenter.cmx",
     "fuchsia.ui.scenic.Scenic": "fuchsia-pkg://fuchsia.com/scenic#meta/scenic.cmx",
+    "fuchsia.ui.text.TextInputContext": "fuchsia-pkg://fuchsia.com/ime_service#meta/ime_service.cmx",
     "fuchsia.ui.sketchy.Canvas": "fuchsia-pkg://fuchsia.com/sketchy_service#meta/sketchy_service.cmx",
     "fuchsia.ui.viewsv1.ViewManager": "fuchsia-pkg://fuchsia.com/view_manager#meta/view_manager.cmx",
     "fuchsia.ui.viewsv1.ViewSnapshot": "fuchsia-pkg://fuchsia.com/view_manager#meta/view_manager.cmx",
diff --git a/garnet/bin/ui/BUILD.gn b/garnet/bin/ui/BUILD.gn
index 2b83e31..b72037e 100644
--- a/garnet/bin/ui/BUILD.gn
+++ b/garnet/bin/ui/BUILD.gn
@@ -165,6 +165,7 @@
 test_package("ime_service_tests") {
   deps = [
     "ime",
+    "//garnet/bin/ui/text/test_suite:test_suite",
   ]
 
   tests = [
diff --git a/garnet/bin/ui/ime/BUILD.gn b/garnet/bin/ui/ime/BUILD.gn
index 72c6462..f4140b6 100644
--- a/garnet/bin/ui/ime/BUILD.gn
+++ b/garnet/bin/ui/ime/BUILD.gn
@@ -10,13 +10,14 @@
   edition = "2018"
 
   deps = [
-    "//sdk/fidl/fuchsia.ui.input:fuchsia.ui.input-rustc",
-    "//sdk/fidl/fuchsia.ui.text:fuchsia.ui.text-rustc",
     "//garnet/public/lib/fidl/rust/fidl",
     "//garnet/public/rust/fuchsia-app",
     "//garnet/public/rust/fuchsia-async",
     "//garnet/public/rust/fuchsia-syslog",
     "//garnet/public/rust/fuchsia-zircon",
+    "//sdk/fidl/fuchsia.ui.input:fuchsia.ui.input-rustc",
+    "//sdk/fidl/fuchsia.ui.text:fuchsia.ui.text-rustc",
+    "//sdk/fidl/fuchsia.ui.text.testing:fuchsia.ui.text.testing-rustc",
     "//third_party/rust_crates:failure",
     "//third_party/rust_crates:futures-preview",
     "//third_party/rust_crates:lazy_static",
diff --git a/garnet/bin/ui/ime/src/ime.rs b/garnet/bin/ui/ime/src/ime.rs
index 92d22048..6b6cdb1 100644
--- a/garnet/bin/ui/ime/src/ime.rs
+++ b/garnet/bin/ui/ime/src/ime.rs
@@ -8,12 +8,14 @@
 use fidl::endpoints::RequestStream;
 use fidl_fuchsia_ui_input as uii;
 use fidl_fuchsia_ui_input::InputMethodEditorRequest as ImeReq;
+use fidl_fuchsia_ui_text as txt;
 use fuchsia_syslog::{fx_log_err, fx_log_warn};
 use futures::prelude::*;
 use lazy_static::lazy_static;
 use parking_lot::Mutex;
 use regex::Regex;
 use std::char;
+use std::collections::HashMap;
 use std::ops::Range;
 use std::sync::{Arc, Weak};
 use unicode_segmentation::{GraphemeCursor, UnicodeSegmentation};
@@ -29,10 +31,38 @@
 /// so it can be accessed from multiple places.
 pub struct ImeState {
     text_state: uii::TextInputState,
+
+    /// A handle to call methods on the text field.
     client: Box<uii::InputMethodEditorClientProxyInterface>,
+
     keyboard_type: uii::KeyboardType,
     action: uii::InputMethodAction,
     ime_service: ImeService,
+
+    /// We expose a TextField interface to an input method. There are also legacy
+    /// input methods that just send key events through inject_input — in this case,
+    /// input_method would be None, and these events would be handled by the
+    /// inject_input method. ImeState can only handle talking to one input_method
+    /// at a time; it's the responsibility of some other code (likely inside
+    /// ImeService) to multiplex multiple TextField interfaces into this one.
+    input_method: Option<txt::TextFieldControlHandle>,
+
+    /// A number used to serve the TextField interface. It increments any time any
+    /// party makes a change to the state.
+    revision: u64,
+
+    /// A TextPoint is a u64 token that represents a character position in the new
+    /// TextField interface. Each token is a unique ID; this represents the ID we
+    /// will assign to the next TextPoint that is created. It increments every time
+    /// a TextPoint is created. This is never reset, even when TextPoints are
+    /// invalidated; TextPoints have globally unique IDs.
+    next_text_point_id: u64,
+
+    /// A TextPoint is a u64 token that represents a character position in the new
+    /// TextField interface. This maps TextPoint IDs to byte indexes inside
+    /// `text_state.text`. When a new revision is created, all preexisting TextPoints
+    /// are deleted, which means we clear this out.
+    text_points: HashMap<u64, usize>,
 }
 
 /// A service that talks to a text field, providing it edits and cursor state updates
@@ -54,6 +84,10 @@
             keyboard_type,
             action,
             ime_service,
+            revision: 0,
+            next_text_point_id: 0,
+            text_points: HashMap::new(),
+            input_method: None,
         };
         Ime(Arc::new(Mutex::new(state)))
     }
@@ -66,6 +100,33 @@
         weak.upgrade().map(|arc| Ime(arc))
     }
 
+    pub fn bind_text_field(&self, mut stream: txt::TextFieldRequestStream) {
+        let control_handle = stream.control_handle();
+        {
+            let mut state = self.0.lock();
+            let res = control_handle.send_on_update(&mut state.as_text_field_state());
+            if let Err(e) = res {
+                fx_log_err!("{}", e);
+            } else {
+                state.input_method = Some(control_handle);
+            }
+        }
+        let self_clone = self.clone();
+        fuchsia_async::spawn(
+            async move {
+                while let Some(msg) = await!(stream.try_next())
+                    .context("error reading value from text field request stream")?
+                {
+                    if let Err(e) = self_clone.handle_text_field_msg(msg) {
+                        fx_log_err!("Error when replying to TextFieldRequest: {}", e);
+                    }
+                }
+                Ok(())
+            }
+                .unwrap_or_else(|e: failure::Error| fx_log_err!("{:?}", e)),
+        );
+    }
+
     pub fn bind_ime(&self, chan: fuchsia_async::Channel) {
         let self_clone = self.clone();
         let self_clone_2 = self.clone();
@@ -75,28 +136,7 @@
                 while let Some(msg) = await!(stream.try_next())
                     .context("error reading value from IME request stream")?
                 {
-                    match msg {
-                        ImeReq::SetKeyboardType { keyboard_type, .. } => {
-                            let mut state = self_clone.0.lock();
-                            state.keyboard_type = keyboard_type;
-                        }
-                        ImeReq::SetState { state, .. } => {
-                            self_clone.set_state(state);
-                        }
-                        ImeReq::InjectInput { event, .. } => {
-                            self_clone.inject_input(event);
-                        }
-                        ImeReq::Show { .. } => {
-                            // clone to ensure we only hold one lock at a time
-                            let ime_service = self_clone.0.lock().ime_service.clone();
-                            ime_service.show_keyboard();
-                        }
-                        ImeReq::Hide { .. } => {
-                            // clone to ensure we only hold one lock at a time
-                            let ime_service = self_clone.0.lock().ime_service.clone();
-                            ime_service.hide_keyboard();
-                        }
-                    }
+                    self_clone.handle_ime_message(msg);
                 }
                 Ok(())
             }
@@ -110,9 +150,65 @@
         );
     }
 
+    /// Handles a TextFieldRequest, returning a FIDL error if one occurred when sending a reply.
+    // TODO(lard): finish implementation
+    fn handle_text_field_msg(&self, msg: txt::TextFieldRequest) -> Result<(), fidl::Error> {
+        match msg {
+            txt::TextFieldRequest::PointOffset { responder, .. } => {
+                return responder.send(&mut txt::TextPoint { id: 0 }, txt::TextError::BadRequest);
+            }
+            txt::TextFieldRequest::Distance { responder, .. } => {
+                return responder.send(0, txt::TextError::BadRequest);
+            }
+            txt::TextFieldRequest::Contents { responder, .. } => {
+                return responder.send(
+                    "",
+                    &mut txt::TextPoint { id: 0 },
+                    txt::TextError::BadRequest,
+                );
+            }
+            txt::TextFieldRequest::CommitEdit { responder, .. } => {
+                return responder.send(txt::TextError::BadRequest);
+            }
+            // other cases don't have a responder, so we can just ignore in this temporary code
+            // instead of replying with an error.
+            _ => {
+                return Ok(());
+            }
+        }
+    }
+
+    /// Handles a request from the legancy IME API, an InputMethodEditorRequest.
+    fn handle_ime_message(&self, msg: uii::InputMethodEditorRequest) {
+        match msg {
+            ImeReq::SetKeyboardType { keyboard_type, .. } => {
+                let mut state = self.0.lock();
+                state.keyboard_type = keyboard_type;
+            }
+            ImeReq::SetState { state, .. } => {
+                self.set_state(state);
+            }
+            ImeReq::InjectInput { event, .. } => {
+                self.inject_input(event);
+            }
+            ImeReq::Show { .. } => {
+                // clone to ensure we only hold one lock at a time
+                let ime_service = self.0.lock().ime_service.clone();
+                ime_service.show_keyboard();
+            }
+            ImeReq::Hide { .. } => {
+                // clone to ensure we only hold one lock at a time
+                let ime_service = self.0.lock().ime_service.clone();
+                ime_service.hide_keyboard();
+            }
+        }
+    }
+
     fn set_state(&self, input_state: uii::TextInputState) {
-        self.0.lock().text_state = input_state;
-        // the old C++ IME implementation didn't call did_update_state here, so we won't either.
+        let mut state = self.0.lock();
+        state.text_state = input_state;
+        // the old C++ IME implementation didn't call did_update_state here, so this second argument is false.
+        state.increment_revision(None, false);
     }
 
     pub fn inject_input(&self, event: uii::InputEvent) {
@@ -127,24 +223,24 @@
         {
             if keyboard_event.code_point != 0 {
                 state.type_keycode(keyboard_event.code_point);
-                state.did_update_state(keyboard_event)
+                state.increment_revision(Some(keyboard_event), true)
             } else {
                 match keyboard_event.hid_usage {
                     HID_USAGE_KEY_BACKSPACE => {
                         state.delete_backward();
-                        state.did_update_state(keyboard_event);
+                        state.increment_revision(Some(keyboard_event), true);
                     }
                     HID_USAGE_KEY_DELETE => {
                         state.delete_forward();
-                        state.did_update_state(keyboard_event);
+                        state.increment_revision(Some(keyboard_event), true);
                     }
                     HID_USAGE_KEY_LEFT => {
                         state.cursor_horizontal_move(keyboard_event.modifiers, false);
-                        state.did_update_state(keyboard_event);
+                        state.increment_revision(Some(keyboard_event), true);
                     }
                     HID_USAGE_KEY_RIGHT => {
                         state.cursor_horizontal_move(keyboard_event.modifiers, true);
-                        state.did_update_state(keyboard_event);
+                        state.increment_revision(Some(keyboard_event), true);
                     }
                     HID_USAGE_KEY_ENTER => {
                         state.client.on_action(state.action).unwrap_or_else(|e| {
@@ -153,7 +249,7 @@
                     }
                     _ => {
                         // Not an editing key, forward the event to clients.
-                        state.did_update_state(keyboard_event);
+                        state.increment_revision(Some(keyboard_event), true);
                     }
                 }
             }
@@ -191,13 +287,85 @@
 }
 
 impl ImeState {
-    pub fn did_update_state(&mut self, e: uii::KeyboardEvent) {
-        self.client
-            .did_update_state(
-                &mut self.text_state,
-                Some(OutOfLine(&mut uii::InputEvent::Keyboard(e))),
-            )
-            .unwrap_or_else(|e| fx_log_warn!("error sending state update to ImeClient: {:?}", e));
+    /// Any time the state is updated, this method is called, which allows ImeState to inform any
+    /// listening clients (either TextField or InputMethodEditorClientProxy) that state has updated.
+    /// If InputMethodEditorClient caused the update with SetState, set call_did_update_state so that
+    /// we don't send its own edit back to it. Otherwise, set to true.
+    pub fn increment_revision(
+        &mut self,
+        e: Option<uii::KeyboardEvent>,
+        call_did_update_state: bool,
+    ) {
+        self.revision += 1;
+        self.text_points = HashMap::new();
+        let mut state = self.as_text_field_state();
+        if let Some(input_method) = &self.input_method {
+            if let Err(e) = input_method.send_on_update(&mut state) {
+                fx_log_err!("error when sending update to TextField listener: {}", e);
+            }
+        }
+
+        if call_did_update_state {
+            if let Some(ev) = e {
+                self.client
+                    .did_update_state(
+                        &mut self.text_state,
+                        Some(OutOfLine(&mut uii::InputEvent::Keyboard(ev))),
+                    )
+                    .unwrap_or_else(|e| {
+                        fx_log_warn!("error sending state update to ImeClient: {:?}", e)
+                    });
+            } else {
+                self.client.did_update_state(&mut self.text_state, None).unwrap_or_else(|e| {
+                    fx_log_warn!("error sending state update to ImeClient: {:?}", e)
+                });
+            }
+        }
+    }
+
+    /// Converts the current self.text_state (the IME API v1 representation of the text field's state)
+    /// into the v2 representation txt::TextFieldState.
+    fn as_text_field_state(&mut self) -> txt::TextFieldState {
+        let anchor_first = self.text_state.selection.base < self.text_state.selection.extent;
+        txt::TextFieldState {
+            document: txt::TextRange {
+                start: self.new_point(0),
+                end: self.new_point(self.text_state.text.len()),
+            },
+            selection: Some(Box::new(txt::TextSelection {
+                range: txt::TextRange {
+                    start: self.new_point(if anchor_first {
+                        self.text_state.selection.base as usize
+                    } else {
+                        self.text_state.selection.extent as usize
+                    }),
+                    end: self.new_point(if anchor_first {
+                        self.text_state.selection.extent as usize
+                    } else {
+                        self.text_state.selection.base as usize
+                    }),
+                },
+                anchor: if anchor_first {
+                    txt::TextSelectionAnchor::AnchoredAtStart
+                } else {
+                    txt::TextSelectionAnchor::AnchoredAtEnd
+                },
+                affinity: txt::TextAffinity::Upstream,
+            })),
+            // TODO(lard): these three regions should be correctly populated from text_state.
+            composition: None,
+            composition_highlight: None,
+            dead_key_highlight: None,
+            revision: self.revision,
+        }
+    }
+
+    /// Creates a new TextPoint corresponding to the byte index `index`.
+    fn new_point(&mut self, index: usize) -> txt::TextPoint {
+        let id = self.next_text_point_id;
+        self.next_text_point_id += 1;
+        self.text_points.insert(id, index);
+        txt::TextPoint { id }
     }
 
     // gets start and len, and sets base/extent to start of string if don't exist
diff --git a/garnet/bin/ui/ime/src/ime_service.rs b/garnet/bin/ui/ime/src/ime_service.rs
index 9ede804..8b76cf3 100644
--- a/garnet/bin/ui/ime/src/ime_service.rs
+++ b/garnet/bin/ui/ime/src/ime_service.rs
@@ -6,6 +6,7 @@
 use failure::ResultExt;
 use fidl::endpoints::{ClientEnd, RequestStream, ServerEnd};
 use fidl_fuchsia_ui_input as uii;
+use fidl_fuchsia_ui_text as txt;
 use fuchsia_syslog::fx_log_err;
 use futures::prelude::*;
 use parking_lot::Mutex;
@@ -15,6 +16,11 @@
     pub keyboard_visible: bool,
     pub active_ime: Option<Weak<Mutex<ImeState>>>,
     pub visibility_listeners: Vec<uii::ImeVisibilityServiceControlHandle>,
+
+    /// `TextInputContext` is a service provided to input methods that want to edit text. Whenever
+    /// a new text field is focused, we provide a TextField interface to any connected `TextInputContext`s,
+    /// which are listed here.
+    pub text_input_context_clients: Vec<txt::TextInputContextControlHandle>,
 }
 
 /// The internal state of the IMEService, usually held behind an Arc<Mutex>
@@ -43,6 +49,7 @@
             keyboard_visible: false,
             active_ime: None,
             visibility_listeners: Vec::new(),
+            text_input_context_clients: Vec::new(),
         })))
     }
 
@@ -66,7 +73,7 @@
         }
     }
 
-    fn get_input_method_editor(
+    pub fn get_input_method_editor(
         &mut self,
         keyboard_type: uii::KeyboardType,
         action: uii::InputMethodAction,
@@ -74,14 +81,20 @@
         client: ClientEnd<uii::InputMethodEditorClientMarker>,
         editor: ServerEnd<uii::InputMethodEditorMarker>,
     ) {
-        if let Ok(client_proxy) = client.into_proxy() {
-            let ime = Ime::new(keyboard_type, action, initial_state, client_proxy, self.clone());
-            let mut state = self.0.lock();
-            state.active_ime = Some(ime.downgrade());
-            if let Ok(chan) = fuchsia_async::Channel::from_channel(editor.into_channel()) {
-                ime.bind_ime(chan);
-            }
+        let client_proxy = match client.into_proxy() {
+            Ok(v) => v,
+            Err(_) => return,
+        };
+        let ime = Ime::new(keyboard_type, action, initial_state, client_proxy, self.clone());
+        let mut state = self.0.lock();
+        state.active_ime = Some(ime.downgrade());
+        if let Ok(chan) = fuchsia_async::Channel::from_channel(editor.into_channel()) {
+            ime.bind_ime(chan);
         }
+        state.text_input_context_clients.retain(|listener| {
+            // drop listeners if they error on send
+            bind_new_text_field(&ime, &listener).is_ok()
+        });
     }
 
     pub fn show_keyboard(&self) {
@@ -92,7 +105,9 @@
         self.0.lock().update_keyboard_visibility(false);
     }
 
-    fn inject_input(&mut self, event: uii::InputEvent) {
+    /// This is called by the operating system when input from the physical keyboard comes in.
+    /// It also is called by legacy onscreen keyboards that just simulate physical keyboard input.
+    fn inject_input(&mut self, mut event: uii::InputEvent) {
         let ime = {
             let state = self.0.lock();
             let active_ime_weak = match state.active_ime {
@@ -104,7 +119,15 @@
                 None => return, // IME no longer exists
             }
         };
-        ime.inject_input(event);
+        self.0.lock().text_input_context_clients.retain(|listener| {
+            // drop listeners if they error on send
+            listener.send_on_input_event(&mut event).is_ok()
+        });
+        // only use the default text input handler in ime.rs if there are no text_input_context_clients
+        // attached to handle it
+        if self.0.lock().text_input_context_clients.len() == 0 {
+            ime.inject_input(event);
+        }
     }
 
     pub fn bind_ime_service(&self, chan: fuchsia_async::Channel) {
@@ -167,6 +190,56 @@
                 .unwrap_or_else(|e: failure::Error| fx_log_err!("{:?}", e)),
         );
     }
+
+    pub fn bind_text_input_context(&self, chan: fuchsia_async::Channel) {
+        let self_clone = self.clone();
+        fuchsia_async::spawn(
+            async move {
+                let mut stream = txt::TextInputContextRequestStream::from_channel(chan);
+                let control_handle = stream.control_handle();
+                {
+                    let mut state = self_clone.0.lock();
+
+                    let active_ime_opt = match state.active_ime {
+                        Some(ref weak) => Ime::upgrade(weak),
+                        None => None, // no currently active IME
+                    };
+
+                    if let Some(active_ime) = active_ime_opt {
+                        if let Err(e) = bind_new_text_field(&active_ime, &control_handle) {
+                            fx_log_err!("Error when binding text field for newly connected TextInputContext: {}", e);
+                        }
+                    }
+                    state.text_input_context_clients.push(control_handle)
+                }
+                while let Some(msg) = await!(stream.try_next())
+                    .context("error reading value from text input context request stream")?
+                {
+                    match msg {
+                        txt::TextInputContextRequest::HideKeyboard { .. } => {
+                            self_clone.hide_keyboard();
+                        }
+                    }
+                }
+                Ok(())
+            }
+                .unwrap_or_else(|e: failure::Error| fx_log_err!("{:?}", e)),
+        );
+    }
+}
+
+pub fn bind_new_text_field(
+    active_ime: &Ime,
+    control_handle: &txt::TextInputContextControlHandle,
+) -> Result<(), fidl::Error> {
+    let (client_end, request_stream) =
+        fidl::endpoints::create_request_stream::<txt::TextFieldMarker>()
+            .expect("Failed to create text field request stream");
+    // TODO(lard): this currently overwrites active_ime's TextField, since it only supports
+    // one at a time. In the future, ImeService should multiplex multiple TextField
+    // implementations into Ime.
+    active_ime.bind_text_field(request_stream);
+    control_handle.send_on_focus(client_end)
 }
 
 #[cfg(test)]
diff --git a/garnet/bin/ui/ime/src/main.rs b/garnet/bin/ui/ime/src/main.rs
index e07a1e4..6b55581 100644
--- a/garnet/bin/ui/ime/src/main.rs
+++ b/garnet/bin/ui/ime/src/main.rs
@@ -3,7 +3,6 @@
 // found in the LICENSE file.
 
 #![feature(async_await, await_macro, futures_api)]
-#![deny(warnings)]
 
 mod ime;
 mod ime_service;
@@ -13,6 +12,7 @@
 use failure::{Error, ResultExt};
 use fidl::endpoints::ServiceMarker;
 use fidl_fuchsia_ui_input::{ImeServiceMarker, ImeVisibilityServiceMarker};
+use fidl_fuchsia_ui_text::TextInputContextMarker;
 use fuchsia_app::server::ServicesServer;
 use fuchsia_syslog;
 
@@ -23,6 +23,7 @@
     let ime_service = ime_service::ImeService::new();
     let ime_service1 = ime_service.clone();
     let ime_service2 = ime_service.clone();
+    let ime_service3 = ime_service.clone();
     let done = ServicesServer::new()
         .add_service((ImeServiceMarker::NAME, move |chan| {
             ime_service1.bind_ime_service(chan);
@@ -30,6 +31,9 @@
         .add_service((ImeVisibilityServiceMarker::NAME, move |chan| {
             ime_service2.bind_ime_visibility_service(chan);
         }))
+        .add_service((TextInputContextMarker::NAME, move |chan| {
+            ime_service3.bind_text_input_context(chan);
+        }))
         .start()
         .context("Creating ServicesServer for IME service failed")?;
     executor
@@ -38,3 +42,88 @@
 
     Ok(())
 }
+
+#[cfg(test)]
+mod test {
+    use fidl_fuchsia_ui_input as uii;
+    use fidl_fuchsia_ui_text as txt;
+    use fidl_fuchsia_ui_text_testing as txt_testing;
+    use fuchsia_app::client::Launcher;
+    use futures::prelude::*;
+
+    #[test]
+    // implementation is not complete, so we're ignoring this test for now.
+    #[ignore]
+    fn test_external_text_field_implementation() {
+        fuchsia_syslog::init_with_tags(&["ime_service"]).expect("ime syslog init should not fail");
+        let mut executor = fuchsia_async::Executor::new()
+            .expect("Creating fuchsia_async executor for IME service failed");
+        let launcher = Launcher::new().expect("Failed to open launcher service");
+        let app = launcher
+            .launch(
+                "fuchsia-pkg://fuchsia.com/text_test_suite#meta/test_suite.cmx".to_string(),
+                None,
+            )
+            .expect("Failed to launch testing service");
+        let tester = app
+            .connect_to_service(txt_testing::TextFieldTestSuiteMarker)
+            .expect("Failed to connect to testing service");
+        let done = (async move || {
+            let mut passed = true;
+            let test_list = await!(tester.list_tests()).expect("Failed to get list of tests");
+            for test in test_list {
+                if let Err(e) = await!(run_test(&tester, test.id)) {
+                    passed = false;
+                    eprintln!("[ FAIL ] {}\n{}", test.name, e);
+                } else {
+                    eprintln!("[  ok  ] {}", test.name);
+                }
+            }
+            if !passed {
+                panic!("Text integration tests failed");
+            }
+        })();
+        executor.run_singlethreaded(done);
+    }
+
+    async fn run_test(
+        tester: &txt_testing::TextFieldTestSuiteProxy,
+        test_id: u64,
+    ) -> Result<(), String> {
+        let mut ime_service = crate::ime_service::ImeService::new();
+        let (text_proxy, server_end) =
+            fidl::endpoints::create_proxy::<txt::TextInputContextMarker>()
+                .expect("Failed to create proxy");
+        let (imec_client, _imec_server) =
+            fidl::endpoints::create_endpoints::<uii::InputMethodEditorClientMarker>()
+                .expect("Failed to create endpoints");
+        let (_ime_client, ime_server) =
+            fidl::endpoints::create_endpoints::<uii::InputMethodEditorMarker>()
+                .expect("Failed to create endpoints");
+        let chan = fuchsia_async::Channel::from_channel(server_end.into_channel())
+            .expect("Failed to create channel");
+        ime_service.bind_text_input_context(chan);
+        ime_service.get_input_method_editor(
+            uii::KeyboardType::Text,
+            uii::InputMethodAction::Done,
+            crate::test_helpers::default_state(),
+            imec_client,
+            ime_server,
+        );
+        let mut stream = text_proxy.take_event_stream();
+        let msg = await!(stream.try_next())
+            .expect("Failed to get event.")
+            .expect("TextInputContext event stream unexpectedly closed.");
+        let text_field = match msg {
+            txt::TextInputContextEvent::OnFocus { text_field, .. } => text_field,
+            _ => panic!("Expected text_field to pass OnFocus event type"),
+        };
+        let (passed, msg) = await!(tester.run_test(text_field, test_id))
+            .expect("Call to text testing service failed");
+        if passed {
+            Ok(())
+        } else {
+            Err(msg)
+        }
+    }
+}
diff --git a/garnet/bin/ui/meta/ime_service_unittests.cmx b/garnet/bin/ui/meta/ime_service_unittests.cmx
index 9d3d5aa..727e654 100644
--- a/garnet/bin/ui/meta/ime_service_unittests.cmx
+++ b/garnet/bin/ui/meta/ime_service_unittests.cmx
@@ -4,7 +4,8 @@
     },
     "sandbox": {
         "services": [
-            "fuchsia.logger.LogSink"
+            "fuchsia.logger.LogSink",
+            "fuchsia.sys.Launcher"
         ]
     }
 }