# Setup guide

> The steps that activate an account, kept in the app’s header: a Welcome button with a ring of the whole setup, and a guide of steps whose rings fill as tasks are done.

An app’s header on a green band: a search field, a green Welcome button carrying a ring of the whole setup, notifications, a language picker and the account. Welcome opens Missing steps under it: a row per step with a ring of its tasks and a count (Done, 1/4, 4/8). A row opens its tasks in place; tick them in any order or Mark next done, and the rings ease to their new share while the counts roll. Skip all asks first and leaves a Resume setup button; finishing every step plays a burst of confetti and turns Welcome into All set, which can be dismissed. The search and the notifications open the guide on a step. Light and dark.

A React component by Bruno Delorence: https://brunodelorence.com/components/setup-guide. MIT License, Copyright (c) 2026 Bruno Delorence.

Category: Feedback.

## Anatomy

1. **Search field**: A rounded field that finds a step or a task as you type; picking a result opens the guide on it.
2. **Welcome button**: The guide’s trigger: its word, a ring of every task done so far, and a chevron that turns while the guide is open.
3. **Guide**: A popover under the button, right edges lined up: the heading, Skip all, a line on what the steps are for, the steps and Support.
4. **Step row**: A ring of its tasks, the step’s name, its count and a chevron; it opens the tasks in place.
5. **Count**: Tasks done over tasks, or Done; it rolls up or down when the number changes.
6. **Task**: A checkbox and the task’s name. Tasks can be ticked in any order and unticked again.
7. **Mark next done**: Ticks the first task left in the step, and names it.
8. **Support**: A link to help, with an info icon, at the foot of the guide.
9. **Account button**: The drawn avatar and a chevron on a grey pill; its menu can hide, show or restart the guide.

## Properties

### Starting progress (`defaultDone`)

1. **Nothing done**: Every ring empty and every count at zero: a brand-new account.
2. **What’s already done (default)**: The tasks finished before the guide shows, ticked: a step can open at Done.

Pass the tasks the person has already finished, from your own records, every time the guide mounts. Work done at sign-up, such as a confirmed email, should never be asked for twice.

### Tasks per step (`steps`)

1. **Two to four**: A row or two of tasks in the two columns: a step done in a sitting.
2. **Five to eight**: Up to four rows, for a step such as a form, where each answer is a task.

Group the tasks that lead to one outcome into one step. A step weighs as much as its tasks in the header’s ring, so a long step moves it most.

### Button label (`label`)

1. **Welcome (default)**: A greeting for a new account’s first days.
2. **Get started**: A call to begin, when nothing is done yet.
3. **Finish setup**: For people coming back to a setup they left half done.

One or two words that fit beside the ring. It turns into All set on its own once every step is done.

## When to use

- Activating a new account that needs a few things done before it is useful: a profile, a first download, a form, a connection.
- Steps people finish over several visits, so the guide has to stay within reach without blocking the page: a button in the header, with its progress on it.
- Steps made of small tasks that can be done in any order, where a count per step and a ring for the whole setup tell people how far they are.
- Products where some people will never want the guide: Skip all puts it away, and it can come back.

## When not to use

- A tour of the interface. Use coach marks or a product tour that points at the parts of the screen; this lists work to do, not places to look.
- One required step before anything works. Ask for it in the flow itself, or with a blocking dialog; a header button is easy to leave for later.
- Long projects with dates, owners and dependencies. Use a task list or a project board; the guide is for a handful of steps one person finishes.
- Steps the product can check on its own and never needs the person to tick. Show their status, but don’t ask people to mark them done.

### Counting progress

- **A step’s count** is its tasks done over its tasks, `1/4`, and turns into Done with the last one.
- **The header’s ring** is every task done over every task, so a step of eight tasks weighs more than one of three.
- **Tasks can be ticked in any order and unticked again**: the guide counts them either way. Mark next done ticks the first one left.
- **Save on every change**: `onTaskToggle` hands over every task done, and `onStepComplete` and `onComplete` mark the milestones.

### Skipping, finishing and coming back

- **Skip all asks first**, and says how to bring the guide back. Confirmed, it leaves a quiet Resume setup button that keeps the ring.
- **The account menu** can hide the guide, show it again or start it over, so skipping is never final.
- **Finishing every step** plays a burst of confetti and turns the button into All set, with × to dismiss it for good.

### Setup guide vs. activation checklist

**Setup guide**
- Waits in the header, out of the way, on every page.
- Small tasks the person ticks, in any order, over several visits.
- Complete your account, Download a file.

**Activation checklist**
- A card on the home page, the main thing to see until it is done.
- Steps the product runs from Start, in an order, some waiting on others.
- Set up your company, Invite your team.

## Do’s and don’ts

- **Do**: Break each step into small tasks of a minute or two, so the count moves on every visit.
- **Don’t**: Make every step a single task. Each row opens onto one checkbox, and Mark next done repeats its name.
- **Do**: Order the steps the way most people do them, the quickest first, so the first visit ends with a step done.
- **Don’t**: Pile on steps. Past five or six the list scrolls inside the guide, and the last ones are out of sight.
- **Do**: Title each step as an outcome, with a verb: Invite your team, Connect your storage.
- **Don’t**: Title steps with a feature’s name. Team or Storage doesn’t say what to do.

## Content

The guide is read in a glance from the header: the button names the setup, the steps say what is left to do.

- **Step titles are outcomes**, a verb and its object: `Complete your account`, `Download at least one file`.
- **Task names are a few words**, short enough for a column of about 150 px: `Add your name`, `Pick a format`.
- **The intro says why** in one sentence (`intro`): what finishing the steps gets people.
- **The button’s word** (`label`) is a greeting or a call to start; All set replaces it at the end.
- **Sentence case**, with no full stops in titles, tasks or the button.

## Installation

Install it with the shadcn CLI, into components/setup-guide of any React project:

```sh
npx shadcn@latest add https://brunodelorence.com/r/setup-guide.json
```

Or add the registry to components.json once, as a namespace that coding agents and the shadcn MCP server search by name:

```json
{
  "registries": {
    "@brunodelorence": "https://brunodelorence.com/r/{name}.json"
  }
}
```

```sh
npx shadcn@latest add @brunodelorence/setup-guide
```

Or copy all the source files below into one folder of your project. Either way it needs React 19 and a bundler with CSS Modules (Next.js, Vite).

It has a dark colour scheme. Its colours are CSS light-dark() pairs, kept inside @supports so that builds which rewrite light-dark() for older browsers leave them alone: it follows your page’s color-scheme (light unless the page sets one) or its colorScheme prop, with nothing to configure. Browsers without light-dark() show it light.

## Usage

```tsx
import { SetupGuide } from './setup-guide';

export function AppHeader({ done }: { done: string[] }) {
  return (
    <SetupGuide
      defaultDone={done}
      onTaskToggle={(id, isDone, all) => saveProgress(all)}
      onComplete={() => console.log('Account active')}
      onSkip={() => console.log('Guide skipped')}
      autoplay={false}
    />
  );
}
```

## States

- **Closed**: The header at rest: Welcome carries the ring of the whole setup, eight of fifteen tasks.
- **Missing steps**: The guide open: one step done, two in progress with their counts.
- **Step open**: A step’s tasks in place, with Mark next done naming the task it will tick.
- **Longer step**: Eight tasks in two columns; the list scrolls inside the guide when the window is short.
- **Skip all**: Skip all asks first and says how to bring the guide back.
- **Skipped**: The guide put away: a quiet Resume setup button keeps its ring and the progress.
- **All set**: Every step done: confetti, You’re all set, and All set in the header with a button to dismiss it.
- **Dismissed**: The finished guide dismissed: the header without it. The account menu can show it again.
- **Search**: Typing finds steps and tasks; each result names its step, and Enter opens the guide on it.
- **Notifications**: Unread notices with a green dot; one about a step opens the guide there.
- **Language**: The languages as radio items, the current one checked.
- **Phone**: Under 600 px the search takes its own row and the guide the window’s width.

## Examples

### New workspace

Four steps of setting up a team workspace under Get started, one task done, with Connect your storage open.

```tsx
import { SetupGuide, type Step } from './setup-guide';

const WORKSPACE: Step[] = [
  {
    id: 'invite',
    title: 'Invite your team',
    tasks: [
      { id: 'invite-editor', label: 'Add an editor' },
      { id: 'invite-viewer', label: 'Add a viewer' },
    ],
  },
  {
    id: 'storage',
    title: 'Connect your storage',
    tasks: [
      { id: 'storage-pick', label: 'Choose a provider' },
      { id: 'storage-folder', label: 'Pick a folder' },
      { id: 'storage-sync', label: 'Run the first sync' },
    ],
  },
  {
    id: 'brand',
    title: 'Set up your brand kit',
    tasks: [
      { id: 'brand-logo', label: 'Upload a logo' },
      { id: 'brand-colours', label: 'Add brand colours' },
      { id: 'brand-fonts', label: 'Add fonts' },
      { id: 'brand-share', label: 'Share the kit' },
    ],
  },
  {
    id: 'billing',
    title: 'Add a billing contact',
    tasks: [{ id: 'billing-contact', label: 'Name who gets invoices' }],
  },
];

export function NewWorkspace() {
  return (
    <SetupGuide
      autoplay={false}
      steps={WORKSPACE}
      defaultDone={['invite-editor']}
      label="Get started"
      title="Set up your workspace"
      intro="Four steps to get your team sharing files. They save as you go, so you can stop at any point."
      notices={[]}
      person={{ name: 'Tomás Reyes', email: 'tomas@harbourline.co', initials: 'TR' }}
      defaultState={{ open: true, expanded: 'storage' }}
    />
  );
}
```

### One task left

Fourteen of fifteen tasks done: the download form open on its last task, a tick away from the celebration.

```tsx
import { SetupGuide } from './setup-guide';

const EVERY_BUT_ONE = [
  'account-name',
  'account-team',
  'account-email',
  'download-browse',
  'download-preview',
  'download-format',
  'download-save',
  'form-company',
  'form-country',
  'form-use',
  'form-team',
  'form-channels',
  'form-reach',
  'form-signer',
];

export function OneTaskLeft() {
  return (
    <SetupGuide
      autoplay={false}
      defaultDone={EVERY_BUT_ONE}
      defaultState={{ open: true, expanded: 'form' }}
    />
  );
}
```

### Skipped for now

The guide put away behind Resume setup, its ring still showing the progress, with German picked.

```tsx
import { SetupGuide } from './setup-guide';

export function SkippedForNow() {
  return <SetupGuide autoplay={false} defaultLanguage="DE" defaultState={{ guide: 'skipped' }} />;
}
```

### All set

Every step done: All set with its dismiss button, and the account menu open on Hide setup guide and Start setup over.

```tsx
import { SetupGuide } from './setup-guide';

const EVERY_BUT_ONE = [
  'account-name',
  'account-team',
  'account-email',
  'download-browse',
  'download-preview',
  'download-format',
  'download-save',
  'form-company',
  'form-country',
  'form-use',
  'form-team',
  'form-channels',
  'form-reach',
  'form-signer',
];

export function AllSet() {
  return (
    <SetupGuide
      autoplay={false}
      defaultDone={[...EVERY_BUT_ONE, 'form-terms']}
      defaultState={{ menu: 'account' }}
    />
  );
}
```

## How it works

- Progress is a set of task ids. A step’s count is its tasks in the set, the header’s ring every task in the set over every task, so a step with eight small tasks weighs more than one with three.
- Each ring is two SVG circles: a track, and an arc whose dash offset is the share left. The offset is a custom property that CSS eases, so a ring glides to its new share; full, the arc fades and a disc with a check springs in, its stroke drawn by its dash offset.
- A count rolls: the number is keyed by its text, so a new value mounts and slides in from below when it grows, from above when it shrinks. The last task turns the count into Done.
- A row is a disclosure button. Its tasks sit in a grid row that eases from 0fr to 1fr, inert while closed; they are checkboxes in two columns, and Mark next done ticks the first left and names it.
- The guide is a non-modal dialog hung under Welcome with their right edges lined up, measured in the window’s own px (offsets, not screen rects) so it stays put when a gallery card scales the stage. On a phone it takes the window’s width, and its list scrolls inside it when the window is short.
- Skip all swaps the steps for a question first. Confirmed, the guide leaves the header for an outlined Resume setup button that keeps the ring; the account menu can also hide it, show it or start it over.
- The last task fires a burst of confetti from the button and the guide: eighteen pieces with their own flight, turn and delay, moved with the translate, rotate and scale properties. Welcome becomes All set with × beside it; dismissed, the slot closes.
- While on screen and untouched, a demo pointer opens the guide, opens Download at least one file, ticks a task and Mark next done, closes the step and the guide. Any real input hands it over; it comes back after 7 s of quiet.

