Skip to content
Shaken UI
Sign in

Selection Actions

Save

A floating AI toolbar for selected text in a passage: Rewrite, Shorten, Explain, or a typed edit, with the rewrite resolving in place for Keep or Discard.

Category
AI elements
Version
0.1.0
Frameworks
Next.js, Vite + React
Styling
Tailwind CSS v4

Preview

Selection Actions preview

Incident summary: API rate limiting

On Tuesday at 14:05 UTC, a configuration change to the rate limiter caused roughly 6% of API requests to fail with 429 errors for about 22 minutes. The change was intended to lower limits only for unauthenticated traffic, but a missing condition applied it to every workspace on the Pro plan.

We rolled the change back at 14:27 and added a check that compares limits before and after each deploy. Going forward, rate limit changes will ship to 1% of traffic first and wait for an hour of clean metrics before going wider.

Select any sentence to rewrite, shorten, or explain it.

Installation

npx @shakenui/cli add selection-actions

Review the plan first. A dry run lists every file and package without changing anything:

npx @shakenui/cli add selection-actions --dry-run

Usage

selection-actions-example.tsx
"use client";

import { type SelectionRequest, SelectionActions } from "@/components/shaken/agent/selection-actions";

const passage = `On Tuesday at 14:05 UTC, a configuration change to the rate limiter caused roughly 6% of API requests to fail with 429 errors for about 22 minutes. The change was intended to lower limits only for unauthenticated traffic, but a missing condition applied it to every workspace on the Pro plan.

We rolled the change back at 14:27 and added a check that compares limits before and after each deploy. Going forward, rate limit changes will ship to 1% of traffic first and wait for an hour of clean metrics before going wider.`;

const selected = "The change was intended to lower limits only for unauthenticated traffic, but a missing condition applied it to every workspace on the Pro plan.";

const rewrites: Record<string, Record<string, string>> = {
  rewrite: {
    [selected]: "The change should have lowered limits for unauthenticated traffic only; a missing condition applied it to every Pro workspace instead.",
  },
  shorten: {
    [selected]: "A missing condition applied a limit meant for anonymous traffic to every Pro workspace.",
  },
};

const swaps: [RegExp, string][] = [
  [/\broughly\b/g, "about"],
  [/\bintended\b/g, "meant"],
  [/\bGoing forward\b/g, "From now on"],
  [/\bwait for\b/g, "need"],
  [/\bgoing wider\b/g, "rolling out further"],
];

// Stands in for a model call: answers after a short pause and stops when aborted.
function fakeModel({ action, prompt, text, signal }: SelectionRequest): Promise<string> {
  return new Promise((resolve, reject) => {
    const timer = setTimeout(() => {
      const id = action?.id ?? "custom";
      if (id === "explain") {
        resolve(
          /429|rate limit/i.test(text)
            ? "A rate limiter caps how many requests one client can send per minute. A 429 status means a request went over that cap and was refused."
            : "This sentence describes how the team will release limit changes: to a small slice of traffic first, and only wider once metrics stay clean.",
        );
        return;
      }
      const canned = rewrites[id]?.[text];
      if (canned) return resolve(canned);
      if (id === "shorten") return resolve((text.split(/,\s|;\s/)[0] ?? text).replace(/[.]?$/, "."));
      if (id === "custom" && /direct/i.test(prompt ?? "")) return resolve(text.replace(/^The change was intended to/, "We meant to"));
      resolve(swaps.reduce((out, [pattern, next]) => out.replace(pattern, next), text));
    }, 900);
    signal.addEventListener("abort", () => {
      clearTimeout(timer);
      reject(new DOMException("Aborted", "AbortError"));
    });
  });
}

export default function SelectionActionsExample() {
  const start = passage.indexOf(selected);
  return (
    <article className="w-full max-w-lg">
      <h3 className="mb-2 text-sm font-semibold text-zinc-950 dark:text-white">Incident summary: API rate limiting</h3>
      <SelectionActions defaultValue={passage} defaultSelection={{ start, end: start + selected.length }} onRun={fakeModel} />
      <p className="mt-16 text-xs text-zinc-500">Select any sentence to rewrite, shorten, or explain it.</p>
    </article>
  );
}

API

