diff --git a/packages/react-grab/e2e/activation-key-config.spec.ts b/packages/react-grab/e2e/activation-key-config.spec.ts
index 40584b4f5..a7d3c62e6 100644
--- a/packages/react-grab/e2e/activation-key-config.spec.ts
+++ b/packages/react-grab/e2e/activation-key-config.spec.ts
@@ -1,4 +1,5 @@
 import { test, expect } from "./fixtures.js";
+import { NON_ACTIVATING_KEY_HOLD_DURATION_MS } from "./constants.js";
 
 test.describe("Activation Key Configuration", () => {
   test.describe.configure({ mode: "serial" });
@@ -154,10 +155,12 @@ test.describe("Activation Key Configuration", () => {
     });
 
     test("should not activate without holding long enough", async ({ reactGrab }) => {
+      await reactGrab.reinitialize({
+        keyHoldDuration: NON_ACTIVATING_KEY_HOLD_DURATION_MS,
+      });
       await reactGrab.page.click("body");
       await reactGrab.page.keyboard.down(reactGrab.modifierKey);
       await reactGrab.page.keyboard.down("c");
-      await reactGrab.page.waitForTimeout(50);
       await reactGrab.page.keyboard.up("c");
       await reactGrab.page.keyboard.up(reactGrab.modifierKey);
 
@@ -169,13 +172,8 @@ test.describe("Activation Key Configuration", () => {
     test("should activate in input by default", async ({ reactGrab }) => {
       await reactGrab.page.click("[data-testid='test-input']");
 
-      await reactGrab.page.keyboard.down(reactGrab.modifierKey);
-      await reactGrab.page.keyboard.down("c");
-      await reactGrab.page.waitForTimeout(500);
-      await reactGrab.page.keyboard.up("c");
-      await reactGrab.page.keyboard.up(reactGrab.modifierKey);
-
-      await expect.poll(() => reactGrab.isOverlayVisible(), { timeout: 1000 }).toBe(true);
+      await reactGrab.activateViaKeyboardFromFocusedInput();
+      expect(await reactGrab.isOverlayVisible()).toBe(true);
     });
 
     test("should not activate in input when disabled", async ({ reactGrab }) => {
diff --git a/packages/react-grab/e2e/activation.spec.ts b/packages/react-grab/e2e/activation.spec.ts
index 9f6e89545..c2629a59e 100644
--- a/packages/react-grab/e2e/activation.spec.ts
+++ b/packages/react-grab/e2e/activation.spec.ts
@@ -99,25 +99,15 @@ test.describe("Activation Mode Configuration", () => {
   test("should activate when focused on input element", async ({ reactGrab }) => {
     await reactGrab.page.click("[data-testid='test-input']");
 
-    await reactGrab.page.keyboard.down(reactGrab.modifierKey);
-    await reactGrab.page.keyboard.down("c");
-    await reactGrab.page.waitForTimeout(500);
-    await reactGrab.page.keyboard.up("c");
-    await reactGrab.page.keyboard.up(reactGrab.modifierKey);
-
-    await expect.poll(() => reactGrab.isOverlayVisible(), { timeout: 1000 }).toBe(true);
+    await reactGrab.activateViaKeyboardFromFocusedInput();
+    expect(await reactGrab.isOverlayVisible()).toBe(true);
   });
 
   test("should activate when focused on textarea", async ({ reactGrab }) => {
     await reactGrab.page.click("[data-testid='test-textarea']");
 
-    await reactGrab.page.keyboard.down(reactGrab.modifierKey);
-    await reactGrab.page.keyboard.down("c");
-    await reactGrab.page.waitForTimeout(500);
-    await reactGrab.page.keyboard.up("c");
-    await reactGrab.page.keyboard.up(reactGrab.modifierKey);
-
-    await expect.poll(() => reactGrab.isOverlayVisible(), { timeout: 1000 }).toBe(true);
+    await reactGrab.activateViaKeyboardFromFocusedInput();
+    expect(await reactGrab.isOverlayVisible()).toBe(true);
   });
 
   test("activation should work after clicking outside input", async ({ reactGrab }) => {
diff --git a/packages/react-grab/e2e/constants.ts b/packages/react-grab/e2e/constants.ts
index 8322a07c6..09f1b54f5 100644
--- a/packages/react-grab/e2e/constants.ts
+++ b/packages/react-grab/e2e/constants.ts
@@ -13,6 +13,8 @@ export const HOST_STYLE_DRAG_DISTANCE_PX = 100;
 export const HOST_STYLE_DRAG_STEP_COUNT = 4;
 export const SHIFT_PENDING_HOVER_STEP_COUNT = 8;
 export const POINTER_SETTLE_DELAY_MS = 32;
+export const FOCUSED_INPUT_KEY_HOLD_DURATION_MS = 700;
+export const NON_ACTIVATING_KEY_HOLD_DURATION_MS = 10_000;
 export const IFRAME_TEST_POINTER_ID = 1;
 export const IFRAME_SCROLL_SETTLE_DELAY_MS = 150;
 export const IFRAME_SCROLL_DELTA_Y_PX = 200;
diff --git a/packages/react-grab/e2e/edit-panel.spec.ts b/packages/react-grab/e2e/edit-panel.spec.ts
index b60573b92..68d7ce3d7 100644
--- a/packages/react-grab/e2e/edit-panel.spec.ts
+++ b/packages/react-grab/e2e/edit-panel.spec.ts
@@ -1178,19 +1178,14 @@ test.describe("Style Panel", () => {
     test("type-to-edit: hover + type m then t → margin-top focused", async ({ reactGrab }) => {
       await reactGrab.activate();
       await reactGrab.hoverUntilSelected(BUTTON_SELECTOR);
-      await reactGrab.page.keyboard.type("mt", { delay: 50 });
+      await reactGrab.page.keyboard.type("m");
       await expect.poll(() => isEditPanelVisible(reactGrab.page)).toBe(true);
-      await reactGrab.page.waitForTimeout(80);
-      const searchValue = await reactGrab.page.evaluate(
-        ({ attrName, inputAttr }) => {
-          const host = document.querySelector(`[${attrName}]`);
-          const shadowRoot = host?.shadowRoot;
-          const input = shadowRoot?.querySelector<HTMLTextAreaElement>(`[${inputAttr}]`);
-          return input?.value ?? null;
-        },
-        { attrName: ATTRIBUTE_NAME, inputAttr: SEARCH_INPUT_ATTR },
-      );
-      expect(searchValue).toBe("mt");
+      const searchInput = reactGrab.page
+        .locator(`[${ATTRIBUTE_NAME}]`)
+        .locator(`[${SEARCH_INPUT_ATTR}]`);
+      await expect(searchInput).toBeFocused();
+      await searchInput.pressSequentially("t");
+      await expect(searchInput).toHaveValue("mt");
       const activeKey = await getActivePropertyKey(reactGrab.page);
       expect(activeKey).toBe("margin-top");
     });
@@ -1200,19 +1195,16 @@ test.describe("Style Panel", () => {
     }) => {
       await reactGrab.activate();
       await reactGrab.hoverUntilSelected(BUTTON_SELECTOR);
-      await reactGrab.page.keyboard.type("mt-", { delay: 50 });
+      await reactGrab.page.keyboard.type("m");
       await expect.poll(() => isEditPanelVisible(reactGrab.page)).toBe(true);
-      await reactGrab.page.waitForTimeout(80);
-      const searchValue = await reactGrab.page.evaluate(
-        ({ attrName, inputAttr }) => {
-          const host = document.querySelector(`[${attrName}]`);
-          const shadowRoot = host?.shadowRoot;
-          const input = shadowRoot?.querySelector<HTMLTextAreaElement>(`[${inputAttr}]`);
-          return input?.value ?? null;
-        },
-        { attrName: ATTRIBUTE_NAME, inputAttr: SEARCH_INPUT_ATTR },
-      );
-      expect(searchValue).toBe("mt-");
+      const searchInput = reactGrab.page
+        .locator(`[${ATTRIBUTE_NAME}]`)
+        .locator(`[${SEARCH_INPUT_ATTR}]`);
+      await searchInput.click();
+      await searchInput.press("t");
+      await expect(searchInput).toHaveValue("mt");
+      await searchInput.press("-");
+      await expect(searchInput).toHaveValue("mt-");
       const activeKey = await getActivePropertyKey(reactGrab.page);
       expect(activeKey).toBe("margin-top");
     });
diff --git a/packages/react-grab/e2e/fixtures.ts b/packages/react-grab/e2e/fixtures.ts
index 45ba12dba..fece67195 100644
--- a/packages/react-grab/e2e/fixtures.ts
+++ b/packages/react-grab/e2e/fixtures.ts
@@ -1,5 +1,5 @@
 import { test as base, expect, Page, Locator } from "@playwright/test";
-import { ATTRIBUTE_NAME } from "./constants.js";
+import { ATTRIBUTE_NAME, FOCUSED_INPUT_KEY_HOLD_DURATION_MS } from "./constants.js";
 import { COVERAGE_RAW_DIR } from "./coverage-config.js";
 
 const COVERAGE_ENABLED = Boolean(process.env.COVERAGE);
@@ -104,6 +104,7 @@ export interface ReactGrabPageObject {
   feedbackModifierKey: ModifierKey;
   activate: () => Promise<void>;
   activateViaKeyboard: () => Promise<void>;
+  activateViaKeyboardFromFocusedInput: () => Promise<void>;
   deactivate: () => Promise<void>;
   isOverlayVisible: () => Promise<boolean>;
   getOverlayHost: () => Locator;
@@ -300,6 +301,15 @@ const createReactGrabPageObject = (
     await waitForActive(true);
   };
 
+  const activateViaKeyboardFromFocusedInput = async () => {
+    await page.keyboard.down(activationModifierKey);
+    await page.keyboard.down("c");
+    await page.waitForTimeout(FOCUSED_INPUT_KEY_HOLD_DURATION_MS);
+    await page.keyboard.up("c");
+    await page.keyboard.up(activationModifierKey);
+    await waitForActive(true);
+  };
+
   const deactivate = async () => {
     await page.keyboard.press("Escape");
     await waitForActive(false);
@@ -654,32 +664,13 @@ const createReactGrabPageObject = (
   };
 
   const typeInInput = async (text: string) => {
-    await page.evaluate((attrName) => {
-      const host = document.querySelector(`[${attrName}]`);
-      const shadowRoot = host?.shadowRoot;
-      if (!shadowRoot) return;
-      const root = shadowRoot.querySelector(`[${attrName}]`);
-      if (!root) return;
-      const textarea = root.querySelector<HTMLTextAreaElement>("[data-react-grab-input]");
-      if (textarea) {
-        textarea.focus();
-      }
-    }, ATTRIBUTE_NAME);
+    const promptInput = getOverlayHost().locator("textarea[data-react-grab-input]");
+    await promptInput.focus();
     await page.keyboard.insertText(text);
   };
 
   const getInputValue = async (): Promise<string> => {
-    return page.evaluate((attrName) => {
-      const host = document.querySelector(`[${attrName}]`);
-      const shadowRoot = host?.shadowRoot;
-      if (!shadowRoot) return "";
-      const root = shadowRoot.querySelector(`[${attrName}]`);
-      if (!root) return "";
-      const textarea = root.querySelector(
-        "textarea[data-react-grab-ignore-events]",
-      ) as HTMLTextAreaElement;
-      return textarea?.value ?? "";
-    }, ATTRIBUTE_NAME);
+    return getOverlayHost().locator("textarea[data-react-grab-input]").inputValue();
   };
 
   const submitInput = async () => {
@@ -1705,6 +1696,7 @@ const createReactGrabPageObject = (
     feedbackModifierKey,
     activate,
     activateViaKeyboard,
+    activateViaKeyboardFromFocusedInput,
     deactivate,
     isOverlayVisible,
     getOverlayHost,
diff --git a/packages/react-grab/e2e/prompt-mode.spec.ts b/packages/react-grab/e2e/prompt-mode.spec.ts
index 2449d418f..6b524506c 100644
--- a/packages/react-grab/e2e/prompt-mode.spec.ts
+++ b/packages/react-grab/e2e/prompt-mode.spec.ts
@@ -137,7 +137,11 @@ test.describe("Prompt Mode", () => {
       await reactGrab.registerCommentAction();
       await reactGrab.enterPromptMode("li:first-child");
 
-      await reactGrab.pressEscape();
+      const promptInput = reactGrab.page.getByRole("textbox", {
+        name: "Add context for selected element",
+      });
+      await promptInput.click();
+      await promptInput.press("Escape");
 
       await expect.poll(() => reactGrab.isPromptModeActive()).toBe(false);
     });
@@ -150,7 +154,11 @@ test.describe("Prompt Mode", () => {
 
       await reactGrab.typeInInput("Some unsaved text");
 
-      await reactGrab.pressEscape();
+      const promptInput = reactGrab.page.getByRole("textbox", {
+        name: "Add context for selected element",
+      });
+      await expect(promptInput).toHaveValue("Some unsaved text");
+      await promptInput.press("Escape");
 
       await expect.poll(() => reactGrab.isPromptModeActive()).toBe(false);
     });
diff --git a/packages/react-grab/e2e/selection.spec.ts b/packages/react-grab/e2e/selection.spec.ts
index dee258e28..94d191c47 100644
--- a/packages/react-grab/e2e/selection.spec.ts
+++ b/packages/react-grab/e2e/selection.spec.ts
@@ -1,5 +1,234 @@
-import { test, expect } from "./fixtures.js";
-import { ATTRIBUTE_NAME } from "./constants.js";
+import { test, expect, type ReactGrabPageObject } from "./fixtures.js";
+import { ATTRIBUTE_NAME, POINTER_SETTLE_DELAY_MS } from "./constants.js";
+
+interface MixedTextTarget {
+  paddingPosition: {
+    x: number;
+    y: number;
+  };
+  position: {
+    x: number;
+    y: number;
+  };
+  textBounds: {
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+  };
+  containerWidth: number;
+}
+
+interface WrappedTextTarget {
+  position: {
+    x: number;
+    y: number;
+  };
+  rectCount: number;
+  rectIndex: number;
+  textBounds: {
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+  };
+}
+
+interface WrappedTextLineTarget {
+  position: {
+    x: number;
+    y: number;
+  };
+  textBounds: {
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+  };
+}
+
+const createMixedTextTarget = async (reactGrab: ReactGrabPageObject): Promise<MixedTextTarget> => {
+  return reactGrab.page.evaluate(() => {
+    const container = document.createElement("div");
+    container.id = "mixed-text-target";
+    container.style.cssText =
+      "position:absolute;left:200px;top:240px;width:500px;padding:12px;background:white;color:black;font:16px sans-serif;z-index:2147483000";
+    container.append("Grab this text ");
+
+    const nestedElement = document.createElement("strong");
+    nestedElement.textContent = "not the nested element";
+    container.append(nestedElement);
+    document.body.append(container);
+    document.body.style.minHeight = "2000px";
+
+    const textNode = container.firstChild;
+    if (!(textNode instanceof Text)) throw new Error("Missing text node");
+
+    const range = document.createRange();
+    range.selectNodeContents(textNode);
+    const textBounds = range.getBoundingClientRect();
+    const containerBounds = container.getBoundingClientRect();
+
+    return {
+      paddingPosition: {
+        x: containerBounds.right - 4,
+        y: containerBounds.top + containerBounds.height / 2,
+      },
+      position: {
+        x: textBounds.left + textBounds.width / 2,
+        y: textBounds.top + textBounds.height / 2,
+      },
+      textBounds: {
+        height: textBounds.height,
+        width: textBounds.width,
+        x: textBounds.x,
+        y: textBounds.y,
+      },
+      containerWidth: containerBounds.width,
+    };
+  });
+};
+
+const createWrappedTextTarget = async (
+  reactGrab: ReactGrabPageObject,
+): Promise<WrappedTextTarget> => {
+  return reactGrab.page.evaluate(() => {
+    const container = document.createElement("div");
+    container.id = "wrapped-text-target";
+    container.style.cssText =
+      "position:absolute;left:200px;top:240px;width:180px;padding:12px;background:white;color:black;font:16px/24px sans-serif;z-index:2147483000";
+    container.append("Grab this wrapped direct text across several separate lines before ");
+
+    const nestedElement = document.createElement("strong");
+    nestedElement.textContent = "nested sibling";
+    container.append(nestedElement);
+    document.body.append(container);
+
+    const textNode = container.firstChild;
+    if (!(textNode instanceof Text)) throw new Error("Missing text node");
+
+    const range = document.createRange();
+    range.selectNodeContents(textNode);
+    const rects = Array.from(range.getClientRects());
+    const textBounds = rects[1];
+    if (!textBounds || rects.length < 2) throw new Error("Text did not wrap");
+
+    return {
+      position: {
+        x: textBounds.left + textBounds.width / 2,
+        y: textBounds.top + textBounds.height / 2,
+      },
+      rectCount: rects.length,
+      rectIndex: 1,
+      textBounds: {
+        height: textBounds.height,
+        width: textBounds.width,
+        x: textBounds.x,
+        y: textBounds.y,
+      },
+    };
+  });
+};
+
+const getWrappedTextLineTarget = async (
+  reactGrab: ReactGrabPageObject,
+  rectIndex: number,
+): Promise<WrappedTextLineTarget> => {
+  return reactGrab.page.evaluate((targetRectIndex) => {
+    const container = document.querySelector("#wrapped-text-target");
+    const textNode = container?.firstChild;
+    if (!(textNode instanceof Text)) throw new Error("Missing wrapped text target");
+
+    const range = document.createRange();
+    range.selectNodeContents(textNode);
+    const textBounds = range.getClientRects()[targetRectIndex];
+    if (!textBounds) throw new Error("Missing wrapped text line");
+
+    return {
+      position: {
+        x: textBounds.left + textBounds.width / 2,
+        y: textBounds.top + textBounds.height / 2,
+      },
+      textBounds: {
+        height: textBounds.height,
+        width: textBounds.width,
+        x: textBounds.x,
+        y: textBounds.y,
+      },
+    };
+  }, rectIndex);
+};
+
+const reflowWrappedTextTarget = async (
+  reactGrab: ReactGrabPageObject,
+  target: WrappedTextTarget,
+): Promise<WrappedTextTarget["textBounds"]> => {
+  return reactGrab.page.evaluate(
+    ({ previousRectCount, previousRectIndex }) => {
+      const container = document.querySelector("#wrapped-text-target");
+      const textNode = container?.firstChild;
+      if (!(container instanceof HTMLElement) || !(textNode instanceof Text)) {
+        throw new Error("Missing wrapped text target");
+      }
+
+      container.style.width = "110px";
+      const range = document.createRange();
+      range.selectNodeContents(textNode);
+      const rects = Array.from(range.getClientRects());
+      const previousMaximumIndex = Math.max(0, previousRectCount - 1);
+      const currentMaximumIndex = rects.length - 1;
+      const normalizedRectIndex =
+        previousMaximumIndex === 0 ? 0 : previousRectIndex / previousMaximumIndex;
+      const currentRectIndex = Math.round(normalizedRectIndex * currentMaximumIndex);
+      const bounds = rects[currentRectIndex];
+      if (!bounds || rects.length === previousRectCount) {
+        throw new Error("Text did not reflow");
+      }
+
+      return {
+        height: bounds.height,
+        width: bounds.width,
+        x: bounds.x,
+        y: bounds.y,
+      };
+    },
+    {
+      previousRectCount: target.rectCount,
+      previousRectIndex: target.rectIndex,
+    },
+  );
+};
+
+const replaceMixedTextNode = async (
+  reactGrab: ReactGrabPageObject,
+  textContent: string,
+): Promise<MixedTextTarget["textBounds"]> => {
+  return reactGrab.page.evaluate((replacementText) => {
+    const container = document.querySelector("#mixed-text-target");
+    const previousTextNode = container?.firstChild;
+    if (!container || !(previousTextNode instanceof Text)) {
+      throw new Error("Missing mixed text target");
+    }
+
+    const textNode = document.createTextNode(replacementText);
+    previousTextNode.replaceWith(textNode);
+    const range = document.createRange();
+    range.selectNodeContents(textNode);
+    const bounds = range.getBoundingClientRect();
+    return {
+      height: bounds.height,
+      width: bounds.width,
+      x: bounds.x,
+      y: bounds.y,
+    };
+  }, textContent);
+};
+
+const getSelectionArrowCenterX = async (reactGrab: ReactGrabPageObject): Promise<number | null> => {
+  const labelBounds = await reactGrab.getSelectionLabelBounds();
+  const arrowBounds = labelBounds?.arrow;
+  return arrowBounds ? arrowBounds.x + arrowBounds.width / 2 : null;
+};
 
 test.describe("Element Selection", () => {
   test("should show selection box when hovering over element while active", async ({
@@ -38,6 +267,462 @@ test.describe("Element Selection", () => {
     await expect.poll(() => reactGrab.getClipboardContent()).toContain("Todo List");
   });
 
+  test("should grab direct text nodes inside mixed-content elements", async ({ reactGrab }) => {
+    const target = await createMixedTextTarget(reactGrab);
+
+    await reactGrab.setupCallbackTracking();
+    await reactGrab.activate();
+    await reactGrab.page.mouse.move(target.position.x, target.position.y);
+
+    await expect
+      .poll(async () => (await reactGrab.getSelectionLabelInfo()).tagName)
+      .toContain("Grab this text");
+
+    const callbackHistory = await reactGrab.getCallbackHistory();
+    const selectionBoxCall = callbackHistory.findLast(
+      (callback) => callback.name === "onSelectionBox" && callback.args[0] === true,
+    );
+    expect(selectionBoxCall?.args[1]).toEqual(
+      expect.objectContaining({
+        width: target.textBounds.width,
+      }),
+    );
+    expect(target.textBounds.width).toBeLessThan(target.containerWidth);
+
+    await reactGrab.page.mouse.click(target.position.x, target.position.y);
+    await expect
+      .poll(
+        async () => {
+          const callbackHistory = await reactGrab.getCallbackHistory();
+          const copySuccessCall = callbackHistory.findLast(
+            (callback) => callback.name === "onCopySuccess",
+          );
+          const copiedContent = copySuccessCall?.args[1];
+          return (
+            typeof copiedContent === "string" &&
+            copiedContent.includes('"Grab this text"') &&
+            !copiedContent.includes("not the nested element")
+          );
+        },
+        { timeout: 10_000 },
+      )
+      .toBe(true);
+
+    const grabbedBoxBeforeScroll = await reactGrab.getGrabbedBoxInfo();
+    const initialGrabbedBoxY = grabbedBoxBeforeScroll.boxes[0]?.bounds.y;
+    if (initialGrabbedBoxY === undefined) throw new Error("Missing grabbed box");
+
+    const scrollYBefore = await reactGrab.page.evaluate(() => window.scrollY);
+    await reactGrab.scrollPage(60);
+    const scrollYAfter = await reactGrab.page.evaluate(() => window.scrollY);
+    const scrollDeltaY = scrollYAfter - scrollYBefore;
+    expect(scrollDeltaY).toBeGreaterThan(0);
+
+    await expect
+      .poll(async () => (await reactGrab.getGrabbedBoxInfo()).boxes[0]?.bounds.y)
+      .toBeCloseTo(initialGrabbedBoxY - scrollDeltaY, 0);
+  });
+
+  test("should edit the parent element of a direct text node", async ({ reactGrab }) => {
+    const target = await createMixedTextTarget(reactGrab);
+
+    await reactGrab.activate();
+    await reactGrab.page.mouse.move(target.position.x, target.position.y);
+    await expect
+      .poll(async () => (await reactGrab.getSelectionLabelInfo()).tagName)
+      .toContain("Grab this text");
+
+    await reactGrab.rightClickAtPosition(target.position.x, target.position.y);
+    await expect
+      .poll(async () => (await reactGrab.getContextMenuInfo()).tagBadgeText)
+      .toContain("Grab this text");
+
+    await reactGrab.clickContextMenuItem("Style");
+    await expect
+      .poll(() =>
+        reactGrab.page.evaluate((attrName) => {
+          const host = document.querySelector(`[${attrName}]`);
+          const panel = host?.shadowRoot?.querySelector("[data-react-grab-edit-panel]");
+          return panel?.textContent?.trim() ?? null;
+        }, ATTRIBUTE_NAME),
+      )
+      .toMatch(/^div/);
+  });
+
+  test("should clear a text target when shift-dragging a multi-selection", async ({
+    reactGrab,
+  }) => {
+    const target = await createMixedTextTarget(reactGrab);
+
+    await reactGrab.activate();
+    await reactGrab.page.mouse.move(target.position.x, target.position.y);
+    await expect
+      .poll(async () => (await reactGrab.getSelectionLabelInfo()).tagName)
+      .toContain("Grab this text");
+
+    await reactGrab.page.keyboard.down("Shift");
+    await reactGrab.dragSelect(
+      "[data-testid='todo-list'] li:first-child",
+      "[data-testid='todo-list'] li:nth-child(2)",
+    );
+
+    const labelTexts = await reactGrab.page.evaluate(() => {
+      const host = document.querySelector("[data-react-grab]");
+      const labels = host?.shadowRoot?.querySelectorAll("[data-react-grab-selection-label]");
+      return Array.from(labels ?? []).map((label) => label.textContent?.trim() ?? "");
+    });
+
+    expect(labelTexts.length).toBeGreaterThanOrEqual(2);
+    expect(labelTexts.join(" ")).not.toContain("Grab this text");
+
+    await reactGrab.page.keyboard.up("Shift");
+  });
+
+  test("should use element bounds when a click misses its direct text", async ({ reactGrab }) => {
+    const target = await createMixedTextTarget(reactGrab);
+
+    await reactGrab.setupCallbackTracking();
+    await reactGrab.activate();
+    await reactGrab.page.mouse.move(target.position.x, target.position.y);
+    await expect
+      .poll(async () => (await reactGrab.getSelectionLabelInfo()).tagName)
+      .toContain("Grab this text");
+
+    await reactGrab.page.mouse.click(target.paddingPosition.x, target.paddingPosition.y);
+    await expect
+      .poll(async () => {
+        const callbackHistory = await reactGrab.getCallbackHistory();
+        const copySuccessCall = callbackHistory.findLast(
+          (callback) => callback.name === "onCopySuccess",
+        );
+        return copySuccessCall?.args[1];
+      })
+      .toContain("selector: #mixed-text-target");
+    await expect
+      .poll(async () => (await reactGrab.getGrabbedBoxInfo()).boxes[0]?.bounds.width)
+      .toBeCloseTo(target.containerWidth, 0);
+  });
+
+  test("should select only the hovered line of wrapped direct text", async ({ reactGrab }) => {
+    const target = await createWrappedTextTarget(reactGrab);
+
+    await reactGrab.setupCallbackTracking();
+    await reactGrab.activate();
+    await reactGrab.page.mouse.move(target.position.x, target.position.y);
+
+    await expect
+      .poll(async () => {
+        const callbackHistory = await reactGrab.getCallbackHistory();
+        const selectionBoxCall = callbackHistory.findLast(
+          (callback) => callback.name === "onSelectionBox" && callback.args[0] === true,
+        );
+        return selectionBoxCall?.args[1];
+      })
+      .toEqual(expect.objectContaining(target.textBounds));
+  });
+
+  test("should update selection when hovering another line of the same text", async ({
+    reactGrab,
+  }) => {
+    const target = await createWrappedTextTarget(reactGrab);
+    const firstLineTarget = await getWrappedTextLineTarget(reactGrab, 0);
+
+    await reactGrab.setupCallbackTracking();
+    await reactGrab.activate();
+    await reactGrab.page.mouse.move(target.position.x, target.position.y);
+    await expect
+      .poll(async () => {
+        const callbackHistory = await reactGrab.getCallbackHistory();
+        const selectionBoxCall = callbackHistory.findLast(
+          (callback) => callback.name === "onSelectionBox" && callback.args[0] === true,
+        );
+        return selectionBoxCall?.args[1];
+      })
+      .toEqual(expect.objectContaining(target.textBounds));
+
+    await reactGrab.page.waitForTimeout(POINTER_SETTLE_DELAY_MS);
+    await reactGrab.page.mouse.move(firstLineTarget.position.x, firstLineTarget.position.y);
+    await expect
+      .poll(async () => {
+        const callbackHistory = await reactGrab.getCallbackHistory();
+        const selectionBoxCall = callbackHistory.findLast(
+          (callback) => callback.name === "onSelectionBox" && callback.args[0] === true,
+        );
+        return selectionBoxCall?.args[1];
+      })
+      .toEqual(expect.objectContaining(firstLineTarget.textBounds));
+  });
+
+  test("should keep the hovered wrapped line targeted after reflow", async ({ reactGrab }) => {
+    const target = await createWrappedTextTarget(reactGrab);
+
+    await reactGrab.setupCallbackTracking();
+    await reactGrab.activate();
+    await reactGrab.page.mouse.move(target.position.x, target.position.y);
+    await expect
+      .poll(async () => {
+        const callbackHistory = await reactGrab.getCallbackHistory();
+        const selectionBoxCall = callbackHistory.findLast(
+          (callback) => callback.name === "onSelectionBox" && callback.args[0] === true,
+        );
+        return selectionBoxCall?.args[1];
+      })
+      .toEqual(expect.objectContaining(target.textBounds));
+
+    const reflowedBounds = await reflowWrappedTextTarget(reactGrab, target);
+    await expect
+      .poll(async () => {
+        const callbackHistory = await reactGrab.getCallbackHistory();
+        const selectionBoxCall = callbackHistory.findLast(
+          (callback) => callback.name === "onSelectionBox" && callback.args[0] === true,
+        );
+        return selectionBoxCall?.args[1];
+      })
+      .toEqual(expect.objectContaining(reflowedBounds));
+  });
+
+  test("should keep prompt cursor aligned with grabbed text", async ({ reactGrab }) => {
+    const target = await createMixedTextTarget(reactGrab);
+
+    await reactGrab.setupCallbackTracking();
+    await reactGrab.registerCommentAction();
+    await reactGrab.activate();
+    await reactGrab.page.mouse.move(target.position.x, target.position.y);
+    await expect
+      .poll(async () => (await reactGrab.getSelectionLabelInfo()).tagName)
+      .toContain("Grab this text");
+
+    await reactGrab.rightClickAtPosition(target.position.x, target.position.y);
+    await expect
+      .poll(async () => {
+        const callbackHistory = await reactGrab.getCallbackHistory();
+        const selectionBoxCall = callbackHistory.findLast(
+          (callback) => callback.name === "onSelectionBox" && callback.args[0] === true,
+        );
+        return selectionBoxCall?.args[1];
+      })
+      .toEqual(expect.objectContaining(target.textBounds));
+
+    await reactGrab.clickContextMenuItem("Comment");
+    await expect.poll(() => reactGrab.isPromptModeActive()).toBe(true);
+
+    await expect
+      .poll(async () => {
+        const arrowCenterX = await getSelectionArrowCenterX(reactGrab);
+        return arrowCenterX === null
+          ? Number.POSITIVE_INFINITY
+          : Math.abs(arrowCenterX - target.position.x);
+      })
+      .toBeLessThan(2);
+  });
+
+  test("should keep toolbar comment cursor aligned with grabbed text", async ({ reactGrab }) => {
+    const target = await createMixedTextTarget(reactGrab);
+
+    await reactGrab.clickToolbarAction("comment");
+    await reactGrab.page.mouse.move(target.position.x, target.position.y);
+    await expect
+      .poll(async () => (await reactGrab.getSelectionLabelInfo()).tagName)
+      .toContain("Grab this text");
+
+    await reactGrab.page.mouse.click(target.position.x, target.position.y);
+    await expect.poll(() => reactGrab.isPromptModeActive()).toBe(true);
+    await expect
+      .poll(async () => {
+        const arrowCenterX = await getSelectionArrowCenterX(reactGrab);
+        return arrowCenterX === null
+          ? Number.POSITIVE_INFINITY
+          : Math.abs(arrowCenterX - target.position.x);
+      })
+      .toBeLessThan(2);
+  });
+
+  test("should keep text targeting when entering comment mode with Enter", async ({
+    reactGrab,
+  }) => {
+    const target = await createMixedTextTarget(reactGrab);
+
+    await reactGrab.setupCallbackTracking();
+    await reactGrab.registerCommentAction();
+    await reactGrab.activate();
+    await reactGrab.page.mouse.move(target.position.x, target.position.y);
+    await expect
+      .poll(async () => (await reactGrab.getSelectionLabelInfo()).tagName)
+      .toContain("Grab this text");
+
+    await reactGrab.pressEnter();
+    await expect.poll(() => reactGrab.isPromptModeActive()).toBe(true);
+    await reactGrab.typeInInput("Update this copy");
+    await reactGrab.submitInput();
+
+    await expect
+      .poll(async () => {
+        const callbackHistory = await reactGrab.getCallbackHistory();
+        const copySuccessCall = callbackHistory.findLast(
+          (callback) => callback.name === "onCopySuccess",
+        );
+        const copiedContent = copySuccessCall?.args[1];
+        return (
+          typeof copiedContent === "string" &&
+          copiedContent.includes('"Grab this text"') &&
+          !copiedContent.includes("not the nested element")
+        );
+      })
+      .toBe(true);
+  });
+
+  test("should keep text targeting while prompt text is disconnected", async ({ reactGrab }) => {
+    const target = await createMixedTextTarget(reactGrab);
+
+    await reactGrab.setupCallbackTracking();
+    await reactGrab.registerCommentAction();
+    await reactGrab.activate();
+    await reactGrab.page.mouse.move(target.position.x, target.position.y);
+    await expect
+      .poll(async () => (await reactGrab.getSelectionLabelInfo()).tagName)
+      .toContain("Grab this text");
+
+    await reactGrab.pressEnter();
+    await expect.poll(() => reactGrab.isPromptModeActive()).toBe(true);
+
+    await reactGrab.page.evaluate(() => {
+      const textNode = document.querySelector("#mixed-text-target")?.firstChild;
+      if (!(textNode instanceof Text)) throw new Error("Missing mixed text target");
+      textNode.remove();
+      window.dispatchEvent(new Event("resize"));
+    });
+
+    await expect
+      .poll(async () => {
+        const callbackHistory = await reactGrab.getCallbackHistory();
+        return callbackHistory.findLast(
+          (callback) => callback.name === "onSelectionBox" && callback.args[0] === true,
+        )?.args[1];
+      })
+      .toEqual(expect.objectContaining(target.textBounds));
+
+    await reactGrab.typeInInput("Update this copy");
+    await reactGrab.submitInput();
+
+    await expect
+      .poll(async () => {
+        const callbackHistory = await reactGrab.getCallbackHistory();
+        const copySuccessCall = callbackHistory.findLast(
+          (callback) => callback.name === "onCopySuccess",
+        );
+        const copiedContent = copySuccessCall?.args[1];
+        return (
+          typeof copiedContent === "string" &&
+          copiedContent.includes('"Grab this text"') &&
+          copiedContent.includes("selector: #mixed-text-target") &&
+          !copiedContent.includes("not the nested element")
+        );
+      })
+      .toBe(true);
+  });
+
+  test("should clear text targeting when the hovered tree is disconnected", async ({
+    reactGrab,
+  }) => {
+    const target = await createMixedTextTarget(reactGrab);
+
+    await reactGrab.activate();
+    await reactGrab.page.mouse.move(target.position.x, target.position.y);
+    await expect
+      .poll(async () => (await reactGrab.getSelectionLabelInfo()).tagName)
+      .toContain("Grab this text");
+
+    await reactGrab.page.evaluate(() => {
+      document.querySelector("#mixed-text-target")?.remove();
+      window.dispatchEvent(new Event("resize"));
+    });
+
+    await expect
+      .poll(async () => (await reactGrab.getSelectionLabelInfo()).tagName)
+      .not.toContain("Grab this text");
+  });
+
+  test("should relink grabbed text after its DOM node is replaced", async ({ reactGrab }) => {
+    const target = await createMixedTextTarget(reactGrab);
+
+    await reactGrab.setupCallbackTracking();
+    await reactGrab.registerCommentAction();
+    await reactGrab.activate();
+    await reactGrab.page.mouse.move(target.position.x, target.position.y);
+    await expect
+      .poll(async () => (await reactGrab.getSelectionLabelInfo()).tagName)
+      .toContain("Grab this text");
+
+    await reactGrab.pressEnter();
+    await expect.poll(() => reactGrab.isPromptModeActive()).toBe(true);
+
+    const replacementBounds = await replaceMixedTextNode(reactGrab, "Grab replacement text ");
+    await expect
+      .poll(async () => {
+        const callbackHistory = await reactGrab.getCallbackHistory();
+        const selectionBoxCall = callbackHistory.findLast(
+          (callback) => callback.name === "onSelectionBox" && callback.args[0] === true,
+        );
+        return selectionBoxCall?.args[1];
+      })
+      .toEqual(expect.objectContaining(replacementBounds));
+
+    await reactGrab.typeInInput("Update this copy");
+    await reactGrab.submitInput();
+    await expect
+      .poll(async () => {
+        const callbackHistory = await reactGrab.getCallbackHistory();
+        const copySuccessCall = callbackHistory.findLast(
+          (callback) => callback.name === "onCopySuccess",
+        );
+        return copySuccessCall?.args[1];
+      })
+      .toContain('"Grab replacement text"');
+
+    const postCopyBounds = await replaceMixedTextNode(reactGrab, "Short replacement ");
+    await expect
+      .poll(async () => (await reactGrab.getGrabbedBoxInfo()).boxes[0]?.bounds)
+      .toEqual(expect.objectContaining(postCopyBounds));
+  });
+
+  test("should keep text targeting when opening the context menu from the keyboard", async ({
+    reactGrab,
+  }) => {
+    const target = await createMixedTextTarget(reactGrab);
+
+    await reactGrab.activate();
+    await reactGrab.page.mouse.move(target.position.x, target.position.y);
+    await expect
+      .poll(async () => (await reactGrab.getSelectionLabelInfo()).tagName)
+      .toContain("Grab this text");
+
+    await reactGrab.pressKey("ContextMenu");
+    await expect.poll(() => reactGrab.isContextMenuVisible()).toBe(true);
+
+    const copyPayloadPromise = reactGrab.captureNextClipboardWrites();
+    await reactGrab.clickContextMenuItem("Copy");
+    const copyPayload = await copyPayloadPromise;
+
+    expect(copyPayload["text/plain"]).toContain('"Grab this text"');
+    expect(copyPayload["text/plain"]).not.toContain("not the nested element");
+  });
+
+  test("should keep text-only elements as element targets", async ({ reactGrab }) => {
+    await reactGrab.page.evaluate(() => {
+      const target = document.createElement("div");
+      target.id = "text-only-target";
+      target.textContent = "Text-only target";
+      target.style.cssText =
+        "position:fixed;left:40px;top:40px;padding:12px;background:white;color:black;font:16px sans-serif;z-index:2147483000";
+      document.body.append(target);
+    });
+
+    await reactGrab.activate();
+    await reactGrab.hoverUntilSelected("#text-only-target");
+
+    await expect.poll(async () => (await reactGrab.getSelectionLabelInfo()).tagName).toBe("div");
+  });
+
   test("should write React Grab clipboard metadata on copy", async ({ reactGrab }) => {
     await reactGrab.activate();
     await reactGrab.hoverUntilSelected("[data-testid='todo-list'] h1");
diff --git a/packages/react-grab/e2e/toolbar-selection-hover.spec.ts b/packages/react-grab/e2e/toolbar-selection-hover.spec.ts
index 43eaacd3c..5720a8ab2 100644
--- a/packages/react-grab/e2e/toolbar-selection-hover.spec.ts
+++ b/packages/react-grab/e2e/toolbar-selection-hover.spec.ts
@@ -42,7 +42,7 @@ test.describe("Toolbar Selection Hover", () => {
 
       await expect.poll(() => reactGrab.isSelectionBoxVisible(), { timeout: 2000 }).toBe(false);
 
-      await hoverAwayFromToolbar(reactGrab.page);
+      await reactGrab.hoverUntilSelected("li");
 
       await expect.poll(() => reactGrab.isSelectionBoxVisible(), { timeout: 2000 }).toBe(true);
     });
diff --git a/packages/react-grab/e2e/touch-mode.spec.ts b/packages/react-grab/e2e/touch-mode.spec.ts
index 14030b291..05d25c393 100644
--- a/packages/react-grab/e2e/touch-mode.spec.ts
+++ b/packages/react-grab/e2e/touch-mode.spec.ts
@@ -113,7 +113,12 @@ test.describe("Touch Mode", () => {
 
       await reactGrab.activate();
 
-      await reactGrab.page.waitForTimeout(100);
+      await reactGrab.page.evaluate(
+        () =>
+          new Promise<void>((resolve) => {
+            requestAnimationFrame(() => requestAnimationFrame(() => resolve()));
+          }),
+      );
 
       expect(await reactGrab.isSelectionBoxVisible()).toBe(false);
     });
diff --git a/packages/react-grab/src/components/edit-panel/index.tsx b/packages/react-grab/src/components/edit-panel/index.tsx
index a80d67bc8..1d61e2ccf 100644
--- a/packages/react-grab/src/components/edit-panel/index.tsx
+++ b/packages/react-grab/src/components/edit-panel/index.tsx
@@ -108,6 +108,7 @@ const EditPanelBody: Component<EditPanelBodyProps> = (props) => {
   let searchInputRef: HTMLTextAreaElement | undefined;
   const preview = props.state.preview;
 
+  const [searchInputElement, setSearchInputElement] = createSignal<HTMLTextAreaElement>();
   const [searchQuery, setSearchQuery] = createSignal(props.state.initialSearchQuery ?? "");
   const [inlineNumericSearchQuery, setInlineNumericSearchQuery] = createSignal<string | null>(null);
   const [activeKey, setActiveKey] = createSignal<"left" | "right" | null>(null);
@@ -157,6 +158,16 @@ const EditPanelBody: Component<EditPanelBodyProps> = (props) => {
 
   const dropdown = createAnchoredDropdown(() => containerRef, props.position);
 
+  createEffect(() => {
+    const searchInput = searchInputElement();
+    if (!dropdown.shouldMount() || !searchInput) return;
+    queueMicrotask(() => {
+      focusInOverlay(searchInput, { preventScroll: true });
+      const searchInputLength = searchInput.value.length;
+      searchInput.setSelectionRange(searchInputLength, searchInputLength);
+    });
+  });
+
   const flashActiveKey = (direction: "left" | "right") => {
     setActiveKey(direction);
     clearTimeout(activeKeyTimerId);
@@ -485,13 +496,6 @@ const EditPanelBody: Component<EditPanelBodyProps> = (props) => {
   };
 
   onMount(() => {
-    queueMicrotask(() => {
-      focusInOverlay(searchInputRef, { preventScroll: true });
-      if (searchInputRef) {
-        const length = searchInputRef.value.length;
-        searchInputRef.setSelectionRange(length, length);
-      }
-    });
     dropdown.measure();
     const initialQuery = searchQuery();
     if (initialQuery) autoApply.applyTailwindClass(initialQuery);
@@ -676,6 +680,7 @@ const EditPanelBody: Component<EditPanelBodyProps> = (props) => {
             <textarea
               ref={(element) => {
                 searchInputRef = element;
+                setSearchInputElement(element);
               }}
               data-react-grab-ignore-events
               data-react-grab-input
diff --git a/packages/react-grab/src/constants.ts b/packages/react-grab/src/constants.ts
index 050476421..5bf19dc59 100644
--- a/packages/react-grab/src/constants.ts
+++ b/packages/react-grab/src/constants.ts
@@ -121,6 +121,7 @@ export const ARROW_LABEL_MARGIN_PX = 16;
 export const ARROW_PANEL_OVERLAP_PX = 1;
 export const LABEL_GAP_PX = 4;
 export const PREVIEW_TEXT_MAX_LENGTH = 100;
+export const TEXT_NODE_LABEL_MAX_LENGTH = 20;
 export const PREVIEW_ATTR_VALUE_MAX_LENGTH = 15;
 export const PREVIEW_PRIORITY_ATTRS: readonly string[] = [
   "id",
diff --git a/packages/react-grab/src/core/context.ts b/packages/react-grab/src/core/context.ts
index 3053ca5d9..97eb4f188 100644
--- a/packages/react-grab/src/core/context.ts
+++ b/packages/react-grab/src/core/context.ts
@@ -595,6 +595,20 @@ export const getElementReferenceContext = async (
   return `${getInlineHTMLPreview(element)}${composeElementContext(element, traceContext).replace(/\n\s+/g, " ")}`;
 };
 
+export const getTextNodeReferenceContext = async (
+  textNode: Text,
+  options: StackContextOptions = {},
+  fallbackParentElement?: Element,
+): Promise<string> => {
+  const textContent = textNode.textContent?.replace(/\s+/g, " ").trim() ?? "";
+  const parentElement = textNode.parentElement ?? fallbackParentElement;
+  if (!parentElement) return JSON.stringify(textContent);
+
+  const traceContext = await getTraceContext(parentElement, options);
+  const parentContext = composeElementContext(parentElement, traceContext).replace(/\n\s+/g, " ");
+  return `${JSON.stringify(textContent)}${parentContext}`;
+};
+
 export const formatElementInfo = async (
   element: Element,
   options: StackContextOptions = {},
diff --git a/packages/react-grab/src/core/copy.ts b/packages/react-grab/src/core/copy.ts
index 3c2e88544..08feeca76 100644
--- a/packages/react-grab/src/core/copy.ts
+++ b/packages/react-grab/src/core/copy.ts
@@ -1,7 +1,14 @@
-import { getElementReferenceContext, getStack, getStackContext, resolveSource } from "./context.js";
+import {
+  getElementReferenceContext,
+  getStack,
+  getStackContext,
+  getTextNodeReferenceContext,
+  resolveSource,
+} from "./context.js";
 import { copyContent } from "../utils/copy-content.js";
 import { normalizeError } from "../utils/normalize-error.js";
 import { getTagName } from "../utils/get-tag-name.js";
+import { formatTextNodeLabel } from "../utils/format-text-node-label.js";
 import { ABORTED_PROMISE_RESULT, racePromiseWithAbort } from "../utils/race-promise-with-abort.js";
 import type { StackFrame } from "bippy/source";
 import type { ReactGrabEntry, ReactGrabStackFrame } from "../types.js";
@@ -11,6 +18,7 @@ interface CopyFlowOptions {
   componentName?: string;
   maxContextLines?: number;
   signal?: AbortSignal;
+  textNode?: Text;
 }
 
 interface CopyFlowHooks {
@@ -68,7 +76,28 @@ const buildElementPayloadEntry = async (
 const buildClipboardPayload = async (
   elements: Element[],
   maxContextLines?: number,
+  textNode?: Text,
 ): Promise<CopyPayload | null> => {
+  const parentElement = elements[0];
+  if (textNode && parentElement) {
+    const stackOptions = { maxLines: maxContextLines };
+    const [referenceContext, stackContext, source, stack] = await Promise.all([
+      getTextNodeReferenceContext(textNode, stackOptions, parentElement),
+      getStackContext(parentElement, stackOptions),
+      resolveSource(parentElement),
+      getStack(parentElement),
+    ]);
+    const entry: ReactGrabEntry = {
+      tagName: formatTextNodeLabel(textNode),
+      componentName: source?.componentName ?? undefined,
+      content: `[${referenceContext}]`,
+      source,
+      stackContext,
+      frames: (stack ?? []).map(formatStackFramePayload),
+    };
+    return { content: entry.content, entries: [entry] };
+  }
+
   const rawEntries = await Promise.all(
     elements.map((element) => buildElementPayloadEntry(element, maxContextLines)),
   );
@@ -122,7 +151,7 @@ export const runCopyFlow = async (
   try {
     const pendingPayload: Promise<CopyPayload | null> = options.getContent
       ? Promise.resolve(options.getContent(elements)).then((content) => ({ content }))
-      : buildClipboardPayload(elements, options.maxContextLines);
+      : buildClipboardPayload(elements, options.maxContextLines, options.textNode);
     const payload = await racePromiseWithAbort(pendingPayload, options.signal);
     if (payload === ABORTED_PROMISE_RESULT) return CANCELLED_COPY_FLOW_RESULT;
     const rawContent = payload?.content;
diff --git a/packages/react-grab/src/core/index.tsx b/packages/react-grab/src/core/index.tsx
index a2b0965f6..353127273 100644
--- a/packages/react-grab/src/core/index.tsx
+++ b/packages/react-grab/src/core/index.tsx
@@ -57,6 +57,12 @@ import { isElementConnected } from "../utils/is-element-connected.js";
 import { getElementsInDrag } from "../utils/get-elements-in-drag.js";
 import { getElementAnchorRatio } from "../utils/get-element-anchor-ratio.js";
 import { createElementBounds } from "../utils/create-element-bounds.js";
+import { createTextNodeBounds } from "../utils/create-text-node-bounds.js";
+import { createGrabbedBoxBounds } from "../utils/create-grabbed-box-bounds.js";
+import { createLabelInstanceBoundsList } from "../utils/create-label-instance-bounds-list.js";
+import { getTextNodeAtPosition } from "../utils/get-text-node-at-position.js";
+import { formatTextNodeLabel } from "../utils/format-text-node-label.js";
+import { resolveLiveTextNode, trackTextNodeAnchor } from "./text-node-anchors.js";
 import { invalidateInteractionCaches } from "../utils/invalidate-interaction-caches.js";
 import { normalizeErrorMessage } from "../utils/normalize-error.js";
 import {
@@ -175,6 +181,7 @@ interface CopyWithLabelOptions {
   element: Element;
   cursorX: number;
   selectedElements?: Element[];
+  textNode?: Text;
   extraPrompt?: string;
   shouldDeactivateAfter?: boolean;
   onComplete?: () => void;
@@ -204,6 +211,7 @@ interface LabeledCopyOptions {
   primaryElement: Element;
   targetElements: Element[];
   labelInstanceIds: string[];
+  textNode?: Text;
   extraPrompt?: string;
   shouldDeactivateAfter?: boolean;
   onComplete?: () => void;
@@ -385,11 +393,13 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       deactivateRenderer: () => deactivateRenderer(),
       performCopyWithLabel: (options) => performCopyWithLabel(options),
       onOpen: () => {
+        setFrozenTextNode(null);
         dismissToolbarMenu();
         stopEditPanelTracking?.();
         stopEditPanelTracking = trackDropdownPosition(computeEditPanelAnchor, setEditPanelPosition);
       },
       onClose: () => {
+        setFrozenTextNode(null);
         stopEditPanelTracking?.();
         stopEditPanelTracking = null;
         setEditPanelPosition(null);
@@ -482,6 +492,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
     createEffect(() => {
       if (current().state !== "justCopied") return;
       const timerId = setTimeout(() => {
+        setFrozenTextNode(null);
         actions.finishJustCopied();
       }, FEEDBACK_DURATION_MS);
       onCleanup(() => clearTimeout(timerId));
@@ -499,15 +510,55 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       }),
     );
 
-    const preparePromptMode = (element: Element, positionX: number, positionY: number) => {
-      actions.setCopyStart({ x: positionX, y: positionY }, element);
+    const isTextNodeTargetForElement = (textNode: Text | null | undefined, element: Element) => {
+      if (!textNode) return false;
+      if (textNode.parentElement === element) return true;
+      return (
+        textNode.isConnected === false &&
+        textNode === frozenTextNode() &&
+        element === store.frozenElement
+      );
+    };
+
+    const getTextNodeForElement = (element: Element, preferredTextNode?: Text | null) => {
+      if (preferredTextNode && isTextNodeTargetForElement(preferredTextNode, element)) {
+        return preferredTextNode;
+      }
+
+      const frozenNode = frozenTextNode();
+      if (frozenNode && isTextNodeTargetForElement(frozenNode, element)) return frozenNode;
+
+      const activeNode = activeTextNode();
+      return activeNode && isTextNodeTargetForElement(activeNode, element) ? activeNode : null;
+    };
+
+    const getPromptSelectionBounds = (element: Element, preferredTextNode?: Text | null) => {
+      const textNode = getTextNodeForElement(element, preferredTextNode);
+      return textNode ? createTextNodeBounds(textNode) : createElementBounds(element);
+    };
+
+    const preparePromptMode = (
+      element: Element,
+      positionX: number,
+      positionY: number,
+      preferredTextNode?: Text | null,
+    ) => {
+      actions.setCopyStart(
+        { x: positionX, y: positionY },
+        element,
+        getPromptSelectionBounds(element, preferredTextNode),
+      );
       actions.clearInputText();
     };
 
     const activatePromptMode = () => {
       const element = store.frozenElement || targetElement();
       if (element) {
-        actions.enterPromptMode({ x: pointer().x, y: pointer().y }, element);
+        actions.enterPromptMode(
+          { x: pointer().x, y: pointer().y },
+          element,
+          getPromptSelectionBounds(element),
+        );
       }
     };
 
@@ -586,6 +637,37 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
     const [resolvedComponentName, setResolvedComponentName] = createComponentNameForElement(
       debouncedElementForComponentName,
     );
+    const [textNodeBoundsVersion, setTextNodeBoundsVersion] = createSignal(0);
+    const [detectedTextNode, setDetectedTextNodeSignal] = createSignal<Text | null>(null);
+    const [frozenTextNode, setFrozenTextNodeSignal] = createSignal<Text | null>(null);
+    const setDetectedTextNode = (textNode: Text | null): void => {
+      const previousTextNode = detectedTextNode();
+      if (textNode) trackTextNodeAnchor(textNode);
+      setDetectedTextNodeSignal(textNode);
+      if (textNode && textNode === previousTextNode) {
+        setTextNodeBoundsVersion((version) => version + 1);
+      }
+    };
+    const setFrozenTextNode = (textNode: Text | null): void => {
+      if (textNode) trackTextNodeAnchor(textNode);
+      setFrozenTextNodeSignal(textNode);
+    };
+    const unfreezeSelection = (): void => {
+      setFrozenTextNode(null);
+      actions.unfreeze();
+    };
+    const relinkLiveTargets = (): void => {
+      const previousDetectedTextNode = detectedTextNode();
+      const previousFrozenTextNode = frozenTextNode();
+      actions.relinkLiveElements();
+      setDetectedTextNode(
+        resolveLiveTextNode(previousDetectedTextNode, store.detectedElement) ??
+          previousDetectedTextNode,
+      );
+      setFrozenTextNode(
+        resolveLiveTextNode(previousFrozenTextNode, store.frozenElement) ?? previousFrozenTextNode,
+      );
+    };
     const toolbarActiveActionId = createMemo(() => {
       if (editMode.isOpen()) return EDIT_ACTION_ID;
       if (isCommentMode()) return COMMENT_ACTION_ID;
@@ -626,13 +708,15 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
 
     const grabbedBoxTimeouts = new Map<string, number>();
 
-    const showTemporaryGrabbedBox = (bounds: OverlayBounds, element: Element) => {
+    const showTemporaryGrabbedBox = (bounds: OverlayBounds, element?: Element, textNode?: Text) => {
       const boxId = generateId("grabbed");
       const createdAt = Date.now();
-      const newBox: GrabbedBox = { id: boxId, bounds, createdAt, element };
+      const newBox: GrabbedBox = { id: boxId, bounds, createdAt, element, textNode };
 
       actions.addGrabbedBox(newBox);
-      pluginRegistry.hooks.onGrabbedBox(bounds, element);
+      if (element) {
+        pluginRegistry.hooks.onGrabbedBox(bounds, element);
+      }
 
       // Keep the box in the store through the canvas fade-out so its bounds
       // keep tracking the element; once removed, the canvas remnant is
@@ -833,7 +917,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
         // no-op outside the active state, and staying in copying strands the
         // overlay (progress cursor, dead hover, swallowed activation keys).
         actions.activate();
-        actions.unfreeze();
+        unfreezeSelection();
       }
       return true;
     };
@@ -867,6 +951,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       signal: AbortSignal,
       extraPrompt?: string,
       resolvedComponentName?: string,
+      textNode?: Text,
     ) => {
       const firstElement = elements[0];
       const componentName =
@@ -880,6 +965,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
           componentName: elementName,
           maxContextLines: pluginRegistry.store.options.maxContextLines,
           signal,
+          textNode,
         },
         pluginRegistry.hooks,
         elements,
@@ -892,6 +978,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       extraPrompt?: string,
       resolvedComponentName?: string,
       signal: AbortSignal = getCopySignal(),
+      textNode?: Text,
     ): Promise<CopyFlowResult> => {
       if (targetElements.length === 0 || signal.aborted) return CANCELLED_COPY_RESULT;
 
@@ -905,7 +992,13 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
         if (pendingResult) {
           pendingResults.push(pendingResult);
         }
-        if (pluginRegistry.store.theme.grabbedBoxes.enabled) {
+        if (
+          pluginRegistry.store.theme.grabbedBoxes.enabled &&
+          textNode &&
+          isTextNodeTargetForElement(textNode, element)
+        ) {
+          showTemporaryGrabbedBox(createTextNodeBounds(textNode), element, textNode);
+        } else if (pluginRegistry.store.theme.grabbedBoxes.enabled) {
           showTemporaryGrabbedBox(createElementBounds(element), element);
         }
       }
@@ -919,6 +1012,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
           signal,
           extraPrompt,
           resolvedComponentName,
+          textNode,
         );
         if (copyResult.status === "cancelled") return copyResult;
       }
@@ -960,6 +1054,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
                 copy.extraPrompt,
                 componentName ?? undefined,
                 copySignal,
+                copy.textNode,
               ),
             copy.labelInstanceIds.length > 0 ? copy.labelInstanceIds : null,
             copy.shouldDeactivateAfter,
@@ -997,6 +1092,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
                     copy.extraPrompt,
                     componentName ?? undefined,
                     retrySignal,
+                    copy.textNode,
                   );
                 }),
               copy.labelInstanceIds,
@@ -1008,7 +1104,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
               deactivateRenderer();
             } else {
               actions.activate();
-              actions.unfreeze();
+              unfreezeSelection();
             }
           }
         })
@@ -1027,12 +1123,17 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
         extraPrompt,
         shouldDeactivateAfter,
         onComplete,
+        textNode,
         dragRect: passedDragRect,
       } = options;
 
       const allTargetElements = selectedElements ?? [element];
       const dragRect = passedDragRect ?? store.frozenDragRect;
       const isMultiSelect = allTargetElements.length > 1;
+      const selectedTextNode =
+        !isMultiSelect && textNode && isTextNodeTargetForElement(textNode, element)
+          ? textNode
+          : undefined;
 
       // Reuse the live selection-box bounds when copying the currently-selected
       // element: the selectionBounds memo already holds them (computed during the
@@ -1042,23 +1143,29 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       // style since the box was last measured. Falls back to a fresh measure when
       // copying an element that isn't the current selection (e.g. context menu).
       const reusableSelectionBounds =
-        !isMultiSelect && element === selectionElement() ? selectionBounds() : undefined;
-      const labelBounds =
-        dragRect && isMultiSelect
+        !isMultiSelect && element === selectionElement() && (selectedTextNode || !activeTextNode())
+          ? selectionBounds()
+          : undefined;
+      const labelBounds = selectedTextNode
+        ? createTextNodeBounds(selectedTextNode)
+        : dragRect && isMultiSelect
           ? createBoundsFromDragRect(dragRect)
           : (reusableSelectionBounds ?? createElementBounds(element));
 
       const labelCursorX = isMultiSelect ? labelBounds.x + labelBounds.width / 2 : cursorX;
 
-      const tagName = getTagName(element);
+      const tagName = selectedTextNode
+        ? formatTextNodeLabel(selectedTextNode)
+        : getTagName(element);
       clearCopyFeedbackCooldown();
       actions.startCopy();
 
       const labelInstanceId = tagName
         ? labelController.createInstance(labelBounds, tagName, undefined, "copying", {
             element,
+            textNode: selectedTextNode,
             mouseX: labelCursorX,
-            elements: selectedElements,
+            elements: selectedTextNode ? undefined : selectedElements,
           })
         : null;
 
@@ -1069,6 +1176,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
         extraPrompt,
         shouldDeactivateAfter,
         onComplete,
+        textNode: selectedTextNode,
       });
     };
 
@@ -1118,6 +1226,23 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       () => store.frozenElement || (isFrozenPhase() ? null : targetElement()),
     );
 
+    const activeTextNode = createMemo(() => {
+      const frozenNode = frozenTextNode();
+      if (
+        frozenNode &&
+        (frozenNode.isConnected === false || frozenNode.parentElement === store.frozenElement)
+      ) {
+        return frozenNode;
+      }
+      if (isFrozenPhase()) return null;
+
+      const detectedNode = detectedTextNode();
+      const detectedElement = targetElement();
+      return detectedNode && detectedElement && detectedNode.parentElement === detectedElement
+        ? detectedNode
+        : null;
+    });
+
     // The hierarchy dropdown appears while keyboard-navigating a frozen
     // selection (arrow keys / Tab), and — for on-demand inspection — for the
     // hovered element whenever Shift is held. It is suppressed in the modes
@@ -1169,7 +1294,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
         // active; if recovery can't relink it, re-detect under the pointer so
         // the selection latches onto its replacement instead of vanishing.
         if (!isElementConnected(store.detectedElement)) {
-          actions.relinkLiveElements();
+          relinkLiveTargets();
         }
         if (!isElementConnected(store.detectedElement)) {
           if (remainingRelinkGraceAttempts > 0) {
@@ -1291,6 +1416,10 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
 
     const selectionBounds = createMemo((): OverlayBounds | undefined => {
       void viewportVersion();
+      void textNodeBoundsVersion();
+
+      const textNode = activeTextNode();
+      if (textNode) return createTextNodeBounds(textNode);
 
       const frozenElements = store.frozenElements;
       if (frozenElements.length > 0) {
@@ -1403,6 +1532,19 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       if (pendingBounds) {
         return [...frozenElementsBounds(), pendingBounds];
       }
+
+      const frozenElements = store.frozenElements;
+      const frozenNode = frozenTextNode();
+      const frozenElement = frozenElements[0];
+      if (
+        frozenElements.length === 1 &&
+        frozenNode &&
+        frozenElement &&
+        isTextNodeTargetForElement(frozenNode, frozenElement)
+      ) {
+        return [createTextNodeBounds(frozenNode)];
+      }
+
       return frozenElementsBounds();
     });
 
@@ -1448,6 +1590,14 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
     const cursorPosition = createMemo(() => {
       if (isCopying() || isPromptMode()) {
         void viewportVersion();
+        const textNode = activeTextNode();
+        if (textNode) {
+          const center = getBoundsCenter(createTextNodeBounds(textNode));
+          return {
+            x: center.x + store.copyOffsetFromCenterX,
+            y: store.copyStart.y,
+          };
+        }
         const element = store.frozenElement || targetElement();
         if (element) {
           const center = getBoundsCenter(createElementBounds(element));
@@ -1531,13 +1681,14 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       ),
     );
 
-    const publicGrabbedBoxes = createMemo(() =>
-      store.grabbedBoxes.map((box) => ({
+    const publicGrabbedBoxes = createMemo(() => {
+      void viewportVersion();
+      return store.grabbedBoxes.map((box) => ({
         id: box.id,
-        bounds: box.bounds,
+        bounds: createGrabbedBoxBounds(box),
         createdAt: box.createdAt,
-      })),
-    );
+      }));
+    });
 
     const publicLabelInstances = createMemo(() =>
       store.labelInstances.map((instance) => ({
@@ -1650,12 +1801,17 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
           ] as const;
         },
         ([visible, variant, position, element, filePath, lineNumber]) => {
+          const textNode = activeTextNode();
           pluginRegistry.hooks.onElementLabel(visible, variant, {
             x: position.x,
             y: position.y,
             content: "",
             element: element ?? undefined,
-            tagName: element ? getTagName(element) || undefined : undefined,
+            tagName: textNode
+              ? formatTextNodeLabel(textNode)
+              : element
+                ? getTagName(element) || undefined
+                : undefined,
             filePath: filePath ?? undefined,
             lineNumber: lineNumber ?? undefined,
           });
@@ -1719,6 +1875,8 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       keyboardSelection.clear();
       setIsPendingContextMenuSelect(false);
       setPendingToolbarActionId(null);
+      setDetectedTextNode(null);
+      setFrozenTextNode(null);
       if (wasDragging) {
         restoreHostBodyStyle("userSelect");
         releaseDragPreview();
@@ -1771,10 +1929,11 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       }
 
       const elements = frozenElements.length > 0 ? frozenElements : [element];
+      const textNode = getTextNodeForElement(element);
 
-      const currentSelectionBounds = elements.map((selectedElement) =>
-        createElementBounds(selectedElement),
-      );
+      const currentSelectionBounds = textNode
+        ? [createTextNodeBounds(textNode)]
+        : elements.map((selectedElement) => createElementBounds(selectedElement));
       const firstBounds = currentSelectionBounds[0];
       const { x: currentX, y: currentY } = getBoundsCenter(firstBounds);
       const labelPositionX = currentX + store.copyOffsetFromCenterX;
@@ -1787,6 +1946,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
         element,
         cursorX: labelPositionX,
         selectedElements: elements,
+        textNode: textNode ?? undefined,
         extraPrompt: prompt || undefined,
         shouldDeactivateAfter: true,
       });
@@ -1925,10 +2085,19 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       handleActivateAction(currentToolbarState()?.defaultAction ?? DEFAULT_ACTION_ID);
     };
 
-    const enterCommentModeForElement = (element: Element, positionX: number, positionY: number) => {
+    const enterCommentModeForElement = (
+      element: Element,
+      positionX: number,
+      positionY: number,
+      textNode?: Text | null,
+    ) => {
       clearPendingToolbarSelection();
       actions.clearInputText();
-      actions.enterPromptMode({ x: positionX, y: positionY }, element);
+      actions.enterPromptMode(
+        { x: positionX, y: positionY },
+        element,
+        getPromptSelectionBounds(element, textNode),
+      );
     };
 
     const openContextMenu = (element: Element, position: Position) => {
@@ -2002,6 +2171,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
         if (candidate !== store.detectedElement) {
           actions.setDetectedElement(candidate);
         }
+        setDetectedTextNode(null);
         return;
       }
 
@@ -2032,6 +2202,15 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
           if (candidate !== store.detectedElement) {
             actions.setDetectedElement(candidate);
           }
+          setDetectedTextNode(
+            candidate
+              ? getTextNodeAtPosition(
+                  candidate,
+                  elementDetectionState.latestPointerX,
+                  elementDetectionState.latestPointerY,
+                )
+              : null,
+          );
           elementDetectionState.pendingDetectionScheduledAt = 0;
         });
       }
@@ -2069,7 +2248,11 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       }
 
       const shouldPreserveKeyboardSelection = keyboardSelection.selectedElement() !== null;
-      actions.startDrag({ x: clientX, y: clientY }, isShiftHeld || shouldPreserveKeyboardSelection);
+      const shouldPreserveFrozenElements = isShiftHeld || shouldPreserveKeyboardSelection;
+      if (!shouldPreserveFrozenElements) {
+        setFrozenTextNode(null);
+      }
+      actions.startDrag({ x: clientX, y: clientY }, shouldPreserveFrozenElements);
       actions.setPointer({ x: clientX, y: clientY });
       setHostBodyStyle("userSelect", "none");
 
@@ -2081,6 +2264,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
     };
 
     const toggleShiftMultiSelection = (element: Element, pointer: Position) => {
+      setFrozenTextNode(null);
       const wasElementSelected = store.frozenElements.includes(element);
       const isFirstFrozenElement = store.frozenElements.length === 0;
 
@@ -2104,7 +2288,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
 
       if (store.frozenElements.length === 0) {
         stopShiftMultiSelecting();
-        actions.unfreeze();
+        unfreezeSelection();
         return;
       }
 
@@ -2144,7 +2328,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       stopShiftMultiSelecting();
 
       if (accumulatedElements.length === 0) {
-        actions.unfreeze();
+        unfreezeSelection();
         return;
       }
 
@@ -2196,6 +2380,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
 
       if (isShiftAccumulating) {
         const lastElement = selectedElements[selectedElements.length - 1];
+        setFrozenTextNode(null);
         setIsShiftMultiSelecting(true);
         clearElementPositionCache();
         actions.setPointer(getBoundsCenter(createElementBounds(lastElement)));
@@ -2210,6 +2395,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
 
       actions.setPointer(center);
       actions.setFrozenElements(selectedElements);
+      setFrozenTextNode(null);
       const dragRect = createPageRectFromBounds(dragSelectionRect);
       actions.setFrozenDragRect(dragRect);
       actions.freeze();
@@ -2293,6 +2479,10 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       const selectedElement =
         validKeyboardSelectedElement ?? selectedElementUnderPointer ?? validFrozenElement;
       if (!selectedElement) return;
+      const selectedTextNode =
+        selectedElement === selectedElementUnderPointer
+          ? getTextNodeAtPosition(selectedElement, clientX, clientY)
+          : null;
 
       let positionX: number;
       let positionY: number;
@@ -2314,7 +2504,8 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       }
 
       if (store.pendingCommentMode) {
-        enterCommentModeForElement(selectedElement, positionX, positionY);
+        setFrozenTextNode(selectedTextNode);
+        enterCommentModeForElement(selectedElement, positionX, positionY, selectedTextNode);
         keyboardSelection.clear();
         return;
       }
@@ -2327,6 +2518,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
 
         freezeAllAnimations([selectedElement]);
         actions.setFrozenElement(selectedElement);
+        setFrozenTextNode(selectedTextNode);
         const position = { x: positionX, y: positionY };
         actions.setPointer(position);
         actions.freeze();
@@ -2345,6 +2537,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       performCopyWithLabel({
         element: selectedElement,
         cursorX: positionX,
+        textNode: selectedTextNode ?? undefined,
         shouldDeactivateAfter,
       });
       keyboardSelection.clear();
@@ -2462,6 +2655,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
 
     const selectAndFocusElement = (element: Element, shouldPromptBeforeMouseHandoff = false) => {
       actions.setFrozenElement(element);
+      setFrozenTextNode(null);
       actions.freeze();
       keyboardSelection.select(element, { shouldPromptBeforeMouseHandoff });
 
@@ -2481,7 +2675,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
 
     const discardKeyboardSelection = () => {
       keyboardSelection.clear();
-      actions.unfreeze();
+      unfreezeSelection();
       clearKeyboardNavigation();
     };
 
@@ -2494,6 +2688,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       const center = getBoundsCenter(createElementBounds(selectedElement));
       clearKeyboardNavigation();
       actions.setLastGrabbed(selectedElement);
+      setFrozenTextNode(null);
       performCopyWithLabel({
         element: selectedElement,
         cursorX: center.x,
@@ -2678,12 +2873,17 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       event.preventDefault();
       event.stopPropagation();
 
-      const center = getBoundsCenter(createElementBounds(element));
+      const textNode = hasMultiFrozenSelection ? null : getTextNodeForElement(element);
+      const center = getBoundsCenter(
+        textNode ? createTextNodeBounds(textNode) : createElementBounds(element),
+      );
       if (hasMultiFrozenSelection) {
         freezeAllAnimations(existingFrozenElements);
+        setFrozenTextNode(null);
       } else {
         freezeAllAnimations([element]);
         actions.setFrozenElement(element);
+        setFrozenTextNode(textNode);
       }
       actions.setPointer(center);
       actions.freeze();
@@ -3080,7 +3280,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
             showKeyboardSelectionDismissPrompt();
             return;
           }
-          actions.unfreeze();
+          unfreezeSelection();
           clearKeyboardNavigation();
         }
         handlePointerMove(event.clientX, event.clientY, event.shiftKey);
@@ -3207,6 +3407,10 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
 
         const element = overlayFrozenElement ?? getElementAtPosition(event.clientX, event.clientY);
         if (!element) return;
+        const textNode =
+          overlayFrozenElement === null
+            ? getTextNodeAtPosition(element, event.clientX, event.clientY)
+            : frozenTextNode();
 
         const existingFrozenElements = store.frozenElements;
         const isClickedElementAlreadyFrozen =
@@ -3214,9 +3418,11 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
 
         if (isClickedElementAlreadyFrozen) {
           freezeAllAnimations(existingFrozenElements);
+          setFrozenTextNode(null);
         } else {
           freezeAllAnimations([element]);
           actions.setFrozenElement(element);
+          setFrozenTextNode(textNode?.parentElement === element ? textNode : null);
         }
 
         actions.setPointer(position);
@@ -3327,6 +3533,9 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       ) {
         const candidate = getElementAtPosition(pointer().x, pointer().y);
         actions.setDetectedElement(candidate);
+        setDetectedTextNode(
+          candidate ? getTextNodeAtPosition(candidate, pointer().x, pointer().y) : null,
+        );
       }
     };
 
@@ -3413,7 +3622,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
         if (boundsRecalcIntervalId !== null) return;
 
         boundsRecalcIntervalId = window.setInterval(() => {
-          actions.relinkLiveElements();
+          relinkLiveTargets();
           scheduleBoundsSync();
         }, BOUNDS_RECALC_INTERVAL_MS);
         return;
@@ -3523,6 +3732,8 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
     });
 
     const selectionTagName = createMemo(() => {
+      const textNode = activeTextNode();
+      if (textNode) return formatTextNodeLabel(textNode);
       const element = selectionElement();
       if (!element) return undefined;
       return getTagName(element) || undefined;
@@ -3540,15 +3751,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
     const labelInstanceCache = new Map<string, SelectionLabelInstance>();
 
     const recomputeLabelInstance = (instance: SelectionLabelInstance): SelectionLabelInstance => {
-      const liveElements = instance.elements?.filter(isElementConnected) ?? [];
-      const instanceElement = instance.element;
-
-      let liveBoundsList: OverlayBounds[] | null = null;
-      if (liveElements.length > 0) {
-        liveBoundsList = liveElements.map(createElementBounds);
-      } else if (instanceElement && isElementConnected(instanceElement)) {
-        liveBoundsList = [createElementBounds(instanceElement)];
-      }
+      const liveBoundsList = createLabelInstanceBoundsList(instance);
 
       let newBounds = instance.bounds;
       let newBoundsMultiple = instance.boundsMultiple;
@@ -3654,15 +3857,10 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       if (!isThemeEnabled()) return [];
       if (!pluginRegistry.store.theme.grabbedBoxes.enabled) return [];
       void viewportVersion();
-      return store.grabbedBoxes.map((box) => {
-        if (!isElementConnected(box.element)) {
-          return box;
-        }
-        return {
-          ...box,
-          bounds: createElementBounds(box.element),
-        };
-      });
+      return store.grabbedBoxes.map((box) => ({
+        ...box,
+        bounds: createGrabbedBoxBounds(box),
+      }));
     });
 
     const dragVisible = createMemo(
@@ -3697,7 +3895,11 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
 
     const contextMenuBounds = createMemo((): OverlayBounds | null => {
       void viewportVersion();
+      const textNode = frozenTextNode();
       const element = store.contextMenuElement;
+      if (textNode && element && isTextNodeTargetForElement(textNode, element)) {
+        return createTextNodeBounds(textNode);
+      }
       if (!element) return null;
       return createElementBounds(element);
     });
@@ -3710,6 +3912,10 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
     const contextMenuTagName = createMemo(() => {
       const element = store.contextMenuElement;
       if (!element) return undefined;
+      const textNode = frozenTextNode();
+      if (textNode && isTextNodeTargetForElement(textNode, element)) {
+        return formatTextNodeLabel(textNode);
+      }
       const frozenCount = store.frozenElements.length;
       if (frozenCount > 1) {
         return `${frozenCount} elements`;
@@ -3751,8 +3957,11 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
           const fallbackSelectionBounds = options?.fallbackSelectionBounds ?? [];
           const position = options?.position ?? store.contextMenuPosition ?? pointer();
           const frozenBounds = frozenElementsBounds();
-          const singleElementBounds = contextMenuBounds() ?? fallbackBounds;
           const hasMultipleElements = elements.length > 1;
+          const feedbackTextNode = hasMultipleElements ? null : getTextNodeForElement(element);
+          const singleElementBounds = feedbackTextNode
+            ? createTextNodeBounds(feedbackTextNode)
+            : (contextMenuBounds() ?? fallbackBounds);
 
           const labelBounds = hasMultipleElements
             ? createFlatOverlayBounds(combineBounds(frozenBounds))
@@ -3785,6 +3994,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
                 mouseX: labelCursorX,
                 elements: hasMultipleElements ? elements : undefined,
                 boundsMultiple: selectionBoundsForLabel,
+                textNode: feedbackTextNode ?? undefined,
               },
             );
 
@@ -3814,7 +4024,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
           if (shouldDeactivateAfter) {
             deactivateRenderer();
           } else {
-            actions.unfreeze();
+            unfreezeSelection();
           }
         });
       };
@@ -3852,10 +4062,13 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
       const copyAction = () => {
         clearPendingToolbarSelection();
         onBeforeCopy?.();
+        const activeNode = activeTextNode();
+        const textNode = getTextNodeForElement(element, activeNode);
         performCopyWithLabel({
           element,
           cursorX: position.x,
           selectedElements: elements.length > 1 ? elements : undefined,
+          textNode: textNode ?? undefined,
           shouldDeactivateAfter: store.wasActivatedByToggle,
         });
         hideContextMenuAction();
@@ -3865,9 +4078,11 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
         labelController.clearAll();
         clearPendingToolbarSelection();
         onBeforePrompt?.();
-        preparePromptMode(element, position.x, position.y);
+        const textNode = getTextNodeForElement(element);
+        preparePromptMode(element, position.x, position.y, textNode);
         actions.setPointer({ x: position.x, y: position.y });
         actions.setFrozenElement(element);
+        setFrozenTextNode(textNode);
         activatePromptMode();
         if (!isActivated()) {
           activateRenderer();
@@ -3880,7 +4095,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
           filePath,
           lineNumber,
           componentName,
-          tagName,
+          tagName: getTagName(element) || undefined,
         });
         if (didOpen) {
           clearPendingToolbarSelection();
@@ -3915,7 +4130,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
           if (store.wasActivatedByToggle) {
             deactivateRenderer();
           } else {
-            actions.unfreeze();
+            unfreezeSelection();
           }
         },
       };
@@ -3945,7 +4160,7 @@ export const init = (rawOptions?: Options): ReactGrabAPI => {
           labelController.clearAll();
           clearPendingToolbarSelection();
           actions.clearInputText();
-          actions.enterPromptMode(position, element);
+          actions.enterPromptMode(position, element, getPromptSelectionBounds(element));
           deferHideContextMenu();
         },
       });
diff --git a/packages/react-grab/src/core/label-controller.ts b/packages/react-grab/src/core/label-controller.ts
index caaebf512..c8ccba352 100644
--- a/packages/react-grab/src/core/label-controller.ts
+++ b/packages/react-grab/src/core/label-controller.ts
@@ -16,6 +16,7 @@ interface LabelStoreBridge {
 
 interface CreateLabelInstanceOptions {
   element?: Element;
+  textNode?: Text;
   mouseX?: number;
   elements?: Element[];
   boundsMultiple?: OverlayBounds[];
@@ -35,6 +36,7 @@ interface BuildLabelInstanceOptions {
   componentName: string | undefined;
   status: SelectionLabelInstance["status"];
   element?: Element;
+  textNode?: Text;
   mouseX?: number;
   elements?: Element[];
   boundsMultiple?: OverlayBounds[];
@@ -74,6 +76,7 @@ const buildLabelInstance = (options: BuildLabelInstanceOptions): SelectionLabelI
     status: options.status,
     createdAt: Date.now(),
     element: options.element,
+    textNode: options.textNode,
     elements: options.elements,
     mouseX: options.mouseX,
     mouseXOffsetFromCenter: mouseXOffset,
@@ -140,6 +143,7 @@ export const createLabelController = (
       componentName,
       status,
       element: options?.element,
+      textNode: options?.textNode,
       mouseX: options?.mouseX,
       elements: options?.elements,
       boundsMultiple: options?.boundsMultiple,
diff --git a/packages/react-grab/src/core/store.ts b/packages/react-grab/src/core/store.ts
index 021d01741..1fa7ccc11 100644
--- a/packages/react-grab/src/core/store.ts
+++ b/packages/react-grab/src/core/store.ts
@@ -1,11 +1,12 @@
 import { createStore, produce } from "solid-js/store";
 import { batch, createSignal } from "solid-js";
-import type { Position, GrabbedBox, SelectionLabelInstance } from "../types.js";
+import type { Position, GrabbedBox, OverlayBounds, SelectionLabelInstance } from "../types.js";
 import { OFFSCREEN_POSITION } from "../constants.js";
 import { createElementBounds } from "../utils/create-element-bounds.js";
 import { getBoundsCenter } from "../utils/get-bounds-center.js";
 import { isElementConnected } from "../utils/is-element-connected.js";
 import { resolveLiveElement, trackElementAnchor } from "./element-anchors.js";
+import { resolveLiveTextNode, trackTextNodeAnchor } from "./text-node-anchors.js";
 
 interface FrozenDragRect {
   pageX: number;
@@ -94,7 +95,13 @@ const relinkSlots = (draft: GrabStore): void => {
   draft.contextMenuElement = draft.contextMenuElement && relinkElement(draft.contextMenuElement);
 
   for (const instance of draft.labelInstances) {
-    if (instance.element) instance.element = relinkElement(instance.element);
+    if (instance.element) {
+      instance.element = relinkElement(instance.element);
+      if (instance.textNode) {
+        instance.textNode =
+          resolveLiveTextNode(instance.textNode, instance.element) ?? instance.textNode;
+      }
+    }
     if (instance.elements) {
       for (let index = 0; index < instance.elements.length; index += 1) {
         instance.elements[index] = relinkElement(instance.elements[index]);
@@ -102,7 +109,12 @@ const relinkSlots = (draft: GrabStore): void => {
     }
   }
   for (const box of draft.grabbedBoxes) {
-    if (box.element) box.element = relinkElement(box.element);
+    if (box.element) {
+      box.element = relinkElement(box.element);
+      if (box.textNode) {
+        box.textNode = resolveLiveTextNode(box.textNode, box.element) ?? box.textNode;
+      }
+    }
   }
 };
 
@@ -159,7 +171,7 @@ interface GrabActions {
   startCopy: () => void;
   completeCopy: () => void;
   finishJustCopied: () => void;
-  enterPromptMode: (position: Position, element: Element) => void;
+  enterPromptMode: (position: Position, element: Element, selectionBounds?: OverlayBounds) => void;
   exitPromptMode: () => void;
   setInputText: (value: string) => void;
   clearInputText: () => void;
@@ -172,7 +184,7 @@ interface GrabActions {
   addFrozenElements: (elements: Element[]) => void;
   setFrozenDragRect: (rect: FrozenDragRect | null) => void;
   relinkLiveElements: () => void;
-  setCopyStart: (position: Position, element: Element) => void;
+  setCopyStart: (position: Position, element: Element, selectionBounds?: OverlayBounds) => void;
   setLastGrabbed: (element: Element | null) => void;
   setWasActivatedByToggle: (value: boolean) => void;
   setPendingCommentMode: (value: boolean) => void;
@@ -432,8 +444,8 @@ const createGrabStore = (input: GrabStoreInput) => {
       }
     },
 
-    enterPromptMode: (position: Position, element: Element) => {
-      const bounds = createElementBounds(element);
+    enterPromptMode: (position: Position, element: Element, selectionBounds?: OverlayBounds) => {
+      const bounds = selectionBounds ?? createElementBounds(element);
       const { x: selectionCenterX } = getBoundsCenter(bounds);
       trackElementAnchor(element);
 
@@ -533,8 +545,8 @@ const createGrabStore = (input: GrabStoreInput) => {
       setStore(produce(relinkSlots));
     },
 
-    setCopyStart: (position: Position, element: Element) => {
-      const bounds = createElementBounds(element);
+    setCopyStart: (position: Position, element: Element, selectionBounds?: OverlayBounds) => {
+      const bounds = selectionBounds ?? createElementBounds(element);
       const { x: selectionCenterX } = getBoundsCenter(bounds);
       setStore("copyStart", position);
       setStore("copyOffsetFromCenterX", position.x - selectionCenterX);
@@ -579,6 +591,7 @@ const createGrabStore = (input: GrabStoreInput) => {
 
     addGrabbedBox: (box: GrabbedBox) => {
       if (box.element) trackElementAnchor(box.element);
+      if (box.textNode) trackTextNodeAnchor(box.textNode);
       setStore("grabbedBoxes", (boxes) => [...boxes, box]);
     },
 
@@ -592,6 +605,7 @@ const createGrabStore = (input: GrabStoreInput) => {
 
     addLabelInstance: (instance: SelectionLabelInstance) => {
       if (instance.element) trackElementAnchor(instance.element);
+      if (instance.textNode) trackTextNodeAnchor(instance.textNode);
       for (const instanceElement of instance.elements ?? []) {
         trackElementAnchor(instanceElement);
       }
diff --git a/packages/react-grab/src/core/text-node-anchors.ts b/packages/react-grab/src/core/text-node-anchors.ts
new file mode 100644
index 000000000..c1a4c2e0a
--- /dev/null
+++ b/packages/react-grab/src/core/text-node-anchors.ts
@@ -0,0 +1,66 @@
+import { transferTextNodeBoundsRectIndex } from "../utils/create-text-node-bounds.js";
+import { isGrabbableTextNode } from "../utils/is-grabbable-text-node.js";
+
+interface TextNodeAnchor {
+  childIndex: number;
+  directTextCount: number;
+  directTextIndex: number;
+  textContent: string;
+}
+
+const anchorByTextNode = new WeakMap<Text, TextNodeAnchor>();
+
+const getDirectTextNodes = (element: Element): Text[] => {
+  const textNodes: Text[] = [];
+  for (const childNode of element.childNodes) {
+    if (isGrabbableTextNode(childNode)) textNodes.push(childNode);
+  }
+  return textNodes;
+};
+
+export const trackTextNodeAnchor = (textNode: Text): void => {
+  const parentElement = textNode.parentElement;
+  if (!textNode.isConnected || !parentElement) return;
+
+  const directTextNodes = getDirectTextNodes(parentElement);
+  anchorByTextNode.set(textNode, {
+    childIndex: Array.from(parentElement.childNodes).indexOf(textNode),
+    directTextCount: directTextNodes.length,
+    directTextIndex: directTextNodes.indexOf(textNode),
+    textContent: textNode.textContent ?? "",
+  });
+};
+
+export const resolveLiveTextNode = (
+  textNode: Text | null | undefined,
+  liveElement: Element | null | undefined,
+): Text | null => {
+  if (!textNode || !liveElement) return null;
+  if (textNode.isConnected && textNode.parentElement === liveElement) {
+    trackTextNodeAnchor(textNode);
+    return textNode;
+  }
+
+  const anchor = anchorByTextNode.get(textNode);
+  if (!anchor) return null;
+
+  const childCandidate = liveElement.childNodes[anchor.childIndex];
+  const directTextNodes = getDirectTextNodes(liveElement);
+  const indexedTextCandidate = directTextNodes[anchor.directTextIndex];
+  const contentCandidate = directTextNodes.find(
+    (candidate) => candidate.textContent === anchor.textContent,
+  );
+  const changedTextCandidate =
+    directTextNodes.length === anchor.directTextCount ? indexedTextCandidate : undefined;
+  const liveTextNode =
+    indexedTextCandidate?.textContent === anchor.textContent
+      ? indexedTextCandidate
+      : isGrabbableTextNode(childCandidate) && childCandidate.textContent === anchor.textContent
+        ? childCandidate
+        : (contentCandidate ?? changedTextCandidate);
+  if (!liveTextNode) return null;
+
+  transferTextNodeBoundsRectIndex(textNode, liveTextNode);
+  trackTextNodeAnchor(liveTextNode);
+  return liveTextNode;
+};
diff --git a/packages/react-grab/src/types.ts b/packages/react-grab/src/types.ts
index c78eaff30..6e6c975c3 100644
--- a/packages/react-grab/src/types.ts
+++ b/packages/react-grab/src/types.ts
@@ -529,6 +529,7 @@ export interface SelectionLabelInstance {
   inputValue?: string;
   createdAt: number;
   element?: Element;
+  textNode?: Text;
   elements?: Element[];
   mouseX?: number;
   mouseXOffsetFromCenter?: number;
@@ -631,6 +632,7 @@ export interface GrabbedBox {
   bounds: OverlayBounds;
   createdAt: number;
   element?: Element;
+  textNode?: Text;
 }
 
 export interface Rect {
diff --git a/packages/react-grab/src/utils/create-grabbed-box-bounds.ts b/packages/react-grab/src/utils/create-grabbed-box-bounds.ts
new file mode 100644
index 000000000..0daf6feab
--- /dev/null
+++ b/packages/react-grab/src/utils/create-grabbed-box-bounds.ts
@@ -0,0 +1,14 @@
+import type { GrabbedBox, OverlayBounds } from "../types.js";
+import { createElementBounds } from "./create-element-bounds.js";
+import { createTextNodeBounds } from "./create-text-node-bounds.js";
+import { isElementConnected } from "./is-element-connected.js";
+
+export const createGrabbedBoxBounds = (box: GrabbedBox): OverlayBounds => {
+  if (box.textNode) {
+    return createTextNodeBounds(box.textNode);
+  }
+  if (isElementConnected(box.element)) {
+    return createElementBounds(box.element);
+  }
+  return box.bounds;
+};
diff --git a/packages/react-grab/src/utils/create-label-instance-bounds-list.ts b/packages/react-grab/src/utils/create-label-instance-bounds-list.ts
new file mode 100644
index 000000000..a7ecd0b98
--- /dev/null
+++ b/packages/react-grab/src/utils/create-label-instance-bounds-list.ts
@@ -0,0 +1,19 @@
+import type { OverlayBounds, SelectionLabelInstance } from "../types.js";
+import { createElementBounds } from "./create-element-bounds.js";
+import { createTextNodeBounds } from "./create-text-node-bounds.js";
+import { isElementConnected } from "./is-element-connected.js";
+
+export const createLabelInstanceBoundsList = (
+  instance: SelectionLabelInstance,
+): OverlayBounds[] | null => {
+  if (instance.textNode) {
+    return [createTextNodeBounds(instance.textNode)];
+  }
+
+  const liveElements = instance.elements?.filter(isElementConnected) ?? [];
+  if (liveElements.length > 0) return liveElements.map(createElementBounds);
+  if (instance.element && isElementConnected(instance.element)) {
+    return [createElementBounds(instance.element)];
+  }
+  return null;
+};
diff --git a/packages/react-grab/src/utils/create-text-node-bounds.ts b/packages/react-grab/src/utils/create-text-node-bounds.ts
new file mode 100644
index 000000000..0405483dd
--- /dev/null
+++ b/packages/react-grab/src/utils/create-text-node-bounds.ts
@@ -0,0 +1,83 @@
+import type { OverlayBounds } from "../types.js";
+import { BOUNDS_CACHE_TTL_MS } from "../constants.js";
+import { convertClientPositionToTopWindow } from "./convert-client-position-to-top-window.js";
+
+interface CachedTextNodeBounds {
+  bounds: OverlayBounds;
+  timestamp: number;
+}
+
+interface TextNodeBoundsAnchor {
+  normalizedRectIndex: number;
+}
+
+let textNodeBoundsCache = new WeakMap<Text, CachedTextNodeBounds>();
+const lastConnectedTextNodeBounds = new WeakMap<Text, OverlayBounds>();
+const boundsAnchorByTextNode = new WeakMap<Text, TextNodeBoundsAnchor>();
+
+export const invalidateTextNodeBoundsCache = () => {
+  textNodeBoundsCache = new WeakMap<Text, CachedTextNodeBounds>();
+};
+
+export const setTextNodeBoundsRectIndex = (
+  textNode: Text,
+  rectIndex: number,
+  rectCount: number,
+): void => {
+  const maximumRectIndex = Math.max(0, rectCount - 1);
+  boundsAnchorByTextNode.set(textNode, {
+    normalizedRectIndex: maximumRectIndex === 0 ? 0 : rectIndex / maximumRectIndex,
+  });
+  textNodeBoundsCache.delete(textNode);
+};
+
+export const transferTextNodeBoundsRectIndex = (
+  previousTextNode: Text,
+  nextTextNode: Text,
+): void => {
+  const boundsAnchor = boundsAnchorByTextNode.get(previousTextNode);
+  if (boundsAnchor) {
+    boundsAnchorByTextNode.set(nextTextNode, boundsAnchor);
+    textNodeBoundsCache.delete(nextTextNode);
+  }
+};
+
+export const createTextNodeBounds = (textNode: Text): OverlayBounds => {
+  const now = performance.now();
+  const cached = textNodeBoundsCache.get(textNode);
+  if (textNode.isConnected === false) {
+    const disconnectedBounds = cached?.bounds ?? lastConnectedTextNodeBounds.get(textNode);
+    if (disconnectedBounds) return disconnectedBounds;
+  } else if (cached && now - cached.timestamp < BOUNDS_CACHE_TTL_MS) {
+    return cached.bounds;
+  }
+
+  const range = textNode.ownerDocument.createRange();
+  range.selectNodeContents(textNode);
+  const rects = range.getClientRects();
+  const boundsAnchor = boundsAnchorByTextNode.get(textNode);
+  let rect: DOMRect | undefined;
+  if (boundsAnchor && rects.length > 0) {
+    const currentMaximumIndex = rects.length - 1;
+    const currentRectIndex = Math.round(boundsAnchor.normalizedRectIndex * currentMaximumIndex);
+    rect = rects[currentRectIndex];
+  }
+  rect ??= range.getBoundingClientRect();
+  const topWindowPosition = convertClientPositionToTopWindow(
+    textNode.ownerDocument.defaultView,
+    rect.left,
+    rect.top,
+  );
+
+  const bounds: OverlayBounds = {
+    borderRadius: "0px",
+    height: rect.height * topWindowPosition.scaleY,
+    width: rect.width * topWindowPosition.scaleX,
+    x: topWindowPosition.x,
+    y: topWindowPosition.y,
+  };
+
+  textNodeBoundsCache.set(textNode, { bounds, timestamp: now });
+  if (textNode.isConnected !== false) lastConnectedTextNodeBounds.set(textNode, bounds);
+  return bounds;
+};
diff --git a/packages/react-grab/src/utils/format-text-node-label.ts b/packages/react-grab/src/utils/format-text-node-label.ts
new file mode 100644
index 000000000..867beaf3d
--- /dev/null
+++ b/packages/react-grab/src/utils/format-text-node-label.ts
@@ -0,0 +1,7 @@
+import { TEXT_NODE_LABEL_MAX_LENGTH } from "../constants.js";
+import { truncateString } from "./truncate-string.js";
+
+export const formatTextNodeLabel = (textNode: Text): string => {
+  const textContent = textNode.textContent?.replace(/\s+/g, " ").trim() ?? "";
+  return `"${truncateString(textContent, TEXT_NODE_LABEL_MAX_LENGTH)}"`;
+};
diff --git a/packages/react-grab/src/utils/get-text-node-at-position.ts b/packages/react-grab/src/utils/get-text-node-at-position.ts
new file mode 100644
index 000000000..a5f1a3f14
--- /dev/null
+++ b/packages/react-grab/src/utils/get-text-node-at-position.ts
@@ -0,0 +1,41 @@
+import { convertClientPositionToTopWindow } from "./convert-client-position-to-top-window.js";
+import { setTextNodeBoundsRectIndex } from "./create-text-node-bounds.js";
+import { isGrabbableTextNode } from "./is-grabbable-text-node.js";
+import { isPointInsideRect } from "./is-point-inside-rect.js";
+
+export const getTextNodeAtPosition = (
+  parentElement: Element,
+  clientX: number,
+  clientY: number,
+): Text | null => {
+  if (parentElement.children.length === 0) return null;
+
+  const range = parentElement.ownerDocument.createRange();
+
+  for (const childNode of parentElement.childNodes) {
+    if (!isGrabbableTextNode(childNode)) continue;
+
+    range.selectNodeContents(childNode);
+    const rects = range.getClientRects();
+    for (let rectIndex = 0; rectIndex < rects.length; rectIndex += 1) {
+      const rect = rects[rectIndex];
+      const topWindowPosition = convertClientPositionToTopWindow(
+        parentElement.ownerDocument.defaultView,
+        rect.left,
+        rect.top,
+      );
+      const topWindowRect = {
+        left: topWindowPosition.x,
+        top: topWindowPosition.y,
+        right: topWindowPosition.x + rect.width * topWindowPosition.scaleX,
+        bottom: topWindowPosition.y + rect.height * topWindowPosition.scaleY,
+      };
+      if (isPointInsideRect(clientX, clientY, topWindowRect)) {
+        setTextNodeBoundsRectIndex(childNode, rectIndex, rects.length);
+        return childNode;
+      }
+    }
+  }
+
+  return null;
+};
diff --git a/packages/react-grab/src/utils/invalidate-interaction-caches.ts b/packages/react-grab/src/utils/invalidate-interaction-caches.ts
index 109acbb0c..a6c7926b6 100644
--- a/packages/react-grab/src/utils/invalidate-interaction-caches.ts
+++ b/packages/react-grab/src/utils/invalidate-interaction-caches.ts
@@ -1,4 +1,5 @@
 import { invalidateBoundsCache } from "./create-element-bounds.js";
+import { invalidateTextNodeBoundsCache } from "./create-text-node-bounds.js";
 import { clearElementPositionCache } from "./get-element-at-position.js";
 
 // The visibility cache is intentionally NOT cleared here: this runs on every
@@ -10,5 +11,6 @@ import { clearElementPositionCache } from "./get-element-at-position.js";
 // mutations already have when they fire outside a scroll event.
 export const invalidateInteractionCaches = (): void => {
   invalidateBoundsCache();
+  invalidateTextNodeBoundsCache();
   clearElementPositionCache();
 };
diff --git a/packages/react-grab/src/utils/is-grabbable-text-node.ts b/packages/react-grab/src/utils/is-grabbable-text-node.ts
new file mode 100644
index 000000000..fd7f3b444
--- /dev/null
+++ b/packages/react-grab/src/utils/is-grabbable-text-node.ts
@@ -0,0 +1,4 @@
+import { isTextNode } from "./is-text-node.js";
+
+export const isGrabbableTextNode = (node: Node): node is Text =>
+  isTextNode(node) && Boolean(node.textContent?.trim());
diff --git a/packages/react-grab/src/utils/is-text-node.ts b/packages/react-grab/src/utils/is-text-node.ts
new file mode 100644
index 000000000..3a3877bbc
--- /dev/null
+++ b/packages/react-grab/src/utils/is-text-node.ts
@@ -0,0 +1 @@
+export const isTextNode = (node: Node): node is Text => node.nodeType === Node.TEXT_NODE;
diff --git a/packages/react-grab/tests/create-grabbed-box-bounds.test.ts b/packages/react-grab/tests/create-grabbed-box-bounds.test.ts
new file mode 100644
index 000000000..343f77bca
--- /dev/null
+++ b/packages/react-grab/tests/create-grabbed-box-bounds.test.ts
@@ -0,0 +1,57 @@
+import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
+import { createGrabbedBoxBounds } from "../src/utils/create-grabbed-box-bounds.js";
+import { createElementBounds } from "../src/utils/create-element-bounds.js";
+import { createTextNodeBounds } from "../src/utils/create-text-node-bounds.js";
+import { isElementConnected } from "../src/utils/is-element-connected.js";
+
+vi.mock("../src/utils/create-element-bounds.js", () => ({
+  createElementBounds: vi.fn(),
+}));
+
+vi.mock("../src/utils/create-text-node-bounds.js", () => ({
+  createTextNodeBounds: vi.fn(),
+}));
+
+vi.mock("../src/utils/is-element-connected.js", () => ({
+  isElementConnected: vi.fn(),
+}));
+
+beforeEach(() => {
+  vi.resetAllMocks();
+});
+
+describe("create grabbed box bounds", () => {
+  it("uses the last measured text bounds while the text node is disconnected", () => {
+    const element: Element = Object.create(null);
+    const textNode: Text = Object.create(null);
+    Object.defineProperty(textNode, "isConnected", { value: false });
+    const bounds = {
+      borderRadius: "0px",
+      height: 20,
+      width: 120,
+      x: 30,
+      y: 40,
+    };
+    const lastMeasuredBounds = {
+      borderRadius: "0px",
+      height: 22,
+      width: 124,
+      x: 34,
+      y: 44,
+    };
+    vi.mocked(createTextNodeBounds).mockReturnValue(lastMeasuredBounds);
+    vi.mocked(isElementConnected).mockReturnValue(true);
+
+    expect(
+      createGrabbedBoxBounds({
+        bounds,
+        createdAt: 0,
+        element,
+        id: "text-box",
+        textNode,
+      }),
+    ).toBe(lastMeasuredBounds);
+    expect(createTextNodeBounds).toHaveBeenCalledWith(textNode);
+    expect(createElementBounds).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/react-grab/tests/create-label-instance-bounds-list.test.ts b/packages/react-grab/tests/create-label-instance-bounds-list.test.ts
new file mode 100644
index 000000000..731190ff2
--- /dev/null
+++ b/packages/react-grab/tests/create-label-instance-bounds-list.test.ts
@@ -0,0 +1,52 @@
+import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
+import { createLabelInstanceBoundsList } from "../src/utils/create-label-instance-bounds-list.js";
+import { createElementBounds } from "../src/utils/create-element-bounds.js";
+import { createTextNodeBounds } from "../src/utils/create-text-node-bounds.js";
+import { isElementConnected } from "../src/utils/is-element-connected.js";
+
+vi.mock("../src/utils/create-element-bounds.js", () => ({
+  createElementBounds: vi.fn(),
+}));
+
+vi.mock("../src/utils/create-text-node-bounds.js", () => ({
+  createTextNodeBounds: vi.fn(),
+}));
+
+vi.mock("../src/utils/is-element-connected.js", () => ({
+  isElementConnected: vi.fn(),
+}));
+
+beforeEach(() => {
+  vi.resetAllMocks();
+});
+
+describe("create label instance bounds list", () => {
+  it("uses the last measured text bounds while the text node is disconnected", () => {
+    const element: Element = Object.create(null);
+    const textNode: Text = Object.create(null);
+    Object.defineProperty(textNode, "isConnected", { value: false });
+    const bounds = {
+      borderRadius: "0px",
+      height: 20,
+      width: 120,
+      x: 30,
+      y: 40,
+    };
+    vi.mocked(createTextNodeBounds).mockReturnValue(bounds);
+    vi.mocked(isElementConnected).mockReturnValue(true);
+
+    expect(
+      createLabelInstanceBoundsList({
+        bounds,
+        createdAt: 0,
+        element,
+        id: "text-label",
+        status: "copied",
+        tagName: "#text",
+        textNode,
+      }),
+    ).toEqual([bounds]);
+    expect(createTextNodeBounds).toHaveBeenCalledWith(textNode);
+    expect(createElementBounds).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/react-grab/tests/create-text-node-bounds.test.ts b/packages/react-grab/tests/create-text-node-bounds.test.ts
new file mode 100644
index 000000000..3fb7a3585
--- /dev/null
+++ b/packages/react-grab/tests/create-text-node-bounds.test.ts
@@ -0,0 +1,97 @@
+import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
+import {
+  createTextNodeBounds,
+  invalidateTextNodeBoundsCache,
+  setTextNodeBoundsRectIndex,
+} from "../src/utils/create-text-node-bounds.js";
+import { BOUNDS_CACHE_TTL_MS } from "../src/constants.js";
+import { convertClientPositionToTopWindow } from "../src/utils/convert-client-position-to-top-window.js";
+
+vi.mock("../src/utils/convert-client-position-to-top-window.js", () => ({
+  convertClientPositionToTopWindow: vi.fn(),
+}));
+
+const createRect = (x: number): DOMRect => {
+  const rect: DOMRect = Object.create(null);
+  Object.assign(rect, {
+    height: 20,
+    left: x,
+    top: 40,
+    width: 80,
+  });
+  return rect;
+};
+
+beforeEach(() => {
+  invalidateTextNodeBoundsCache();
+  vi.resetAllMocks();
+  vi.mocked(convertClientPositionToTopWindow).mockImplementation(
+    (_ownerWindow, clientX, clientY) => ({
+      scaleX: 1,
+      scaleY: 1,
+      x: clientX,
+      y: clientY,
+    }),
+  );
+});
+
+describe("create text node bounds", () => {
+  it("preserves the original wrapped-line position across repeated reflows", () => {
+    let rects = [createRect(10), createRect(20)];
+    const range: Range = Object.create(null);
+    Object.assign(range, {
+      getBoundingClientRect: () => rects[0],
+      getClientRects: () => rects,
+      selectNodeContents: vi.fn(),
+    });
+    const ownerDocument: Document = Object.create(null);
+    Object.assign(ownerDocument, {
+      createRange: () => range,
+      defaultView: null,
+    });
+    const textNode: Text = Object.create(null);
+    Object.defineProperty(textNode, "ownerDocument", { value: ownerDocument });
+
+    setTextNodeBoundsRectIndex(textNode, 1, 4);
+    expect(createTextNodeBounds(textNode).x).toBe(10);
+
+    invalidateTextNodeBoundsCache();
+    rects = [createRect(10), createRect(20), createRect(30), createRect(40)];
+    expect(createTextNodeBounds(textNode).x).toBe(20);
+  });
+
+  it("preserves cached bounds while a text node is briefly disconnected", () => {
+    let isConnected = true;
+    let rect = createRect(10);
+    const getBoundingClientRect = vi.fn(() => rect);
+    const range: Range = Object.create(null);
+    Object.assign(range, {
+      getBoundingClientRect,
+      getClientRects: () => [],
+      selectNodeContents: vi.fn(),
+    });
+    const ownerDocument: Document = Object.create(null);
+    Object.assign(ownerDocument, {
+      createRange: () => range,
+      defaultView: null,
+    });
+    const textNode: Text = Object.create(null);
+    Object.defineProperties(textNode, {
+      isConnected: { get: () => isConnected },
+      ownerDocument: { value: ownerDocument },
+    });
+    const performanceNow = vi.spyOn(performance, "now");
+    performanceNow.mockReturnValue(0);
+
+    expect(createTextNodeBounds(textNode).x).toBe(10);
+
+    isConnected = false;
+    rect = createRect(20);
+    performanceNow.mockReturnValue(BOUNDS_CACHE_TTL_MS + 1);
+    invalidateTextNodeBoundsCache();
+
+    expect(createTextNodeBounds(textNode).x).toBe(10);
+    expect(getBoundingClientRect).toHaveBeenCalledOnce();
+    performanceNow.mockRestore();
+  });
+});
diff --git a/packages/react-grab/tests/store-text-node-anchors.test.ts b/packages/react-grab/tests/store-text-node-anchors.test.ts
new file mode 100644
index 000000000..9089ab53f
--- /dev/null
+++ b/packages/react-grab/tests/store-text-node-anchors.test.ts
@@ -0,0 +1,91 @@
+import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
+import { createGrabStore } from "../src/core/store.js";
+import { resolveLiveElement, trackElementAnchor } from "../src/core/element-anchors.js";
+import { resolveLiveTextNode, trackTextNodeAnchor } from "../src/core/text-node-anchors.js";
+
+vi.mock("../src/core/element-anchors.js", () => ({
+  resolveLiveElement: vi.fn(),
+  trackElementAnchor: vi.fn(),
+}));
+
+vi.mock("../src/core/text-node-anchors.js", () => ({
+  resolveLiveTextNode: vi.fn(),
+  trackTextNodeAnchor: vi.fn(),
+}));
+
+beforeEach(() => {
+  vi.resetAllMocks();
+});
+
+describe("store text node anchors", () => {
+  it("tracks text nodes added to feedback collections", () => {
+    const element: Element = Object.create(null);
+    const textNode: Text = Object.create(null);
+    const bounds = {
+      borderRadius: "0px",
+      height: 20,
+      width: 120,
+      x: 30,
+      y: 40,
+    };
+    const { actions } = createGrabStore({ keyHoldDuration: 100 });
+
+    actions.addGrabbedBox({
+      bounds,
+      createdAt: 0,
+      element,
+      id: "text-box",
+      textNode,
+    });
+    actions.addLabelInstance({
+      bounds,
+      createdAt: 0,
+      element,
+      id: "text-label",
+      status: "copied",
+      tagName: "#text",
+      textNode,
+    });
+
+    expect(trackElementAnchor).toHaveBeenCalledTimes(2);
+    expect(trackTextNodeAnchor).toHaveBeenCalledTimes(2);
+    expect(trackTextNodeAnchor).toHaveBeenNthCalledWith(1, textNode);
+    expect(trackTextNodeAnchor).toHaveBeenNthCalledWith(2, textNode);
+  });
+
+  it("keeps text targets when a relink attempt temporarily fails", () => {
+    const element: Element = Object.create(null);
+    const textNode: Text = Object.create(null);
+    const bounds = {
+      borderRadius: "0px",
+      height: 20,
+      width: 120,
+      x: 30,
+      y: 40,
+    };
+    vi.mocked(resolveLiveElement).mockReturnValue(element);
+    vi.mocked(resolveLiveTextNode).mockReturnValue(null);
+    const { actions, store } = createGrabStore({ keyHoldDuration: 100 });
+
+    actions.addGrabbedBox({
+      bounds,
+      createdAt: 0,
+      element,
+      id: "text-box",
+      textNode,
+    });
+    actions.addLabelInstance({
+      bounds,
+      createdAt: 0,
+      element,
+      id: "text-label",
+      status: "copied",
+      tagName: "#text",
+      textNode,
+    });
+    actions.relinkLiveElements();
+
+    expect(store.grabbedBoxes[0]?.textNode).toBe(textNode);
+    expect(store.labelInstances[0]?.textNode).toBe(textNode);
+  });
+});
diff --git a/packages/react-grab/tests/text-node-anchors.test.ts b/packages/react-grab/tests/text-node-anchors.test.ts
new file mode 100644
index 000000000..b9215b2fb
--- /dev/null
+++ b/packages/react-grab/tests/text-node-anchors.test.ts
@@ -0,0 +1,116 @@
+import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
+import { resolveLiveTextNode, trackTextNodeAnchor } from "../src/core/text-node-anchors.js";
+import { transferTextNodeBoundsRectIndex } from "../src/utils/create-text-node-bounds.js";
+import { isTextNode } from "../src/utils/is-text-node.js";
+
+vi.mock("../src/utils/create-text-node-bounds.js", () => ({
+  transferTextNodeBoundsRectIndex: vi.fn(),
+}));
+
+vi.mock("../src/utils/is-text-node.js", () => ({
+  isTextNode: vi.fn(),
+}));
+
+const textNodes = new Set<Node>();
+
+const createElement = (childNodes: Node[]): Element => {
+  const element: Element = Object.create(null);
+  Object.defineProperty(element, "childNodes", { value: childNodes });
+  return element;
+};
+
+const createTextNode = (textContent: string, parentElement: Element): Text => {
+  const textNode: Text = Object.create(null);
+  Object.defineProperties(textNode, {
+    isConnected: { configurable: true, value: true },
+    parentElement: { configurable: true, value: parentElement },
+    textContent: { value: textContent },
+  });
+  textNodes.add(textNode);
+  return textNode;
+};
+
+beforeEach(() => {
+  vi.resetAllMocks();
+  textNodes.clear();
+  vi.mocked(isTextNode).mockImplementation((node) => textNodes.has(node));
+});
+
+describe("text node anchors", () => {
+  it("prefers matching text content over a stale child index", () => {
+    const previousChildren: Node[] = [];
+    const previousElement = createElement(previousChildren);
+    const previousTextNode = createTextNode("tracked text", previousElement);
+    previousChildren.push(previousTextNode);
+    trackTextNodeAnchor(previousTextNode);
+    Object.defineProperty(previousTextNode, "isConnected", { value: false });
+
+    const liveChildren: Node[] = [];
+    const liveElement = createElement(liveChildren);
+    const wrongTextNode = createTextNode("new sibling", liveElement);
+    const matchingTextNode = createTextNode("tracked text", liveElement);
+    liveChildren.push(wrongTextNode, matchingTextNode);
+
+    expect(resolveLiveTextNode(previousTextNode, liveElement)).toBe(matchingTextNode);
+    expect(transferTextNodeBoundsRectIndex).toHaveBeenCalledWith(
+      previousTextNode,
+      matchingTextNode,
+    );
+  });
+
+  it("ignores whitespace-only siblings when text content changes", () => {
+    const previousChildren: Node[] = [];
+    const previousElement = createElement(previousChildren);
+    const previousTextNode = createTextNode("previous text", previousElement);
+    previousChildren.push(previousTextNode);
+    trackTextNodeAnchor(previousTextNode);
+    Object.defineProperty(previousTextNode, "isConnected", { value: false });
+
+    const liveChildren: Node[] = [];
+    const liveElement = createElement(liveChildren);
+    const whitespaceTextNode = createTextNode(" \n ", liveElement);
+    const changedTextNode = createTextNode("changed text", liveElement);
+    liveChildren.push(whitespaceTextNode, changedTextNode);
+
+    expect(resolveLiveTextNode(previousTextNode, liveElement)).toBe(changedTextNode);
+  });
+
+  it("does not relink to a sibling that shifts into a removed text node's index", () => {
+    const previousChildren: Node[] = [];
+    const previousElement = createElement(previousChildren);
+    const removedTextNode = createTextNode("removed text", previousElement);
+    const nestedElement = createElement([]);
+    const remainingTextNode = createTextNode("remaining text", previousElement);
+    previousChildren.push(removedTextNode, nestedElement, remainingTextNode);
+    trackTextNodeAnchor(removedTextNode);
+    Object.defineProperty(removedTextNode, "isConnected", { value: false });
+
+    const liveChildren: Node[] = [];
+    const liveElement = createElement(liveChildren);
+    const liveNestedElement = createElement([]);
+    const liveRemainingTextNode = createTextNode("remaining text", liveElement);
+    liveChildren.push(liveNestedElement, liveRemainingTextNode);
+
+    expect(resolveLiveTextNode(removedTextNode, liveElement)).toBe(null);
+    expect(transferTextNodeBoundsRectIndex).not.toHaveBeenCalled();
+  });
+
+  it("preserves the selected occurrence when direct text content is duplicated", () => {
+    const previousChildren: Node[] = [];
+    const previousElement = createElement(previousChildren);
+    const firstPreviousTextNode = createTextNode("duplicate", previousElement);
+    const selectedPreviousTextNode = createTextNode("duplicate", previousElement);
+    previousChildren.push(firstPreviousTextNode, selectedPreviousTextNode);
+    trackTextNodeAnchor(selectedPreviousTextNode);
+    Object.defineProperty(selectedPreviousTextNode, "isConnected", { value: false });
+
+    const liveChildren: Node[] = [];
+    const liveElement = createElement(liveChildren);
+    const insertedElement = createElement([]);
+    const firstLiveTextNode = createTextNode("duplicate", liveElement);
+    const selectedLiveTextNode = createTextNode("duplicate", liveElement);
+    liveChildren.push(insertedElement, firstLiveTextNode, selectedLiveTextNode);
+
+    expect(resolveLiveTextNode(selectedPreviousTextNode, liveElement)).toBe(selectedLiveTextNode);
+  });
+});