## API reference

- **steps** (`Step[]`, default `three steps`): The steps in order, each an id, a title and its tasks (an id and a label).
- **defaultDone** (`string[]`, default `eight of fifteen tasks`): Task ids done at first.
- **title** (`string`, default `'Missing steps'`): The guide’s heading while steps are left.
- **intro** (`string`): The line under the heading.
- **label** (`string`, default `'Welcome'`): The header button’s word while steps are left; All set once they are done.
- **person** (`Person`): Who is signed in: a name, an email and two initials for the drawn avatar.
- **notices** (`Notice[]`, default `two notices`): The notifications; one with a step opens the guide there.
- **languages** (`{ code: string; name: string }[]`, default `five languages`): What the language picker offers; defaultLanguage picks the first.
- **searchPlaceholder** (`string`, default `'Search the library'`): The search field’s placeholder.
- **supportHref** (`string`, default `'#support'`): Where Support goes.
- **defaultState** (`SetupGuideState`): Opens locked in a moment, with the demo off: the guide open, a step open, Skip all asking, skipped or dismissed, a menu or search held open, or the burst of a finished setup.
- **onTaskToggle** (`(taskId: string, done: boolean, all: string[]) => void`): Called when a task is ticked or unticked, with every task done.
- **onStepComplete** (`(step: Step) => void`): Called when the last task of a step is ticked.
- **onComplete** (`() => void`): Called when every step is done.
- **onSkip** (`() => void`): Called when Skip all is confirmed.
- **onDismiss** (`() => void`): Called when the finished guide is dismissed from the header.
- **onLanguageChange** (`(code: string) => void`): Called with the language picked.
- **autoplay** (`boolean`, default `true`): While on screen and untouched, a demo pointer works through a step. Any real input stops it.
- **colorScheme** (`'light' | 'dark' | 'system'`): Light or dark colours, or the reader’s; without it, the page’s color-scheme.
- **className** (`string`): Classes for the stage.

## Accessibility

### Keyboard

- Welcome opens the guide and moves focus to the first step with tasks left; Escape closes it and hands focus back to Welcome.
- Up and Down arrows move between the step rows; Enter or Space opens a step’s tasks, and Space or Enter ticks a task.
- While Skip all is asking, Escape goes back to the steps, with focus on Skip all.
- Closed steps’ tasks are `inert`, so Tab never lands on a task that can’t be seen.

### Screen readers

- Welcome is named with its progress, `Welcome: setup 53% done`, and opens a dialog (`aria-haspopup="dialog"`, `aria-expanded`).
- The guide is a non-modal dialog named by its heading. Each row is a disclosure button with `aria-expanded`; each task a checkbox with `aria-checked`.
- Every tick is read out in a polite status region, `Pick a format done. Download at least one file: 3 of 4.`, as are skipping and finishing (WCAG 4.1.3, Status messages).

### Search

The search field is a combobox over a listbox of steps and tasks: arrows move through the results, Enter opens the guide on that step and focuses the row or the task, Escape closes the results.

### Targets and motion

Tasks are at least 32 px tall and step rows at least 58 px; the smallest header button, the × beside All set, is 32 × 38 px on a phone. All are above the 24 × 24 px minimum (WCAG 2.5.8, AA). With reduced motion the rings, counts and drawers change at once and the confetti doesn’t play.

### Colour and contrast

Every text measures at least 4.5 to 1 on what it sits on, in light and dark: the white Welcome on its green, the grey counts and ticked task names, the hints and placeholders (WCAG 1.4.3). Checkbox edges, rings’ arcs against their tracks and the white checks measure at least 3 to 1 (WCAG 1.4.11). A step’s state is also in its count and a ticked task’s in its check, so colour isn’t the only cue (WCAG 1.4.1).

### In this build

- Welcome is a button with aria-haspopup="dialog" and aria-expanded, named with the share done (“Welcome: setup 53% done”); the guide is a non-modal dialog labelled by its heading. Opening it moves the focus to the first step left; Escape or a press outside closes it, with the focus back on the button.
- Each step is a disclosure button with aria-expanded and aria-controls; ↑ and ↓ move between steps. Its tasks are role="checkbox" buttons, and a closed step’s tasks are inert.
- The rings, the confetti and the avatar are hidden from assistive technology; a polite live region says each task ticked with the step’s count, a step done, the setup complete, a skip and a language change.
- Skip all opens an inline question with Keep going focused; confirming moves the focus to Resume setup. The search is a combobox with a listbox of steps and tasks, moved with the arrows and chosen with Enter. Notifications, language and account are menu buttons whose menus move with the arrows, Home and End, and close with Escape.
- Under reduced motion nothing eases, rolls, springs or flies and the demo never plays. The demo pointer is decorative.

## Source

### setup-guide/setup-guide.tsx