PropTypeDefaultDescription
defaultValue / valuestring—The passage. Blank lines separate paragraphs. Pass value with onValueChange to control it.
onValueChange(value: string) => void—Called with the new passage when the user keeps a rewrite.
onRun(request) => string | Promise<string>—Returns the rewrite or note. The request has action, prompt, text, value, start, end, and an AbortSignal for Stop.
actionsSelectionAction[]Rewrite, Shorten, ExplainToolbar buttons: { id, label, icon?, kind?: "replace" | "note", pending? }. A note action shows its answer under the toolbar instead of editing.
allowPromptbooleantrueAdds an Ask button that turns the toolbar into a field for a typed edit.
defaultSelection{ start, end }—Opens the toolbar on this range at first, as if the user had selected it.
paragraphClassNamestring—Classes for each paragraph.

Accessibility

  • The toolbar is role="toolbar" named "Edit selection", placed right after the passage in the DOM, so Tab moves from a selection into it; Left and Right arrows move between its buttons.
  • Choosing an action keeps the selected range drawn as a highlight, since the native selection goes away when focus moves.
  • When the toolbar is used from the keyboard, focus follows each state: Stop while working, then Keep, then back to the first action after Discard.
  • Escape stops a running request, discards a proposal under review, or closes the toolbar. A polite status region announces working, ready, kept, and discarded.
  • The custom edit field has a visually hidden label, "Describe the edit".
  • Selecting text needs a pointer or caret browsing; the toolbar itself is fully keyboard operable.
  • With reduced motion the toolbar moves and resizes instantly, the working spinner is still, and the rewrite appears without the word-by-word blur.

Files

Installed into src/components/shaken, or components/shaken when the project has no src directory.

  • src/components/shaken/agent/selection-actions.tsxselection-actions
  • npm packages: motion@^14.14.0React and Tailwind CSS v4 required

Source

The exact source the CLI installs, from /r/items/react/selection-actions/0.1.0.json.

agent/selection-actions.tsxShow
agent/selection-actions.tsx
"use client";

import { motion, useReducedMotion } from "motion/react";
import {
  type ComponentProps,
  type KeyboardEvent,
  type ReactNode,
  useCallback,
  useEffect,
  useId,
  useLayoutEffect,
  useRef,
  useState,
} from "react";

function cx(...classes: (string | false | null | undefined)[]) {
  return classes.filter(Boolean).join(" ");
}

const ease = "ease-[cubic-bezier(0.23,1,0.32,1)]";
const quint = [0.23, 1, 0.32, 1] as const;

export interface SelectionAction {
  id: string;
  label: string;
  icon?: ReactNode;
  /** replace rewrites the selection in place for Keep or Discard; note shows the answer under the toolbar. @default "replace" */
  kind?: "replace" | "note";
  /** What the toolbar says while it runs, e.g. "Shortening". Defaults to "Working". */
  pending?: string;
}

export interface SelectionRequest {
  /** The action picked, or null for a typed request. */
  action: SelectionAction | null;
  /** The typed request, for a custom edit. */
  prompt?: string;
  /** The selected text. */
  text: string;
  /** The whole passage, for context. */
  value: string;
  start: number;
  end: number;
  /** Aborted when the user presses Stop or closes the toolbar. */
  signal: AbortSignal;
}

export interface SelectionRange {
  start: number;
  end: number;
}

export interface SelectionActionsProps extends Omit<ComponentProps<"div">, "children" | "defaultValue" | "onChange"> {
  /** The passage. Blank lines separate paragraphs. Pass with `onValueChange` to control it. */
  value?: string;
  defaultValue?: string;
  /** Called when the user keeps a rewrite. */
  onValueChange?: (value: string) => void;
  /** Returns the rewrite (or the note) for a request. May be async. */
  onRun: (request: SelectionRequest) => string | Promise<string>;
  /** The buttons in the toolbar. Defaults to Rewrite, Shorten, and Explain. */
  actions?: SelectionAction[];
  /** Adds an Ask button that turns the toolbar into a field for a custom edit. @default true */
  allowPrompt?: boolean;
  /** Opens the toolbar on this range at first, as if the user had selected it. */
  defaultSelection?: SelectionRange;
  /** Classes for each paragraph. */
  paragraphClassName?: string;
}

type Phase = "idle" | "prompt" | "working" | "review" | "note" | "error";

