diff --git a/crates/tinycomputer-browser/src/convert/convert_tests/interaction_tests.rs b/crates/tinycomputer-browser/src/convert/convert_tests/interaction_tests.rs
index 490c4705..d269e0ce 100644
--- a/crates/tinycomputer-browser/src/convert/convert_tests/interaction_tests.rs
+++ b/crates/tinycomputer-browser/src/convert/convert_tests/interaction_tests.rs
@@ -103,6 +103,7 @@ fn every_plain_action_names_its_engine_command() {
         (
             Action::Press {
                 key: "Enter".to_owned(),
+                target: None,
             },
             "press",
         ),
@@ -117,7 +118,8 @@ fn every_plain_action_names_its_engine_command() {
     assert!(
         invalid(action(
             &Action::Press {
-                key: " ".to_owned()
+                key: " ".to_owned(),
+                target: None,
             },
             1_000
         ))
@@ -125,6 +127,23 @@ fn every_plain_action_names_its_engine_command() {
     );
 }
 
+#[test]
+fn a_press_on_a_target_is_the_plain_key_the_focus_check_precedes() {
+    // `Browser::perform` gives the target the focus and checks it first; the
+    // key itself goes to the focus, as every press does.
+    assert_eq!(
+        action(
+            &Action::Press {
+                key: "Enter".to_owned(),
+                target: Some(Target::reference("e4")),
+            },
+            1_000
+        )
+        .unwrap(),
+        json!({"action": "press", "key": "Enter"})
+    );
+}
+
 #[test]
 fn typing_with_and_without_a_target() {
     let focused = action(
diff --git a/crates/tinycomputer-browser/src/convert/interaction.rs b/crates/tinycomputer-browser/src/convert/interaction.rs
index 03fc7b44..862004f1 100644
--- a/crates/tinycomputer-browser/src/convert/interaction.rs
+++ b/crates/tinycomputer-browser/src/convert/interaction.rs
@@ -35,7 +35,9 @@ pub(crate) fn action(action: &Action, default_timeout_ms: u64) -> Result<Value>
         Action::Back => Ok(json!({"action": "back"})),
         Action::Forward => Ok(json!({"action": "forward"})),
         Action::Reload => Ok(json!({"action": "reload"})),
-        Action::Press { key } => {
+        // A press goes wherever the focus is: with a target, `Browser::perform`
+        // first puts the focus there and checks it landed.
+        Action::Press { key, .. } => {
             if key.trim().is_empty() {
                 return Err(Error::invalid_input("press needs a key"));
             }
@@ -168,7 +170,7 @@ fn wait_for(
 ///
 /// [`Error::InvalidInput`] for a locator, which agent-browser only accepts on
 /// its semantic commands (click, fill, check, hover, text).
-pub(super) fn selector(target: &Target, operation: &str) -> Result<String> {
+pub(crate) fn selector(target: &Target, operation: &str) -> Result<String> {
     match target {
         Target::Ref { value } if !value.trim().is_empty() => {
             Ok(format!("@{}", value.trim_start_matches('@')))
diff --git a/crates/tinycomputer-browser/src/convert/mod.rs b/crates/tinycomputer-browser/src/convert/mod.rs
index 8fd94a34..1d152837 100644
--- a/crates/tinycomputer-browser/src/convert/mod.rs
+++ b/crates/tinycomputer-browser/src/convert/mod.rs
@@ -13,7 +13,7 @@ mod interaction;
 mod page;
 mod session;
 
-pub(crate) use interaction::action;
+pub(crate) use interaction::{action, selector};
 pub(crate) use page::{evaluate, navigate, read, screenshot, snapshot};
 pub(crate) use session::{launch, viewport};
 
diff --git a/crates/tinycomputer-browser/src/error/error_tests.rs b/crates/tinycomputer-browser/src/error/error_tests.rs
index 5339d84f..89958115 100644
--- a/crates/tinycomputer-browser/src/error/error_tests.rs
+++ b/crates/tinycomputer-browser/src/error/error_tests.rs
@@ -103,6 +103,9 @@ fn every_variant() -> Vec<Error> {
             reference: "e1".to_string(),
         },
         Error::not_actionable("covered by a banner"),
+        Error::FocusMissed {
+            focused: "input".to_string(),
+        },
         Error::timeout("navigate", 30_000),
         Error::BlockedByPolicy {
             url: "https://evil.test/".to_string(),
@@ -239,3 +242,23 @@ fn a_lost_connection_suggests_a_new_session() {
             .is_some_and(|s| s.contains("BrowserOpenSession"))
     );
 }
+
+#[test]
+fn a_missed_focus_is_not_actionable_and_says_to_act_on_the_field() {
+    let error = Error::FocusMissed {
+        focused: "input".to_string(),
+    };
+    assert_eq!(error.wire_name(), errors::NOT_ACTIONABLE);
+    assert!(errors::is_agent_recoverable(error.wire_name()));
+    let envelope = error.envelope();
+    assert!(
+        envelope.message.contains("it is on input"),
+        "{}",
+        envelope.message
+    );
+    assert!(
+        envelope
+            .suggestion
+            .is_some_and(|hint| hint.contains("act on the field itself")),
+    );
+}
diff --git a/crates/tinycomputer-browser/src/error/mod.rs b/crates/tinycomputer-browser/src/error/mod.rs
index e6728649..258409d3 100644
--- a/crates/tinycomputer-browser/src/error/mod.rs
+++ b/crates/tinycomputer-browser/src/error/mod.rs
@@ -60,6 +60,16 @@ pub enum Error {
         reason: String,
     },
 
+    /// The element did not take the keyboard focus, so nothing was typed or
+    /// pressed: the keys would have gone to whatever held the focus instead,
+    /// such as a field filled earlier or a button.
+    #[error("the element did not take the keyboard focus (it is on {focused}), nothing was sent")]
+    FocusMissed {
+        /// What holds the focus instead: a tag name, such as `input`, or
+        /// `nothing`.
+        focused: String,
+    },
+
     /// An operation ran out of time.
     #[error("{operation} timed out after {elapsed_ms}ms")]
     Timeout {
@@ -156,7 +166,7 @@ impl Error {
             Self::NoSuchSession { .. } | Self::ConnectionLost { .. } => errors::NO_SUCH_SESSION,
             Self::NoSuchElement { .. } => errors::NO_SUCH_ELEMENT,
             Self::StaleRef { .. } => errors::STALE_REF,
-            Self::NotActionable { .. } => errors::NOT_ACTIONABLE,
+            Self::NotActionable { .. } | Self::FocusMissed { .. } => errors::NOT_ACTIONABLE,
             Self::Timeout { .. } => errors::TIMEOUT,
             Self::BlockedByPolicy { .. } | Self::LeftRefusedPage { .. } => {
                 errors::BLOCKED_BY_POLICY
@@ -215,6 +225,9 @@ impl Error {
             Self::NotActionable { .. } => {
                 Some("dismiss whatever covers the element, or scroll it into view, then retry")
             }
+            Self::FocusMissed { .. } => Some(
+                "act on the field itself (an input, a text area, or an editable region), not its label or heading; take a fresh BrowserSnapshot to find it",
+            ),
             Self::NoSuchSession { .. } | Self::ConnectionLost { .. } => {
                 Some("open a new session with BrowserOpenSession")
             }
diff --git a/crates/tinycomputer-browser/src/fake/mod.rs b/crates/tinycomputer-browser/src/fake/mod.rs
index a163555f..8ab5ec21 100644
--- a/crates/tinycomputer-browser/src/fake/mod.rs
+++ b/crates/tinycomputer-browser/src/fake/mod.rs
@@ -12,13 +12,32 @@ use crate::engine::{Engine, Launcher, Reply};
 type Script = dyn Fn(&Value) -> Option<Value> + Send + Sync;
 type Stall = dyn Fn(&Value) -> bool + Send + Sync;
 
-/// Records every command; answers from an optional override, else like the
-/// engine would, and never answers a command it is told to stall on.
+/// Where a page puts the focus once an element is given it, as the focus
+/// check (`sessions/focus.rs`) reads it.
+#[derive(Clone, Copy, Debug)]
+pub(crate) enum PageFocus {
+    /// On the element: every element named takes it. The default.
+    OnTarget,
+    /// On another element, by its tag.
+    Elsewhere(&'static str),
+    /// On nothing: the element took none, and nothing else holds it.
+    Nowhere,
+    /// Inside a cross-origin frame, which the page cannot see into.
+    InAFrame,
+    /// On the element, whose ref the engine no longer resolves when asked
+    /// for its mark.
+    Stale,
+}
+
+/// Records every command; answers the focus check as its page's focus says,
+/// the rest from an optional override, else like the engine would, and never
+/// answers a command it is told to stall on.
 #[derive(Clone)]
 pub(crate) struct Fake {
     sent: Arc<Mutex<Vec<Value>>>,
     script: Arc<Script>,
     stall: Arc<Stall>,
+    focus: PageFocus,
 }
 
 impl std::fmt::Debug for Fake {
@@ -39,9 +58,17 @@ impl Fake {
             sent: Arc::new(Mutex::new(Vec::new())),
             script: Arc::new(script),
             stall: Arc::new(|_| false),
+            focus: PageFocus::OnTarget,
         }
     }
 
+    /// The same fake, its page putting the focus where `focus` says once an
+    /// element is given it.
+    pub(crate) fn with_focus(mut self, focus: PageFocus) -> Self {
+        self.focus = focus;
+        self
+    }
+
     /// The same fake, never answering a command `stall` picks, as a page
     /// being replaced may not.
     pub(crate) fn stalling(
@@ -149,11 +176,61 @@ impl Engine for Fake {
         if (self.stall)(&command) {
             return Box::pin(std::future::pending());
         }
-        let reply = (self.script)(&command).unwrap_or_else(|| default_reply(&command));
+        let reply = self
+            .focus_reply(&command)
+            .or_else(|| (self.script)(&command))
+            .unwrap_or_else(|| default_reply(&command));
         Box::pin(async move { reply })
     }
 }
 
+impl Fake {
+    /// The page's answer to the focus check (`sessions/focus.rs`): where
+    /// the marking script finds the focus, and the target's mark.
+    fn focus_reply(&self, command: &Value) -> Option<Value> {
+        let script = command["script"].as_str().unwrap_or_default();
+        if command["action"] == "evaluate" && script.contains("setAttribute('data-tc-focus'") {
+            let found = match self.focus {
+                PageFocus::OnTarget | PageFocus::Stale => {
+                    json!({"focus": "element", "on": "input"})
+                }
+                PageFocus::Elsewhere(tag) => json!({"focus": "element", "on": tag}),
+                PageFocus::Nowhere => json!({"focus": "none", "on": "nothing"}),
+                PageFocus::InAFrame => json!({"focus": "frame", "on": "a frame"}),
+            };
+            return Some(ok(&json!({"result": found})));
+        }
+        if command["action"] == "getattribute" && command["attribute"] == "data-tc-focus" {
+            let target = command["selector"].as_str().unwrap_or_default();
+            return Some(match self.focus {
+                PageFocus::OnTarget => {
+                    let sent = self.sent.lock().unwrap();
+                    let mark = sent
+                        .iter()
+                        .rev()
+                        .find_map(|earlier| focus_mark(earlier["script"].as_str()?));
+                    ok(&json!({"value": mark}))
+                }
+                PageFocus::Stale => {
+                    failure(&format!("Unknown ref: {}", target.trim_start_matches('@')))
+                }
+                _ => ok(&json!({"value": null})),
+            });
+        }
+        None
+    }
+}
+
+/// The mark value a focus-marking script was called with, if `script` is one.
+pub(crate) fn focus_mark(script: &str) -> Option<String> {
+    if !script.contains("setAttribute('data-tc-focus'") {
+        return None;
+    }
+    let start = script.rfind("(\"tc-")? + 2;
+    let end = start + script[start..].find('"')?;
+    Some(script[start..end].to_owned())
+}
+
 impl Launcher for Fake {
     fn open(&self, _session: &str) -> Box<dyn Engine> {
         Box::new(self.clone())
diff --git a/crates/tinycomputer-browser/src/sessions/focus.rs b/crates/tinycomputer-browser/src/sessions/focus.rs
new file mode 100644
index 00000000..b6d25a3a
--- /dev/null
+++ b/crates/tinycomputer-browser/src/sessions/focus.rs
@@ -0,0 +1,190 @@
+//! Keys go only where the caller pointed.
+//!
+//! The engine types and presses into whatever holds the keyboard focus: it
+//! asks the target element to take the focus, and an element that takes none
+//! (a heading, a label) leaves it where it was. Text typed "into" a heading
+//! would then land in the field filled before it, a card number say, and a
+//! key pressed on one would press whatever button last had the focus.
+//!
+//! So before an element is focused, filled, typed into, or sent a key, the
+//! focus comes off whatever held it, the element is given it, and the focus
+//! is checked to be on the element, or the action is refused
+//! ([`Error::FocusMissed`]). The check marks the elements holding the focus
+//! with a fresh random value, then asks the engine for that attribute on the
+//! target, which resolves the target in its own frame: only the target, or a
+//! shadow host around it, carries the mark. The marks come off again whatever
+//! the check found.
+//!
+//! What the page cannot show: the focus inside a cross-origin frame (a
+//! payment provider's card field). Once the focus was taken off everything,
+//! it can only be in such a frame because the target took it, so that goes
+//! ahead. A page's own scripts run between these steps and could fool the
+//! check: it stops mistakes, not a page set on defeating it.
+
+use std::fmt::Write as _;
+
+use serde_json::{Value, json};
+
+use super::Session;
+use crate::error::{Error, Result};
+
+/// The attribute marking the elements that hold the focus while it is
+/// checked.
+const MARK: &str = "data-tc-focus";
+
+/// Takes the focus off whatever holds it: the deepest element reachable
+/// through open shadow roots and same-origin frames, or the frame element of
+/// a cross-origin frame, which takes the focus out of that frame.
+const BLUR_JS: &str = r"(() => {
+  let doc = document;
+  let element = doc.activeElement;
+  for (;;) {
+    while (element && element.shadowRoot && element.shadowRoot.activeElement) {
+      element = element.shadowRoot.activeElement;
+    }
+    if (!element || element === doc.body || element === doc.documentElement) return;
+    if (element.tagName === 'IFRAME' || element.tagName === 'FRAME') {
+      let inner = null;
+      try { inner = element.contentDocument; } catch (e) { inner = null; }
+      if (inner) { doc = inner; element = inner.activeElement; continue; }
+    }
+    element.blur();
+    return;
+  }
+})()";
+
+/// Marks the elements holding the focus with the value it is given: the
+/// focused element and the open shadow hosts around it, in its own frame.
+/// Answers where the focus is, `element`, `frame` (inside a cross-origin
+/// frame), or `none`, with the focused element's tag name as `on`. The
+/// marked elements are kept for [`UNMARK_JS`] under a key named for the value.
+const MARK_JS: &str = r"((value) => {
+  let doc = document;
+  let element = doc.activeElement;
+  let chain = [];
+  for (;;) {
+    while (element && element.shadowRoot && element.shadowRoot.activeElement) {
+      chain.push(element);
+      element = element.shadowRoot.activeElement;
+    }
+    if (!element || element === doc.body || element === doc.documentElement) {
+      return { focus: 'none', on: 'nothing' };
+    }
+    if (element.tagName === 'IFRAME' || element.tagName === 'FRAME') {
+      let inner = null;
+      try { inner = element.contentDocument; } catch (e) { inner = null; }
+      if (!inner) return { focus: 'frame', on: 'a frame' };
+      doc = inner;
+      element = inner.activeElement;
+      chain = [];
+      continue;
+    }
+    chain.push(element);
+    for (const marked of chain) marked.setAttribute('data-tc-focus', value);
+    window[Symbol.for('tinycomputer.focus.' + value)] = chain;
+    return { focus: 'element', on: (element.tagName || '').toLowerCase() };
+  }
+})";
+
+/// Takes the marks [`MARK_JS`] put down with the value it is given.
+const UNMARK_JS: &str = r"((value) => {
+  const key = Symbol.for('tinycomputer.focus.' + value);
+  for (const marked of window[key] || []) {
+    if (marked.getAttribute('data-tc-focus') === value) marked.removeAttribute('data-tc-focus');
+  }
+  delete window[key];
+})";
+
+impl Session {
+    /// Takes the page's focus off whatever holds it.
+    ///
+    /// # Errors
+    ///
+    /// Whatever the engine reports.
+    pub(super) async fn blur(&mut self) -> Result<()> {
+        self.run(json!({"action": "evaluate", "script": BLUR_JS}))
+            .await
+            .map(drop)
+    }
+
+    /// Gives `selector` the focus, and only it: the focus comes off whatever
+    /// held it, the element is focused, and the focus is checked to be on it.
+    ///
+    /// # Errors
+    ///
+    /// [`Error::FocusMissed`] when the focus is anywhere else, and whatever
+    /// the engine reports.
+    pub(super) async fn focus_only(&mut self, selector: &str) -> Result<()> {
+        self.blur().await?;
+        self.run(json!({"action": "focus", "selector": selector}))
+            .await?;
+        let value = mark_value()?;
+        let found = self
+            .run(json!({"action": "evaluate", "script": with_value(MARK_JS, &value)}))
+            .await?;
+        let checked = self.focus_is_on(selector, &value, &found["result"]).await;
+        // The marks come off whatever the check found; a page that went away
+        // took them with it.
+        let _unmarked = self
+            .run(json!({"action": "evaluate", "script": with_value(UNMARK_JS, &value)}))
+            .await;
+        checked
+    }
+
+    /// Whether `found`, where [`MARK_JS`] saw the focus, is on `selector`.
+    async fn focus_is_on(&mut self, selector: &str, value: &str, found: &Value) -> Result<()> {
+        match found["focus"].as_str() {
+            Some("frame") => Ok(()),
+            Some("element") => {
+                let data = self
+                    .run(json!({"action": "getattribute", "selector": selector, "attribute": MARK}))
+                    .await?;
+                if data["value"].as_str() == Some(value) {
+                    Ok(())
+                } else {
+                    Err(missed(found))
+                }
+            }
+            _ => Err(missed(found)),
+        }
+    }
+}
+
+/// The refusal for a focus that landed elsewhere, naming where by tag only:
+/// anything more would be page text in an error a model reads.
+fn missed(found: &Value) -> Error {
+    let on = found["on"]
+        .as_str()
+        .filter(|tag| {
+            !tag.is_empty()
+                && tag
+                    .chars()
+                    .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == ' ')
+        })
+        .unwrap_or("nothing");
+    Error::FocusMissed {
+        focused: on.to_owned(),
+    }
+}
+
+/// `script`, a function of one value, called with `value`.
+fn with_value(script: &str, value: &str) -> String {
+    format!("{script}({})", json!(value))
+}
+
+/// A fresh mark: 64 random bits, hex-encoded, which a page cannot guess.
+///
+/// # Errors
+///
+/// [`Error::ModuleFailed`] when the platform's random source is unavailable.
+fn mark_value() -> Result<String> {
+    let mut bytes = [0_u8; 8];
+    getrandom::fill(&mut bytes)
+        .map_err(|error| Error::failed(format!("no randomness for a focus mark: {error}")))?;
+    let mut value = String::with_capacity(20);
+    value.push_str("tc-");
+    for byte in bytes {
+        let _ = write!(value, "{byte:02x}");
+    }
+    Ok(value)
+}
diff --git a/crates/tinycomputer-browser/src/sessions/mod.rs b/crates/tinycomputer-browser/src/sessions/mod.rs
index 701d7dba..669e7fcc 100644
--- a/crates/tinycomputer-browser/src/sessions/mod.rs
+++ b/crates/tinycomputer-browser/src/sessions/mod.rs
@@ -20,6 +20,7 @@ use crate::outputs::OutputStore;
 use crate::reply;
 
 mod artifacts;
+mod focus;
 mod page;
 
 /// How many sessions may be open at once.
diff --git a/crates/tinycomputer-browser/src/sessions/page.rs b/crates/tinycomputer-browser/src/sessions/page.rs
index aba3e858..ad49c062 100644
--- a/crates/tinycomputer-browser/src/sessions/page.rs
+++ b/crates/tinycomputer-browser/src/sessions/page.rs
@@ -101,20 +101,33 @@ impl Browser {
 
     /// Performs one interaction and reports the page it left.
     ///
+    /// Keys go only where the action points: an element focused, filled,
+    /// typed into, or sent a key is given the focus first, and the action is
+    /// refused unless the focus lands on it (see `sessions/focus.rs`). A
+    /// locator's fill, which only the engine resolves, has the focus taken
+    /// off whatever held it first, so its text lands in the field or nowhere.
+    ///
     /// # Errors
     ///
     /// [`Error::NoSuchSession`], [`Error::InvalidInput`] for an action the
     /// engine cannot express, [`Error::StaleRef`] for a ref from an earlier
-    /// snapshot, [`Error::BlockedByPolicy`] when the page it would act on, or
-    /// the page it leads to, is outside the allowed origins, and whatever
-    /// else the action reports.
+    /// snapshot, [`Error::FocusMissed`] when the focus does not land on the
+    /// element keys were meant for, [`Error::BlockedByPolicy`] when the page
+    /// it would act on, or the page it leads to, is outside the allowed
+    /// origins, and whatever else the action reports.
     pub async fn perform(&self, id: &SessionId, action: Action) -> Result<ActionOutcome> {
         let session = self.session(id)?;
         let mut session = session.lock().await;
         let command = convert::action(&action, session.options.default_timeout_ms)?;
+        let keys = keys_go_to(&action)?;
         // The page may have moved on its own since the last call (a redirect,
         // a timer): an action is never sent to a refused one.
         session.check_if_readable(false).await?;
+        match keys {
+            Keys::Checked(selector) => session.focus_only(&selector).await?,
+            Keys::Blurred => session.blur().await?,
+            Keys::Anywhere => {}
+        }
         let data = session.run(command).await?;
         let value = match &action {
             Action::GetText { .. } => data.get("text").cloned().unwrap_or(Value::Null),
@@ -294,3 +307,37 @@ impl Browser {
             .insert(bytes, request.format.media_type(), width, height)
     }
 }
+
+/// How an action's keys, or focus, are kept on its target.
+enum Keys {
+    /// The target's selector: focus it and check the focus landed there.
+    Checked(String),
+    /// A target only the engine resolves: take the focus off whatever held it.
+    Blurred,
+    /// Nothing to keep on a target: no keys, or keys for whatever has focus.
+    Anywhere,
+}
+
+/// Where `action` sends keys or focus.
+///
+/// # Errors
+///
+/// [`Error::InvalidInput`] for a press on a locator, which has no selector to
+/// check the focus against.
+fn keys_go_to(action: &Action) -> Result<Keys> {
+    Ok(match action {
+        Action::Focus { target } | Action::Fill { target, .. } => match target {
+            Target::Locator { .. } => Keys::Blurred,
+            other => Keys::Checked(convert::selector(other, "focus")?),
+        },
+        Action::Type {
+            target: Some(target),
+            ..
+        }
+        | Action::Press {
+            target: Some(target),
+            ..
+        } => Keys::Checked(convert::selector(target, "press")?),
+        _ => Keys::Anywhere,
+    })
+}
diff --git a/crates/tinycomputer-browser/src/sessions/sessions_tests.rs b/crates/tinycomputer-browser/src/sessions/sessions_tests.rs
index 35248c89..a5992f53 100644
--- a/crates/tinycomputer-browser/src/sessions/sessions_tests.rs
+++ b/crates/tinycomputer-browser/src/sessions/sessions_tests.rs
@@ -15,6 +15,7 @@ use super::Browser;
 use crate::fake::Fake;
 
 mod artifacts_tests;
+mod focus_tests;
 mod lifecycle_tests;
 mod origins_tests;
 mod page_tests;
diff --git a/crates/tinycomputer-browser/src/sessions/sessions_tests/focus_tests.rs b/crates/tinycomputer-browser/src/sessions/sessions_tests/focus_tests.rs
new file mode 100644
index 00000000..2ea5ab98
--- /dev/null
+++ b/crates/tinycomputer-browser/src/sessions/sessions_tests/focus_tests.rs
@@ -0,0 +1,296 @@
+//! Tests that keys go only where an action points: the focus is taken off
+//! whatever held it, given to the target, and checked to be there, or the
+//! action is refused with nothing typed or pressed.
+
+use serde_json::json;
+use tinycomputer_bus::browser::{Action, LocateBy, Locator, Target};
+
+use super::open;
+use crate::error::Error;
+use crate::fake::{Fake, PageFocus, focus_mark};
+
+/// A page whose focus, once an element is given it, is `focus`.
+fn page(focus: PageFocus) -> Fake {
+    Fake::new().with_focus(focus)
+}
+
+/// The commands that move or check the focus, or send keys, in order:
+/// `blur`, `mark`, and `unmark` for the three page scripts.
+fn steps(fake: &Fake) -> Vec<String> {
+    fake.sent()
+        .iter()
+        .filter_map(|command| {
+            let action = command["action"].as_str().unwrap_or_default();
+            let script = command["script"].as_str().unwrap_or_default();
+            match action {
+                "evaluate" if script.contains("element.blur()") => Some("blur".to_owned()),
+                "evaluate" if script.contains("setAttribute") => Some("mark".to_owned()),
+                "evaluate" if script.contains("removeAttribute") => Some("unmark".to_owned()),
+                "focus" | "getattribute" | "type" | "inserttext" | "press" | "fill"
+                | "getbylabel" => Some(action.to_owned()),
+                _ => None,
+            }
+        })
+        .collect()
+}
+
+/// Every mark value a marking script put down, in order.
+fn marks(fake: &Fake) -> Vec<String> {
+    fake.sent()
+        .iter()
+        .filter_map(|command| focus_mark(command["script"].as_str()?))
+        .collect()
+}
+
+fn typing(target: Option<Target>) -> Action {
+    Action::Type {
+        target,
+        text: "4242 4242 4242 4242".to_owned(),
+        delay_ms: None,
+    }
+}
+
+#[tokio::test]
+async fn typing_into_a_target_gives_it_the_focus_and_checks_it_first() {
+    let fake = page(PageFocus::OnTarget);
+    let (browser, id) = open(&fake, "focus-typed").await;
+    browser
+        .perform(&id, typing(Some(Target::reference("e3"))))
+        .await
+        .unwrap();
+    assert_eq!(
+        steps(&fake),
+        ["blur", "focus", "mark", "getattribute", "unmark", "type"]
+    );
+    assert_eq!(fake.last("focus")["selector"], "@e3");
+    assert_eq!(fake.last("getattribute")["selector"], "@e3");
+    assert_eq!(fake.last("type")["selector"], "@e3");
+    // The mark it read back is the one it put down.
+    let unmark = fake
+        .sent()
+        .into_iter()
+        .rev()
+        .find(|command| {
+            command["script"]
+                .as_str()
+                .is_some_and(|script| script.contains("removeAttribute"))
+        })
+        .unwrap();
+    assert!(
+        unmark["script"]
+            .as_str()
+            .unwrap()
+            .ends_with(&format!("(\"{}\")", marks(&fake)[0]))
+    );
+}
+
+#[tokio::test]
+async fn text_meant_for_a_heading_never_reaches_the_field_that_had_the_focus() {
+    let fake = page(PageFocus::Elsewhere("input"));
+    let (browser, id) = open(&fake, "focus-heading").await;
+    let refused = browser
+        .perform(&id, typing(Some(Target::reference("e1"))))
+        .await;
+    assert!(
+        matches!(&refused, Err(Error::FocusMissed { focused }) if focused == "input"),
+        "{refused:?}"
+    );
+    // Nothing typed, and the marks came off.
+    assert_eq!(
+        steps(&fake),
+        ["blur", "focus", "mark", "getattribute", "unmark"]
+    );
+}
+
+#[tokio::test]
+async fn a_target_that_takes_no_focus_is_refused_without_asking_for_the_mark() {
+    let fake = page(PageFocus::Nowhere);
+    let (browser, id) = open(&fake, "focus-nowhere").await;
+    let refused = browser
+        .perform(
+            &id,
+            Action::Fill {
+                target: Target::reference("e2"),
+                value: "Ada".to_owned(),
+            },
+        )
+        .await;
+    assert!(
+        matches!(&refused, Err(Error::FocusMissed { focused }) if focused == "nothing"),
+        "{refused:?}"
+    );
+    assert_eq!(steps(&fake), ["blur", "focus", "mark", "unmark"]);
+}
+
+#[tokio::test]
+async fn the_focus_inside_a_cross_origin_frame_goes_ahead() {
+    // A payment provider's card field: the page cannot see into its frame,
+    // and with the focus taken off everything first, only the target can
+    // have put it there.
+    let fake = page(PageFocus::InAFrame);
+    let (browser, id) = open(&fake, "focus-frame").await;
+    browser
+        .perform(
+            &id,
+            Action::Fill {
+                target: Target::reference("e9"),
+                value: "4242 4242 4242 4242".to_owned(),
+            },
+        )
+        .await
+        .unwrap();
+    assert_eq!(steps(&fake), ["blur", "focus", "mark", "unmark", "fill"]);
+}
+
+#[tokio::test]
+async fn a_key_pressed_on_an_element_goes_only_to_it() {
+    let pressing = Action::Press {
+        key: "Enter".to_owned(),
+        target: Some(Target::reference("e5")),
+    };
+    // A heading, with the order button holding the focus: no press.
+    let fake = page(PageFocus::Elsewhere("button"));
+    let (browser, id) = open(&fake, "press-refused").await;
+    let refused = browser.perform(&id, pressing.clone()).await;
+    assert!(
+        matches!(&refused, Err(Error::FocusMissed { focused }) if focused == "button"),
+        "{refused:?}"
+    );
+    assert!(!steps(&fake).contains(&"press".to_owned()));
+    // The element itself: the key goes, to the focus it now holds.
+    let fake = page(PageFocus::OnTarget);
+    let (browser, id) = open(&fake, "press-checked").await;
+    browser.perform(&id, pressing).await.unwrap();
+    assert_eq!(
+        steps(&fake),
+        ["blur", "focus", "mark", "getattribute", "unmark", "press"]
+    );
+    assert_eq!(
+        fake.last("press"),
+        json!({"action": "press", "key": "Enter"})
+    );
+}
+
+#[tokio::test]
+async fn keys_without_a_target_go_where_the_focus_is_unchecked() {
+    let fake = page(PageFocus::Elsewhere("input"));
+    let (browser, id) = open(&fake, "focus-untargeted").await;
+    browser
+        .perform(
+            &id,
+            Action::Press {
+                key: "Tab".to_owned(),
+                target: None,
+            },
+        )
+        .await
+        .unwrap();
+    browser.perform(&id, typing(None)).await.unwrap();
+    assert_eq!(steps(&fake), ["press", "inserttext"]);
+}
+
+#[tokio::test]
+async fn a_locator_fill_takes_the_focus_off_first_but_is_not_checked() {
+    // Only the engine resolves a locator, so there is no selector to check;
+    // with the focus off everything, its text lands in the field or nowhere.
+    let fake = page(PageFocus::Elsewhere("input"));
+    let (browser, id) = open(&fake, "focus-locator").await;
+    browser
+        .perform(
+            &id,
+            Action::Fill {
+                target: Target::locator(Locator::new(LocateBy::Label, "Name")),
+                value: "Ada".to_owned(),
+            },
+        )
+        .await
+        .unwrap();
+    assert_eq!(steps(&fake), ["blur", "getbylabel"]);
+}
+
+#[tokio::test]
+async fn focusing_an_element_that_takes_none_is_refused() {
+    let fake = page(PageFocus::Elsewhere("input"));
+    let (browser, id) = open(&fake, "focus-action").await;
+    assert!(matches!(
+        browser
+            .perform(
+                &id,
+                Action::Focus {
+                    target: Target::reference("e1"),
+                },
+            )
+            .await,
+        Err(Error::FocusMissed { .. })
+    ));
+}
+
+#[tokio::test]
+async fn a_press_on_a_locator_is_refused_before_anything_is_sent() {
+    let fake = page(PageFocus::OnTarget);
+    let (browser, id) = open(&fake, "press-locator").await;
+    let before = fake.sent().len();
+    assert!(matches!(
+        browser
+            .perform(
+                &id,
+                Action::Press {
+                    key: "Enter".to_owned(),
+                    target: Some(Target::locator(Locator::new(LocateBy::Text, "Pay"))),
+                },
+            )
+            .await,
+        Err(Error::InvalidInput { .. })
+    ));
+    assert_eq!(fake.sent().len(), before);
+}
+
+#[tokio::test]
+async fn a_failed_mark_read_is_reported_and_the_marks_still_come_off() {
+    let fake = page(PageFocus::Stale);
+    let (browser, id) = open(&fake, "focus-stale").await;
+    assert!(matches!(
+        browser
+            .perform(&id, typing(Some(Target::reference("e3"))))
+            .await,
+        Err(Error::StaleRef { reference }) if reference == "e3"
+    ));
+    assert_eq!(
+        steps(&fake),
+        ["blur", "focus", "mark", "getattribute", "unmark"]
+    );
+}
+
+#[tokio::test]
+async fn where_the_focus_is_is_named_by_tag_only() {
+    // Page text never rides in an error a model reads.
+    let fake = page(PageFocus::Elsewhere("input onfocus=alert(1)"));
+    let (browser, id) = open(&fake, "focus-named").await;
+    let refused = browser
+        .perform(&id, typing(Some(Target::reference("e1"))))
+        .await;
+    assert!(
+        matches!(&refused, Err(Error::FocusMissed { focused }) if focused == "nothing"),
+        "{refused:?}"
+    );
+}
+
+#[tokio::test]
+async fn every_check_uses_a_fresh_mark_a_page_cannot_guess() {
+    let fake = page(PageFocus::OnTarget);
+    let (browser, id) = open(&fake, "focus-marks").await;
+    for _ in 0..2 {
+        browser
+            .perform(&id, typing(Some(Target::reference("e3"))))
+            .await
+            .unwrap();
+    }
+    let marks = marks(&fake);
+    assert_eq!(marks.len(), 2);
+    assert_ne!(marks[0], marks[1]);
+    assert!(
+        marks
+            .iter()
+            .all(|mark| mark.starts_with("tc-") && mark.len() == 19)
+    );
+}
diff --git a/crates/tinycomputer-browser/src/sessions/sessions_tests/page_tests.rs b/crates/tinycomputer-browser/src/sessions/sessions_tests/page_tests.rs
index 533741de..fff34d35 100644
--- a/crates/tinycomputer-browser/src/sessions/sessions_tests/page_tests.rs
+++ b/crates/tinycomputer-browser/src/sessions/sessions_tests/page_tests.rs
@@ -120,6 +120,7 @@ async fn actions_return_read_values_and_the_page_they_left() {
             &id,
             Action::Press {
                 key: "Enter".to_owned(),
+                target: None,
             },
         )
         .await
diff --git a/crates/tinycomputer-browser/src/surface/operations.rs b/crates/tinycomputer-browser/src/surface/operations.rs
index 0f8a74e1..60f3d56e 100644
--- a/crates/tinycomputer-browser/src/surface/operations.rs
+++ b/crates/tinycomputer-browser/src/surface/operations.rs
@@ -243,7 +243,7 @@ impl Surface for BrowserSurface {
                 DesktopError::new("INVALID_KEY", "press needs a key"),
             );
         }
-        self.perform("press", Action::Press { key })
+        self.perform("press", Action::Press { key, target: None })
     }
 
     fn launch(&self, _app: &str) -> DesktopResponse {
diff --git a/crates/tinycomputer-bus/src/browser/action/action_tests.rs b/crates/tinycomputer-bus/src/browser/action/action_tests.rs
index 358ec321..4a89014d 100644
--- a/crates/tinycomputer-bus/src/browser/action/action_tests.rs
+++ b/crates/tinycomputer-bus/src/browser/action/action_tests.rs
@@ -124,6 +124,40 @@ fn typing_defaults_to_the_focused_element() {
     );
 }
 
+#[test]
+fn a_press_carries_its_target_only_when_it_has_one() {
+    let untargeted = Action::Press {
+        key: "Enter".to_string(),
+        target: None,
+    };
+    assert_eq!(
+        serde_json::to_value(&untargeted).expect("serializes"),
+        json!({ "action": "press", "key": "Enter" })
+    );
+    assert_eq!(
+        serde_json::from_value::<Action>(json!({ "action": "press", "key": "Enter" }))
+            .expect("deserializes"),
+        untargeted
+    );
+    let targeted = Action::Press {
+        key: " ".to_string(),
+        target: Some(Target::reference("e5")),
+    };
+    let encoded = json!({
+        "action": "press",
+        "key": " ",
+        "target": { "kind": "ref", "value": "e5" },
+    });
+    assert_eq!(
+        serde_json::to_value(&targeted).expect("serializes"),
+        encoded
+    );
+    assert_eq!(
+        serde_json::from_value::<Action>(encoded).expect("deserializes"),
+        targeted
+    );
+}
+
 #[test]
 fn wait_for_defaults_to_waiting_for_visibility() {
     let action: Action = serde_json::from_value(json!({
diff --git a/crates/tinycomputer-bus/src/browser/action/types.rs b/crates/tinycomputer-bus/src/browser/action/types.rs
index 8d1312af..20608deb 100644
--- a/crates/tinycomputer-bus/src/browser/action/types.rs
+++ b/crates/tinycomputer-bus/src/browser/action/types.rs
@@ -222,11 +222,18 @@ pub enum Action {
         target: Target,
     },
     /// Give an element keyboard focus without clicking it.
+    ///
+    /// Refused when the focus does not land on the element (a heading, say,
+    /// which takes none), rather than reported done with the focus elsewhere.
     Focus {
         /// The element to focus.
         target: Target,
     },
     /// Clear a field and set its value in one step.
+    ///
+    /// The field is given the focus first, and the fill is refused unless the
+    /// focus lands on it: a value meant for one field never goes into
+    /// whichever field last had the focus.
     Fill {
         /// The field to fill.
         target: Target,
@@ -239,7 +246,9 @@ pub enum Action {
     /// — an autocomplete, a search-as-you-type box — never sees the input event
     /// a bulk value assignment skips.
     Type {
-        /// The field to type into. Defaults to whatever currently has focus.
+        /// The field to type into: it is given the focus first, and typing is
+        /// refused unless the focus lands on it. Without one, the text goes to
+        /// whatever has the focus.
         #[serde(default)]
         target: Option<Target>,
         /// The text to type.
@@ -252,6 +261,12 @@ pub enum Action {
     Press {
         /// The key or chord.
         key: String,
+        /// The element to press it on: it is given the focus first, and the
+        /// press is refused unless the focus lands on it, so a key meant for
+        /// one element never presses whichever control last had the focus.
+        /// Without one, the key goes to whatever has the focus.
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        target: Option<Target>,
     },
     /// Choose one or more options in a `<select>`.
     Select {
diff --git a/crates/tinycomputer-bus/src/browser/tool/mod.rs b/crates/tinycomputer-bus/src/browser/tool/mod.rs
index b416f37e..2d3e2234 100644
--- a/crates/tinycomputer-bus/src/browser/tool/mod.rs
+++ b/crates/tinycomputer-bus/src/browser/tool/mod.rs
@@ -258,6 +258,7 @@ impl ToolArgs {
             ToolAction::Hover => Action::Hover { target: target()? },
             ToolAction::Press => Action::Press {
                 key: Self::required(&self.key, "key")?.into(),
+                target: self.selector.as_deref().map(Target::parse),
             },
             ToolAction::Scroll => Action::Scroll {
                 direction: match Self::required(&self.direction, "direction")? {
diff --git a/crates/tinycomputer-bus/src/browser/tool/tool_tests.rs b/crates/tinycomputer-bus/src/browser/tool/tool_tests.rs
index af1d838d..62c3e7d0 100644
--- a/crates/tinycomputer-bus/src/browser/tool/tool_tests.rs
+++ b/crates/tinycomputer-bus/src/browser/tool/tool_tests.rs
@@ -103,6 +103,28 @@ fn click_fill_and_type_parse_their_targets() {
     );
 }
 
+#[test]
+fn a_press_takes_the_selector_as_its_target_when_one_is_given() {
+    assert_eq!(
+        args(json!({"action":"press","key":"Enter"}))
+            .to_action()
+            .unwrap(),
+        Action::Press {
+            key: "Enter".into(),
+            target: None
+        }
+    );
+    assert_eq!(
+        args(json!({"action":"press","key":"Enter","selector":"@e5"}))
+            .to_action()
+            .unwrap(),
+        Action::Press {
+            key: "Enter".into(),
+            target: Some(Target::parse("@e5"))
+        }
+    );
+}
+
 #[test]
 fn a_blank_required_parameter_is_missing() {
     let err = args(json!({"action":"click","selector":"  "}))
diff --git a/crates/tinycomputer-bus/src/version/mod.rs b/crates/tinycomputer-bus/src/version/mod.rs
index 5a94b741..6d49a302 100644
--- a/crates/tinycomputer-bus/src/version/mod.rs
+++ b/crates/tinycomputer-bus/src/version/mod.rs
@@ -8,7 +8,7 @@
 //! release workflow bumps, which tracks the shipped artifact.
 
 /// The wire contract version this crate defines.
-pub const CONTRACT_VERSION: (u32, u32) = (2, 17);
+pub const CONTRACT_VERSION: (u32, u32) = (2, 18);
 
 /// Returns whether a host holding [`CONTRACT_VERSION`] can bind to a module
 /// reporting `module`.
@@ -22,7 +22,7 @@ pub const CONTRACT_VERSION: (u32, u32) = (2, 17);
 /// ```
 /// # use tinycomputer_bus::{is_compatible, CONTRACT_VERSION};
 /// assert!(is_compatible(CONTRACT_VERSION));
-/// assert!(is_compatible((2, 17)));
+/// assert!(is_compatible((2, 18)));
 /// assert!(!is_compatible((2, 11)));
 /// assert!(!is_compatible((1, 8)));
 /// ```
diff --git a/crates/tinycomputer-bus/src/version/version_tests.rs b/crates/tinycomputer-bus/src/version/version_tests.rs
index 25603b63..f80202ed 100644
--- a/crates/tinycomputer-bus/src/version/version_tests.rs
+++ b/crates/tinycomputer-bus/src/version/version_tests.rs
@@ -6,7 +6,7 @@ use super::{CONTRACT_VERSION, binds, is_compatible};
 
 #[test]
 fn the_shipped_contract_version_is_pinned() {
-    assert_eq!(CONTRACT_VERSION, (2, 17));
+    assert_eq!(CONTRACT_VERSION, (2, 18));
 }
 
 #[test]
@@ -16,7 +16,7 @@ fn the_contract_binds_to_itself() {
 
 #[test]
 fn a_newer_minor_on_the_module_side_binds() {
-    assert!(is_compatible((2, 17)));
+    assert!(is_compatible((2, 18)));
     assert!(is_compatible((2, 97)));
     // 2.12 adds replayable GlobeRead and joined terminal GlobeShutdown.
     // A 2.11 module does not implement those members.
@@ -29,6 +29,10 @@ fn a_newer_minor_on_the_module_side_binds() {
     // 2.15 adds browser::tool: the recorded `browser` tool schema and ToolArgs.
     // 2.16 adds desktop_tool: the eight desktop tool declarations and request builders.
     // 2.17 adds `StartTask.site` and the `epoch` on `SiteMemoryHost` Load/Save.
+    // 2.18 gives `Press` an optional `target`, which the module focuses and
+    // checks before the key goes: a 2.17 module would ignore the field and
+    // press the key wherever the focus is.
+    assert!(!is_compatible((2, 17)));
     assert!(!is_compatible((2, 16)));
     assert!(!is_compatible((2, 15)));
     assert!(!is_compatible((2, 14)));
diff --git a/crates/tinycomputer/src/tinybus_module/tinybus_module_tests/browser_tests.rs b/crates/tinycomputer/src/tinybus_module/tinybus_module_tests/browser_tests.rs
index dedbb782..ad5bede6 100644
--- a/crates/tinycomputer/src/tinybus_module/tinybus_module_tests/browser_tests.rs
+++ b/crates/tinycomputer/src/tinybus_module/tinybus_module_tests/browser_tests.rs
@@ -225,6 +225,44 @@ async fn a_stale_ref_fails_with_the_desktop_code_and_recovery() -> tinybus::Resu
     Ok(())
 }
 
+#[tokio::test]
+async fn a_key_for_an_element_the_focus_misses_is_refused_unsent() -> tinybus::Result<()> {
+    // The scripted page never shows the focus on anything, as a heading that
+    // takes none would leave it: the press is refused, not sent.
+    let scratch = Scratch::new("focus");
+    let launcher = Arc::new(ScriptedLauncher::default());
+    let (_server, proxy) = serve_with(&scratch, &json!({}), launcher.clone()).await?;
+    let opened = call(&proxy, methods::OPEN_SESSION, json!({})).await?;
+    let session = data(&opened)["id"].clone();
+
+    let reply = call(
+        &proxy,
+        methods::PERFORM,
+        json!({
+            "session": session,
+            "action": "press",
+            "key": "Enter",
+            "target": {"kind": "ref", "value": "e5"},
+        }),
+    )
+    .await?;
+    let error = reply.error.expect("a missed focus fails");
+    assert_eq!(error.code, "NOT_ACTIONABLE");
+    assert_eq!(
+        error.details.expect("details carry the wire name")["name"],
+        tinycomputer_bus::browser::errors::NOT_ACTIONABLE
+    );
+    assert!(
+        error
+            .suggestion
+            .is_some_and(|hint| hint.contains("act on the field itself"))
+    );
+    let sent = launcher.0.lock().expect("the log is not poisoned");
+    assert!(sent.iter().any(|command| command["action"] == "focus"));
+    assert!(!sent.iter().any(|command| command["action"] == "press"));
+    Ok(())
+}
+
 #[tokio::test]
 async fn an_unknown_session_is_refused_before_anything_is_sent() -> tinybus::Result<()> {
     let scratch = Scratch::new("unknown");
diff --git a/crates/tinycomputer/tests/public_api_tests.rs b/crates/tinycomputer/tests/public_api_tests.rs
index 1a377bc2..7b8e9e33 100644
--- a/crates/tinycomputer/tests/public_api_tests.rs
+++ b/crates/tinycomputer/tests/public_api_tests.rs
@@ -34,7 +34,7 @@ fn the_crate_re_exports_the_contract_rather_than_redefining_it() {
 #[test]
 fn the_shipped_contract_binds_to_itself() {
     assert!(is_compatible(CONTRACT_VERSION));
-    assert_eq!(CONTRACT_VERSION, (2, 17));
+    assert_eq!(CONTRACT_VERSION, (2, 18));
 }
 
 #[test]
diff --git a/docs/crates/tinycomputer-browser/interacting.md b/docs/crates/tinycomputer-browser/interacting.md
index 41adb9f2..90037f38 100644
--- a/docs/crates/tinycomputer-browser/interacting.md
+++ b/docs/crates/tinycomputer-browser/interacting.md
@@ -21,7 +21,9 @@ the same `convert` functions and the same agent-browser engine:
 
 This page is mostly about the second path, because it is where the
 interesting behavior lives. The direct path is a straightforward
-`Action → JSON command` mapping in `convert/interaction.rs`, with no logic of its own.
+`Action → JSON command` mapping in `convert/interaction.rs`, with no logic of its own
+beyond the focus check every action that sends keys passes first (see "Keys go only
+where an action points").
 
 ## Targets: ref, selector, or locator
 
@@ -169,6 +171,38 @@ up. Selecting is idempotent, so pressing an already-selected element a
 second time is harmless; a checkbox, which *toggles* rather than selects,
 is never pressed this way.
 
+## Keys go only where an action points
+
+agent-browser types and presses into whatever holds the keyboard focus. It
+asks the target to take the focus first, but an element that takes none (a
+heading, a label) leaves the focus where it was, so text typed "into" a
+heading lands in the field filled before it, a card number say, and a key
+pressed on one presses whatever button last had the focus.
+
+So `Browser::perform` checks first (`sessions/focus.rs`), for `Focus`,
+`Fill`, `Type` with a target, and `Press` with a target:
+
+1. It takes the focus off whatever holds it, reaching through open shadow
+   roots and same-origin frames.
+2. It gives the target the focus (agent-browser's `focus`).
+3. It marks the elements now holding the focus with a fresh random value
+   (`data-tc-focus`) and asks agent-browser for that attribute on the
+   target, which resolves the target in its own frame. Only the target, or
+   a shadow host around it, carries the mark. The marks come off again
+   either way.
+4. If the mark is not on the target, the action fails with
+   `Error::FocusMissed` (`NOT_ACTIONABLE` on the wire, naming only the tag
+   that holds the focus) and nothing is typed or pressed.
+
+Two limits. Inside a cross-origin frame (a payment provider's card field)
+the page cannot see where the focus is; with the focus taken off everything
+first, it can only be there because the target took it, so that goes ahead.
+And a page's own scripts run between these steps and could fool the check:
+it stops mistakes, not a page set on defeating it. A locator's `Fill`, which
+only agent-browser resolves, cannot be checked; the focus is taken off
+whatever held it first, so its text lands in the field or nowhere. `Type`
+and `Press` without a target still go wherever the focus is.
+
 ## Typing text
 
 There are two distinct actions, on purpose:
@@ -206,7 +240,9 @@ the same `NOT_A_TEXT_FIELD` case as typing.
 
 ## Pressing keys
 
-`Action::Press` sends one key or chord (`Enter`, `Tab`, `Control+a`).
+`Action::Press` sends one key or chord (`Enter`, `Tab`, `Control+a`), to
+whatever has the focus, or, with a `target`, to that element once the focus
+is checked to be on it (see "Keys go only where an action points").
 `BrowserSurface::press` takes a logical combo string like `cmd+a` or
 `return` and spells it the way agent-browser expects (`browser_key` in
 `surface/operations.rs`): the logical `cmd` becomes whichever platform key
diff --git a/docs/crates/tinycomputer-bus/browser.md b/docs/crates/tinycomputer-bus/browser.md
index bbb54b8c..59256eb2 100644
--- a/docs/crates/tinycomputer-bus/browser.md
+++ b/docs/crates/tinycomputer-bus/browser.md
@@ -151,6 +151,11 @@ Two distinctions worth knowing:
   there, the only way to trigger the per-keystroke handlers an
   autocomplete or search-as-you-type box depends on, which a bulk value
   assignment skips entirely.
+- **Keys go only where an action points.** `Focus`, `Fill`, and `Type` and
+  `Press` with a `target` (a press's target is optional, from 2.18) are
+  refused, `NOT_ACTIONABLE`, unless the page's focus lands on the target,
+  rather than sending keys to whichever element last had the focus. `Type`
+  and `Press` without a target go wherever the focus is.
 - **`Click` fails loudly, not quietly, when covered.** A click on an element
   another element covers (a consent banner, a modal) fails and names the
   covering element, rather than reporting success while the click actually
diff --git a/docs/crates/tinycomputer-bus/versioning.md b/docs/crates/tinycomputer-bus/versioning.md
index d1727119..cffd1940 100644
--- a/docs/crates/tinycomputer-bus/versioning.md
+++ b/docs/crates/tinycomputer-bus/versioning.md
@@ -9,7 +9,7 @@ code, so this page exists mostly to keep them apart.
 ## `CONTRACT_VERSION`: does this host understand this module
 
 ```rust,ignore
-pub const CONTRACT_VERSION: (u32, u32) = (2, 17);
+pub const CONTRACT_VERSION: (u32, u32) = (2, 18);
 ```
 
 This describes the *vocabulary*: the member set and the payload shapes,
@@ -45,15 +45,15 @@ Two conditions, both necessary:
    relies on changed shape or disappeared, so a mismatched major is refused
    outright, in either direction.
 2. **The module must be at least as new, minor-wise, as the host.** A host
-   built against `(2, 17)` expects at least the members and fields that
-   existed at `(2, 17)`. A module reporting `(2, 11)` might be missing one of
-   them, so it is rejected. A module reporting `(2, 17)` has everything the
+   built against `(2, 18)` expects at least the members and fields that
+   existed at `(2, 18)`. A module reporting `(2, 11)` might be missing one of
+   them, so it is rejected. A module reporting `(2, 18)` has everything the
    host expects, plus something newer the host simply does not use yet, so
    it is accepted.
 
 ```rust,ignore
-assert!(is_compatible(CONTRACT_VERSION));   // (2, 17), the exact version this crate ships
-assert!(is_compatible((2, 17)));            // a newer, still-compatible module
+assert!(is_compatible(CONTRACT_VERSION));   // (2, 18), the exact version this crate ships
+assert!(is_compatible((2, 18)));            // a newer, still-compatible module
 assert!(!is_compatible((2, 11)));            // an older module, missing something
 assert!(!is_compatible((1, 10)));           // a different major, all bets off
 ```
diff --git a/docs/technical/specs/desktop-module-contract.md b/docs/technical/specs/desktop-module-contract.md
index 633d6734..abb84164 100644
--- a/docs/technical/specs/desktop-module-contract.md
+++ b/docs/technical/specs/desktop-module-contract.md
@@ -70,7 +70,12 @@ engine's argument types, the permission preflight, and the bus surface.
   `not_delivered`; every other failure's delivery is `unknown`. The members share
   one `Browser` with the task runner, so `BrowserReadOutput` reads a
   screenshot in a task's `TaskReport.artifacts` (never in a task view) and
-  `BrowserListSessions` shows a task's session. The `ai.tinyhumans.tinycomputer.Browser` interface and its
+  `BrowserListSessions` shows a task's session. `BrowserPerform` sends keys
+  only where an action points (2.18 gives `Press` an optional `target`): a
+  `Focus`, a `Fill`, a `Type` with a target, and a `Press` with one first take
+  the page's focus off whatever holds it, give it to the target, and check it
+  landed there, or fail `NOT_ACTIONABLE` with nothing typed or pressed; a
+  2.17 module ignores a press's `target`. The `ai.tinyhumans.tinycomputer.Browser` interface and its
   unprefixed names, never served by any release, are retired; the error
   names keep that prefix because they are published values, not members.
 - `TaskReport` takes a `TaskReportRequest` (2.7), `{"id", "trace"}` with