```tsx
// Copyright (c) 2026 Bruno Delorence. MIT License.

'use client';

import {
  useCallback,
  useEffect,
  useEffectEvent,
  useId,
  useLayoutEffect,
  useMemo,
  useRef,
  useState,
  type CSSProperties,
  type KeyboardEvent as ReactKeyboardEvent,
} from 'react';
import {
  DONE,
  LANGUAGES,
  NOTICES,
  PERSON,
  STEPS,
  countDone,
  type Notice,
  type Person,
  type Step,
} from './data';
import { DemoPointer, runDemo, type Point } from './demo-pointer';
import { Avatar, Icon, Ring } from './glyphs';
import { Menu, MenuHeader, MenuItem, MenuSeparator, usePlacement } from './menu';
import { useAutoplay } from './use-autoplay';
import styles from './setup-guide.module.css';

/*
 * Setup guide: the steps that activate an account, kept in the app's header.
 *
 * - The header holds a search field, a green Welcome button with a ring of the whole setup, the
 *   notifications, the language and the account. The page behind is a quiet skeleton.
 * - Welcome opens the guide under it: Missing steps, a line on what they are for, a row per step
 *   with a ring of its tasks and its count, and Support at the foot.
 * - A row opens its tasks in place: tick them in any order, or Mark next done. Rings ease to their
 *   new share, counts roll, and a finished step's ring turns into a check.
 * - Skip all asks first, then hides the guide behind a quiet Resume setup button (and the account
 *   menu). Finishing every step plays a burst of confetti and turns Welcome into All set, which
 *   can be dismissed.
 * - The search finds a step or a task and opens the guide on it; a notification does the same.
 * - While on screen and untouched, a demo pointer opens the guide, works through a step and
 *   closes it, in a loop.
 */

export type { Notice, Person, Step, Task } from './data';

export type GuideStatus = 'active' | 'skipped' | 'dismissed';
export type MenuId = 'notifications' | 'language' | 'account';

/** A moment to open in, locked: the demo stays off. Used by the docs. */
export type SetupGuideState = {
  /** The guide's popover open. */
  open?: boolean;
  /** The step whose tasks show. */
  expanded?: string;
  /** Task ids done, in place of defaultDone. */
  done?: string[];
  /** Skip all asking to confirm. */
  confirming?: boolean;
  guide?: GuideStatus;
  /** A header menu held open. */
  menu?: MenuId;
  /** Text in the search field, with its results open. */
  query?: string;
  /** The burst of a finished setup, frozen mid-flight. */
  celebrating?: boolean;
};

/** The confetti: where each piece flies, in px, how far it turns, and its colour token. */
const CONFETTI = Array.from({ length: 18 }, (_, i) => {
  const angle = (i / 18) * Math.PI * 2 + (i % 3) * 0.21;
  const reach = 56 + ((i * 37) % 5) * 14;
  return {
    x: Math.round(Math.cos(angle) * reach),
    y: Math.round(Math.sin(angle) * reach * 0.8 - 12),
    r: ((i * 83) % 360) - 180,
    tone: (['a', 'b', 'c', 'd'] as const)[i % 4],
    round: i % 3 === 0,
    delay: (i % 4) * 30,
  };
});

export function SetupGuide({
  steps = STEPS,
  defaultDone = DONE,
  title = 'Missing steps',
  intro = 'This short guide walks you through what’s left to activate your account and start downloading.',
  label = 'Welcome',
  person = PERSON,
  notices = NOTICES,
  languages = LANGUAGES,
  defaultLanguage = 'EN',
  searchPlaceholder = 'Search the library',
  supportHref = '#support',
  defaultState,
  onTaskToggle,
  onStepComplete,
  onComplete,
  onSkip,
  onDismiss,
  onLanguageChange,
  autoplay = true,
  colorScheme,
  className = '',
}: {
  /** The steps, in order, each with its tasks. */
  steps?: Step[];
  /** Task ids done at first. */
  defaultDone?: string[];
  /** The guide's heading. */
  title?: string;
  /** The line under it. */
  intro?: string;
  /** The header button’s word while steps are left. */
  label?: string;
  /** Who is signed in: the avatar’s initials and the account menu. */
  person?: Person;
  /** The notifications; one with a step opens the guide there. */
  notices?: Notice[];
  /** The languages the picker offers: a code shown in the header and a name. */
  languages?: { code: string; name: string }[];
  defaultLanguage?: string;
  searchPlaceholder?: string;
  /** Where Support goes. */
  supportHref?: string;
  /** Opens locked in a moment, with the demo off. */
  defaultState?: SetupGuideState;
  /** Called when a task is ticked or unticked, with every task done. */
  onTaskToggle?: (taskId: string, done: boolean, all: string[]) => void;
  /** Called when the last task of a step is ticked. */
  onStepComplete?: (step: Step) => void;
  /** Called when every step is done. */
  onComplete?: () => void;
  /** Called when Skip all is confirmed. */
  onSkip?: () => void;
  /** Called when the finished guide is dismissed from the header. */
  onDismiss?: () => void;
  onLanguageChange?: (code: string) => void;
  autoplay?: boolean;
  colorScheme?: 'light' | 'dark' | 'system';
  className?: string;
}) {
  const uid = useId();
  const { ref: root, playing, take } = useAutoplay<HTMLDivElement>(7000);
  const pointer = useRef<HTMLSpanElement>(null);
  const welcome = useRef<HTMLButtonElement>(null);
  const resume = useRef<HTMLButtonElement>(null);
  const popover = useRef<HTMLDivElement>(null);
  const bell = useRef<HTMLButtonElement>(null);
  const lang = useRef<HTMLButtonElement>(null);
  const account = useRef<HTMLButtonElement>(null);
  /** Where the focus goes after the next render. */
  const focusNext = useRef<string | null>(null);
  /** True while the demo presses something: its presses never move the focus. */
  const demoing = useRef(false);

  const locked = defaultState !== undefined;
  const s = defaultState ?? {};
  const start = useMemo(
    () => defaultDone,
    // Only the first value counts.
    // eslint-disable-next-line react-hooks/exhaustive-deps
    [],
  );

  const [done, setDone] = useState<Set<string>>(() => new Set(s.done ?? start));
  const [open, setOpen] = useState(s.open ?? false);
  const [expanded, setExpanded] = useState<string | null>(s.expanded ?? null);
  const [confirming, setConfirming] = useState(s.confirming ?? false);
  const [guide, setGuide] = useState<GuideStatus>(s.guide ?? 'active');
  const [menu, setMenu] = useState<{ id: MenuId; byReader: boolean } | null>(
    s.menu ? { id: s.menu, byReader: false } : null,
  );
  const [language, setLanguage] = useState(defaultLanguage);
  const [unread, setUnread] = useState<Set<string>>(() => new Set(notices.map((n) => n.id)));
  const [query, setQuery] = useState(s.query ?? '');
  const [results, setResultsOpen] = useState(!!s.query);
  const [active, setActive] = useState(0);
  const [burst, setBurst] = useState(s.celebrating ? 1 : 0);
  const [live, setLive] = useState('');

  // ---- Progress ---------------------------------------------------------------------------------

  const counts = steps.map((step) => countDone(step, done));
  const total = steps.reduce((sum, step) => sum + step.tasks.length, 0);
  const totalDone = counts.reduce((sum, n) => sum + n, 0);
  const progress = total ? totalDone / total : 0;
  const stepsLeft = steps.filter((step, i) => counts[i] < step.tasks.length).length;
  const allDone = stepsLeft === 0;

  const say = (text: string) => setLive(text);
  const byReader = () => !demoing.current;

  const toggleTask = (taskId: string) => {
    const step = steps.find((x) => x.tasks.some((t) => t.id === taskId));
    if (!step) return;
    const next = new Set(done);
    const ticking = !next.has(taskId);
    if (ticking) next.add(taskId);
    else next.delete(taskId);
    setDone(next);
    onTaskToggle?.(taskId, ticking, [...next]);
    const task = step.tasks.find((t) => t.id === taskId)!;
    const stepDone = countDone(step, next) === step.tasks.length;
    const everyDone = steps.every((x) => countDone(x, next) === x.tasks.length);
    if (ticking && everyDone) {
      setBurst((n) => n + 1);
      onStepComplete?.(step);
      onComplete?.();
      say('Setup complete. Every step is done.');
    } else if (ticking && stepDone) {
      onStepComplete?.(step);
      say(`${step.title}: done.`);
    } else {
      say(
        `${task.label} ${ticking ? 'done' : 'not done'}. ${step.title}: ${countDone(step, next)} of ${step.tasks.length}.`,
      );
    }
  };

  const markNext = (step: Step) => {
    const next = step.tasks.find((t) => !done.has(t.id));
    if (next) toggleTask(next.id);
  };

  // ---- Opening and closing ----------------------------------------------------------------------

  const openGuide = (stepId: string | null = null) => {
    setMenu(null);
    setResultsOpen(false);
    setConfirming(false);
    setGuide('active');
    setOpen(true);
    if (stepId) setExpanded(stepId);
    if (byReader()) {
      focusNext.current = stepId
        ? `row-${stepId}`
        : `row-${steps.find((x, i) => counts[i] < x.tasks.length)?.id ?? steps[0]?.id}`;
    }
  };

  const closeGuide = (back: boolean) => {
    setOpen(false);
    setConfirming(false);
    if (back) focusNext.current = 'welcome';
  };

  const toggleGuide = () => (open ? closeGuide(byReader()) : openGuide());

  const skipAll = () => {
    setConfirming(false);
    setOpen(false);
    setExpanded(null);
    setGuide('skipped');
    onSkip?.();
    say('Setup guide hidden. Resume setup brings it back.');
    if (byReader()) focusNext.current = 'resume';
  };

  const dismiss = () => {
    setOpen(false);
    setGuide('dismissed');
    onDismiss?.();
    say('Setup guide dismissed. The account menu can show it again.');
    if (byReader()) focusNext.current = 'account';
  };

  const startOver = () => {
    setDone(new Set());
    setExpanded(null);
    setGuide('active');
    setMenu(null);
    say('Setup started over: every step is open again.');
    if (byReader()) focusNext.current = 'welcome';
  };

  // The focus, once what it goes to is drawn.
  useLayoutEffect(() => {
    const target = focusNext.current;
    if (!target) return;
    focusNext.current = null;
    const stage = root.current;
    const element =
      target === 'welcome'
        ? welcome.current
        : target === 'resume'
          ? resume.current
          : target === 'account'
            ? account.current
            : stage?.querySelector<HTMLElement>(`[data-focus="${target}"]`);
    element?.focus({ preventScroll: true });
  });

  // A press outside the guide closes it.
  useEffect(() => {
    if (!open) return;
    const away = (event: PointerEvent) => {
      const target = event.target as Node;
      if (popover.current?.contains(target) || welcome.current?.contains(target)) return;
      setOpen(false);
      setConfirming(false);
    };
    document.addEventListener('pointerdown', away);
    return () => document.removeEventListener('pointerdown', away);
  }, [open]);

  const popoverStyle = usePlacement(welcome, popover, open && guide === 'active', 16);

  const onPopoverKey = (event: ReactKeyboardEvent<HTMLDivElement>) => {
    if (event.key === 'Escape') {
      event.preventDefault();
      if (confirming) {
        setConfirming(false);
        focusNext.current = 'skip';
      } else closeGuide(true);
      return;
    }
    if (event.key !== 'ArrowDown' && event.key !== 'ArrowUp') return;
    const rows = [...(popover.current?.querySelectorAll<HTMLElement>('[data-row]') ?? [])];
    const index = rows.indexOf(document.activeElement as HTMLElement);
    if (index < 0) return;
    event.preventDefault();
    rows[(index + (event.key === 'ArrowDown' ? 1 : -1) + rows.length) % rows.length]?.focus();
  };

  // ---- The header's menus -----------------------------------------------------------------------

  const toggleMenu = (id: MenuId) =>
    setMenu((now) => (now?.id === id ? null : { id, byReader: byReader() }));
  const closeMenu = useCallback((back: boolean) => {
    setMenu((now) => {
      if (back && now) focusNext.current = now.id === 'notifications' ? 'bell' : now.id;
      return null;
    });
  }, []);

  const readNotice = (notice: Notice) => {
    setUnread((now) => {
      const next = new Set(now);
      next.delete(notice.id);
      return next;
    });
    if (notice.step) openGuide(notice.step);
    else setMenu(null);
  };

  const pickLanguage = (code: string) => {
    setLanguage(code);
    onLanguageChange?.(code);
    setMenu(null);
    if (byReader()) focusNext.current = 'language';
    say(`Language: ${languages.find((l) => l.code === code)?.name ?? code}.`);
  };

  // ---- Search -----------------------------------------------------------------------------------

  const found = useMemo(() => {
    const q = query.trim().toLowerCase();
    if (!q) return [];
    const out: { id: string; step: Step; label: string; task: boolean }[] = [];
    for (const step of steps) {
      if (step.title.toLowerCase().includes(q))
        out.push({ id: step.id, step, label: step.title, task: false });
      for (const task of step.tasks)
        if (task.label.toLowerCase().includes(q))
          out.push({ id: task.id, step, label: task.label, task: true });
    }
    return out.slice(0, 6);
  }, [query, steps]);

  const choose = (index: number) => {
    const hit = found[index];
    if (!hit) return;
    setQuery('');
    openGuide(hit.step.id);
    if (byReader()) focusNext.current = hit.task ? `task-${hit.id}` : `row-${hit.step.id}`;
    say(`Opened ${hit.step.title}.`);
  };

  const onSearchKey = (event: ReactKeyboardEvent<HTMLInputElement>) => {
    if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {
      if (!found.length) return;
      event.preventDefault();
      setResultsOpen(true);
      const step = event.key === 'ArrowDown' ? 1 : -1;
      setActive((i) => (i + step + found.length) % found.length);
    } else if (event.key === 'Enter') {
      if (results && found.length) {
        event.preventDefault();
        choose(active);
      }
    } else if (event.key === 'Escape') {
      if (results && query) {
        event.preventDefault();
        setResultsOpen(false);
      } else setQuery('');
    }
  };

  // ---- The demo ---------------------------------------------------------------------------------

  const demo = autoplay && !locked && playing;
  const demoStep = steps[1] ?? steps[0];
  const dirty = useEffectEvent(
    () =>
      open ||
      guide !== 'active' ||
      menu !== null ||
      expanded !== null ||
      done.size !== start.length ||
      start.some((id) => !done.has(id)),
  );
  const reset = useEffectEvent(() => {
    setDone(new Set(start));
    setOpen(false);
    setExpanded(null);
    setConfirming(false);
    setGuide('active');
    setMenu(null);
    setQuery('');
  });

  useEffect(() => {
    const stage = root.current;
    const arrow = pointer.current;
    if (!demo || !stage || !arrow || !demoStep) return;
    const find = (name: string) => stage.querySelector<HTMLElement>(`[data-demo="${name}"]`);
    const on = (element: Element | null, fx = 0.5, fy = 0.5): Point => {
      const frame = stage.getBoundingClientRect();
      const scale = frame.width / stage.offsetWidth || 1;
      const rect = element?.getBoundingClientRect() ?? frame;
      return {
        x: (rect.left + rect.width * fx - frame.left) / scale,
        y: (rect.top + rect.height * fy - frame.top) / scale,
      };
    };
    let over: HTMLElement | null = null;
    const stop = runDemo(stage, arrow, async ({ wait, glide, glyph }) => {
      const press = async (name: string, ms: number, after: number, fx = 0.5, fy = 0.5) => {
        const element = find(name);
        if (!element) return;
        glyph('arrow');
        await glide(on(element, fx, fy), ms);
        glyph('hand');
        over = element;
        element.dataset.over = '';
        await wait(220);
        delete element.dataset.over;
        over = null;
        demoing.current = true;
        (find(name) ?? element).click();
        demoing.current = false;
        await wait(after);
      };
      for (;;) {
        if (dirty()) {
          reset();
          await wait(500);
        }
        await wait(900);
        await press('welcome', 820, 1000, 0.35);
        await press(`row-${demoStep.id}`, 700, 900, 0.4);
        const next = demoStep.tasks.find(
          (t) => !stage.querySelector(`[data-demo="task-${t.id}"][aria-checked="true"]`),
        );
        if (next) await press(`task-${next.id}`, 620, 1100, 0.2);
        await press('mark-next', 560, 1500, 0.4);
        await press(`row-${demoStep.id}`, 620, 800, 0.4);
        await press('welcome', 700, 900, 0.35);
        glyph('arrow');
        await glide(on(stage, 0.8, 0.88), 800);
        await wait(2200);
      }
    });
    return () => {
      stop();
      demoing.current = false;
      if (over) delete over.dataset.over;
    };
  }, [demo, root, demoStep]);

  // ---- Drawing ----------------------------------------------------------------------------------

  const percent = Math.round(progress * 100);
  const unreadCount = notices.filter((n) => unread.has(n.id)).length;
  const langName = languages.find((l) => l.code === language)?.name ?? language;

  return (
    <div
      ref={root}
      className={`${styles.root} ${className}`}
      data-part="stage"
      data-color-scheme={colorScheme}
      onPointerDownCapture={take}
      onKeyDownCapture={take}
      onWheel={take}
      onPointerMove={(event) => {
        if (event.pointerType !== 'touch') take();
      }}
    >
      <div className={styles.window} data-part="window">
        <header className={styles.header} data-part="header">
          <div className={styles.search} data-part="search">
            <Icon name="search" className={styles.searchIcon} />
            <input
              type="search"
              role="combobox"
              aria-label="Search steps and tasks"
              aria-expanded={results && !!query.trim()}
              aria-controls={`${uid}-results`}
              aria-autocomplete="list"
              aria-activedescendant={
                results && found[active] ? `${uid}-hit-${found[active].id}` : undefined
              }
              placeholder={searchPlaceholder}
              value={query}
              onChange={(event) => {
                setQuery(event.target.value);
                setResultsOpen(true);
                setActive(0);
              }}
              onFocus={() => query && setResultsOpen(true)}
              onBlur={() => setResultsOpen(false)}
              onKeyDown={onSearchKey}
            />
            {results && query.trim() && (
              <div className={styles.results} data-part="results">
                <ul id={`${uid}-results`} role="listbox" aria-label="Setup steps and tasks">
                  {found.map((hit, i) => (
                    <li
                      key={hit.id}
                      id={`${uid}-hit-${hit.id}`}
                      role="option"
                      aria-selected={i === active}
                      className={styles.result}
                      onPointerDown={(event) => event.preventDefault()}
                      onPointerEnter={() => setActive(i)}
                      onClick={() => choose(i)}
                    >
                      <span className={styles.resultLabel}>{hit.label}</span>
                      <span className={styles.resultStep}>
                        {hit.task ? hit.step.title : 'Step'}
                      </span>
                    </li>
                  ))}
                </ul>
                {!found.length && (
                  <p className={styles.noResults}>No step or task matches “{query.trim()}”.</p>
                )}
              </div>
            )}
          </div>

          <div className={styles.tools}>
            <div className={styles.guideSlot} data-status={guide} data-done={allDone || undefined}>
              {guide === 'active' && (
                <div className={styles.welcomeWrap} data-part="welcome">
                  <button
                    ref={welcome}
                    type="button"
                    className={styles.welcome}
                    aria-haspopup="dialog"
                    aria-expanded={open}
                    aria-controls={open ? `${uid}-guide` : undefined}
                    aria-label={
                      allDone ? 'All set: setup guide' : `${label}: setup ${percent}% done`
                    }
                    data-demo="welcome"
                    data-open={open || undefined}
                    data-focus="welcome"
                    onClick={toggleGuide}
                  >
                    <span className={styles.welcomeText}>{allDone ? 'All set' : label}</span>
                    <Ring value={progress} className={styles.welcomeRing} stroke={2.8} />
                    <Icon name="chevronDown" width={2.2} className={styles.welcomeChevron} />
                  </button>
                  {allDone && (
                    <button
                      type="button"
                      className={styles.dismiss}
                      aria-label="Dismiss the setup guide"
                      onClick={dismiss}
                      data-part="dismiss"
                    >
                      <Icon name="close" width={2.2} />
                    </button>
                  )}
                  {burst > 0 && (
                    <span
                      key={burst}
                      className={styles.burst}
                      data-frozen={locked || undefined}
                      aria-hidden="true"
                    >
                      {CONFETTI.map((c, i) => (
                        <i
                          key={i}
                          data-tone={c.tone}
                          data-round={c.round || undefined}
                          style={
                            {
                              '--x': `${c.x}px`,
                              '--y': `${c.y}px`,
                              '--r': `${c.r}deg`,
                              '--delay': `${c.delay}ms`,
                            } as CSSProperties
                          }
                        />
                      ))}
                    </span>
                  )}
                </div>
              )}
              {guide === 'skipped' && (
                <button
                  ref={resume}
                  type="button"
                  className={styles.resume}
                  data-part="resume"
                  onClick={() => openGuide()}
                >
                  <Ring value={progress} className={styles.resumeRing} />
                  Resume setup
                </button>
              )}
            </div>

            <button
              ref={bell}
              type="button"
              className={styles.iconButton}
              aria-label={unreadCount ? `Notifications, ${unreadCount} unread` : 'Notifications'}
              aria-haspopup="menu"
              aria-expanded={menu?.id === 'notifications'}
              data-focus="bell"
              data-part="bell"
              onClick={() => toggleMenu('notifications')}
            >
              <Icon name="bell" width={1.6} />
              {unreadCount > 0 && <span className={styles.badge} aria-hidden="true" />}
            </button>

            <button
              ref={lang}
              type="button"
              className={styles.lang}
              aria-label={`Language: ${langName}`}
              aria-haspopup="menu"
              aria-expanded={menu?.id === 'language'}
              data-focus="language"
              data-part="language"
              onClick={() => toggleMenu('language')}
            >
              <span
                key={language}
                className={styles.langCode}
                data-roll={language !== defaultLanguage || undefined}
              >
                {language}
              </span>
              <Icon name="chevronDown" width={1.8} className={styles.chevron} />
            </button>

            <button
              ref={account}
              type="button"
              className={styles.account}
              aria-label={`Account: ${person.name}`}
              aria-haspopup="menu"
              aria-expanded={menu?.id === 'account'}
              data-part="account"
              onClick={() => toggleMenu('account')}
            >
              <span className={styles.avatar}>
                <Avatar initials={person.initials} />
              </span>
              <Icon name="chevronDown" width={1.8} className={styles.chevron} />
            </button>
          </div>
        </header>

        <div className={styles.body} aria-hidden="true">
          {Array.from({ length: 6 }, (_, i) => (
            <span key={i} className={styles.card} />
          ))}
        </div>

        {open && guide === 'active' && (
          <div
            ref={popover}
            id={`${uid}-guide`}
            role="dialog"
            aria-labelledby={`${uid}-title`}
            className={styles.popover}
            data-part="popover"
            style={popoverStyle}
            onKeyDown={onPopoverKey}
          >
            <div className={styles.popHead}>
              <h2 id={`${uid}-title`} className={styles.title}>
                {allDone ? 'You’re all set' : title}
              </h2>
              {allDone ? (
                <button type="button" className={styles.skip} onClick={dismiss} data-part="skip">
                  Hide guide
                </button>
              ) : (
                <button
                  type="button"
                  className={styles.skip}
                  aria-expanded={confirming}
                  data-part="skip"
                  data-focus="skip"
                  onClick={() => {
                    setConfirming(true);
                    if (byReader()) focusNext.current = 'keep';
                  }}
                >
                  Skip all
                </button>
              )}
            </div>

            {confirming ? (
              <div
                className={styles.confirm}
                role="group"
                aria-labelledby={`${uid}-confirm`}
                data-part="confirm"
              >
                <p id={`${uid}-confirm`} className={styles.confirmTitle}>
                  Skip the {stepsLeft === 1 ? 'last step' : `${stepsLeft} steps left`}?
                </p>
                <p className={styles.confirmText}>
                  The guide leaves the header. Resume setup, or your account menu, brings it back
                  with your progress kept.
                </p>
                <div className={styles.confirmActions}>
                  <button
                    type="button"
                    className={styles.ghost}
                    data-focus="keep"
                    onClick={() => {
                      setConfirming(false);
                      if (byReader()) focusNext.current = 'skip';
                    }}
                  >
                    Keep going
                  </button>
                  <button
                    type="button"
                    className={styles.primary}
                    onClick={skipAll}
                    data-part="confirm-skip"
                  >
                    Skip all
                  </button>
                </div>
              </div>
            ) : (
              <>
                <p className={styles.intro}>
                  {allDone
                    ? 'Every step is done and your account is active. Download anything from the library, any time.'
                    : intro}
                </p>
                <ul className={styles.steps} data-part="steps">
                  {steps.map((step, i) => {
                    const n = counts[i];
                    const of = step.tasks.length;
                    const isOpen = expanded === step.id;
                    const nextTask = step.tasks.find((t) => !done.has(t.id));
                    return (
                      <li key={step.id} className={styles.step} data-done={n === of || undefined}>
                        <button
                          type="button"
                          className={styles.row}
                          aria-expanded={isOpen}
                          aria-controls={`${uid}-tasks-${step.id}`}
                          data-row=""
                          data-part="row"
                          data-demo={`row-${step.id}`}
                          data-focus={`row-${step.id}`}
                          onClick={() => setExpanded(isOpen ? null : step.id)}
                        >
                          <Ring value={of ? n / of : 0} className={styles.ring} />
                          <span className={styles.rowTitle}>{step.title}</span>
                          <Count value={n} total={of} />
                          <Icon name="chevronRight" width={1.8} className={styles.rowChevron} />
                        </button>
                        <div
                          id={`${uid}-tasks-${step.id}`}
                          className={styles.drawer}
                          data-open={isOpen || undefined}
                          inert={!isOpen}
                        >
                          <div className={styles.drawerInner}>
                            <ul className={styles.tasks} aria-label={`${step.title}: tasks`}>
                              {step.tasks.map((task) => {
                                const on = done.has(task.id);
                                return (
                                  <li key={task.id}>
                                    <button
                                      type="button"
                                      role="checkbox"
                                      aria-checked={on}
                                      className={styles.task}
                                      data-part="task"
                                      data-demo={`task-${task.id}`}
                                      data-focus={`task-${task.id}`}
                                      onClick={() => toggleTask(task.id)}
                                    >
                                      <span className={styles.box} aria-hidden="true">
                                        <Icon name="check" width={2.6} />
                                      </span>
                                      {task.label}
                                    </button>
                                  </li>
                                );
                              })}
                            </ul>
                            {nextTask && (
                              <button
                                type="button"
                                className={styles.markNext}
                                data-demo={isOpen ? 'mark-next' : undefined}
                                data-part="mark-next"
                                onClick={() => markNext(step)}
                              >
                                Mark next done
                                <span className={styles.markNextTask}>{nextTask.label}</span>
                              </button>
                            )}
                          </div>
                        </div>
                      </li>
                    );
                  })}
                </ul>
              </>
            )}

            <a href={supportHref} className={styles.support} data-part="support">
              <Icon name="info" width={1.5} className={styles.supportIcon} />
              Support
              <span aria-hidden="true">›</span>
            </a>
            {burst > 0 && allDone && (
              <span
                key={burst}
                className={`${styles.burst} ${styles.burstWide}`}
                data-frozen={locked || undefined}
                aria-hidden="true"
              >
                {CONFETTI.map((c, i) => (
                  <i
                    key={i}
                    data-tone={c.tone}
                    data-round={c.round || undefined}
                    style={
                      {
                        '--x': `${c.x * 2.2}px`,
                        '--y': `${c.y * 1.6 + 40}px`,
                        '--r': `${c.r * 2}deg`,
                        '--delay': `${c.delay + 120}ms`,
                      } as CSSProperties
                    }
                  />
                ))}
              </span>
            )}
          </div>
        )}

        {menu?.id === 'notifications' && (
          <Menu
            anchor={bell}
            label="Notifications"
            takeFocus={menu.byReader}
            onClose={closeMenu}
            part="notifications"
          >
            <MenuHeader>Notifications</MenuHeader>
            {notices.map((notice) => (
              <MenuItem
                key={notice.id}
                lead={
                  <span className={styles.dot} data-unread={unread.has(notice.id) || undefined} />
                }
                hint={notice.text}
                onSelect={() => readNotice(notice)}
              >
                {notice.title}
              </MenuItem>
            ))}
            <MenuSeparator />
            <MenuItem
              onSelect={() => {
                setUnread(new Set());
                closeMenu(true);
                say('All notifications read.');
              }}
            >
              Mark all as read
            </MenuItem>
          </Menu>
        )}
        {menu?.id === 'language' && (
          <Menu
            anchor={lang}
            label="Language"
            takeFocus={menu.byReader}
            onClose={closeMenu}
            part="language-menu"
          >
            {languages.map((l) => (
              <MenuItem
                key={l.code}
                checked={l.code === language}
                lead={<span className={styles.code}>{l.code}</span>}
                onSelect={() => pickLanguage(l.code)}
              >
                {l.name}
              </MenuItem>
            ))}
          </Menu>
        )}
        {menu?.id === 'account' && (
          <Menu
            anchor={account}
            label="Account"
            takeFocus={menu.byReader}
            onClose={closeMenu}
            part="account-menu"
          >
            <MenuHeader>
              <span className={styles.who}>{person.name}</span>
              <span className={styles.whoMail}>{person.email}</span>
            </MenuHeader>
            {guide === 'active' ? (
              <MenuItem
                hint={
                  allDone
                    ? 'Every step is done'
                    : `${stepsLeft} ${stepsLeft === 1 ? 'step' : 'steps'} left`
                }
                onSelect={() => {
                  setMenu(null);
                  setOpen(false);
                  setGuide(allDone ? 'dismissed' : 'skipped');
                  say('Setup guide hidden.');
                  if (byReader()) focusNext.current = allDone ? 'account' : 'resume';
                }}
              >
                Hide setup guide
              </MenuItem>
            ) : (
              <MenuItem hint={`${percent}% done`} onSelect={() => openGuide()}>
                Show setup guide
              </MenuItem>
            )}
            <MenuItem hint="Untick every task" onSelect={startOver}>
              Start setup over
            </MenuItem>
          </Menu>
        )}
      </div>

      <p className={styles.srOnly} role="status">
        {live}
      </p>

      <div className={styles.pointerLayer}>
        <DemoPointer
          ref={pointer}
          className={styles.pointer}
          arrowClass={styles.arrow}
          handClass={styles.hand}
        />
      </div>
    </div>
  );
}

/** A step's count, rolling to its new value: up when it grows, down when it shrinks. */
function Count({ value, total }: { value: number; total: number }) {
  const [shown, setShown] = useState<{ value: number; dir: 'up' | 'down' | null }>({
    value,
    dir: null,
  });
  if (shown.value !== value) setShown({ value, dir: value > shown.value ? 'up' : 'down' });
  const text = value >= total ? 'Done' : `${value}/${total}`;
  return (
    <span className={styles.count} data-part="count">
      <span key={text} className={styles.countText} data-roll={shown.dir ?? undefined}>
        {text}
      </span>
    </span>
  );
}
```