const defaultActions: SelectionAction[] = [
  { id: "rewrite", label: "Rewrite", pending: "Rewriting", icon: <RewriteIcon /> },
  { id: "shorten", label: "Shorten", pending: "Shortening", icon: <ShortenIcon /> },
  { id: "explain", label: "Explain", pending: "Reading", kind: "note", icon: <ExplainIcon /> },
];

interface Paragraph {
  start: number;
  text: string;
}

function paragraphs(text: string): Paragraph[] {
  const out: Paragraph[] = [];
  const pattern = /\n{2,}/g;
  let last = 0;
  let match: RegExpExecArray | null;
  while ((match = pattern.exec(text))) {
    out.push({ start: last, text: text.slice(last, match.index) });
    last = match.index + match[0].length;
  }
  out.push({ start: last, text: text.slice(last) });
  return out;
}

/**
 * A floating AI toolbar for text the user selects inside a passage: Rewrite, Shorten, Explain, or a
 * typed request. It follows the selection, morphs between its idle, working and Keep or Discard
 * states as one object, and the rewrite resolves in place out of a soft blur.
 */
export function SelectionActions({
  value: valueProp,
  defaultValue = "",
  onValueChange,
  onRun,
  actions = defaultActions,
  allowPrompt = true,
  defaultSelection,
  paragraphClassName,
  className,
  ...props
}: SelectionActionsProps) {
  const id = useId();
  const reduce = useReducedMotion();
  const [inner, setInner] = useState(defaultValue);
  const value = valueProp ?? inner;
  const [range, setRange] = useState<SelectionRange | null>(defaultSelection ?? null);
  // Frozen: the range is drawn as a highlight in the text, because focus has moved to the toolbar.
  const [frozen, setFrozen] = useState(Boolean(defaultSelection));
  const [phase, setPhase] = useState<Phase>("idle");
  const [result, setResult] = useState("");
  const [prompt, setPrompt] = useState("");
  const [pendingLabel, setPendingLabel] = useState("Working");
  const [kept, setKept] = useState<SelectionRange | null>(null);
  const [announcement, setAnnouncement] = useState("");
  const [position, setPosition] = useState<{ x: number; y: number; above: boolean } | null>(null);
  const [size, setSize] = useState<{ width: number; height: number } | null>(null);

  const rootRef = useRef<HTMLDivElement>(null);
  const textRef = useRef<HTMLDivElement>(null);
  const barRef = useRef<HTMLDivElement>(null);
  const barInnerRef = useRef<HTMLDivElement>(null);
  const controller = useRef<AbortController | null>(null);
  const lastRequest = useRef<{ action: SelectionAction | null; prompt?: string } | null>(null);
  const shown = useRef(false);
  // True while the user drives the toolbar from the keyboard, so focus follows each state change.
  const keyboard = useRef(false);

  const locked = phase === "working" || phase === "review" || phase === "note";
  const open = range !== null && range.end > range.start;
  // Read by the selection listener, which must not act on a stale render.
  const state = useRef({ locked, frozen, value });
  state.current = { locked, frozen, value };

  const close = useCallback(() => {
    controller.current?.abort();
    controller.current = null;
    setRange(null);
    setFrozen(false);
    setPhase("idle");
    setPrompt("");
    setResult("");
  }, []);

  // Read the user's selection into text offsets while the toolbar is not busy.
  useEffect(() => {
    let frame = 0;
    const read = () => {
      frame = 0;
      const root = textRef.current;
      const bar = barRef.current;
      const { locked, frozen, value } = state.current;
      if (!root || locked) return;
      if (bar?.contains(document.activeElement)) return;
      const selection = document.getSelection();
      if (!selection || selection.rangeCount === 0 || selection.isCollapsed) {
        if (!frozen) setRange(null);
        return;
      }
      const dom = selection.getRangeAt(0);
      if (!root.contains(dom.startContainer) || !root.contains(dom.endContainer)) {
        if (!frozen) setRange(null);
        return;
      }
      const start = offsetOf(dom.startContainer, dom.startOffset);
      const end = offsetOf(dom.endContainer, dom.endOffset);
      if (start == null || end == null || end <= start) return;
      // Trim surrounding whitespace so a double-clicked word does not carry its space.
      const text = value.slice(start, end);
      const lead = text.length - text.trimStart().length;
      const trail = text.length - text.trimEnd().length;
      if (end - trail <= start + lead) return;
      setFrozen(false);
      setPhase("idle");
      setRange({ start: start + lead, end: end - trail });
    };
    const onChange = () => {
      if (!frame) frame = requestAnimationFrame(read);
    };
    document.addEventListener("selectionchange", onChange);
    return () => {
      document.removeEventListener("selectionchange", onChange);
      if (frame) cancelAnimationFrame(frame);
    };
  }, []);

  // Click outside closes an idle toolbar; Escape anywhere closes it.
  useEffect(() => {
    if (!open) return;
    const onPointer = (event: PointerEvent) => {
      if (locked) return;
      if (rootRef.current?.contains(event.target as Node)) return;
      close();
    };
    const onKey = (event: globalThis.KeyboardEvent) => {
      if (event.key !== "Escape" || event.defaultPrevented) return;
      if (phase === "working") {
        controller.current?.abort();
        setPhase("idle");
        return;
      }
      if (phase === "review") return discard();
      document.getSelection()?.removeAllRanges();
      close();
    };
    document.addEventListener("pointerdown", onPointer);
    document.addEventListener("keydown", onKey);
    return () => {
      document.removeEventListener("pointerdown", onPointer);
      document.removeEventListener("keydown", onKey);
    };
  });

  // Fade the "kept" tint away.
  useEffect(() => {
    if (!kept) return;
    const timer = setTimeout(() => setKept(null), 1200);
    return () => clearTimeout(timer);
  }, [kept]);

  // Size of the bar's content, so the bar can ease between widths instead of jumping.
  useLayoutEffect(() => {
    const el = barInnerRef.current;
    if (!el) return;
    const measure = () => setSize({ width: el.offsetWidth, height: el.offsetHeight });
    measure();
    const observer = new ResizeObserver(measure);
    observer.observe(el);
    return () => observer.disconnect();
  }, [open]);

  // Place the bar centred under the selection, or above it when there is no room below.
  const place = useCallback(() => {
    const root = rootRef.current;
    const text = textRef.current;
    if (!root || !text || !open) return;
    let rects: DOMRect[] = [];
    const marks = text.querySelectorAll<HTMLElement>("[data-range]");
    if (marks.length) {
      marks.forEach((mark) => rects.push(...Array.from(mark.getClientRects())));
    } else {
      const selection = document.getSelection();
      if (selection && selection.rangeCount) rects = Array.from(selection.getRangeAt(0).getClientRects());
    }
    rects = rects.filter((rect) => rect.width > 0 && rect.height > 0);
    if (!rects.length) return;
    const box = root.getBoundingClientRect();
    const first = rects[0]!;
    const last = rects[rects.length - 1]!;
    const left = Math.min(...rects.map((rect) => rect.left));
    const right = Math.max(...rects.map((rect) => rect.right));
    const width = size?.width ?? 0;
    const height = size?.height ?? 36;
    const center = (left + right) / 2 - box.left;
    const x = Math.max(0, Math.min(box.width - width, center - width / 2));
    const below = last.bottom - box.top + 8;
    const roomBelow = window.innerHeight - (last.bottom + 8 + height) > 8;
    const above = !roomBelow && first.top - height - 8 > 8;
    const y = above ? first.top - box.top - 8 - height : below;
    setPosition((current) => (current && current.x === x && current.y === y && current.above === above ? current : { x, y, above }));
  }, [open, size]);

  useLayoutEffect(() => {
    if (!open) {
      setPosition(null);
      shown.current = false;
      return;
    }
    place();
  });

  useEffect(() => {
    if (!open) return;
    window.addEventListener("resize", place);
    window.addEventListener("scroll", place, true);
    return () => {
      window.removeEventListener("resize", place);
      window.removeEventListener("scroll", place, true);
    };
  }, [open, place]);

  // Draw the range as a highlight and drop the native selection, which re-rendering would break.
  function freeze() {
    if (frozen || !range) return;
    state.current.frozen = true;
    setFrozen(true);
    document.getSelection()?.removeAllRanges();
  }

  // Moves focus to the new state's main button, but only for someone already working in the toolbar.
  function focusPrimary() {
    if (!keyboard.current) return;
    requestAnimationFrame(() => barRef.current?.querySelector<HTMLElement>("[data-primary]")?.focus({ preventScroll: true }));
  }

  async function run(action: SelectionAction | null, typed?: string) {
    if (!range) return;
    keyboard.current = Boolean(barRef.current?.contains(document.activeElement));
    freeze();
    document.getSelection()?.removeAllRanges();
    controller.current?.abort();
    const abort = new AbortController();
    controller.current = abort;
    lastRequest.current = { action, prompt: typed };
    const label = action?.pending ?? "Working";
    setPendingLabel(label);
    setPhase("working");
    setAnnouncement(`${label}…`);
    focusPrimary();
    try {
      const output = await onRun({
        action,
        prompt: typed,
        text: value.slice(range.start, range.end),
        value,
        start: range.start,
        end: range.end,
        signal: abort.signal,
      });
      if (abort.signal.aborted) return;
      setResult(output);
      const note = action?.kind === "note";
      setPhase(note ? "note" : "review");
      setAnnouncement(note ? output : "Rewrite ready. Keep or discard it.");
      focusPrimary();
    } catch {
      if (abort.signal.aborted) return;
      setPhase("error");
      setAnnouncement("That did not work. Try again.");
      focusPrimary();
    }
  }

  function keep() {
    if (!range) return;
    const next = value.slice(0, range.start) + result + value.slice(range.end);
    if (valueProp === undefined) setInner(next);
    onValueChange?.(next);
    setKept({ start: range.start, end: range.start + result.length });
    setAnnouncement("Change kept.");
    close();
  }

  function discard() {
    keyboard.current = Boolean(barRef.current?.contains(document.activeElement));
    setResult("");
    setPhase("idle");
    setAnnouncement("Change discarded.");
    focusPrimary();
  }

  function retry() {
    const request = lastRequest.current;
    if (request) void run(request.action, request.prompt);
  }

  function onBarKeyDown(event: KeyboardEvent<HTMLDivElement>) {
    if (event.key !== "ArrowRight" && event.key !== "ArrowLeft") return;
    if ((event.target as HTMLElement).tagName === "INPUT") return;
    const buttons = Array.from(barRef.current?.querySelectorAll<HTMLElement>("button:not(:disabled)") ?? []);
    const index = buttons.indexOf(event.target as HTMLElement);
    if (index === -1) return;
    event.preventDefault();
    buttons[(index + (event.key === "ArrowRight" ? 1 : -1) + buttons.length) % buttons.length]?.focus();
  }

  // What the text shows: the proposal stands in for the range while it is under review.
  const reviewing = phase === "review" && range !== null;
  const display = reviewing ? value.slice(0, range.start) + result + value.slice(range.end) : value;
  const highlight: SelectionRange | null = reviewing
    ? { start: range.start, end: range.start + result.length }
    : frozen && range
      ? range
      : kept;
  const highlightKind = reviewing ? "proposal" : frozen && range ? "selection" : "kept";

  // Words of the proposal get a running index so they resolve one after another across paragraphs.
  let wordIndex = 0;

  const enterTransition = reduce
    ? { duration: 0 }
    : shown.current
      ? { type: "spring" as const, duration: 0.42, bounce: 0 }
      : { duration: 0 };
  if (position) shown.current = true;

  return (
    <div ref={rootRef} className={cx("@container relative", className)} {...props}>
      <div
        ref={textRef}
        id={`${id}-text`}
        onPointerDown={() => {
          // Starting a new selection: drop the drawn highlight first so the browser selects plain text.
          if (frozen && !locked) {
            state.current.frozen = false;
            setFrozen(false);
            setRange(null);
            setPhase("idle");
          }
        }}
        className="grid gap-3 text-sm leading-relaxed text-zinc-700 dark:text-zinc-300"
      >
        {paragraphs(display).map((paragraph) => {
          const pEnd = paragraph.start + paragraph.text.length;
          const parts: ReactNode[] = [];
          if (highlight && highlight.start < pEnd && highlight.end > paragraph.start) {
            const from = Math.max(highlight.start, paragraph.start) - paragraph.start;
            const to = Math.min(highlight.end, pEnd) - paragraph.start;
            const middle = paragraph.text.slice(from, to);
            parts.push(paragraph.text.slice(0, from));
            if (highlightKind === "proposal") {
              const tokens = middle.split(/(\s+)/);
              parts.push(
                <span key="range" data-range="" className="rounded-[3px] bg-zinc-950/[0.05] box-decoration-clone text-zinc-950 dark:bg-white/[0.08] dark:text-white">
                  {tokens.map((token, index) =>
                    /^\s+$/.test(token) || token === "" ? (
                      token
                    ) : (
                      <span
                        key={index}
                        style={reduce ? undefined : { transitionDelay: `${Math.min(wordIndex++ * 32, 640)}ms` }}
                        className={cx(
                          "inline-block whitespace-pre",
                          "transition-[opacity,filter,translate] duration-500",
                          ease,
                          "starting:translate-y-[3px] starting:opacity-0 starting:blur-[6px] motion-reduce:transition-none",
                        )}
                      >
                        {token}
                      </span>
                    ),
                  )}
                </span>,
              );
            } else {
              parts.push(
                <mark
                  key={`range-${highlightKind}`}
                  data-range={highlightKind === "selection" ? "" : undefined}
                  className={cx(
                    "rounded-[3px] box-decoration-clone text-inherit",
                    highlightKind === "selection"
                      ? "bg-sky-500/20 dark:bg-sky-400/25"
                      : `bg-transparent transition-[background-color] duration-1000 ${ease} starting:bg-zinc-950/[0.08] motion-reduce:transition-none dark:starting:bg-white/[0.12]`,
                  )}
                >
                  {middle}
                </mark>,
              );
            }
            parts.push(paragraph.text.slice(to));
          } else {
            parts.push(paragraph.text);
          }
          return (
            <p key={paragraph.start} data-start={paragraph.start} className={cx("whitespace-pre-wrap", paragraphClassName)}>
              {parts}
            </p>
          );
        })}
      </div>

      {open ? (
        <motion.div
          ref={barRef}
          role="toolbar"
          aria-label="Edit selection"
          aria-controls={`${id}-text`}
          onKeyDown={onBarKeyDown}
          onMouseDown={(event) => {
            // Buttons act without taking focus from the text; the field still takes it.
            if ((event.target as HTMLElement).tagName !== "INPUT") event.preventDefault();
            freeze();
          }}
          onFocus={freeze}
          initial={false}
          animate={{
            x: position?.x ?? 0,
            y: position?.y ?? 0,
            width: size?.width ?? "auto",
            height: size?.height ?? "auto",
          }}
          transition={{
            x: enterTransition,
            y: enterTransition,
            width: reduce ? { duration: 0 } : { duration: 0.32, ease: quint },
            height: reduce ? { duration: 0 } : { duration: 0.32, ease: quint },
          }}
          style={{ visibility: position ? "visible" : "hidden" }}
          className="absolute top-0 left-0 z-10"
        >
          <div
            className={cx(
              "size-full overflow-hidden rounded-xl border border-zinc-950/10 bg-white text-zinc-950",
              "has-[input:focus]:border-sky-500/60 dark:has-[input:focus]:border-sky-400/60",
              "shadow-[0_12px_32px_-8px_rgb(0_0_0/0.18),0_1px_2px_rgb(0_0_0/0.05)]",
              "dark:border-white/15 dark:bg-black dark:text-white dark:shadow-[0_16px_48px_-12px_rgb(0_0_0/1),inset_0_1px_0_rgb(255_255_255/0.08)]",
              position?.above ? "origin-bottom" : "origin-top",
              `transition-[opacity,scale,translate] duration-200 ${ease} motion-reduce:transition-none`,
              "starting:scale-[0.96] starting:opacity-0",
              position?.above ? "starting:translate-y-1" : "starting:-translate-y-1",
            )}
          >
            <div ref={barInnerRef} className="w-max max-w-[min(22rem,calc(100vw-2rem))]">
              <div
                key={phase}
                className={cx(
                  "flex items-center gap-0.5 p-1",
                  `transition-[opacity,filter] duration-200 ${ease} starting:opacity-0 starting:blur-[2px] motion-reduce:transition-none`,
                  phase === "note" && "flex-col items-stretch gap-0 p-0",
                )}
              >
                {phase === "idle" ? (
                  <>
                    {actions.map((action, index) => (
                      <button key={action.id} type="button" data-primary={index === 0 ? "" : undefined} onClick={() => void run(action)} className={barButton}>
                        {action.icon ? <span aria-hidden="true" className={iconSlot}>{action.icon}</span> : null}
                        {action.label}
                      </button>
                    ))}
                    {allowPrompt ? (
                      <>
                        <span aria-hidden="true" className="mx-0.5 h-4 w-px bg-zinc-950/10 dark:bg-white/15" />
                        <button
                          type="button"
                          onClick={() => {
                            setPhase("prompt");
                            requestAnimationFrame(() => barRef.current?.querySelector("input")?.focus());
                          }}
                          className={barButton}
                        >
                          <span aria-hidden="true" className={iconSlot}>
                            <AskIcon />
                          </span>
                          Ask
                        </button>
                      </>
                    ) : null}
                  </>
                ) : phase === "prompt" ? (
                  <form
                    className="flex items-center gap-1"
                    onSubmit={(event) => {
                      event.preventDefault();
                      if (prompt.trim()) void run(null, prompt.trim());
                    }}
                  >
                    <label htmlFor={`${id}-prompt`} className="sr-only">
                      Describe the edit
                    </label>
                    <input
                      id={`${id}-prompt`}
                      value={prompt}
                      onChange={(event) => setPrompt(event.target.value)}
                      onKeyDown={(event) => {
                        if (event.key === "Escape") {
                          event.preventDefault();
                          setPhase("idle");
                          requestAnimationFrame(() => barRef.current?.querySelector<HTMLElement>("button")?.focus());
                        }
                      }}
                      placeholder="Make it more direct"
                      autoComplete="off"
                      className="h-7 w-56 max-w-[calc(100vw-7rem)] bg-transparent px-2 text-sm text-zinc-950 placeholder:text-zinc-500 focus:outline-none dark:text-white"
                    />
                    <button type="submit" aria-label="Run edit" disabled={!prompt.trim()} className={cx(barButton, "w-7 px-0")}>
                      <svg aria-hidden="true" viewBox="0 0 16 16" fill="none" className="size-4">
                        <path d="M8 12.5v-9m0 0L4.5 7M8 3.5 11.5 7" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" strokeLinejoin="round" />
                      </svg>
                    </button>
                  </form>
                ) : phase === "working" ? (
                  <>
                    <span className="flex h-7 items-center gap-2 pr-1 pl-2 text-sm text-zinc-600 dark:text-zinc-400">
                      <svg aria-hidden="true" viewBox="0 0 16 16" fill="none" className="size-3.5 text-zinc-950 motion-safe:animate-spin dark:text-white">
                        <circle cx="8" cy="8" r="6" stroke="currentColor" strokeOpacity="0.2" strokeWidth="1.75" />
                        <path d="M14 8a6 6 0 0 0-6-6" stroke="currentColor" strokeWidth="1.75" strokeLinecap="round" />
                      </svg>
                      {pendingLabel}…
                    </span>
                    <button
                      type="button"
                      data-primary=""
                      onClick={() => {
                        controller.current?.abort();
                        setPhase("idle");
                        setAnnouncement("Stopped.");
                      }}
                      className={barButton}
                    >
                      Stop
                    </button>
                  </>
                ) : phase === "review" ? (
                  <>
                    <button type="button" data-primary="" onClick={keep} className={keepButton}>
                      Keep
                    </button>
                    <button type="button" onClick={discard} className={barButton}>
                      Discard
                    </button>
                    <button type="button" aria-label="Try again" onClick={retry} className={cx(barButton, "w-7 px-0")}>
                      <RetryIcon />
                    </button>
                  </>
                ) : phase === "note" ? (
                  <>
                    <p className="max-h-48 overflow-y-auto px-3 pt-2.5 pb-2 text-sm leading-relaxed text-pretty text-zinc-700 dark:text-zinc-300">{result}</p>
                    <div className="flex justify-end gap-0.5 border-t border-zinc-950/[0.07] p-1 dark:border-white/[0.08]">
                      <button type="button" onClick={retry} className={barButton}>
                        Try again
                      </button>
                      <button
                        type="button"
                        data-primary=""
                        onClick={() => {
                          document.getSelection()?.removeAllRanges();
                          close();
                        }}
                        className={barButton}
                      >
                        Done
                      </button>
                    </div>
                  </>
                ) : (
                  <>
                    <span className="flex h-7 items-center gap-2 px-2 text-sm text-red-700 dark:text-red-400">That did not work.</span>
                    <button type="button" data-primary="" onClick={retry} className={barButton}>
                      Try again
                    </button>
                    <button type="button" onClick={close} className={barButton}>
                      Close
                    </button>
                  </>
                )}
              </div>
            </div>
          </div>
        </motion.div>
      ) : null}

      <span role="status" className="sr-only">
        {announcement}
      </span>
    </div>
  );
}

