diff --git a/crates/engine/src/cmd/table.rs b/crates/engine/src/cmd/table.rs
index a8476e6b..4c46eb5f 100644
--- a/crates/engine/src/cmd/table.rs
+++ b/crates/engine/src/cmd/table.rs
@@ -89,6 +89,14 @@ pub fn table_frame(st: &DocState, sh: &Shape) -> Option<TableFrame> {
 }
 
 impl TableFrame {
+    pub fn width(&self) -> f64 {
+        self.cols.iter().map(|w| w.max(0.0)).sum()
+    }
+
+    pub fn height(&self) -> f64 {
+        self.heights.iter().map(|h| h.max(0.0)).sum()
+    }
+
     /// Table-local point for slide point `p`.
     pub fn local(&self, p: Point) -> Point {
         self.affine.inverse() * p
@@ -98,6 +106,18 @@ impl TableFrame {
     pub fn cell_rect(&self, r: usize, c: usize) -> Option<Rect> {
         self.cells.iter().find(|(cr, cc, _)| (*cr, *cc) == (r, c)).map(|x| x.2)
     }
+
+    /// The visible cell at table-local point `p` (points outside the table go to the nearest cell).
+    pub fn cell_at(&self, p: Point) -> Option<(usize, usize)> {
+        let q = Point::new(p.x.clamp(0.0, self.width().max(0.0)), p.y.clamp(0.0, self.height().max(0.0)));
+        let inside = |r: &Rect| q.x >= r.x0 && q.x <= r.x1 && q.y >= r.y0 && q.y <= r.y1;
+        // Edges are shared: prefer the cell the point is strictly inside.
+        self.cells
+            .iter()
+            .find(|(_, _, r)| q.x >= r.x0 && q.x < r.x1 && q.y >= r.y0 && q.y < r.y1)
+            .or_else(|| self.cells.iter().rev().find(|(_, _, r)| inside(r)))
+            .map(|(r, c, _)| (*r, *c))
+    }
 }
 
 fn cell_param(p: &Value, key: &str) -> Option<(usize, usize)> {
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 10630add..69d3bc68 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -415,6 +415,17 @@ fn table_at(s: &mut Session, cols: &[f64], data: serde_json::Value) -> deckcraft
     id
 }
 
+fn table_of(s: &Session, id: deckcraft_model::ShapeId) -> deckcraft_model::Table {
+    match &s.doc().unwrap().shape(id).unwrap().kind {
+        deckcraft_model::ShapeKind::Table(t) => t.clone(),
+        k => panic!("not a table: {k:?}"),
+    }
+}
+
+fn tev(kind: PointerKind, x: f64, y: f64) -> PointerEvent {
+    PointerEvent { kind, x, y, mods: Mods::default(), tol: 3.0 }
+}
+
 fn text_sel(s: &Session) -> Option<TextSel> {
     s.doc().unwrap().selection.text.clone()
 }
@@ -451,6 +462,86 @@ fn cell_text_is_laid_out_where_the_cell_draws_it() {
     assert_eq!(cmd::text::text_pos_at(st, &t, deckcraft_geom::Point::new(295.0, 115.0)), (0, 11));
 }
 
+#[test]
+fn double_click_in_a_cell_selects_the_word_clicked() {
+    let mut s = session();
+    let id = table_at(&mut s, &[200.0, 200.0], json!([["Hello world", "b"], ["c", "d"]]));
+    // Where "world" is drawn.
+    s.execute("text.edit", &json!({"id": id, "cell": [0, 0]})).unwrap();
+    let p = caret_point(&s, 0, 8);
+    s.execute("text.exit", &json!({})).unwrap();
+    s.execute("edit.deselect", &json!({})).unwrap();
+    // As the UI sends it: press, release, press, double-click (on release), then the release.
+    s.pointer(tev(PointerKind::Down, p.x, p.y)).unwrap();
+    s.pointer(tev(PointerKind::Up, p.x, p.y)).unwrap();
+    assert!(text_sel(&s).is_none(), "a click on an unselected table selects it");
+    s.pointer(tev(PointerKind::Down, p.x, p.y)).unwrap();
+    s.pointer(tev(PointerKind::DoubleClick, p.x, p.y)).unwrap();
+    s.pointer(tev(PointerKind::Up, p.x, p.y)).unwrap();
+    let t = text_sel(&s).unwrap();
+    assert_eq!((t.cell, t.ordered()), (Some((0, 0)), ((0, 6), (0, 11))), "the word under the double-click");
+    // The control channel sends the double-click alone.
+    s.execute("text.exit", &json!({})).unwrap();
+    s.execute("edit.deselect", &json!({})).unwrap();
+    s.pointer(tev(PointerKind::DoubleClick, p.x, p.y)).unwrap();
+    assert_eq!(text_sel(&s).map(|t| t.ordered()), Some(((0, 6), (0, 11))));
+}
+
+#[test]
+fn clicks_while_editing_a_cell_move_the_caret_between_cells() {
+    let mut s = session();
+    let id = table_at(&mut s, &[200.0, 200.0], json!([["Hello world", "Second cell"], ["c", "d"]]));
+    s.execute("text.edit", &json!({"id": id, "cell": [0, 1], "at": [0, 0]})).unwrap();
+    let p6 = caret_point(&s, 0, 6);
+    let p11 = caret_point(&s, 0, 11);
+    s.execute("text.edit", &json!({"id": id, "cell": [1, 0]})).unwrap();
+    // A click in another cell of the table moves the caret there, at the click.
+    s.pointer(tev(PointerKind::Down, p6.x, p6.y)).unwrap();
+    let t = text_sel(&s).unwrap();
+    assert_eq!((t.shape, t.cell, t.caret, t.anchor), (id, Some((0, 1)), (0, 6), (0, 6)));
+    // Dragging selects within that cell, even past its edge.
+    s.pointer(tev(PointerKind::Drag, p11.x, p11.y)).unwrap();
+    s.pointer(tev(PointerKind::Drag, 600.0, p11.y)).unwrap();
+    s.pointer(tev(PointerKind::Up, 600.0, p11.y)).unwrap();
+    let t = text_sel(&s).unwrap();
+    assert_eq!((t.cell, t.ordered()), (Some((0, 1)), ((0, 6), (0, 11))));
+    // Shift+click in another cell starts a new caret there instead of extending across cells.
+    let shift = Mods { shift: true, ..Default::default() };
+    s.pointer(PointerEvent { mods: shift, ..tev(PointerKind::Down, 150.0, 165.0) }).unwrap();
+    s.pointer(tev(PointerKind::Up, 150.0, 165.0)).unwrap();
+    let t = text_sel(&s).unwrap();
+    assert_eq!((t.cell, t.is_range()), (Some((1, 0)), false));
+    // Typing goes into the clicked cell.
+    s.execute("text.insert", &json!({"text": "X"})).unwrap();
+    assert_eq!(table_of(&s, id).cell(1, 0).unwrap().text.text(), "cX");
+    // A click outside the table stops editing.
+    s.pointer(tev(PointerKind::Down, 50.0, 400.0)).unwrap();
+    s.pointer(tev(PointerKind::Up, 50.0, 400.0)).unwrap();
+    assert!(text_sel(&s).is_none());
+}
+
+#[test]
+fn a_click_in_a_selected_table_enters_the_clicked_cell() {
+    let mut s = session();
+    let id = table_at(&mut s, &[200.0, 200.0], json!([["a", "b"], ["c", "Hello world"]]));
+    s.pointer(tev(PointerKind::Down, 350.0, 160.0)).unwrap();
+    s.pointer(tev(PointerKind::Up, 350.0, 160.0)).unwrap();
+    assert_eq!((s.doc().unwrap().selection.shapes.clone(), text_sel(&s)), (vec![id], None), "the first click selects the table");
+    let st = s.doc().unwrap();
+    let p = text_point(st, &TextSel { shape: id, cell: Some((1, 1)), ..Default::default() }, 0, 6);
+    s.pointer(tev(PointerKind::Down, p.x, p.y)).unwrap();
+    s.pointer(tev(PointerKind::Up, p.x, p.y)).unwrap();
+    let t = text_sel(&s).unwrap();
+    assert_eq!((t.cell, t.caret), (Some((1, 1)), (0, 6)), "caret at the click");
+    // Dragging a selected table still moves it.
+    s.execute("text.exit", &json!({})).unwrap();
+    s.pointer(tev(PointerKind::Down, 150.0, 120.0)).unwrap();
+    s.pointer(tev(PointerKind::Drag, 170.0, 130.0)).unwrap();
+    s.pointer(tev(PointerKind::Up, 170.0, 130.0)).unwrap();
+    assert!(text_sel(&s).is_none());
+    assert_ne!(s.doc().unwrap().shape(id).unwrap().xfrm.unwrap().x, 100.0);
+}
+
 #[test]
 fn caret_moves_by_line_in_a_wrapped_cell() {
     let mut s = session();
@@ -466,6 +557,18 @@ fn caret_moves_by_line_in_a_wrapped_cell() {
     assert!(text_sel(&s).unwrap().caret.1 < down.1);
 }
 
+#[test]
+fn rotated_tables_hit_the_cell_under_the_pointer() {
+    let mut s = session();
+    let id = table_at(&mut s, &[100.0, 100.0], json!([["a", "b"], ["c", "d"]]));
+    s.execute("shape.rotate", &json!({"ids": [id], "deg": 90})).unwrap();
+    let st = s.doc().unwrap();
+    let f = cmd::table::table_frame(st, st.shape(id).unwrap()).unwrap();
+    let p = f.affine * deckcraft_geom::Point::new(150.0, 60.0);
+    s.pointer(tev(PointerKind::DoubleClick, p.x, p.y)).unwrap();
+    assert_eq!(text_sel(&s).and_then(|t| t.cell), Some((1, 1)));
+}
+
 #[test]
 fn right_to_left_paragraphs() {
     let mut s = session();
diff --git a/crates/engine/src/tools.rs b/crates/engine/src/tools.rs
index c684dc68..ab051c7a 100644
--- a/crates/engine/src/tools.rs
+++ b/crates/engine/src/tools.rs
@@ -361,30 +361,10 @@ impl Session {
             }
             ToolKind::Select => {}
         }
-        let st = self.doc()?;
         // Clicking inside the text being edited moves the caret / starts a text selection.
-        if let Some(t) = st.selection.text.clone()
-            && !t.notes
-            && t.cell.is_none()
-            && let Some(sh) = st.shape(t.shape)
-        {
-            let x = xfrm_of(&st.doc, &st.selection, sh);
-            if x.bounds().inflate(tol, tol).contains(p)
-                && !matches!(self.hit_test(p, tol), Some(Hit::Resize { .. } | Hit::Rotate { .. } | Hit::Adjust { .. }))
-            {
-                let pos = text_pos(st, sh, p);
-                let shift = mods.shift;
-                self.select(|_, sel| {
-                    if let Some(tt) = sel.text.as_mut() {
-                        tt.caret = pos;
-                        if !shift {
-                            tt.anchor = pos;
-                        }
-                    }
-                })?;
-                self.tool.drag = Some(Drag::TextSelect { shape: t.shape });
-                return Ok(json!({"caret": [pos.0, pos.1]}));
-            }
+        if let Some((shape, pos)) = self.place_caret(p, tol, mods.shift)? {
+            self.tool.drag = Some(Drag::TextSelect { shape });
+            return Ok(json!({"caret": [pos.0, pos.1]}));
         }
         let hit = self.hit_test(p, tol);
         let st = self.doc()?;
@@ -432,8 +412,10 @@ impl Session {
                 let origs: Vec<(ShapeId, Xfrm)> =
                     ids.iter().filter_map(|i| st.shape(*i).filter(|s| !s.locked).map(|s| (*i, xfrm_of(&st.doc, &st.selection, s)))).collect();
                 // A click (no drag) on text puts the caret there; unselected text boxes and
-                // placeholders take the caret straight away like PowerPoint.
-                let enter_text = (text && !toggle && (selected || is_text_first(st, id))).then_some((id, p));
+                // placeholders take the caret straight away like PowerPoint. A click in a selected
+                // table puts the caret in the clicked cell.
+                let table = st.shape(id).is_some_and(|s| matches!(s.kind, ShapeKind::Table(_)));
+                let enter_text = (!toggle && ((text && (selected || is_text_first(st, id))) || (table && selected))).then_some((id, p));
                 let ids2 = ids.clone();
                 self.select(|_, sel| {
                     sel.shapes = ids2;
@@ -630,9 +612,10 @@ impl Session {
                 self.tool.preview = Some(x);
             }
             Drag::TextSelect { shape } => {
+                // The selection stays in the shape or table cell where it started.
                 let st = self.doc()?;
-                if let Some(sh) = st.shape(shape) {
-                    let pos = text_pos(st, sh, p);
+                if let Some(t) = st.selection.text.as_ref().filter(|t| t.shape == shape) {
+                    let pos = cmd::text::text_pos_at(st, t, p);
                     self.select(|_, sel| {
                         if let Some(t) = sel.text.as_mut() {
                             t.caret = pos;
@@ -669,11 +652,8 @@ impl Session {
         let mut out = Value::Null;
         match drag {
             Some(Drag::Move { moved: false, enter_text: Some((id, at)), .. }) => {
-                // Plain click on text: caret at the click.
-                let st = self.doc()?;
-                if let Some(sh) = st.shape(id) {
-                    let pos = text_pos(st, sh, at);
-                    self.execute("text.edit", &json!({"id": id, "at": [pos.0, pos.1]}))?;
+                // Plain click on text: caret at the click (in a table, in the clicked cell).
+                if self.edit_text_at(id, at)? {
                     out = json!({"editing": id});
                 }
             }
@@ -792,8 +772,12 @@ impl Session {
             self.tool.sticky = false;
             return Ok(Value::Null);
         }
-        let st = self.doc()?;
-        if st.selection.text.is_some() {
+        // The double-click's second press started a click (caret on release): this replaces it.
+        if matches!(self.tool.drag, Some(Drag::Move { moved: false, .. })) {
+            self.tool.drag = None;
+        }
+        // In the text being edited: select the word double-clicked.
+        if self.place_caret(p, tol, false)?.is_some() {
             return self.execute("text.selectWord", &json!({}));
         }
         match self.hit_test(p, tol) {
@@ -801,18 +785,12 @@ impl Session {
                 let st = self.doc()?;
                 let Some(sh) = st.shape(id).cloned() else { return Ok(Value::Null) };
                 match &sh.kind {
-                    ShapeKind::Table(_) => {
-                        let x = xfrm_of(&st.doc, &st.selection, &sh);
-                        let local = x.affine().inverse() * p;
-                        if let ShapeKind::Table(t) = &sh.kind {
-                            let cell = deckcraft_render_cell(t, &table_rows(st, t), local);
-                            return self.execute("text.edit", &json!({"id": id, "cell": [cell.0, cell.1]}));
+                    ShapeKind::Table(_) | ShapeKind::Shape | ShapeKind::Connector { .. } if !sh.is_line() => {
+                        // Caret at the double-click (in a table, in the clicked cell), then select
+                        // the word there.
+                        if !self.edit_text_at(id, p)? {
+                            return Ok(Value::Null);
                         }
-                        Ok(Value::Null)
-                    }
-                    ShapeKind::Shape | ShapeKind::Connector { .. } if !sh.is_line() => {
-                        let pos = text_pos(st, &sh, p);
-                        self.execute("text.edit", &json!({"id": id, "at": [pos.0, pos.1]}))?;
                         self.execute("text.selectWord", &json!({}))
                     }
                     ShapeKind::Group { .. } => Ok(Value::Null),
@@ -826,6 +804,62 @@ impl Session {
         }
     }
 
+    /// A click at `p` inside the text being edited: the caret goes there (`extend`: the selection
+    /// grows to it). In a table being edited, a click in another cell moves the caret into that
+    /// cell. Returns the edited shape and the caret, or `None` when `p` isn't in the edited text
+    /// (or is on a handle or a table border).
+    fn place_caret(&mut self, p: Point, tol: f64, extend: bool) -> Result<Option<(ShapeId, (usize, usize))>> {
+        let st = self.doc()?;
+        let Some(mut t) = st.selection.text.clone().filter(|t| !t.notes) else { return Ok(None) };
+        let Some(sh) = st.shape(t.shape) else { return Ok(None) };
+        let x = xfrm_of(&st.doc, &st.selection, sh);
+        if !x.bounds().inflate(tol, tol).contains(p)
+            || matches!(self.hit_test(p, tol), Some(Hit::Resize { .. } | Hit::Rotate { .. } | Hit::Adjust { .. }))
+        {
+            return Ok(None);
+        }
+        let old_cell = t.cell;
+        if old_cell.is_some()
+            && let Some(f) = cmd::table::table_frame(st, sh)
+        {
+            t.cell = f.cell_at(f.local(p)).or(old_cell);
+        }
+        let pos = cmd::text::text_pos_at(st, &t, p);
+        // A selection can't span cells: a click in another cell starts afresh.
+        let extend = extend && t.cell == old_cell;
+        let cell = t.cell;
+        self.select(|_, sel| {
+            if let Some(tt) = sel.text.as_mut() {
+                tt.cell = cell;
+                tt.caret = pos;
+                if !extend {
+                    tt.anchor = pos;
+                }
+            }
+        })?;
+        Ok(Some((t.shape, pos)))
+    }
+
+    /// Start editing shape `id`'s text with the caret at slide point `p`; for a table, in the cell
+    /// at `p`. Returns whether editing started.
+    fn edit_text_at(&mut self, id: ShapeId, p: Point) -> Result<bool> {
+        let st = self.doc()?;
+        let Some(sh) = st.shape(id) else { return Ok(false) };
+        let params = match cmd::table::table_frame(st, sh) {
+            Some(f) => {
+                let Some((r, c)) = f.cell_at(f.local(p)) else { return Ok(false) };
+                let pos = cmd::text::text_pos_at(st, &TextSel { shape: id, cell: Some((r, c)), ..Default::default() }, p);
+                json!({"id": id, "cell": [r, c], "at": [pos.0, pos.1]})
+            }
+            None => {
+                let pos = text_pos(st, sh, p);
+                json!({"id": id, "at": [pos.0, pos.1]})
+            }
+        };
+        self.execute("text.edit", &params)?;
+        Ok(true)
+    }
+
     fn is_picture(&self, id: ShapeId) -> bool {
         self.active().and_then(|d| d.shape(id)).is_some_and(|s| matches!(s.kind, ShapeKind::Picture { .. } | ShapeKind::Media(_)))
     }
@@ -1281,29 +1315,6 @@ pub fn table_rows(st: &crate::DocState, t: &deckcraft_model::Table) -> Vec<f64>
     cmd::table_drawn_heights(&st.doc, &st.selection, t)
 }
 
-/// Which table cell contains a table-local point (`heights` from [`table_rows`]).
-fn deckcraft_render_cell(t: &deckcraft_model::Table, heights: &[f64], p: Point) -> (usize, usize) {
-    let mut y = 0.0;
-    let mut row = heights.len().saturating_sub(1);
-    for (i, h) in heights.iter().enumerate() {
-        if p.y < y + h {
-            row = i;
-            break;
-        }
-        y += h;
-    }
-    let mut x = 0.0;
-    let mut col = t.cols.len().saturating_sub(1);
-    for (i, w) in t.cols.iter().enumerate() {
-        if p.x < x + w {
-            col = i;
-            break;
-        }
-        x += w;
-    }
-    (row, col)
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs
index e853130c..d3181247 100644
--- a/crates/ui-egui/src/canvas.rs
+++ b/crates/ui-egui/src/canvas.rs
@@ -743,7 +743,7 @@ mod tests {
         }
     }
 
-    /// Double-clicking a table cell edits it with the caret drawn in that cell.
+    /// Double-clicking a table cell edits it with the caret drawn in that cell, where clicked.
     #[test]
     fn double_click_in_a_table_cell_shows_the_caret_there() {
         let (mut harness, id) = app_with_table();
@@ -762,5 +762,14 @@ mod tests {
         for q in [top, bottom] {
             assert!(q.x > 300.0 && q.x < 500.0 && q.y >= 140.0 && q.y <= 180.0, "caret {q:?} outside cell (1, 1)");
         }
+        // A click in another cell moves the caret there.
+        let p = screen(harness.state(), 110.0, 120.0);
+        click(&mut harness, p);
+        harness.run_steps(1);
+        let st = harness.state().session.active().unwrap();
+        let ts = st.selection.text.clone().unwrap();
+        assert_eq!((ts.cell, ts.caret), (Some((0, 0)), (0, 0)));
+        let (top, _) = deckcraft_engine::cmd::text::caret_line(st, &ts).unwrap();
+        assert!(top.x > 100.0 && top.x < 120.0 && top.y >= 100.0 && top.y < 140.0, "caret {top:?} at the start of cell (0, 0)");
     }
 }