### setup-guide/setup-guide.module.css

```css
/* Setup guide (setup-guide.tsx): an app window on a green band, its header carrying the guide.
   The window runs off the stage at the left and the bottom, as a crop of a larger screen; its
   body is a skeleton of empty cards. The guide, the menus and the search results hang under
   their triggers (placed in the window's px by menu.tsx).

   Under 600 px of stage the search drops to a row of its own under the header's buttons, the
   band thins and the guide takes the window's width.

   Colours are the tokens below, light-dark(light, dark) where the two differ: the component takes
   the color-scheme it inherits from the page, or the one its colorScheme prop sets
   (data-color-scheme). Text measures at least 4.5:1 on the surface it sits on, white on the green
   fills included, and the checkboxes' edges and the rings' arcs at least 3:1, in both schemes. */

.root {
  --band: #318b6c;
  --window: #ffffff;
  --page: #f2f2f2;
  --skeleton: #e6e6e6;
  --line: #e4e4e4;
  --field: #ffffff;
  --field-edge: #e2e2e2;
  --ink: #232323;
  --ink-2: #555555;
  --ink-3: #6d6d6d;
  --hover: #f5f5f5;
  --pill: #f0f0f0;
  --pill-hover: #e8e8e8;
  --popover: #ffffff;
  --popover-edge: #e6e6e6;
  --shadow: rgb(20 30 25 / 0.13);
  --accent: #238462;
  --accent-hover: #1e7b59;
  --accent-ink: #ffffff;
  --accent-soft: #e7f6ef;
  --accent-text: #1c7c59;
  --ring-track: #ececec;
  --ring-fill: #289871;
  --ring-check: #ffffff;
  --box-edge: #8c8c8c;
  --badge: #e5533d;
  --avatar-bg: #d9ecf7;
  --avatar-head: #f3d7c2;
  --avatar-body: #3c6e91;
  --avatar-ink: #33495a;
  --confetti-a: #2fb385;
  --confetti-b: #f2b134;
  --confetti-c: #5aa7e6;
  --confetti-d: #ef7a5a;
  /* The same on both schemes. */
  --focus: #3a8cf0;
  --pointer: #1c1c1e;
  --pointer-edge: #fff;
  --pointer-shadow: rgb(0 0 0 / 0.3);
  --sans:
    'Avenir Next', 'Nunito Sans', Avenir, var(--body, Inter), ui-sans-serif, system-ui, sans-serif;
}
@supports (color: light-dark(#fff, #000)) {
  .root {
    --band: light-dark(#318b6c, #1d5442);
    --window: light-dark(#ffffff, #181b1a);
    --page: light-dark(#f2f2f2, #101211);
    --skeleton: light-dark(#e6e6e6, #232726);
    --line: light-dark(#e4e4e4, #2a2f2d);
    --field: light-dark(#ffffff, #1e2221);
    --field-edge: light-dark(#e2e2e2, #303533);
    --ink: light-dark(#232323, #eef0ef);
    --ink-2: light-dark(#555555, #b5bbb8);
    --ink-3: light-dark(#6d6d6d, #919895);
    --hover: light-dark(#f5f5f5, #232826);
    --pill: light-dark(#f0f0f0, #252a28);
    --pill-hover: light-dark(#e8e8e8, #2e3431);
    --popover: light-dark(#ffffff, #1d2120);
    --popover-edge: light-dark(#e6e6e6, #2f3532);
    --shadow: light-dark(rgb(20 30 25 / 0.13), rgb(0 0 0 / 0.55));
    --accent: light-dark(#238462, #217d5d);
    --accent-hover: light-dark(#1e7b59, #258464);
    --accent-soft: light-dark(#e7f6ef, #173328);
    --accent-text: light-dark(#1c7c59, #4fd3a2);
    --ring-track: light-dark(#ececec, #333937);
    --ring-fill: light-dark(#289871, #2fa67b);
    --box-edge: light-dark(#8c8c8c, #687470);
    --badge: light-dark(#e5533d, #f0634d);
    --avatar-bg: light-dark(#d9ecf7, #24394a);
    --avatar-head: light-dark(#f3d7c2, #d8b9a2);
    --avatar-body: light-dark(#3c6e91, #5d8fb3);
    --avatar-ink: light-dark(#33495a, #22313d);
  }
}
.root[data-color-scheme='light'] {
  color-scheme: light;
}
.root[data-color-scheme='dark'] {
  color-scheme: dark;
}
.root[data-color-scheme='system'] {
  color-scheme: light dark;
}

.root {
  position: relative;
  container-type: inline-size;
  display: flex;
  width: 100%;
  /* Shares of the stage's own width: a container query cannot reach the container itself. */
  padding: clamp(16px, 6.4%, 60px) clamp(12px, 6.4%, 60px) 0 0;
  overflow: hidden;
  overflow: clip;
  border-radius: 18px;
  background: var(--band);
  color: var(--ink);
  font-family: var(--sans);
  font-size: 15px;
  line-height: 1.4;
  -webkit-tap-highlight-color: transparent;
}
.root :where(button, input, a) {
  font: inherit;
  color: inherit;
}
.root :where(button) {
  cursor: pointer;
  border: 0;
  background: none;
  padding: 0;
}
.root :focus-visible {
  outline: 2px solid var(--focus);
  outline-offset: 2px;
}
.root svg {
  flex: none;
  display: block;
}
.srOnly {
  position: absolute;
  width: 1px;
  height: 1px;
  overflow: hidden;
  clip-path: inset(50%);
  white-space: nowrap;
}

/* ---- The window -------------------------------------------------------------------------------- */

.window {
  position: relative;
  flex: 1;
  min-height: 620px;
  min-width: 0;
  display: flex;
  flex-direction: column;
  border-radius: 0 24px 0 0;
  background: var(--page);
}
.header {
  display: flex;
  align-items: center;
  gap: 28px;
  height: 85px;
  padding: 0 25px 0 32px;
  border-bottom: 1px solid var(--line);
  border-radius: 0 24px 0 0;
  background: var(--window);
}

.search {
  position: relative;
  flex: 1 1 auto;
  min-width: 0;
  max-width: 470px;
}
.searchIcon {
  position: absolute;
  top: 50%;
  left: 18px;
  width: 18px;
  height: 18px;
  translate: 0 -50%;
  color: var(--ink-3);
  pointer-events: none;
}
.search input {
  width: 100%;
  height: 44px;
  padding: 0 18px 0 46px;
  border: 1.5px solid var(--field-edge);
  border-radius: 999px;
  background: var(--field);
  font-size: 15px;
  appearance: none;
  transition: border-color 0.2s ease;
}
.search input::placeholder {
  color: var(--ink-3);
}
.search input::-webkit-search-cancel-button {
  appearance: none;
}
.search input:focus-visible {
  outline: none;
  border-color: var(--accent);
}
.results {
  position: absolute;
  z-index: 6;
  top: calc(100% + 8px);
  left: 0;
  right: 0;
  padding: 6px;
  border: 1px solid var(--popover-edge);
  border-radius: 12px;
  background: var(--popover);
  filter: drop-shadow(0 14px 22px var(--shadow));
  transform-origin: top center;
  animation: pop 0.28s cubic-bezier(0.34, 1.4, 0.64, 1);
}
.results ul {
  margin: 0;
  padding: 0;
  list-style: none;
}
.result {
  display: flex;
  justify-content: space-between;
  align-items: baseline;
  gap: 12px;
  padding: 9px 12px;
  border-radius: 8px;
  cursor: pointer;
}
.result[aria-selected='true'] {
  background: var(--hover);
}
.resultLabel {
  font-weight: 600;
}
.resultStep {
  overflow: hidden;
  color: var(--ink-3);
  font-size: 13px;
  white-space: nowrap;
  text-overflow: ellipsis;
}
.noResults {
  margin: 0;
  padding: 10px 12px;
  color: var(--ink-3);
  font-size: 14px;
}

.tools {
  display: flex;
  align-items: center;
  gap: 8px;
  margin-left: auto;
}

/* ---- The Welcome button ------------------------------------------------------------------------ */

.guideSlot {
  display: flex;
  margin-right: 24px;
}
.guideSlot[data-status='dismissed'] {
  margin-right: 0;
}
.welcomeWrap {
  position: relative;
  display: flex;
  animation: pop 0.4s cubic-bezier(0.34, 1.4, 0.64, 1);
}
.welcome {
  display: flex;
  align-items: center;
  gap: 16px;
  height: 41px;
  padding: 0 16px 0 16px;
  border-radius: 5px;
  background: var(--accent);
  color: var(--accent-ink);
  font-size: 17px;
  font-weight: 600;
  letter-spacing: 0.005em;
  white-space: nowrap;
  transition:
    background-color 0.2s ease,
    scale 0.25s cubic-bezier(0.34, 1.5, 0.64, 1);
}
.welcome:hover,
.welcome[data-over] {
  background: var(--accent-hover);
}
.welcome:active {
  scale: 0.97;
}
.welcomeText {
  min-width: 0;
}
.welcomeRing {
  width: 26px;
  height: 26px;
  --ring-track: rgb(255 255 255 / 0.22);
  --ring-fill: #fff;
  --ring-check: var(--accent);
}
.welcomeChevron {
  width: 16px;
  height: 16px;
  rotate: 180deg;
  transition: rotate 0.35s cubic-bezier(0.34, 1.5, 0.64, 1);
}
.welcome:not([data-open]) .welcomeChevron {
  rotate: 0deg;
}
.guideSlot[data-done] .welcome {
  border-radius: 5px 0 0 5px;
}
.dismiss {
  display: grid;
  place-items: center;
  width: 36px;
  height: 41px;
  border-left: 1px solid rgb(255 255 255 / 0.3);
  border-radius: 0 5px 5px 0;
  background: var(--accent);
  color: var(--accent-ink);
  animation: slideIn 0.35s cubic-bezier(0.34, 1.4, 0.64, 1);
}
.dismiss:hover {
  background: var(--accent-hover);
}
.dismiss svg {
  width: 16px;
  height: 16px;
}
@keyframes slideIn {
  from {
    opacity: 0;
    translate: -8px 0;
  }
}

.resume {
  display: flex;
  align-items: center;
  gap: 9px;
  height: 41px;
  padding: 0 14px 0 11px;
  border: 1.5px solid var(--field-edge);
  border-radius: 5px;
  color: var(--ink-2);
  font-size: 15px;
  font-weight: 600;
  white-space: nowrap;
  animation: pop 0.35s cubic-bezier(0.34, 1.4, 0.64, 1);
  transition: background-color 0.2s ease;
}
.resume:hover {
  background: var(--hover);
}
.resumeRing {
  width: 20px;
  height: 20px;
}

/* ---- The confetti ------------------------------------------------------------------------------ */

.burst {
  position: absolute;
  z-index: 7;
  top: 50%;
  left: 50%;
  width: 0;
  height: 0;
  pointer-events: none;
}
.burstWide {
  top: 30px;
  left: 50%;
}
.burst i {
  position: absolute;
  top: -4px;
  left: -3px;
  width: 6px;
  height: 9px;
  border-radius: 1.5px;
  background: var(--confetti-a);
  opacity: 0;
  animation: fly 1.3s cubic-bezier(0.2, 0.7, 0.3, 1) var(--delay) forwards;
}
.burst i[data-round] {
  width: 7px;
  height: 7px;
  border-radius: 50%;
}
.burst i[data-tone='b'] {
  background: var(--confetti-b);
}
.burst i[data-tone='c'] {
  background: var(--confetti-c);
}
.burst i[data-tone='d'] {
  background: var(--confetti-d);
}
.burst[data-frozen] i {
  animation-play-state: paused;
  animation-delay: -0.45s;
}
@keyframes fly {
  0% {
    opacity: 1;
    translate: 0 0;
    rotate: 0deg;
    scale: 0.4;
  }
  55% {
    opacity: 1;
    scale: 1;
  }
  100% {
    opacity: 0;
    translate: var(--x) calc(var(--y) + 26px);
    rotate: var(--r);
    scale: 0.8;
  }
}

/* ---- Header buttons ---------------------------------------------------------------------------- */

.iconButton {
  position: relative;
  display: grid;
  place-items: center;
  width: 44px;
  height: 44px;
  margin-right: 14px;
  border-radius: 50%;
  color: var(--ink);
  transition: background-color 0.2s ease;
}
.iconButton:hover,
.iconButton[aria-expanded='true'] {
  background: var(--hover);
}
.iconButton svg {
  width: 25px;
  height: 25px;
}
.badge {
  position: absolute;
  top: 9px;
  right: 10px;
  width: 8px;
  height: 8px;
  border: 1.5px solid var(--window);
  border-radius: 50%;
  background: var(--badge);
  box-sizing: content-box;
}
.lang {
  display: flex;
  align-items: center;
  gap: 8px;
  height: 40px;
  margin-right: 16px;
  padding: 0 8px;
  border-radius: 8px;
  font-size: 15.5px;
  font-weight: 500;
  transition: background-color 0.2s ease;
}
.lang:hover,
.lang[aria-expanded='true'] {
  background: var(--hover);
}
.langCode {
  display: inline-block;
  min-width: 22px;
}
.langCode[data-roll] {
  animation: rollUp 0.35s cubic-bezier(0.34, 1.4, 0.64, 1);
}
.chevron {
  width: 15px;
  height: 15px;
  color: var(--ink-2);
  transition: rotate 0.3s cubic-bezier(0.34, 1.5, 0.64, 1);
}
[aria-expanded='true'] > .chevron {
  rotate: 180deg;
}
.account {
  display: flex;
  align-items: center;
  gap: 9px;
  height: 45px;
  padding: 3px 14px 3px 3px;
  border-radius: 999px;
  background: var(--pill);
  transition: background-color 0.2s ease;
}
.account:hover,
.account[aria-expanded='true'] {
  background: var(--pill-hover);
}
.avatar {
  display: block;
  width: 39px;
  height: 39px;
  overflow: hidden;
  border-radius: 50%;
}
.avatar svg {
  width: 100%;
  height: 100%;
}
.avatar [data-avatar='bg'] {
  fill: var(--avatar-bg);
}
.avatar [data-avatar='head'] {
  fill: var(--avatar-head);
}
.avatar [data-avatar='body'] {
  fill: var(--avatar-body);
}
.avatar [data-avatar='text'] {
  fill: var(--avatar-ink);
  font-family: var(--sans);
  font-size: 8.5px;
  font-weight: 700;
  letter-spacing: 0.02em;
}

/* ---- The skeleton behind ----------------------------------------------------------------------- */

.body {
  flex: 1;
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
  grid-auto-rows: 285px;
  gap: 44px;
  margin-left: -150px;
  padding: 55px 55px 0 0;
  overflow: hidden;
}
.card {
  border: 1.5px solid var(--skeleton);
  border-radius: 20px;
}

/* ---- The guide --------------------------------------------------------------------------------- */

.popover {
  position: absolute;
  z-index: 5;
  top: 0;
  left: 0;
  display: flex;
  flex-direction: column;
  width: min(430px, calc(100% - 24px));
  max-height: var(--room, 560px);
  border: 1px solid var(--popover-edge);
  border-radius: 8px;
  background: var(--popover);
  filter: drop-shadow(0 18px 26px var(--shadow));
  transform-origin: 85% 0;
  animation: pop 0.34s cubic-bezier(0.34, 1.35, 0.64, 1);
}
@keyframes pop {
  from {
    opacity: 0;
    scale: 0.94;
    translate: var(--from, 0 -6px);
  }
}
.popHead {
  display: flex;
  align-items: baseline;
  justify-content: space-between;
  gap: 16px;
  padding: 30px 36px 0 35px;
}
.title {
  margin: 0;
  font-size: 22px;
  font-weight: 600;
  line-height: 1.3;
  letter-spacing: 0.002em;
}
.skip {
  flex: none;
  color: var(--ink-3);
  font-size: 16.5px;
  font-weight: 500;
  border-radius: 4px;
  transition: color 0.2s ease;
}
.skip:hover {
  color: var(--ink-2);
}
.intro {
  margin: 18px 0 0;
  padding: 0 35px 30px;
  color: var(--ink);
  font-size: 16.8px;
  line-height: 26px;
  border-bottom: 1px solid var(--line);
  margin-left: 0;
}
.steps {
  min-height: 0;
  margin: 0;
  padding: 0;
  overflow: auto;
  overscroll-behavior: contain;
  list-style: none;
  scrollbar-width: thin;
}
.intro,
.step,
.confirm {
  margin-left: 35px;
  padding-left: 0;
}
.step {
  border-bottom: 1px solid var(--line);
}
.row {
  display: flex;
  align-items: center;
  width: 100%;
  min-height: 66px;
  padding: 10px 32px 10px 0;
  text-align: left;
}
.row:focus-visible {
  outline-offset: -2px;
  border-radius: 6px;
}
.ring {
  width: 25px;
  height: 25px;
  margin-right: 13px;
}
.rowTitle {
  flex: 1;
  min-width: 0;
  font-size: 16.5px;
  font-weight: 600;
  line-height: 1.3;
}
.count {
  display: inline-flex;
  overflow: hidden;
  margin-left: 16px;
  color: var(--ink-3);
  font-size: 14.5px;
  font-variant-numeric: tabular-nums;
  line-height: 20px;
}
.countText {
  display: block;
}
.countText[data-roll='up'] {
  animation: rollUp 0.42s cubic-bezier(0.34, 1.45, 0.64, 1);
}
.countText[data-roll='down'] {
  animation: rollDown 0.42s cubic-bezier(0.34, 1.45, 0.64, 1);
}
@keyframes rollUp {
  from {
    translate: 0 100%;
    opacity: 0;
  }
}
@keyframes rollDown {
  from {
    translate: 0 -100%;
    opacity: 0;
  }
}
.rowChevron {
  width: 19px;
  height: 19px;
  margin-left: 18px;
  margin-right: -4px;
  color: var(--ink-3);
  transition:
    rotate 0.35s cubic-bezier(0.34, 1.5, 0.64, 1),
    translate 0.2s ease;
}
.row:hover .rowChevron,
.row[data-over] .rowChevron {
  translate: 2px 0;
}
.row[aria-expanded='true'] .rowChevron {
  rotate: 90deg;
  translate: 0 0;
}

/* The ring: an arc that eases to its share, then a check that pops in its place. */
.root [data-ring='track'] {
  stroke: var(--ring-track);
  transition: opacity 0.2s ease;
}
.root [data-ring='arc'] {
  stroke: var(--ring-fill);
  stroke-dashoffset: var(--gap);
  rotate: -90deg;
  transform-origin: 12px 12px;
  transition:
    stroke-dashoffset 0.8s cubic-bezier(0.22, 1, 0.36, 1),
    opacity 0.2s ease 0.25s;
}
.root [data-ring='done'] {
  scale: 0;
  opacity: 0;
  transform-origin: 12px 12px;
  transition:
    scale 0.25s ease,
    opacity 0.2s ease;
}
.root [data-ring='disc'] {
  fill: var(--ring-fill);
}
.root [data-ring='check'] {
  stroke: var(--ring-check);
  stroke-dasharray: 1;
  stroke-dashoffset: 1;
  transition: stroke-dashoffset 0.3s ease;
}
.root [data-full] [data-ring='track'],
.root [data-full] [data-ring='arc'] {
  opacity: 0;
}
.root [data-full] [data-ring='done'] {
  scale: 1;
  opacity: 1;
  transition:
    scale 0.5s cubic-bezier(0.34, 1.7, 0.6, 1) 0.45s,
    opacity 0.15s ease 0.45s;
}
.root [data-full] [data-ring='check'] {
  stroke-dashoffset: 0;
  transition: stroke-dashoffset 0.35s ease 0.7s;
}

/* A step's tasks, opening in place. */
.drawer {
  display: grid;
  grid-template-rows: 0fr;
  transition: grid-template-rows 0.38s cubic-bezier(0.3, 1, 0.4, 1);
}
.drawer[data-open] {
  grid-template-rows: 1fr;
}
.drawerInner {
  min-height: 0;
  overflow: hidden;
  padding-right: 32px;
}
.tasks {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));
  gap: 2px 12px;
  margin: -4px 0 0 30px;
  padding: 0;
  list-style: none;
}
.task {
  display: flex;
  align-items: center;
  gap: 9px;
  width: 100%;
  min-height: 32px;
  padding: 4px 6px;
  margin-left: -6px;
  border-radius: 6px;
  color: var(--ink-2);
  font-size: 14.5px;
  text-align: left;
  transition:
    background-color 0.15s ease,
    color 0.2s ease;
}
.task:hover,
.task[data-over] {
  background: var(--hover);
}
.task[aria-checked='true'] {
  color: var(--ink-3);
}
.box {
  display: grid;
  flex: none;
  place-items: center;
  width: 17px;
  height: 17px;
  border: 1.5px solid var(--box-edge);
  border-radius: 5px;
  color: var(--accent-ink);
  transition:
    background-color 0.2s ease,
    border-color 0.2s ease;
}
.box svg {
  width: 13px;
  height: 13px;
  scale: 0;
  transition: scale 0.3s cubic-bezier(0.34, 1.8, 0.6, 1);
}
.task[aria-checked='true'] .box {
  border-color: var(--ring-fill);
  background: var(--ring-fill);
}
.task[aria-checked='true'] .box svg {
  scale: 1;
}
.markNext {
  display: inline-flex;
  align-items: baseline;
  gap: 8px;
  max-width: 100%;
  margin: 8px 0 16px 24px;
  padding: 6px 12px;
  border-radius: 6px;
  background: var(--accent-soft);
  color: var(--accent-text);
  font-size: 14px;
  font-weight: 600;
  white-space: nowrap;
  transition: scale 0.2s cubic-bezier(0.34, 1.5, 0.64, 1);
}
.markNext:active,
.markNext[data-over] {
  scale: 0.97;
}
.markNextTask {
  overflow: hidden;
  color: var(--ink-3);
  font-weight: 500;
  white-space: nowrap;
  text-overflow: ellipsis;
}

/* Skip all, asking first. */
.confirm {
  margin-top: 18px;
  padding: 0 35px 26px 0;
  border-bottom: 1px solid var(--line);
  animation: pop 0.3s cubic-bezier(0.34, 1.3, 0.64, 1);
}
.confirmTitle {
  margin: 0;
  font-size: 16.5px;
  font-weight: 600;
}
.confirmText {
  margin: 6px 0 0;
  color: var(--ink-2);
  font-size: 15px;
  line-height: 23px;
}
.confirmActions {
  display: flex;
  justify-content: flex-end;
  gap: 10px;
  margin-top: 18px;
}
.ghost,
.primary {
  height: 38px;
  padding: 0 16px;
  border-radius: 6px;
  font-size: 15px;
  font-weight: 600;
}
.ghost {
  border: 1.5px solid var(--field-edge);
}
.ghost:hover {
  background: var(--hover);
}
.primary {
  background: var(--ink);
  color: var(--window);
}

.support {
  display: flex;
  align-items: center;
  gap: 13px;
  align-self: flex-start;
  margin: 20px 35px 25px;
  color: var(--ink-3);
  font-size: 16.5px;
  font-weight: 600;
  text-decoration: none;
  border-radius: 4px;
}
.support:hover {
  color: var(--ink-2);
}
.support > span {
  margin-left: -7px;
}
.supportIcon {
  width: 25px;
  height: 25px;
}

/* ---- Menus ------------------------------------------------------------------------------------- */

.menu {
  position: absolute;
  z-index: 6;
  top: 0;
  left: 0;
  min-width: 190px;
  max-width: min(320px, calc(100% - 24px));
  padding: 6px;
  border: 1px solid var(--popover-edge);
  border-radius: 12px;
  background: var(--popover);
  filter: drop-shadow(0 14px 22px var(--shadow));
  transform-origin: 90% 0;
  animation: pop 0.28s cubic-bezier(0.34, 1.4, 0.64, 1);
}
.menu:focus {
  outline: none;
}
.menuHeader {
  display: flex;
  flex-direction: column;
  padding: 8px 10px 6px;
  color: var(--ink-3);
  font-size: 12.5px;
  font-weight: 600;
  letter-spacing: 0.02em;
}
.who {
  color: var(--ink);
  font-size: 15px;
  letter-spacing: 0;
}
.whoMail {
  font-weight: 500;
  letter-spacing: 0;
}
.menuItem {
  display: flex;
  align-items: center;
  gap: 10px;
  width: 100%;
  padding: 8px 10px;
  border-radius: 8px;
  font-size: 14.5px;
  text-align: left;
}
.menuItem:hover,
.menuItem:focus-visible {
  outline: none;
  background: var(--hover);
}
.menuText {
  display: flex;
  flex: 1;
  flex-direction: column;
  min-width: 0;
  font-weight: 600;
}
.menuHint {
  color: var(--ink-3);
  font-size: 13px;
  font-weight: 500;
  line-height: 1.35;
}
.menuCheck {
  width: 16px;
  height: 16px;
  color: var(--accent-text);
  opacity: 0;
}
.menuCheck[data-on] {
  opacity: 1;
}
.menuSeparator {
  height: 1px;
  margin: 5px 4px;
  background: var(--line);
}
.dot {
  flex: none;
  align-self: flex-start;
  width: 8px;
  height: 8px;
  margin-top: 7px;
  border-radius: 50%;
  background: var(--line);
}
.dot[data-unread] {
  background: var(--accent);
}
.code {
  flex: none;
  width: 26px;
  color: var(--ink-3);
  font-size: 12.5px;
  font-weight: 700;
}

/* ---- Narrow stages ----------------------------------------------------------------------------- */

@container (max-width: 760px) {
  .header {
    gap: 16px;
    padding-left: 22px;
  }
  .guideSlot {
    margin-right: 6px;
  }
  .iconButton,
  .lang {
    margin-right: 2px;
  }
}

@container (max-width: 600px) {
  .window {
    min-height: 600px;
  }
  .header {
    flex-wrap: wrap;
    height: auto;
    row-gap: 12px;
    padding: 14px 12px 14px 14px;
    border-radius: 0 18px 0 0;
  }
  .window {
    border-radius: 0 18px 0 0;
  }
  .search {
    flex-basis: 100%;
    max-width: none;
  }
  .search input {
    height: 40px;
  }
  .tools {
    gap: 2px;
    width: 100%;
  }
  .guideSlot {
    margin-right: auto;
  }
  .welcome {
    gap: 10px;
    height: 38px;
    padding: 0 10px 0 12px;
    font-size: 16px;
  }
  .dismiss {
    height: 38px;
    width: 32px;
  }
  .welcomeRing {
    width: 22px;
    height: 22px;
  }
  .iconButton {
    width: 38px;
    height: 38px;
  }
  .iconButton svg {
    width: 22px;
    height: 22px;
  }
  .lang {
    gap: 4px;
    padding: 0 6px;
  }
  .account {
    gap: 4px;
    height: 40px;
    padding-right: 8px;
  }
  .avatar {
    width: 34px;
    height: 34px;
  }
  .body {
    grid-template-columns: repeat(2, 1fr);
    grid-auto-rows: 180px;
    gap: 16px;
    margin-left: -60px;
    padding: 20px 16px 0 0;
  }
  .popHead {
    padding: 22px 20px 0 20px;
  }
  .title {
    font-size: 20px;
  }
  .skip {
    font-size: 15px;
  }
  .intro {
    margin-top: 12px;
    padding: 0 20px 20px 0;
    font-size: 15.5px;
    line-height: 23px;
  }
  .intro,
  .step,
  .confirm {
    margin-left: 20px;
  }
  .row {
    min-height: 58px;
    padding-right: 18px;
  }
  .rowTitle {
    font-size: 15.5px;
  }
  .ring {
    width: 22px;
    height: 22px;
    margin-right: 11px;
  }
  .rowChevron {
    margin-left: 10px;
  }
  .drawerInner {
    padding-right: 16px;
  }
  .tasks {
    margin-left: 22px;
    grid-template-columns: 1fr;
  }
  .markNext {
    margin-left: 16px;
  }
  .support {
    margin: 16px 20px 20px;
  }
  .confirm {
    padding-right: 20px;
  }
}

@container (max-width: 400px) {
  .header {
    padding-right: 8px;
    padding-left: 12px;
  }
  .tools {
    gap: 0;
  }
  .welcome {
    gap: 8px;
    padding: 0 8px 0 11px;
  }
  .welcomeRing {
    width: 20px;
    height: 20px;
  }
  .welcomeChevron {
    width: 14px;
    height: 14px;
  }
  .lang {
    padding: 0 4px;
  }
  .welcome {
    font-size: 15px;
  }
  .iconButton {
    width: 34px;
  }
  .badge {
    right: 6px;
  }
  .lang .chevron,
  .account .chevron {
    display: none;
  }
  .account {
    padding: 3px;
  }
  .popHead {
    padding-right: 16px;
  }
  .title {
    font-size: 19px;
    white-space: nowrap;
  }
  .skip {
    font-size: 14.5px;
  }
}

/* ---- The demo's pointer ------------------------------------------------------------------------ */

.pointerLayer {
  position: absolute;
  inset: 0;
  z-index: 8;
  pointer-events: none;
}
.pointer {
  width: 20px;
  height: 20px;
}
.hand {
  visibility: hidden;
}
.pointer[data-glyph='hand'] .arrow {
  visibility: hidden;
}
.pointer[data-glyph='hand'] .hand {
  visibility: visible;
}

@media (prefers-reduced-motion: reduce) {
  .root *,
  .root [data-ring] {
    transition: none !important;
    animation: none !important;
  }
  .burst {
    display: none;
  }
}
```