/** Text offset of a DOM point inside a paragraph rendered by SelectionActions. */
function offsetOf(node: Node, offset: number): number | null {
  const element = node.nodeType === Node.ELEMENT_NODE ? (node as Element) : node.parentElement;
  const paragraph = element?.closest<HTMLElement>("[data-start]");
  if (!paragraph) return null;
  const range = document.createRange();
  range.setStart(paragraph, 0);
  range.setEnd(node, offset);
  return Number(paragraph.dataset.start) + range.toString().length;
}

// In a narrow passage the toolbar keeps its words and drops the icons.
const iconSlot = "flex text-zinc-500 @max-[26rem]:hidden dark:text-zinc-400";

const barButton = cx(
  "inline-flex h-7 items-center justify-center gap-1.5 rounded-lg px-2 text-sm font-medium whitespace-nowrap select-none",
  "text-zinc-700 hover:bg-zinc-950/[0.05] hover:text-zinc-950 dark:text-zinc-300 dark:hover:bg-white/[0.08] dark:hover:text-white",
  "transition-[background-color,color,scale] duration-150 ease-out motion-safe:active:scale-[0.96] motion-reduce:transition-none",
  "focus-visible:outline-2 focus-visible:-outline-offset-2 focus-visible:outline-sky-500 focus-visible:outline-solid",
  "disabled:pointer-events-none disabled:opacity-40 [&_svg]:size-4 [&_svg]:shrink-0",
);