### setup-guide/data.ts

```tsx
// Copyright (c) 2026 Bruno Delorence. MIT License.

/*
 * What the setup guide shows by default: the steps that activate an account in an assets
 * library, each made of small tasks, and who is signed in. A step is done when all its tasks are.
 */

export type Task = { id: string; label: string };

export type Step = {
  id: string;
  title: string;
  /** Done one after another, or in any order: the guide counts them either way. */
  tasks: Task[];
};

export type Person = {
  name: string;
  email: string;
  /** Two letters for the drawn avatar. */
  initials: string;
};

export type Notice = {
  id: string;
  title: string;
  text: string;
  /** The step it points to: choosing the notice opens the guide there. */
  step?: string;
};

export const STEPS: Step[] = [
  {
    id: 'account',
    title: 'Complete your account',
    tasks: [
      { id: 'account-name', label: 'Add your name' },
      { id: 'account-team', label: 'Name your workspace' },
      { id: 'account-email', label: 'Confirm your email' },
    ],
  },
  {
    id: 'download',
    title: 'Download at least one file',
    tasks: [
      { id: 'download-browse', label: 'Browse a collection' },
      { id: 'download-preview', label: 'Preview an asset' },
      { id: 'download-format', label: 'Pick a format' },
      { id: 'download-save', label: 'Save it to your device' },
    ],
  },
  {
    id: 'form',
    title: 'Fill out the download form',
    tasks: [
      { id: 'form-company', label: 'Company name' },
      { id: 'form-country', label: 'Billing country' },
      { id: 'form-use', label: 'Intended use' },
      { id: 'form-team', label: 'Team size' },
      { id: 'form-channels', label: 'Where it will run' },
      { id: 'form-reach', label: 'Expected audience' },
      { id: 'form-signer', label: 'Who signs' },
      { id: 'form-terms', label: 'Accept the licence' },
    ],
  },
];

/** Done at first: the account, one download task and half the form. */
export const DONE: string[] = [
  'account-name',
  'account-team',
  'account-email',
  'download-browse',
  'form-company',
  'form-country',
  'form-use',
  'form-team',
];

export const PERSON: Person = {
  name: 'Ines Halvorsen',
  email: 'ines@northfold.studio',
  initials: 'IH',
};

export const NOTICES: Notice[] = [
  {
    id: 'form-half',
    title: 'Your licence form is half done',
    text: 'Four answers left before your first download.',
    step: 'form',
  },
  {
    id: 'download-ready',
    title: 'Files are ready to download',
    text: 'Pick a format and save one to finish the step.',
    step: 'download',
  },
];

export const LANGUAGES = [
  { code: 'EN', name: 'English' },
  { code: 'PT', name: 'Português' },
  { code: 'ES', name: 'Español' },
  { code: 'DE', name: 'Deutsch' },
  { code: 'FR', name: 'Français' },
];

/** How many of a step's tasks are done. */
export const countDone = (step: Step, done: ReadonlySet<string>) =>
  step.tasks.filter((task) => done.has(task.id)).length;
```

### setup-guide/glyphs.tsx

```tsx
// Copyright (c) 2026 Bruno Delorence. MIT License.

/*
 * The guide's line icons and its progress ring, drawn on a 24-unit grid. The icons take the
 * text colour; the ring its tokens (--ring-track, --ring-fill, --ring-check).
 */

export type IconName =
  'search' | 'bell' | 'chevronDown' | 'chevronRight' | 'info' | 'close' | 'check';

const PATHS: Record<IconName, string> = {
  search: 'M10.5 17a6.5 6.5 0 1 0 0-13 6.5 6.5 0 0 0 0 13zM15.3 15.3 20 20',
  bell: 'M6 16.5V11a6 6 0 0 1 12 0v5.5l1.6 1.8H4.4zM10 20.3a2.2 2.2 0 0 0 4 0',
  chevronDown: 'm6.5 9.5 5.5 5.5 5.5-5.5',
  chevronRight: 'm9.5 6 6 6-6 6',
  info: 'M12 21a9 9 0 1 0 0-18 9 9 0 0 0 0 18zM12 11v6M12 7.6v.1',
  close: 'M7 7l10 10M17 7 7 17',
  check: 'm6.5 12.5 3.6 3.6 7.4-8',
};

export function Icon({
  name,
  width = 1.7,
  className,
}: {
  name: IconName;
  width?: number;
  className?: string;
}) {
  return (
    <svg
      viewBox="0 0 24 24"
      className={className}
      fill="none"
      stroke="currentColor"
      strokeWidth={width}
      strokeLinecap="round"
      strokeLinejoin="round"
      aria-hidden="true"
    >
      <path d={PATHS[name]} />
    </svg>
  );
}

/** r = 10 on the 24 grid. */
const ROUND = 2 * Math.PI * 10;

/**
 * A ring that fills clockwise from the top to `value` (0 to 1); full, it turns into a filled
 * disc with a check, which pops in. The arc's length is a custom property, so CSS eases it.
 */
export function Ring({
  value,
  className,
  stroke = 2.6,
}: {
  value: number;
  className?: string;
  stroke?: number;
}) {
  const full = value >= 1;
  return (
    <svg
      viewBox="0 0 24 24"
      className={className}
      data-full={full || undefined}
      style={{ ['--gap' as string]: `${ROUND * (1 - Math.max(0, Math.min(1, value)))}px` }}
      aria-hidden="true"
    >
      <circle cx="12" cy="12" r="10" fill="none" strokeWidth={stroke} data-ring="track" />
      <circle
        cx="12"
        cy="12"
        r="10"
        fill="none"
        strokeWidth={stroke}
        strokeLinecap="round"
        strokeDasharray={ROUND}
        data-ring="arc"
      />
      <g data-ring="done">
        <circle cx="12" cy="12" r="11.3" data-ring="disc" />
        <path
          d="m7.2 12.4 3.2 3.2 6.4-6.9"
          fill="none"
          strokeWidth="2.2"
          strokeLinecap="round"
          strokeLinejoin="round"
          pathLength={1}
          data-ring="check"
        />
      </g>
    </svg>
  );
}

/**
 * Initials on a drawn head and shoulders: the signed-in person, without a photo. Its box rounds
 * it (border-radius), so no clip path needs an id.
 */
export function Avatar({ initials }: { initials: string }) {
  return (
    <svg viewBox="0 0 40 40" aria-hidden="true" data-part="avatar-face">
      <g>
        <rect width="40" height="40" data-avatar="bg" />
        <path d="M4 44c1.5-8.5 8-12.5 16-12.5S34.5 35.5 36 44z" data-avatar="body" />
        <circle cx="20" cy="18" r="8.6" data-avatar="head" />
        <text x="20" y="21.4" textAnchor="middle" data-avatar="text">
          {initials}
        </text>
      </g>
    </svg>
  );
}
```