const keepButton = cx(
  "inline-flex h-7 items-center justify-center rounded-lg px-2.5 text-sm font-medium whitespace-nowrap select-none",
  "bg-zinc-950 text-white shadow-[inset_0_1px_0_rgb(255_255_255/0.12),0_1px_2px_rgb(0_0_0/0.2)] hover:bg-zinc-800",
  "dark:bg-white dark:text-black dark:shadow-[inset_0_-1px_0_rgb(0_0_0/0.12)] dark:hover:bg-zinc-200",
  "transition-[background-color,scale] duration-150 ease-out motion-safe:active:scale-[0.96] motion-reduce:transition-none",
  "focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-sky-500 focus-visible:outline-solid",
);

const stroke = { fill: "none", stroke: "currentColor", strokeWidth: 1.5, strokeLinecap: "round", strokeLinejoin: "round" } as const;

function RewriteIcon() {
  return (
    <svg viewBox="0 0 16 16" {...stroke}>
      <path d="M10.75 2.75 13.25 5.25 6 12.5 3 13l.5-3z" />
      <path d="M9 4.5 11.5 7" />
    </svg>
  );
}

function ShortenIcon() {
  return (
    <svg viewBox="0 0 16 16" {...stroke}>
      <path d="M2.75 8h3.5m0 0L4.5 6.25M6.25 8 4.5 9.75M13.25 8h-3.5m0 0 1.75-1.75M9.75 8l1.75 1.75" />
    </svg>
  );
}

function ExplainIcon() {
  return (
    <svg viewBox="0 0 16 16" {...stroke}>
      <circle cx="8" cy="8" r="6" />
      <path d="M6.4 6.3a1.7 1.7 0 0 1 3.2.6c0 1.1-1.6 1.4-1.6 2.4" />
      <path d="M8 11.25h.01" strokeWidth={2} />
    </svg>
  );
}

function AskIcon() {
  return (
    <svg viewBox="0 0 16 16" {...stroke}>
      <path d="M8 2.5 9.2 6.8 13.5 8 9.2 9.2 8 13.5 6.8 9.2 2.5 8 6.8 6.8Z" />
    </svg>
  );
}

function RetryIcon() {
  return (
    <svg viewBox="0 0 16 16" {...stroke}>
      <path d="M12.75 8a4.75 4.75 0 1 1-1.4-3.36M12.75 3v2.5h-2.5" />
    </svg>
  );
}