### setup-guide/menu.tsx

```tsx
// Copyright (c) 2026 Bruno Delorence. MIT License.

'use client';

import {
  useEffect,
  useLayoutEffect,
  useRef,
  useState,
  type CSSProperties,
  type KeyboardEvent as ReactKeyboardEvent,
  type ReactNode,
  type RefObject,
} from 'react';
import styles from './setup-guide.module.css';

/*
 * Placement and the header's menus. Everything that opens from the header (the guide, the
 * notifications, the languages, the account) hangs under its trigger with their right edges
 * lined up, kept inside the window, in the window's own px: a gallery card may scale the whole
 * stage, so offsets are read from offsetLeft/offsetTop, never from the screen.
 */

/** Where `box` goes under `anchor`, inside their common offsetParent; null until measured. */
export function usePlacement(
  anchor: RefObject<HTMLElement | null>,
  box: RefObject<HTMLElement | null>,
  open: boolean,
  gap = 10,
) {
  const [at, setAt] = useState<{ left: number; top: number; room: number } | null>(null);
  useLayoutEffect(() => {
    if (!open) return;
    const a = anchor.current;
    const b = box.current;
    const frame = b?.offsetParent as HTMLElement | null;
    if (!a || !b || !frame) return;
    const place = () => {
      // The anchor's box in the frame's px, through its offset parents.
      let left = 0;
      let top = 0;
      let node: HTMLElement | null = a;
      while (node && node !== frame) {
        left += node.offsetLeft;
        top += node.offsetTop;
        node = node.offsetParent as HTMLElement | null;
      }
      const right = left + a.offsetWidth;
      const y = top + a.offsetHeight + gap;
      const x = Math.max(
        12,
        Math.min(right - b.offsetWidth, frame.clientWidth - b.offsetWidth - 12),
      );
      setAt({ left: x, top: y, room: frame.clientHeight - y - 14 });
    };
    place();
    const observer = new ResizeObserver(place);
    observer.observe(frame);
    observer.observe(b);
    return () => {
      observer.disconnect();
      setAt(null);
    };
  }, [anchor, box, open, gap]);

  const style: CSSProperties = at
    ? { left: at.left, top: at.top, ['--room' as string]: `${at.room}px` }
    : { visibility: 'hidden' };
  return style;
}

const ITEMS = '[role="menuitem"], [role="menuitemradio"]';

export function Menu({
  anchor,
  label,
  takeFocus,
  onClose,
  part,
  children,
}: {
  anchor: RefObject<HTMLElement | null>;
  label: string;
  /** Moves the focus to the checked or first item: when the reader opened it, not the demo. */
  takeFocus: boolean;
  /** `back`: give the focus back to the trigger. */
  onClose: (back: boolean) => void;
  part: string;
  children: ReactNode;
}) {
  const box = useRef<HTMLDivElement>(null);
  const style = usePlacement(anchor, box, true, 8);
  const placed = style.visibility === undefined;

  useEffect(() => {
    if (!takeFocus || !placed) return;
    box.current
      ?.querySelector<HTMLElement>('[aria-checked="true"], [role^="menuitem"]')
      ?.focus({ preventScroll: true });
  }, [takeFocus, placed]);

  useEffect(() => {
    const away = (event: PointerEvent) => {
      const target = event.target as Node;
      if (box.current?.contains(target) || anchor.current?.contains(target)) return;
      onClose(false);
    };
    document.addEventListener('pointerdown', away);
    return () => document.removeEventListener('pointerdown', away);
  }, [anchor, onClose]);

  const onKeyDown = (event: ReactKeyboardEvent) => {
    const items = [...(box.current?.querySelectorAll<HTMLElement>(ITEMS) ?? [])];
    const index = items.indexOf(document.activeElement as HTMLElement);
    const move = (to: number) => {
      event.preventDefault();
      items[(to + items.length) % items.length]?.focus();
    };
    if (event.key === 'ArrowDown') move(index + 1);
    else if (event.key === 'ArrowUp') move(index - 1);
    else if (event.key === 'Home') move(0);
    else if (event.key === 'End') move(items.length - 1);
    else if (event.key === 'Escape') {
      event.preventDefault();
      event.stopPropagation();
      onClose(true);
    } else if (event.key === 'Tab') onClose(false);
  };

  return (
    <div
      ref={box}
      role="menu"
      tabIndex={-1}
      aria-label={label}
      className={styles.menu}
      data-part={part}
      style={style}
      onKeyDown={onKeyDown}
    >
      {children}
    </div>
  );
}

export function MenuItem({
  onSelect,
  checked,
  lead,
  hint,
  demo,
  children,
}: {
  onSelect: () => void;
  /** Set for one of a set (a radio item): the checked one shows a check. */
  checked?: boolean;
  lead?: ReactNode;
  /** A second, quieter line. */
  hint?: ReactNode;
  demo?: string;
  children: ReactNode;
}) {
  const radio = checked !== undefined;
  return (
    <button
      type="button"
      role={radio ? 'menuitemradio' : 'menuitem'}
      aria-checked={radio ? checked : undefined}
      tabIndex={-1}
      className={styles.menuItem}
      data-demo={demo}
      onClick={onSelect}
    >
      {lead}
      <span className={styles.menuText}>
        <span>{children}</span>
        {hint && <span className={styles.menuHint}>{hint}</span>}
      </span>
      {radio && (
        <svg
          viewBox="0 0 24 24"
          className={styles.menuCheck}
          data-on={checked || undefined}
          aria-hidden="true"
        >
          <path
            d="m6.5 12.5 3.6 3.6 7.4-8"
            fill="none"
            stroke="currentColor"
            strokeWidth="2.2"
            strokeLinecap="round"
            strokeLinejoin="round"
          />
        </svg>
      )}
    </button>
  );
}

export function MenuSeparator() {
  return <div role="separator" className={styles.menuSeparator} />;
}

export function MenuHeader({ children }: { children: ReactNode }) {
  return (
    <div className={styles.menuHeader} role="presentation">
      {children}
    </div>
  );
}
```

### setup-guide/use-autoplay.ts

```tsx
// Copyright (c) 2026 Bruno Delorence. MIT License.

'use client';

import { useCallback, useEffect, useRef, useState } from 'react';

/*
 * When a demo may play on its own: while part of it is on screen and the tab is visible, never
 * under reduced motion, and not while the reader is using it. `take()` hands it to the reader; it
 * takes back over `idle` ms after their last input.
 */
export function useAutoplay<T extends HTMLElement>(idle = 6000) {
  const ref = useRef<T>(null);
  const [visible, setVisible] = useState(false);
  const [reduced, setReduced] = useState(true);
  const [taken, setTaken] = useState(false);
  const timer = useRef(0);

  useEffect(() => {
    const element = ref.current;
    if (!element) return;
    let onScreen = false;
    const update = () => setVisible(onScreen && !document.hidden);
    const observer = new IntersectionObserver(
      ([entry]) => {
        onScreen = entry.isIntersecting;
        update();
      },
      { threshold: 0.3 },
    );
    observer.observe(element);
    document.addEventListener('visibilitychange', update);
    const motion = window.matchMedia('(prefers-reduced-motion: reduce)');
    const readMotion = () => setReduced(motion.matches);
    readMotion();
    motion.addEventListener('change', readMotion);
    return () => {
      observer.disconnect();
      document.removeEventListener('visibilitychange', update);
      motion.removeEventListener('change', readMotion);
    };
  }, []);

  const take = useCallback(() => {
    setTaken(true);
    window.clearTimeout(timer.current);
    timer.current = window.setTimeout(() => setTaken(false), idle);
  }, [idle]);
  useEffect(() => () => window.clearTimeout(timer.current), []);

  return { ref, take, visible, reduced, playing: visible && !reduced && !taken };
}
```

### setup-guide/demo-pointer.tsx

```tsx
// Copyright (c) 2026 Bruno Delorence. MIT License.

'use client';

import type { CSSProperties, Ref } from 'react';

/*
 * The demo's pointer, and the steps that move it. A demo is a script of awaited steps: wait, or
 * glide the pointer somewhere. Stopping the demo (the reader takes over, or it scrolls away) ends
 * the step in progress at once: its promise rejects, which ends the script right there, and the
 * pointer fades out.
 *
 * Each glide is a curved flight played by the Web Animations API, so nothing runs frame by frame.
 * The points of the flight are handed to whoever wants to move along with it. The arrow and the
 * hand are HTML boxes
 * that swap by their visibility: a change of style inside an SVG would lay the SVG out again.
 */

export type Point = { x: number; y: number };

/** A glide's path and timing, for an animation that plays along with it. */
export type Flight = { points: Point[]; timing: KeyframeAnimationOptions };

export type Demo = {
  /** Resolves after `ms`. */
  wait: (ms: number) => Promise<void>;
  /** Glides the pointer to `to`, in the stage's own px, in `ms`; `along` gets the flight. */
  glide: (to: Point, ms: number, along?: (flight: Flight) => void) => Promise<void>;
  /** Shows the arrow, or the hand a link shows. */
  glyph: (name: 'arrow' | 'hand') => void;
};

/** What a stopped demo's pending step rejects with. */
class Stopped extends Error {}

/** Where the arrow's tip is, as shares of its box: the point the pointer stands on. */
const TIP: Point = { x: 0.15, y: 0.1 };

/** How many points a flight is drawn through. */
const SAMPLES = 24;

/** Plays `script` with the pointer over `stage`; returns the function that stops it. */
export function runDemo(
  stage: HTMLElement,
  pointer: HTMLElement,
  script: (demo: Demo) => Promise<void>,
): () => void {
  let alive = true;
  let flight: Animation | null = null;
  // The stylesheet sizes the pointer from the stage's width; its tip is where it stands.
  const tip = { x: pointer.offsetWidth * TIP.x, y: pointer.offsetHeight * TIP.y };
  const place = ({ x, y }: Point) => `translate(${x - tip.x}px, ${y - tip.y}px)`;
  const timers = new Set<number>();
  const pending = new Set<() => void>();
  // The pointer comes in from the lower right.
  let at: Point = { x: stage.offsetWidth * 0.8, y: stage.offsetHeight * 0.9 };

  /** Settles like `promise`, or rejects as soon as the demo stops. */
  const step = (promise: Promise<unknown>) =>
    new Promise<void>((resolve, reject) => {
      if (!alive) return reject(new Stopped());
      const cancel = () => reject(new Stopped());
      pending.add(cancel);
      promise.then(
        () => {
          pending.delete(cancel);
          if (alive) resolve();
        },
        () => {
          pending.delete(cancel);
          reject(new Stopped());
        },
      );
    });

  const wait = (ms: number) =>
    step(
      new Promise<void>((resolve) => {
        const timer = window.setTimeout(() => {
          timers.delete(timer);
          resolve();
        }, ms);
        timers.add(timer);
      }),
    );

  const glide: Demo['glide'] = (to, ms, along) => {
    const from = at;
    at = to;
    const dx = to.x - from.x;
    const dy = to.y - from.y;
    // A gentle curve, as a hand moves: the control point sits off the straight line.
    const bend = { x: (from.x + to.x) / 2 - dy * 0.18, y: (from.y + to.y) / 2 + dx * 0.18 };
    const points: Point[] = [];
    for (let i = 0; i <= SAMPLES; i += 1) {
      const t = i / SAMPLES;
      const u = 1 - t;
      points.push({
        x: u * u * from.x + 2 * u * t * bend.x + t * t * to.x,
        y: u * u * from.y + 2 * u * t * bend.y + t * t * to.y,
      });
    }
    const timing: KeyframeAnimationOptions = {
      duration: ms,
      easing: 'cubic-bezier(0.45, 0, 0.25, 1)',
    };
    flight?.cancel();
    // Where it rests once the flight is over.
    pointer.style.transform = place(to);
    flight = pointer.animate(
      points.map((point) => ({ transform: place(point) })),
      timing,
    );
    along?.({ points, timing });
    return step(flight.finished);
  };

  const glyph: Demo['glyph'] = (name) => {
    pointer.dataset.glyph = name;
  };

  pointer.dataset.glyph = 'arrow';
  pointer.style.transform = place(at);
  pointer.style.opacity = '1';
  script({ wait, glide, glyph }).catch((error: unknown) => {
    if (!(error instanceof Stopped)) throw error;
  });

  return () => {
    if (!alive) return;
    alive = false;
    timers.forEach((timer) => window.clearTimeout(timer));
    flight?.cancel();
    pending.forEach((cancel) => cancel());
    pointer.style.opacity = '0';
  };
}

/**
 * The pointer's box: it moves, on a layer of its own. Its size comes from its class, its colours
 * from the stage's tokens (setup-guide.module.css).
 */
const POINTER: CSSProperties = {
  position: 'absolute',
  top: 0,
  left: 0,
  zIndex: 2,
  display: 'block',
  pointerEvents: 'none',
  opacity: 0,
  transition: 'opacity 0.3s ease',
  filter: 'drop-shadow(0 1px 1.5px var(--pointer-shadow))',
  willChange: 'transform',
};

/** One glyph over the other, each filling the box. */
const GLYPH: CSSProperties = { position: 'absolute', inset: 0, display: 'block' };
const DRAWING: CSSProperties = {
  display: 'block',
  width: '100%',
  height: '100%',
  overflow: 'visible',
};
/** The arrow is dark on a white edge, the hand white on a dark one, as the system draws them. */
const ARROW: CSSProperties = { fill: 'var(--pointer)', stroke: 'var(--pointer-edge)' };
const HAND: CSSProperties = { fill: 'var(--pointer-edge)', stroke: 'var(--pointer)' };

/**
 * The pointer the demo moves around: an arrow, or a pointing hand over what it can press. It is
 * decorative: what it does shows on the guide itself. The stylesheet shows one glyph at a time,
 * from the box's data-glyph.
 */
export function DemoPointer({
  ref,
  className,
  arrowClass,
  handClass,
}: {
  ref: Ref<HTMLSpanElement>;
  className?: string;
  arrowClass?: string;
  handClass?: string;
}) {
  return (
    <span ref={ref} className={className} style={POINTER} aria-hidden="true">
      <span className={arrowClass} style={GLYPH}>
        <svg viewBox="0 0 20 20" style={DRAWING}>
          <path
            d="M3 2v14.5l3.6-3.3 2.6 5.6 2.4-1.1-2.6-5.5h5.2z"
            style={ARROW}
            strokeWidth="1.3"
            strokeLinejoin="round"
          />
        </svg>
      </span>
      <span className={handClass} style={GLYPH}>
        <svg viewBox="0 0 20 20" style={DRAWING}>
          {/* The tip of the finger sits where the arrow's tip is. */}
          <path
            d="M6.4 3.3c0-.8.6-1.4 1.3-1.4S9 2.5 9 3.3v5.5c.2-.5.6-.8 1.2-.8.7 0 1.2.5 1.2 1.2v.5c.2-.5.6-.8 1.2-.8.7 0 1.2.5 1.2 1.2v.7c.2-.4.6-.7 1.1-.7.7 0 1.2.5 1.2 1.2v3.5c0 2.8-1.9 4.9-4.6 4.9h-1.2c-1.8 0-3.1-.8-4.1-2.3l-2.6-3.9c-.4-.6-.2-1.3.4-1.7.6-.3 1.3-.2 1.7.4l.6.9z"
            style={HAND}
            strokeWidth="1.1"
            strokeLinejoin="round"
            transform="translate(-4.7 0.1)"
          />
        </svg>
      </span>
    </span>
  );
}
```