@umriss-ui/schedule 0.44.0 → 0.46.0

package/docs/llms-full.md

@@ -1,4 +1,4 @@
-# @umriss-ui/schedule 0.44.0
+# @umriss-ui/schedule 0.46.0
 
 > React Gantt-style schedule for data-dense applications - work on lanes over time, with dependencies, blocked time, findings and controlled editing.
 
@@ -1433,38 +1433,38 @@ Under forced colours the plot paints itself in the system colours: the work in t
 | Prop | Type | Default | Description |
 |---|---|---|---|
 | `ref` | `Ref<HTMLDivElement> \| undefined` | — | Receives the root element. |
-| `height` | `number` | fills the frame, at least 400 px | Height in CSS pixels, both bands included, fixed. Left out, the schedule fills its frame - a stretched grid cell, a card the grid stretches, a container of definite height - and never goes below 400 px, which is also its height in a frame without one. A different floor goes through `style`'s `minHeight` ([ADR-0050](https://github.com/romanhaendler/umriss-ui/blob/main/docs/adr/0050-a-chart-fills-its-frame-never-below-its-floor.md)). The width is the host's.<br>Shown in: [A day of tours](#first-schedule), [Start from an empty plan](#first-schedule), [Plan a day in the machine shop](#first-schedule) and 80 more |
-| `laneHeight` | `number` | `44` | Height of one lane in pixels at the default font size of 16 px; the schedule multiplies it by the root font size over 16 px when that ratio is above 1, so lane names keep their room in a reader's larger font.<br>Shown in: [Scroll more lanes than fit (Lanes)](#lanes), [Measure a plan (Benchmark)](#benchmark) |
-| `headerWidth` | `number` | `160` | Width of the lane headers in pixels - at most 40 % of the schedule, so that on a phone the plot keeps the larger part.<br>Shown in: [What a lane header says (Lanes)](#lanes), [Scroll more lanes than fit (Lanes)](#lanes), [Group lanes under a head (Lane groups)](#lane-groups) and 1 more |
+| `height` | `number` | fills the frame, at least 400 px | Height in CSS pixels, both bands included, fixed. Left out, the schedule fills its frame - a stretched grid cell, a card the grid stretches, a container of definite height - and never goes below 400 px, which is also its height in a frame without one. A different floor goes through `style`'s `minHeight` ([ADR-0050](https://github.com/romanhaendler/umriss-ui/blob/main/docs/adr/0050-a-chart-fills-its-frame-never-below-its-floor.md)). The width is the host's.<br>Shown in: [A day of tours](#first-schedule), [Start from an empty plan](#first-schedule), [Plan a day in the machine shop](#first-schedule) and 85 more |
+| `laneHeight` | `number` | `44` | Height of one lane in pixels at the default font size of 16 px; the schedule multiplies it by the root font size over 16 px when that ratio is above 1, so lane names keep their room in a reader's larger font.<br>Shown in: [Highlight a lane (Lanes)](#lanes), [Scroll more lanes than fit (Lanes)](#lanes), [Measure a plan (Benchmark)](#benchmark) |
+| `headerWidth` | `number` | `160` | Width of the lane headers in pixels - at most 40 % of the schedule, so that on a phone the plot keeps the larger part.<br>Shown in: [What a lane header says (Lanes)](#lanes), [Highlight a lane (Lanes)](#lanes), [Scroll more lanes than fit (Lanes)](#lanes) and 2 more |
 | `calendar` | `CalendarInput` | `[]` | A working calendar: the intervals in which time counts. Nights and weekends outside them are cut out of the axis. Without intervals every hour counts, as on the wall clock.<br>Shown in: [Cut the nights out of the axis (Time axis and calendar)](#time-axis-and-calendar), [Plan in office hours only (Time axis and calendar)](#time-axis-and-calendar), [Plan the sprint around leave (Scenarios)](#plan-the-sprint-around-leave) |
-| `zoomLimits` | `ZoomLimits` | one hour to 28 days | The narrowest and widest time span zoom may reach, in milliseconds.<br>Shown in: [Move through the plan (Pan and zoom)](#pan-and-zoom) |
+| `zoomLimits` | `ZoomLimits` | one hour to 28 days | The narrowest and widest time span zoom may reach, in milliseconds.<br>Shown in: [Move through the plan (Pan and zoom)](#pan-and-zoom), [Zoom and fit with buttons (Pan and zoom)](#pan-and-zoom) |
 | `snap` | `"ticks" \| number \| ``SnapRaster`` \| false` | `"ticks"` | The raster a drag lands on: `"ticks"` - the fine band's current step -, a step in milliseconds from local midnight, a step with an offset (shifts at 06:00, 14:00 and 22:00 are eight hours offset by six), or `false` for none. It shapes the ghost and the intent, never the data.<br>Shown in: [Snap to a duration (Snapping)](#snapping), [Snap to handover times (Snapping)](#snapping), [Place without snapping (Snapping)](#snapping) |
-| `intents` | `readonly ``IntentKind``[]` | `[]` | The intents the caller handles. Each one enables its interaction; none leaves a read-only schedule ([ADR-0023](https://github.com/romanhaendler/umriss-ui/blob/main/docs/adr/0023-editing-is-controlled-the-schedule-reports-intents.md)).<br>Shown in: [Show that a plan is on its way](#first-schedule), [Read a folded group (Lane groups)](#lane-groups), [Cut the nights out of the axis (Time axis and calendar)](#time-axis-and-calendar) and 19 more |
+| `intents` | `readonly ``IntentKind``[]` | `[]` | The intents the caller handles. Each one enables its interaction; none leaves a read-only schedule ([ADR-0023](https://github.com/romanhaendler/umriss-ui/blob/main/docs/adr/0023-editing-is-controlled-the-schedule-reports-intents.md)).<br>Shown in: [Show that a plan is on its way](#first-schedule), [Read a folded group (Lane groups)](#lane-groups), [Cut the nights out of the axis (Time axis and calendar)](#time-axis-and-calendar) and 20 more |
 | `canMoveTo` | `(subtask: `[`Subtask`](#subtasks)`, lane: string) => boolean` | every lane is open | Whether a subtask may go to a lane. It narrows `"lane"`, it does not enable it. Asked once per lane when a drag takes hold, and asked again at the drop. The lanes it turns down are marked from the first frame of the drag - a planner sees the refusal before meeting it - and over one of them the ghost stays on the last lane that was allowed, the cursor says no and a line ties the ghost to the pointer. A refused lane costs the lane and nothing else: a drop after it still reports the move in time. It is asked for work dragged in from outside as well, with the key and task the application declared in `placing`.<br>Shown in: [Keep work on the lanes that fit (Where a subtask may go)](#where-a-subtask-may-go), [Apply the same rule to work dragged in (Where a subtask may go)](#where-a-subtask-may-go), [Keep work out of someone's leave (Where a subtask may go)](#where-a-subtask-may-go) and 1 more |
 | `selectedTask` | `string \| null` | — | The selected task, controlled. Leave it out and the schedule keeps the selection itself.<br>Shown in: [Control the selection (Selection)](#selection) |
 | `onSelectedTaskChange` | `(task: string \| null, subtask: string \| null) => void` | — | Called when a click selects a task or clears the selection, with the subtask that was clicked - null where the click was on a dependency or on nothing. It is called again when another subtask of the same task is clicked.<br>Shown in: [Control the selection (Selection)](#selection) |
 | `placing` | `PlacingItem`` \| null` | — | What the application is dragging in from outside while it drags it - its key, task, the length of its main time, its lead-in and lead-out. The browser hands the dragged data over only on the drop, so the ghost before it can only come from here: set it on your own `dragstart`, clear it on `dragend`. Without `"place"` in `intents` no drop is accepted.<br>Shown in: [Drag work in from the backlog (Placing from outside)](#placing-from-outside), [Apply the same rule to work dragged in (Where a subtask may go)](#where-a-subtask-may-go) |
 | `route` | `DependencyRoute`<br>`"curve" \| "straight" \| "orthogonal"` | `"curve"` | How the dependencies are drawn: a `"curve"` that leaves and arrives forwards, a `"straight"` line, or `"orthogonal"` segments. A dependency may say otherwise for itself.<br>Shown in: [Straight (Routes)](#routes), [Orthogonal (Routes)](#routes), [Per dependency (Routes)](#routes) |
-| `attach` | `DependencyAttachment`<br>`"centre" \| "nearest"` | `"centre"` | Where a dependency's ends sit on their bars: the `"centre"` of both, or the `"nearest"` edge - which is the shortest line between two stops. Within one lane both mean the middle. A dependency may say otherwise for itself. It changes the picture and never a finding: whether a dependency is violated follows from its `leaves` and `arrives` alone.<br>Shown in: [Choose where a line touches its bars (Dependencies)](#dependencies), [Mark the ends with a dot (Dependencies)](#dependencies), [Draw one handover its own way (Dependencies)](#dependencies) and 3 more |
+| `attach` | `DependencyAttachment`<br>`"centre" \| "nearest"` | `"centre"` | Where a dependency's ends sit on their bars: the `"centre"` of both, or the `"nearest"` edge - which is the shortest line between two stops. Within one lane both mean the middle. A dependency may say otherwise for itself. It changes the picture and never a finding: whether a dependency is violated follows from its `leaves` and `arrives` alone.<br>Shown in: [Choose where a line touches its bars (Dependencies)](#dependencies), [Mark the ends with a dot (Dependencies)](#dependencies), [Draw one handover its own way (Dependencies)](#dependencies) and 4 more |
 | `ends` | `DependencyEnds`<br>`"dot" \| "none"` | `"dot"` | Whether a dependency's two ends carry a dot (`"dot"`) or the line stands alone (`"none"`). The dot says where the line is anchored - a help while a plan is being read, and noise in a plan full of short moves. A dependency may say otherwise for itself.<br>Shown in: [Mark the ends with a dot (Dependencies)](#dependencies), [Draw one handover its own way (Dependencies)](#dependencies) |
 | `label` | `(subtask: `[`Subtask`](#subtasks)`) => string` | — | What stands written in a bar: a function from a subtask to a line of text, or nothing for bars without text. The text is cut off with an ellipsis where the bar is too narrow for it and left out where even that would say nothing; a bar that began before the view keeps its text at the view's edge.<br>Shown in: [Plan a day in the machine shop](#first-schedule), [Plan a sprint for a team (Subtasks)](#subtasks), [Write into the bars (Bar labels)](#bar-labels) and 7 more |
 | `tooltip` | `false \| ((target: `[`ScheduleTooltipTarget`](#tooltip)`) => ReactNode)` | — | The tooltip on a hovered subtask or dependency: its order, its times, its parts and its findings. `false` switches it off; a function receives what the pointer rests on and returns content of the application's own.<br>Shown in: [Say what a milestone is in your own tooltip (Milestones)](#milestones), [Write your own tooltip content (Tooltip)](#tooltip), [Show a detail panel instead (Tooltip)](#tooltip) and 1 more |
 | `now` | `boolean \| number` | `false` | A line marking the present across the lanes: `true` follows the clock by the minute, an instant fixes it there.<br>Shown in: [Plan a day in the machine shop](#first-schedule), [Mark the present (Now line)](#now-line), [Follow the clock (Now line)](#now-line) and 2 more |
 | `loading` | `boolean` | `false` | The plan is on its way, as the chart's `loading` says ([ADR-0042](https://github.com/romanhaendler/umriss-ui/blob/main/docs/adr/0042-a-rows-height-never-follows-what-it-shows.md)). A plan already drawn stays: it dims after a moment and takes no pointer - no new drag, no tooltip, no intent by key - until the answer is in; a drag begun before finishes and reports. The keys still walk it. With no lanes, placeholder lines stand in the lane column. The plot is `aria-busy` meanwhile.<br>Shown in: [Show that a plan is on its way](#first-schedule) |
-| `children` | `ReactNode` | — | `Lane`, `Dependencies` and `Subtasks`, in the order they are to stand and be drawn.<br>Shown in: [A day of tours](#first-schedule), [Start from an empty plan](#first-schedule), [Plan a day in the machine shop](#first-schedule) and 82 more |
+| `children` | `ReactNode` | — | `Lane`, `Dependencies` and `Subtasks`, in the order they are to stand and be drawn.<br>Shown in: [A day of tours](#first-schedule), [Start from an empty plan](#first-schedule), [Plan a day in the machine shop](#first-schedule) and 87 more |
 
 ###### Events
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| `onIntent` | `(intent: ``Intent``) => void` | — | Called once per intent when a drag ends. The data changes only if the caller changes it.<br>Shown in: [Read a folded group (Lane groups)](#lane-groups), [Cut the nights out of the axis (Time axis and calendar)](#time-axis-and-calendar), [Plan work around someone's leave (Blocked time)](#blocked-time) and 18 more |
+| `onIntent` | `(intent: ``Intent``) => void` | — | Called once per intent when a drag ends. The data changes only if the caller changes it.<br>Shown in: [Read a folded group (Lane groups)](#lane-groups), [Cut the nights out of the axis (Time axis and calendar)](#time-axis-and-calendar), [Plan work around someone's leave (Blocked time)](#blocked-time) and 19 more |
 | `onInteraction` | `(interaction: `[`ScheduleInteraction`](#interactions)`) => void` | — | Click, context menu and hover, with what the pointer is on and where. While it is set, a right-click opens no browser menu.<br>Shown in: [Report what the pointer is on (Interactions)](#interactions), [Open a context menu (Interactions)](#interactions), [Show a detail panel instead (Tooltip)](#tooltip) and 3 more |
 
 ###### Accessibility
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| `aria-label` *required* | `string` | — | What the schedule shows, for a screen reader: "Plan of week 38".<br>Shown in: [A day of tours](#first-schedule), [Start from an empty plan](#first-schedule), [Plan a day in the machine shop](#first-schedule) and 82 more |
+| `aria-label` *required* | `string` | — | What the schedule shows, for a screen reader: "Plan of week 38".<br>Shown in: [A day of tours](#first-schedule), [Start from an empty plan](#first-schedule), [Plan a day in the machine shop](#first-schedule) and 87 more |
 
 Also takes every attribute of `<div>` – without `aria-label`, `children`.
 
@@ -1666,11 +1666,11 @@ no subtask yet; the caller creates one, with its own identity, from
 
 #### Known limits
 
-- No dependency types, critical path or auto-scheduling: the application decides where work goes, the schedule shows the result and its findings ([ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.44.0/docs/adr/0032-what-umriss-is-not.md)).
+- No dependency types, critical path or auto-scheduling: the application decides where work goes, the schedule shows the result and its findings ([ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.46.0/docs/adr/0032-what-umriss-is-not.md)).
 - No milestones yet: a point in time on a lane has no mark of its own.
 - A dependency joins two subtasks of one task; dependencies across tasks are not yet possible.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.44.0/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.46.0/docs/adr/0032-what-umriss-is-not.md).
 
 ## Plan
 
@@ -1741,6 +1741,79 @@ export default function LaneHeaders() {
 }
 ```
 
+##### Highlight a lane
+
+The application marks a lane by putting a `Badge` into its `label`, and `scrollToLane` brings it into view when it is picked from the list; the schedule has no highlight of its own.
+
+```tsx
+import { useState } from "react";
+import { Badge, Button, Stack, Text } from "@umriss-ui/core";
+import { useSchedule } from "@umriss-ui/schedule";
+import type { Subtask, Task } from "@umriss-ui/schedule";
+
+const at = (hours: number, minutes = 0) => new Date(2026, 2, 17, hours, minutes).getTime();
+
+const ROUNDS: Task[] = [{ id: "rounds", name: "Rounds", color: "light-dark(#0d9488, #3cc7b8)" }];
+
+const CREWS = Array.from({ length: 12 }, (_, i) => ({ id: `crew-${i + 1}`, label: `Crew ${String(i + 1).padStart(2, "0")}` }));
+
+const WORK: Subtask[] = CREWS.map((crew, i) => ({
+  id: `${crew.id}-round`,
+  task: "rounds",
+  lane: crew.id,
+  from: at(7, 30 * (i % 6)),
+  to: at(9, 30 * (i % 6)),
+  leadIn: 15 * 60_000,
+}));
+
+export default function HighlightLane() {
+  const [marked, setMarked] = useState<string | null>(null);
+  const { Schedule, Lane, Subtasks, scrollToLane } = useSchedule({ initialView: { domain: [at(6), at(14)] } });
+
+  const pick = (id: string) => {
+    setMarked(id);
+    scrollToLane(id);
+  };
+
+  return (
+    <Stack direction="row" gap={3} align="flex-start">
+      <Stack gap={1} style={{ flex: "none" }}>
+        {CREWS.map((crew) => (
+          <Button
+            key={crew.id}
+            size="sm"
+            variant={marked === crew.id ? "secondary" : "ghost"}
+            aria-pressed={marked === crew.id}
+            onClick={() => pick(crew.id)}
+          >
+            {crew.label}
+          </Button>
+        ))}
+      </Stack>
+      <Schedule aria-label="Twelve crews, one round each, a crew picked from the list" height={200} laneHeight={32} headerWidth={150}>
+        {CREWS.map((crew) => (
+          <Lane
+            key={crew.id}
+            id={crew.id}
+            label={
+              marked === crew.id ? (
+                <Stack direction="row" gap={1} align="center">
+                  <Text size="sm">{crew.label}</Text>
+                  <Badge tone="accent">Picked</Badge>
+                </Stack>
+              ) : (
+                crew.label
+              )
+            }
+          />
+        ))}
+        <Subtasks data={WORK} tasks={ROUNDS} />
+      </Schedule>
+    </Stack>
+  );
+}
+```
+
 ##### Scroll more lanes than fit
 
 Twenty vans in 300 pixels: the lanes scroll with their headers, while the time bands and the header column hold still.
@@ -1803,8 +1876,8 @@ The keys of [First schedule](#first-schedule) apply here.
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| `id` *required* | `string` | — | The identity subtasks name in their `lane`.<br>Shown in: [What a lane header says](#lanes), [Scroll more lanes than fit](#lanes), [The smallest schedule (Installation)](#installation) and 82 more |
-| `label` | `ReactNode` | `id` | What the lane header says - the person, vehicle or room. Real text, read by a screen reader.<br>Shown in: [What a lane header says](#lanes), [Scroll more lanes than fit](#lanes), [The smallest schedule (Installation)](#installation) and 81 more |
+| `id` *required* | `string` | — | The identity subtasks name in their `lane`.<br>Shown in: [What a lane header says](#lanes), [Highlight a lane](#lanes), [Scroll more lanes than fit](#lanes) and 87 more |
+| `label` | `ReactNode` | `id` | What the lane header says - the person, vehicle or room. Real text, read by a screen reader.<br>Shown in: [What a lane header says](#lanes), [Highlight a lane](#lanes), [Scroll more lanes than fit](#lanes) and 86 more |
 
 ### Lane groups
 
@@ -2112,7 +2185,7 @@ The keys of [First schedule](#first-schedule) apply here.
 
 - A folded group shows no summary - no utilisation band, no bar spanning its work: a computed claim would look like a drawn fact ([ADR-0025](https://github.com/romanhaendler/umriss-ui/blob/main/docs/adr/0025-a-lane-group-is-structure-over-lanes-never-a-lane.md)).
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.44.0/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.46.0/docs/adr/0032-what-umriss-is-not.md).
 
 ### Subtasks
 
@@ -2312,31 +2385,31 @@ The keys of [First schedule](#first-schedule) apply here.
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| `data` *required* | `readonly ``Subtask``[]` | — | The subtasks, as the caller holds them. The schedule never changes one.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [Plan a sprint for a team](#subtasks) and 82 more |
-| `tasks` *required* | `readonly ``Task``[]` | — | The tasks the subtasks belong to - their identity and their colour. A subtask whose task is not among them is drawn in a muted colour.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [Plan a sprint for a team](#subtasks) and 82 more |
+| `data` *required* | `readonly ``Subtask``[]` | — | The subtasks, as the caller holds them. The schedule never changes one.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [Plan a sprint for a team](#subtasks) and 87 more |
+| `tasks` *required* | `readonly ``Task``[]` | — | The tasks the subtasks belong to - their identity and their colour. A subtask whose task is not among them is drawn in a muted colour.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [Plan a sprint for a team](#subtasks) and 87 more |
 
 ##### `Subtask`
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| `id` *required* | `string` | — | The caller's identity of the subtask.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [Plan a sprint for a team](#subtasks) and 79 more |
-| `task` *required* | `string` | — | The id of the task it belongs to.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [The smallest schedule (Installation)](#installation) and 75 more |
-| `lane` *required* | `string` | — | The id of the lane it sits on.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [The smallest schedule (Installation)](#installation) and 75 more |
-| `from` *required* | `number` | — | Start of the main time.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [The smallest schedule (Installation)](#installation) and 75 more |
-| `to` *required* | `number` | — | End of the main time.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [The smallest schedule (Installation)](#installation) and 75 more |
-| `leadIn` | `number` | — | Duration of the lead-in before the main time; none is zero.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [The smallest schedule (Installation)](#installation), [A day of tours (First schedule)](#first-schedule) and 25 more |
-| `leadOut` | `number` | — | Duration of the lead-out after the main time; none is zero.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [The smallest schedule (Installation)](#installation), [A day of tours (First schedule)](#first-schedule) and 22 more |
-| `name` | `string` | — | What the subtask is called, where the schedule names it.<br>Shown in: [Plan a sprint for a team](#subtasks), [Write into the bars (Bar labels)](#bar-labels), [Join the stops of a tour (Dependencies)](#dependencies) and 28 more |
-| `appearance` | `readonly ``SubtaskAppearance``[]` | — | What the bar says besides its colour: `"provisional"`, `"fixed"`, `"muted"`, `"open"`. Several hold at once; `"provisional"` and `"fixed"` contradict, and the later one in the list wins.<br>Shown in: [Plan a sprint for a team](#subtasks), [Provisional (Appearances)](#appearances), [Fixed (Appearances)](#appearances) and 3 more |
+| `id` *required* | `string` | — | The caller's identity of the subtask.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [Plan a sprint for a team](#subtasks) and 84 more |
+| `task` *required* | `string` | — | The id of the task it belongs to.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [The smallest schedule (Installation)](#installation) and 80 more |
+| `lane` *required* | `string` | — | The id of the lane it sits on.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [The smallest schedule (Installation)](#installation) and 80 more |
+| `from` *required* | `number` | — | Start of the main time.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [The smallest schedule (Installation)](#installation) and 80 more |
+| `to` *required* | `number` | — | End of the main time.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [The smallest schedule (Installation)](#installation) and 80 more |
+| `leadIn` | `number` | — | Duration of the lead-in before the main time; none is zero.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [The smallest schedule (Installation)](#installation), [A day of tours (First schedule)](#first-schedule) and 27 more |
+| `leadOut` | `number` | — | Duration of the lead-out after the main time; none is zero.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [The smallest schedule (Installation)](#installation), [A day of tours (First schedule)](#first-schedule) and 23 more |
+| `name` | `string` | — | What the subtask is called, where the schedule names it.<br>Shown in: [Plan a sprint for a team](#subtasks), [Write into the bars (Bar labels)](#bar-labels), [Join the stops of a tour (Dependencies)](#dependencies) and 31 more |
+| `appearance` | `readonly ``SubtaskAppearance``[]` | — | What the bar says besides its colour: `"provisional"`, `"fixed"`, `"muted"`, `"open"`. Several hold at once; `"provisional"` and `"fixed"` contradict, and the later one in the list wins.<br>Shown in: [Plan a sprint for a team](#subtasks), [Provisional (Appearances)](#appearances), [Fixed (Appearances)](#appearances) and 4 more |
 | `progress` | `number` | — | The share of the work that is done, from 0 to 1, drawn as a filled part of the bar. Without it nothing is claimed - an empty bar and a bar at zero per cent are two different statements.<br>Shown in: [Progress (Appearances)](#appearances), [Several at once (Appearances)](#appearances) |
 
 ##### `Task`
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| `id` *required* | `string` | — | The caller's identity of the task.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [The smallest schedule (Installation)](#installation) and 74 more |
-| `color` *required* | `string` | — | Any CSS colour - a literal, a token, `light-dark(…)`. The colour means what the caller's domain needs it to mean.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [The smallest schedule (Installation)](#installation) and 74 more |
-| `name` | `string` | — | What the task is called, where the schedule names it.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [The smallest schedule (Installation)](#installation) and 74 more |
+| `id` *required* | `string` | — | The caller's identity of the task.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [The smallest schedule (Installation)](#installation) and 79 more |
+| `color` *required* | `string` | — | Any CSS colour - a literal, a token, `light-dark(…)`. The colour means what the caller's domain needs it to mean.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [The smallest schedule (Installation)](#installation) and 79 more |
+| `name` | `string` | — | What the task is called, where the schedule names it.<br>Shown in: [Main time, lead-in and lead-out](#subtasks), [Colour by what the task means](#subtasks), [The smallest schedule (Installation)](#installation) and 79 more |
 
 ##### Types on this page
 
@@ -2976,7 +3049,7 @@ From `ScheduleView` — the full table stands on [View](#view).
 
 - No stacked layout on request yet: an overlap is always drawn offset, as the finding it is.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.44.0/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.46.0/docs/adr/0032-what-umriss-is-not.md).
 
 ### Dependencies
 
@@ -3274,6 +3347,62 @@ export default function OneHandoverDrawnItsOwnWay() {
 }
 ```
 
+##### Mark the critical path
+
+The planning system works out the critical path and hands over its subtask ids; `muted` takes the rest back so the path reads first. The schedule computes nothing ([ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.46.0/docs/adr/0032-what-umriss-is-not.md)), so the switch only changes what the application marks.
+
+```tsx
+import { useState } from "react";
+import { Stack, Switch } from "@umriss-ui/core";
+import { useSchedule } from "@umriss-ui/schedule";
+import type { Dependency, Subtask, Task } from "@umriss-ui/schedule";
+
+const at = (hours: number, minutes = 0) => new Date(2026, 2, 17, hours, minutes).getTime();
+const min = (n: number) => n * 60_000;
+
+const PROJECTS: Task[] = [{ id: "portal", name: "Member portal", color: "light-dark(#2563eb, #6b9bff)" }];
+
+const WORK: Subtask[] = [
+  { id: "design", task: "portal", lane: "noah", from: at(7), to: at(8), name: "Design" },
+  { id: "copy", task: "portal", lane: "mira", from: at(7), to: at(8, 30), name: "Copy" },
+  { id: "build", task: "portal", lane: "arjun", from: at(8, 30), to: at(9, 30), name: "Build" },
+  { id: "test", task: "portal", lane: "eva", from: at(10), to: at(11), name: "Test" },
+  { id: "docs", task: "portal", lane: "mira", from: at(9), to: at(10), name: "Docs" },
+];
+
+const HANDOVERS: Dependency[] = [
+  { id: "design-build", from: "design", to: "build", lag: min(15) },
+  { id: "copy-docs", from: "copy", to: "docs", lag: min(15) },
+  { id: "build-test", from: "build", to: "test", lag: min(15) },
+];
+
+/* As the planning system hands it over. */
+const CRITICAL_PATH = ["design", "build", "test"];
+
+export default function CriticalPath() {
+  const [marked, setMarked] = useState(true);
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(6, 30), at(11, 30)] } });
+
+  const plan: Subtask[] = WORK.map((subtask): Subtask =>
+    marked && !CRITICAL_PATH.includes(subtask.id) ? { ...subtask, appearance: ["muted"] } : subtask,
+  );
+
+  return (
+    <Stack gap={3}>
+      <Switch label="Mark the critical path" checked={marked} onChange={(event) => setMarked(event.target.checked)} />
+      <Schedule aria-label="Portal work, the critical path marked" height={188} attach="nearest">
+        <Lane id="noah" label="Noah Fischer" />
+        <Lane id="mira" label="Mira Stone" />
+        <Lane id="arjun" label="Arjun Mehta" />
+        <Lane id="eva" label="Eva Novak" />
+        <Dependencies data={HANDOVERS} />
+        <Subtasks data={plan} tasks={PROJECTS} />
+      </Schedule>
+    </Stack>
+  );
+}
+```
+
 #### When to use something else
 
 - The shape of the line → Routes
@@ -3293,21 +3422,21 @@ The keys of [First schedule](#first-schedule) apply here.
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| `data` *required* | `readonly ``Dependency``[]` | — | The dependencies, as the caller holds them.<br>Shown in: [Join the stops of a tour](#dependencies), [Choose what a dependency connects](#dependencies), [Choose where a line touches its bars](#dependencies) and 28 more |
+| `data` *required* | `readonly ``Dependency``[]` | — | The dependencies, as the caller holds them.<br>Shown in: [Join the stops of a tour](#dependencies), [Choose what a dependency connects](#dependencies), [Choose where a line touches its bars](#dependencies) and 30 more |
 
 ##### `Dependency`
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| `id` *required* | `string` | — | The caller's identity of the dependency.<br>Shown in: [Join the stops of a tour](#dependencies), [Choose what a dependency connects](#dependencies), [Choose where a line touches its bars](#dependencies) and 27 more |
-| `from` *required* | `string` | — | The id of the subtask it leaves.<br>Shown in: [Join the stops of a tour](#dependencies), [Choose what a dependency connects](#dependencies), [Choose where a line touches its bars](#dependencies) and 27 more |
-| `to` *required* | `string` | — | The id of the subtask it arrives at.<br>Shown in: [Join the stops of a tour](#dependencies), [Choose what a dependency connects](#dependencies), [Choose where a line touches its bars](#dependencies) and 27 more |
-| `lag` *required* | `number` | — | The least time between the two anchors; zero where the successor may begin as soon as the predecessor ends.<br>Shown in: [Join the stops of a tour](#dependencies), [Choose what a dependency connects](#dependencies), [Choose where a line touches its bars](#dependencies) and 27 more |
+| `id` *required* | `string` | — | The caller's identity of the dependency.<br>Shown in: [Join the stops of a tour](#dependencies), [Choose what a dependency connects](#dependencies), [Choose where a line touches its bars](#dependencies) and 29 more |
+| `from` *required* | `string` | — | The id of the subtask it leaves.<br>Shown in: [Join the stops of a tour](#dependencies), [Choose what a dependency connects](#dependencies), [Choose where a line touches its bars](#dependencies) and 29 more |
+| `to` *required* | `string` | — | The id of the subtask it arrives at.<br>Shown in: [Join the stops of a tour](#dependencies), [Choose what a dependency connects](#dependencies), [Choose where a line touches its bars](#dependencies) and 29 more |
+| `lag` *required* | `number` | — | The least time between the two anchors; zero where the successor may begin as soon as the predecessor ends.<br>Shown in: [Join the stops of a tour](#dependencies), [Choose what a dependency connects](#dependencies), [Choose where a line touches its bars](#dependencies) and 29 more |
 | `leaves` | `"main" \| "leadOut"` | `"leadOut"` | Where it leaves: at the end of the main time, or after the lead-out. The predecessor counts as ended once its lead-out is.<br>Shown in: [Choose what a dependency connects](#dependencies), [Plan a day in the machine shop (First schedule)](#first-schedule), [Replan the day on the line (Scenarios)](#replan-the-day-on-the-line) |
 | `arrives` | `"main" \| "leadIn"` | `"leadIn"` | Where it arrives: at the start of the main time, or before the lead-in. The lag must have run out before the successor's lead-in begins.<br>Shown in: [Choose what a dependency connects](#dependencies), [A day of tours (First schedule)](#first-schedule), [Plan a day in the machine shop (First schedule)](#first-schedule) and 1 more |
-| `route` | `DependencyRoute`<br>`"curve" \| "straight" \| "orthogonal"` | — | How this one is drawn, where it is not drawn like the rest. It changes the picture and never the finding: whether a dependency is violated follows from `leaves` and `arrives` alone.<br>Shown in: [Per dependency (Routes)](#routes) |
+| `route` | `DependencyRoute`<br>`"curve" \| "straight" \| "orthogonal"` | — | How this one is drawn, where it is not drawn like the rest. It changes the picture and never the finding: whether a dependency is violated follows from `leaves` and `arrives` alone.<br>Shown in: [Per dependency (Routes)](#routes), [Undo the applied intents (Undo)](#undo) |
 | `attach` | `DependencyAttachment`<br>`"centre" \| "nearest"` | — | Where on the bars this one's line attaches, where it does not attach like the rest. Also picture only, and not to be confused with the two anchors above: those say what the dependency connects, this says where the line touches.<br>Shown in: [Draw one handover its own way](#dependencies) |
-| `ends` | `DependencyEnds`<br>`"dot" \| "none"` | — | Whether this one's ends are marked with a dot, where it is not marked like the rest. Also picture only.<br>Shown in: [Draw one handover its own way](#dependencies) |
+| `ends` | `DependencyEnds`<br>`"dot" \| "none"` | — | Whether this one's ends are marked with a dot, where it is not marked like the rest. Also picture only.<br>Shown in: [Draw one handover its own way](#dependencies), [Undo the applied intents (Undo)](#undo) |
 
 ##### Types on this page
 
@@ -3346,9 +3475,9 @@ type DependencyEnds = "dot" | "none";
 
 #### Known limits
 
-- Only finish-to-start within one task; no dependency types and no critical path ([ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.44.0/docs/adr/0032-what-umriss-is-not.md)).
+- Only finish-to-start within one task; no dependency types and no critical path ([ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.46.0/docs/adr/0032-what-umriss-is-not.md)).
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.44.0/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.46.0/docs/adr/0032-what-umriss-is-not.md).
 
 ### Routes
 
@@ -4743,6 +4872,59 @@ export default function PanAndZoom() {
 }
 ```
 
+##### Zoom and fit with buttons
+
+The schedule has no zoom buttons of its own: `visibleDomain` reads the span in view, `setDomain` puts a new one in, and `setDomain(null)` fits the subtasks. The application keeps each zoom within the `zoomLimits` it passes.
+
+```tsx
+import { Button, Stack } from "@umriss-ui/core";
+import { useSchedule } from "@umriss-ui/schedule";
+import type { Subtask, Task } from "@umriss-ui/schedule";
+
+const at = (hours: number, minutes = 0) => new Date(2026, 2, 17, hours, minutes).getTime();
+const HOUR = 60 * 60_000;
+
+const TASKS: Task[] = [{ id: "release", name: "Release 4.12", color: "light-dark(#2563eb, #6b9bff)" }];
+
+const WORK: Subtask[] = [
+  { id: "build", task: "release", lane: "priya", from: at(6), to: at(7) },
+  { id: "rollout", task: "release", lane: "jonas", from: at(8), to: at(10, 30) },
+  { id: "verify", task: "release", lane: "ada", from: at(11), to: at(12) },
+];
+
+const LIMITS = { min: 2 * HOUR, max: 48 * HOUR };
+
+export default function ZoomAndFit() {
+  const { Schedule, Lane, Subtasks, setDomain, visibleDomain } = useSchedule({
+    initialView: { domain: [at(5, 30), at(18)] },
+  });
+
+  /* Halves or doubles the span about its middle, clamped to the limits. */
+  const zoom = (factor: number) => {
+    const [from, to] = visibleDomain();
+    const middle = (from + to) / 2;
+    const span = Math.min(LIMITS.max, Math.max(LIMITS.min, (to - from) * factor));
+    setDomain([middle - span / 2, middle + span / 2]);
+  };
+
+  return (
+    <Stack gap={3}>
+      <Stack direction="row" gap={2}>
+        <Button size="sm" onClick={() => zoom(0.5)}>Zoom in</Button>
+        <Button size="sm" onClick={() => zoom(2)}>Zoom out</Button>
+        <Button size="sm" onClick={() => setDomain(null)}>Fit</Button>
+      </Stack>
+      <Schedule aria-label="The release, with zoom and fit buttons" height={160} zoomLimits={LIMITS}>
+        <Lane id="priya" label="Priya Raman" />
+        <Lane id="jonas" label="Jonas Keller" />
+        <Lane id="ada" label="Ada Mwangi" />
+        <Subtasks data={WORK} tasks={TASKS} />
+      </Schedule>
+    </Stack>
+  );
+}
+```
+
 #### Keyboard
 
 | Key | Action |
@@ -5051,7 +5233,7 @@ From `ScheduleView` — the full table stands on [View](#view).
 
 - One task at a time: there is no multiple selection.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.44.0/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.46.0/docs/adr/0032-what-umriss-is-not.md).
 
 ### Interactions
 
@@ -5643,6 +5825,43 @@ export default function SayWhatABarCoversAndALineJoins() {
 }
 ```
 
+##### Read the plan as a table
+
+Place `DataTable` inside the schedule and a Show data key opens the subtasks in view as a table - lane, task, subtask, from and to with their dates, duration and findings. Press it: batch B-2 runs across midnight and overlaps B-1.
+
+```tsx
+import { useSchedule } from "@umriss-ui/schedule";
+import type { Subtask, Task } from "@umriss-ui/schedule";
+
+const at = (day: number, hours: number, minutes = 0) => new Date(2026, 2, day, hours, minutes).getTime();
+const min = (n: number) => n * 60_000;
+
+const BATCHES: readonly Task[] = [
+  { id: "b-1", name: "Batch B-1 Oat drink", color: "light-dark(#2563eb, #6b9bff)" },
+  { id: "b-2", name: "Batch B-2 Almond drink", color: "light-dark(#c2410c, #f08a52)" },
+];
+
+/* B-2 starts on the mixer before B-1 has left it, and runs on past midnight. */
+const STEPS: readonly Subtask[] = [
+  { id: "b-1-mix", task: "b-1", lane: "mixer", from: at(17, 21), to: at(18, 1), name: "Mix", leadIn: min(15) },
+  { id: "b-1-fill", task: "b-1", lane: "filler", from: at(18, 1, 30), to: at(18, 4), name: "Fill" },
+  { id: "b-2-mix", task: "b-2", lane: "mixer", from: at(17, 23, 30), to: at(18, 3), name: "Mix" },
+  { id: "b-2-fill", task: "b-2", lane: "filler", from: at(18, 4, 30), to: at(18, 6), name: "Fill", leadOut: min(30) },
+];
+
+export default function PlanAsTable() {
+  const { Schedule, Lane, Subtasks, DataTable } = useSchedule({ initialView: { domain: [at(17, 20), at(18, 7)] } });
+  return (
+    <Schedule aria-label="Two batches over the night shift, as a plan and as a table" height={300}>
+      <Lane id="mixer" label="Mixer" />
+      <Lane id="filler" label="Filling line" />
+      <Subtasks data={STEPS} tasks={BATCHES} />
+      <DataTable />
+    </Schedule>
+  );
+}
+```
+
 #### Keyboard
 
 The keys of [First schedule](#first-schedule) apply here.
@@ -5793,7 +6012,7 @@ The keys of [First schedule](#first-schedule) apply here.
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| `initialView` | `ScheduleView` | — | The view to start from, read once when the hook first runs; a different value on a later render is ignored, as React ignores a changed `defaultValue`. To go to a view later, call `setView`. The schedule remembers none: where a view is kept is the application's decision.<br>Shown in: [Keep and restore a view](#view), [The smallest schedule (Installation)](#installation), [A day of tours (First schedule)](#first-schedule) and 82 more |
+| `initialView` | `ScheduleView` | — | The view to start from, read once when the hook first runs; a different value on a later render is ignored, as React ignores a changed `defaultValue`. To go to a view later, call `setView`. The schedule remembers none: where a view is kept is the application's decision.<br>Shown in: [Keep and restore a view](#view), [The smallest schedule (Installation)](#installation), [A day of tours (First schedule)](#first-schedule) and 87 more |
 
 ###### Events
 
@@ -5805,7 +6024,7 @@ The keys of [First schedule](#first-schedule) apply here.
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| `domain` | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`.<br>Shown in: [Keep and restore a view](#view), [The smallest schedule (Installation)](#installation), [A day of tours (First schedule)](#first-schedule) and 81 more |
+| `domain` | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`.<br>Shown in: [Keep and restore a view](#view), [The smallest schedule (Installation)](#installation), [A day of tours (First schedule)](#first-schedule) and 86 more |
 | `folded` | `readonly string[]` | — | The **Lane group**s that are folded, by id. An id no group carries falls out. A folded outer group hides the inner ones without their ids leaving the list, so unfolding it gives back the view that was there.<br>Shown in: [Fold groups from outside (Lane groups)](#lane-groups), [Read a folded group (Lane groups)](#lane-groups), [Start with groups folded (Lane groups)](#lane-groups) |
 
 ### Linked schedules
@@ -6133,7 +6352,7 @@ From `ScheduleView` — the full table stands on [View](#view).
 
 - Only the view is shared - the span and the folded groups, not the selection, the hover or the vertical scroll.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.44.0/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.46.0/docs/adr/0032-what-umriss-is-not.md).
 
 ### Functions on the hook
 
@@ -6591,7 +6810,7 @@ The keys of [First schedule](#first-schedule) apply here.
 
 - Overlapping work is marked, not packed into sub-lanes; stacked overlap is not built yet.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.44.0/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.46.0/docs/adr/0032-what-umriss-is-not.md).
 
 ## Editing
 
@@ -6966,10 +7185,189 @@ From `Overlap` — the full table stands on [Findings as data](#findings-as-data
 
 #### Known limits
 
-- No undo: your application owns the data, and with it the history ([ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.44.0/docs/adr/0032-what-umriss-is-not.md)).
+- No undo: your application owns the data, and with it the history - see [Undo](#undo) ([ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.46.0/docs/adr/0032-what-umriss-is-not.md)).
 - The keys move work in time only; a lane change needs the pointer.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.44.0/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.46.0/docs/adr/0032-what-umriss-is-not.md).
+
+### Undo
+
+Taking back the last applied change: the application keeps the plan before each intent and pops it on Ctrl+Z, ⌘Z on a Mac, or an Undo button (also called history).
+
+```ts
+import { useSchedule, applyIntent } from "@umriss-ui/schedule";
+```
+
+The schedule keeps no history: it reports each intent and the application applies it ([ADR-0023](https://github.com/romanhaendler/umriss-ui/blob/main/docs/adr/0023-editing-is-controlled-the-schedule-reports-intents.md)), so the stack of plans is the application's to keep ([ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.46.0/docs/adr/0032-what-umriss-is-not.md)). The key is the page's, not the plot's - the plot leaves Ctrl and ⌘ to it.
+
+#### Examples
+
+##### Undo the applied intents
+
+The history is the application's, not the schedule's ([ADR-0023](https://github.com/romanhaendler/umriss-ui/blob/main/docs/adr/0023-editing-is-controlled-the-schedule-reports-intents.md), [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.46.0/docs/adr/0032-what-umriss-is-not.md)): it keeps the plan before each intent it applies, and Ctrl+Z, ⌘Z on a Mac, or the Undo button pops the last one. The schedule only knows end-to-start, so a start-to-start is one dependency with a negative lag: the lag is the delay less the spec's three hours, and the line is drawn apart.
+
+```tsx
+import { useState, type KeyboardEvent } from "react";
+import { Button, Stack, Text } from "@umriss-ui/core";
+import { applyIntent, useSchedule } from "@umriss-ui/schedule";
+import type { Dependency, Intent, Subtask, Task } from "@umriss-ui/schedule";
+
+const at = (hours: number) => new Date(2026, 2, 17, hours).getTime();
+const HOUR = 60 * 60_000;
+
+const PROJECTS: Task[] = [{ id: "portal", name: "Member portal", color: "light-dark(#7c3aed, #a98bfa)" }];
+
+const START: readonly Subtask[] = [
+  { id: "spec", task: "portal", lane: "arjun", from: at(9), to: at(12), name: "Specification" },
+  { id: "build", task: "portal", lane: "chloe", from: at(10), to: at(13), name: "Build" },
+];
+
+/* Start-to-start: the build may begin an hour after the spec begins, which is
+   a lag of one hour less the spec's three hours. */
+const LINKS: readonly Dependency[] = [
+  { id: "spec-starts-build", from: "spec", to: "build", lag: HOUR - 3 * HOUR, route: "orthogonal", ends: "dot" },
+];
+
+export default function UndoIntents() {
+  const [state, setState] = useState<{ plan: readonly Subtask[]; history: readonly (readonly Subtask[])[] }>({
+    plan: START,
+    history: [],
+  });
+
+  const apply = (intent: Intent) =>
+    setState((s) => ({ plan: s.plan.map((item) => applyIntent(item, intent)), history: [...s.history, s.plan] }));
+
+  const undo = () =>
+    setState((s) => {
+      const previous = s.history.at(-1);
+      return previous === undefined ? s : { plan: previous, history: s.history.slice(0, -1) };
+    });
+
+  /* The key belongs to the page: the plot leaves Ctrl and ⌘ to it. */
+  const onKeyDown = (event: KeyboardEvent<HTMLDivElement>) => {
+    if ((event.ctrlKey || event.metaKey) && !event.shiftKey && !event.altKey && event.key.toLowerCase() === "z") {
+      event.preventDefault();
+      undo();
+    }
+  };
+
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(8), at(15)] } });
+
+  return (
+    <Stack gap={3}>
+      <Stack direction="row" gap={2} align="center">
+        <Button size="sm" variant="secondary" disabled={state.history.length === 0} onClick={undo}>
+          Undo
+        </Button>
+        <Text size="xs" tone="muted">
+          {state.history.length} to undo
+        </Text>
+      </Stack>
+      <div onKeyDown={onKeyDown}>
+        <Schedule
+          aria-label="Specification and build, the build starting an hour after the spec starts"
+          height={150}
+          intents={["move", "lane"]}
+          onIntent={apply}
+        >
+          <Lane id="arjun" label="Arjun Mehta" />
+          <Lane id="chloe" label="Chloe Durand" />
+          <Dependencies data={LINKS} />
+          <Subtasks data={state.plan} tasks={PROJECTS} />
+        </Schedule>
+      </div>
+    </Stack>
+  );
+}
+```
+
+#### Keyboard
+
+The keys of [First schedule](#first-schedule) apply here.
+
+#### Props on this page
+
+From `ScheduleProps` — the full table stands on [First schedule](#first-schedule).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`height`](#first-schedule) | `number` | fills the frame, at least 400 px | Height in CSS pixels, both bands included, fixed. Left out, the schedule fills its frame - a stretched grid cell, a card the grid stretches, a container of definite height - and never goes below 400 px, which is also its height in a frame without one. A different floor goes through `style`'s `minHeight` ([ADR-0050](https://github.com/romanhaendler/umriss-ui/blob/main/docs/adr/0050-a-chart-fills-its-frame-never-below-its-floor.md)). The width is the host's. |
+| [`intents`](#first-schedule) | `readonly `[`IntentKind`](#first-schedule)`[]` | `[]` | The intents the caller handles. Each one enables its interaction; none leaves a read-only schedule ([ADR-0023](https://github.com/romanhaendler/umriss-ui/blob/main/docs/adr/0023-editing-is-controlled-the-schedule-reports-intents.md)). |
+| [`children`](#first-schedule) | `ReactNode` | — | `Lane`, `Dependencies` and `Subtasks`, in the order they are to stand and be drawn. |
+
+###### Events
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`onIntent`](#first-schedule) | `(intent: `[`Intent`](#first-schedule)`) => void` | — | Called once per intent when a drag ends. The data changes only if the caller changes it. |
+
+###### Accessibility
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`aria-label`](#first-schedule) *required* | `string` | — | What the schedule shows, for a screen reader: "Plan of week 38". |
+
+From `LaneProps` — the full table stands on [Lanes](#lanes).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`id`](#lanes) *required* | `string` | — | The identity subtasks name in their `lane`. |
+| [`label`](#lanes) | `ReactNode` | `id` | What the lane header says - the person, vehicle or room. Real text, read by a screen reader. |
+
+From `SubtasksProps` — the full table stands on [Subtasks](#subtasks).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`data`](#subtasks) *required* | `readonly `[`Subtask`](#subtasks)`[]` | — | The subtasks, as the caller holds them. The schedule never changes one. |
+| [`tasks`](#subtasks) *required* | `readonly `[`Task`](#subtasks)`[]` | — | The tasks the subtasks belong to - their identity and their colour. A subtask whose task is not among them is drawn in a muted colour. |
+
+From `Subtask` — the full table stands on [Subtasks](#subtasks).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`id`](#subtasks) *required* | `string` | — | The caller's identity of the subtask. |
+| [`task`](#subtasks) *required* | `string` | — | The id of the task it belongs to. |
+| [`lane`](#subtasks) *required* | `string` | — | The id of the lane it sits on. |
+| [`from`](#subtasks) *required* | `number` | — | Start of the main time. |
+| [`to`](#subtasks) *required* | `number` | — | End of the main time. |
+| [`name`](#subtasks) | `string` | — | What the subtask is called, where the schedule names it. |
+
+From `Task` — the full table stands on [Subtasks](#subtasks).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`id`](#subtasks) *required* | `string` | — | The caller's identity of the task. |
+| [`color`](#subtasks) *required* | `string` | — | Any CSS colour - a literal, a token, `light-dark(…)`. The colour means what the caller's domain needs it to mean. |
+| [`name`](#subtasks) | `string` | — | What the task is called, where the schedule names it. |
+
+From `DependenciesProps` — the full table stands on [Dependencies](#dependencies).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`data`](#dependencies) *required* | `readonly `[`Dependency`](#dependencies)`[]` | — | The dependencies, as the caller holds them. |
+
+From `Dependency` — the full table stands on [Dependencies](#dependencies).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`id`](#dependencies) *required* | `string` | — | The caller's identity of the dependency. |
+| [`from`](#dependencies) *required* | `string` | — | The id of the subtask it leaves. |
+| [`to`](#dependencies) *required* | `string` | — | The id of the subtask it arrives at. |
+| [`lag`](#dependencies) *required* | `number` | — | The least time between the two anchors; zero where the successor may begin as soon as the predecessor ends. |
+| [`route`](#dependencies) | [`DependencyRoute`](#dependencies)<br>`"curve" \| "straight" \| "orthogonal"` | — | How this one is drawn, where it is not drawn like the rest. It changes the picture and never the finding: whether a dependency is violated follows from `leaves` and `arrives` alone. |
+| [`ends`](#dependencies) | [`DependencyEnds`](#dependencies)<br>`"dot" \| "none"` | — | Whether this one's ends are marked with a dot, where it is not marked like the rest. Also picture only. |
+
+From `ScheduleOptions` — the full table stands on [View](#view).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`initialView`](#view) | [`ScheduleView`](#view) | — | The view to start from, read once when the hook first runs; a different value on a later render is ignored, as React ignores a changed `defaultValue`. To go to a view later, call `setView`. The schedule remembers none: where a view is kept is the application's decision. |
+
+From `ScheduleView` — the full table stands on [View](#view).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`domain`](#view) | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`. |
 
 ### Stretch, lead-in, lead-out
 
@@ -7141,7 +7539,7 @@ From `ScheduleView` — the full table stands on [View](#view).
 
 - A main time never becomes shorter than one raster step, or a minute without a raster.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.44.0/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.46.0/docs/adr/0032-what-umriss-is-not.md).
 
 ### Snapping
 
@@ -8000,7 +8398,7 @@ From `ScheduleView` — the full table stands on [View](#view).
 
 - A rule that changes while a drag runs is noticed at the drop, not before.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.44.0/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.46.0/docs/adr/0032-what-umriss-is-not.md).
 
 ### Ripple
 
@@ -8285,10 +8683,10 @@ From `ScheduleView` — the full table stands on [View](#view).
 
 #### Known limits
 
-- No dependency types, slack or critical path: the schedule is no project-planning engine ([ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.44.0/docs/adr/0032-what-umriss-is-not.md)).
+- No dependency types, slack or critical path: the schedule is no project-planning engine ([ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.46.0/docs/adr/0032-what-umriss-is-not.md)).
 - A dependency joins subtasks of one task, so work of other tasks is never pushed.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.44.0/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/schedule-v0.46.0/docs/adr/0032-what-umriss-is-not.md).
 
 ## Measuring
 
@@ -8714,7 +9112,7 @@ Everything `@umriss-ui/schedule` exports, with its signature. A component's prop
 ##### `useSchedule`
 
 Declares a schedule: hands back `Schedule` and the parts declared inside it
-- `Lane`, `LaneGroup`, `Subtasks`, `Dependencies`, `BlockedTimes`, `Milestones` -, its
+- `Lane`, `LaneGroup`, `Subtasks`, `Dependencies`, `BlockedTimes`, `Milestones`, `DataTable` -, its
 `view` and the setters `setView`, `setDomain`, `toggleGroup`, `foldAll` and
 `unfoldAll`, `positionAt`, `clientPointOf` and `visibleDomain`, and `scrollToLane`, `scrollToSubtask` and
 `focusSubtask`.
@@ -8723,7 +9121,7 @@ Declares a schedule: hands back `Schedule` and the parts declared inside it
 function useSchedule(options?: ScheduleOptions): ScheduleParts;
 ```
 
-Used on [Scenarios](#scenarios), [Installation](#installation), [First schedule](#first-schedule), [Lanes](#lanes), [Lane groups](#lane-groups), [Subtasks](#subtasks), [Bar labels](#bar-labels), [Appearances](#appearances), [Overlap](#overlap), [Dependencies](#dependencies), [Routes](#routes), [Time axis and calendar](#time-axis-and-calendar), [Blocked time](#blocked-time), [Milestones](#milestones), [Now line](#now-line), [Pan and zoom](#pan-and-zoom), [Selection](#selection), [Interactions](#interactions), [Tooltip](#tooltip), [View](#view), [Linked schedules](#linked-schedules), [Functions on the hook](#functions-on-the-hook), [Findings as data](#findings-as-data), [Move and lane](#move-and-lane), [Stretch, lead-in, lead-out](#stretch-lead-in-lead-out), [Snapping](#snapping), [Placing from outside](#placing-from-outside), [Where a subtask may go](#where-a-subtask-may-go), [Ripple](#ripple) and [Benchmark](#benchmark).
+Used on [Scenarios](#scenarios), [Installation](#installation), [First schedule](#first-schedule), [Lanes](#lanes), [Lane groups](#lane-groups), [Subtasks](#subtasks), [Bar labels](#bar-labels), [Appearances](#appearances), [Overlap](#overlap), [Dependencies](#dependencies), [Routes](#routes), [Time axis and calendar](#time-axis-and-calendar), [Blocked time](#blocked-time), [Milestones](#milestones), [Now line](#now-line), [Pan and zoom](#pan-and-zoom), [Selection](#selection), [Interactions](#interactions), [Tooltip](#tooltip), [View](#view), [Linked schedules](#linked-schedules), [Functions on the hook](#functions-on-the-hook), [Findings as data](#findings-as-data), [Move and lane](#move-and-lane), [Undo](#undo), [Stretch, lead-in, lead-out](#stretch-lead-in-lead-out), [Snapping](#snapping), [Placing from outside](#placing-from-outside), [Where a subtask may go](#where-a-subtask-may-go), [Ripple](#ripple) and [Benchmark](#benchmark).
 
 #### Functions
 
@@ -8736,7 +9134,7 @@ it as it is.
 function applyIntent<S extends Subtask>(subtask: S, intent: Intent): S;
 ```
 
-Used on [Scenarios](#scenarios), [Lane groups](#lane-groups), [Time axis and calendar](#time-axis-and-calendar), [Blocked time](#blocked-time), [Interactions](#interactions), [Move and lane](#move-and-lane), [Stretch, lead-in, lead-out](#stretch-lead-in-lead-out), [Snapping](#snapping), [Placing from outside](#placing-from-outside), [Where a subtask may go](#where-a-subtask-may-go) and [Ripple](#ripple).
+Used on [Scenarios](#scenarios), [Lane groups](#lane-groups), [Time axis and calendar](#time-axis-and-calendar), [Blocked time](#blocked-time), [Interactions](#interactions), [Move and lane](#move-and-lane), [Undo](#undo), [Stretch, lead-in, lead-out](#stretch-lead-in-lead-out), [Snapping](#snapping), [Placing from outside](#placing-from-outside), [Where a subtask may go](#where-a-subtask-may-go) and [Ripple](#ripple).
 
 ##### `arrival`
 
@@ -8851,12 +9249,12 @@ Used on [Scenarios](#scenarios) and [Ripple](#ripple).
 
 ##### `snapTime`
 
-`time` onto the nearest line of the raster in local time - a step alone
-starts at local midnight. A step of zero or less is no raster: the time
-stays as it is.
+`time` onto the nearest line of the raster in the zone's time, the reader's
+unless one is named - a step alone starts at the zone's midnight. A step of
+zero or less is no raster: the time stays as it is.
 
 ```ts
-function snapTime(time: number, raster: number | SnapRaster): number;
+function snapTime(time: number, raster: number | SnapRaster, timeZone?: string): number;
 ```
 
 Used on [Snapping](#snapping).
@@ -8903,7 +9301,7 @@ Its table stands on [Dependencies](#dependencies).
 
 Its table stands on [Dependencies](#dependencies).
 
-Used on [Scenarios](#scenarios), [Installation](#installation), [First schedule](#first-schedule), [Lane groups](#lane-groups), [Dependencies](#dependencies), [Routes](#routes), [Time axis and calendar](#time-axis-and-calendar), [Selection](#selection), [Interactions](#interactions), [Tooltip](#tooltip), [Findings as data](#findings-as-data), [Move and lane](#move-and-lane), [Placing from outside](#placing-from-outside), [Ripple](#ripple) and [Benchmark](#benchmark).
+Used on [Scenarios](#scenarios), [Installation](#installation), [First schedule](#first-schedule), [Lane groups](#lane-groups), [Dependencies](#dependencies), [Routes](#routes), [Time axis and calendar](#time-axis-and-calendar), [Selection](#selection), [Interactions](#interactions), [Tooltip](#tooltip), [Findings as data](#findings-as-data), [Move and lane](#move-and-lane), [Undo](#undo), [Placing from outside](#placing-from-outside), [Ripple](#ripple) and [Benchmark](#benchmark).
 
 ##### `DependencyAttachment`
 
@@ -8966,7 +9364,7 @@ drop - a move and a lane - give the same data in either order.
 type Intent = MoveIntent | StretchIntent | LeadInIntent | LeadOutIntent | LaneIntent | PlaceIntent;
 ```
 
-Used on [Scenarios](#scenarios), [Blocked time](#blocked-time), [Move and lane](#move-and-lane), [Placing from outside](#placing-from-outside), [Where a subtask may go](#where-a-subtask-may-go) and [Ripple](#ripple).
+Used on [Scenarios](#scenarios), [Blocked time](#blocked-time), [Move and lane](#move-and-lane), [Undo](#undo), [Placing from outside](#placing-from-outside), [Where a subtask may go](#where-a-subtask-may-go) and [Ripple](#ripple).
 
 ##### `IntentKind`
 
@@ -9119,21 +9517,22 @@ it, its view and the setters that change it.
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| `Schedule` *required* | `(props: `[`ScheduleProps`](#first-schedule)`) => ReactNode` | — | The schedule. One per `useSchedule`: a second schedule is a second call.<br>Shown in: [The smallest schedule (Installation)](#installation), [A day of tours (First schedule)](#first-schedule), [Start from an empty plan (First schedule)](#first-schedule) and 82 more |
-| `Lane` *required* | `typeof Lane` | — | <br>Shown in: [The smallest schedule (Installation)](#installation), [A day of tours (First schedule)](#first-schedule), [Start from an empty plan (First schedule)](#first-schedule) and 82 more |
+| `Schedule` *required* | `(props: `[`ScheduleProps`](#first-schedule)`) => ReactNode` | — | The schedule. One per `useSchedule`: a second schedule is a second call.<br>Shown in: [The smallest schedule (Installation)](#installation), [A day of tours (First schedule)](#first-schedule), [Start from an empty plan (First schedule)](#first-schedule) and 87 more |
+| `Lane` *required* | `typeof Lane` | — | <br>Shown in: [The smallest schedule (Installation)](#installation), [A day of tours (First schedule)](#first-schedule), [Start from an empty plan (First schedule)](#first-schedule) and 87 more |
 | `LaneGroup` *required* | `typeof LaneGroup` | — | <br>Shown in: [Group lanes under a head (Lane groups)](#lane-groups), [Nest groups to any depth (Lane groups)](#lane-groups), [Fold groups from outside (Lane groups)](#lane-groups) and 5 more |
-| `Subtasks` *required* | `typeof Subtasks` | — | <br>Shown in: [The smallest schedule (Installation)](#installation), [A day of tours (First schedule)](#first-schedule), [Start from an empty plan (First schedule)](#first-schedule) and 82 more |
-| `Dependencies` *required* | `typeof Dependencies` | — | <br>Shown in: [The smallest schedule (Installation)](#installation), [A day of tours (First schedule)](#first-schedule), [Plan a day in the machine shop (First schedule)](#first-schedule) and 28 more |
+| `Subtasks` *required* | `typeof Subtasks` | — | <br>Shown in: [The smallest schedule (Installation)](#installation), [A day of tours (First schedule)](#first-schedule), [Start from an empty plan (First schedule)](#first-schedule) and 87 more |
+| `Dependencies` *required* | `typeof Dependencies` | — | <br>Shown in: [The smallest schedule (Installation)](#installation), [A day of tours (First schedule)](#first-schedule), [Plan a day in the machine shop (First schedule)](#first-schedule) and 30 more |
 | `BlockedTimes` *required* | `typeof BlockedTimes` | — | <br>Shown in: [Block out leave and maintenance (Blocked time)](#blocked-time), [Plan work around someone's leave (Blocked time)](#blocked-time), [Check a sprint against the leave calendar (Blocked time)](#blocked-time) and 5 more |
 | `Milestones` *required* | `typeof Milestones` | — | <br>Shown in: [Mark a handover and a release (Milestones)](#milestones), [Say what a milestone is in your own tooltip (Milestones)](#milestones) |
+| `DataTable` *required* | `typeof DataTable` | — | The plan as a table, on demand: placed inside the `Schedule`, it gives the schedule a "Show data" key beside the bottom time band, and the key opens a table of the subtasks in view - lane, task, subtask, from and to with their dates, duration and findings in words. For a reader who wants every value at once. It takes no props and renders nothing outside a `Schedule`.<br>Shown in: [Read the plan as a table (Tooltip)](#tooltip) |
 | `view` *required* | [`ScheduleView`](#view) | — | How the planner is looking at the plan: the span and the folded groups.<br>Shown in: [Fold groups from outside (Lane groups)](#lane-groups), [Keep and restore a view (View)](#view), [Keep two schedules in step (Linked schedules)](#linked-schedules) and 1 more |
 | `setView` *required* | `(view: `[`ScheduleView`](#view)`) => void` | — | Goes to a whole view; what it leaves out is shown whole again. Not reported through `onViewChange`: two schedules kept in step by `onViewChange: (v) => other.setView(v)` in both directions do not answer each other. A view with the content already shown changes nothing.<br>Shown in: [Keep and restore a view (View)](#view), [Keep two schedules in step (Linked schedules)](#linked-schedules), [Read a rota beside the incidents (Linked schedules)](#linked-schedules) |
-| `setDomain` *required* | `(span: readonly [number, number] \| null) => void` | — | Puts a span of two wall-clock instants in view; `null` shows the subtasks' extent.<br>Shown in: [Keep and restore a view (View)](#view) |
+| `setDomain` *required* | `(span: readonly [number, number] \| null) => void` | — | Puts a span of two wall-clock instants in view; `null` shows the subtasks' extent.<br>Shown in: [Zoom and fit with buttons (Pan and zoom)](#pan-and-zoom), [Keep and restore a view (View)](#view) |
 | `toggleGroup` *required* | `(id: string) => void` | — | Folds or unfolds one **Lane group**. |
 | `positionAt` *required* | `(clientX: number, clientY: number) => { time: number; lane: string \| null } \| null` | — | The time and the lane at a client point, or null outside the plot - and null while no schedule is mounted.<br>Shown in: [Place a mark of your own (Functions on the hook)](#functions-on-the-hook) |
 | `clientPointOf` *required* | `(time: number, lane?: string) => { x: number; y: number } \| null` | — | The client point of a time - on the middle of a lane where one is named - or null while the schedule is not on screen.<br>Shown in: [Place a mark of your own (Functions on the hook)](#functions-on-the-hook) |
-| `visibleDomain` *required* | `() => readonly [number, number]` | — | The visible span, as two wall-clock instants. |
-| `scrollToLane` *required* | `(lane: string) => boolean` | — | Scrolls the lanes until the lane's row is in view, and returns `true`; `false` and nothing changed for an unknown lane, one inside a folded **Lane group** (none is unfolded), or while no schedule is mounted. |
+| `visibleDomain` *required* | `() => readonly [number, number]` | — | The visible span, as two wall-clock instants.<br>Shown in: [Zoom and fit with buttons (Pan and zoom)](#pan-and-zoom) |
+| `scrollToLane` *required* | `(lane: string) => boolean` | — | Scrolls the lanes until the lane's row is in view, and returns `true`; `false` and nothing changed for an unknown lane, one inside a folded **Lane group** (none is unfolded), or while no schedule is mounted.<br>Shown in: [Highlight a lane (Lanes)](#lanes) |
 | `scrollToSubtask` *required* | `(id: string) => boolean` | — | Brings the subtask's lane and time into view, the span moving to it and keeping its width as `setDomain` would, and leaves the focus where it is; `false` and nothing changed in the cases of `scrollToLane`.<br>Shown in: [Show a finding (Functions on the hook)](#functions-on-the-hook) |
 | `focusSubtask` *required* | `(id: string) => boolean` | — | Does what `scrollToSubtask` does, then makes the subtask the **Active subtask** and moves the focus to the plot, where the live region reads it out as the arrow keys do; `false` and nothing changed in the cases of `scrollToLane`.<br>Shown in: [Show a finding (Functions on the hook)](#functions-on-the-hook) |
 | `foldAll` *required* | `() => void` | — | Folds every group.<br>Shown in: [Fold groups from outside (Lane groups)](#lane-groups) |
@@ -9183,7 +9582,7 @@ Stretch the main time at one or both of its edges.
 
 Its table stands on [Subtasks](#subtasks).
 
-Used on [Scenarios](#scenarios), [Installation](#installation), [First schedule](#first-schedule), [Lanes](#lanes), [Lane groups](#lane-groups), [Subtasks](#subtasks), [Bar labels](#bar-labels), [Appearances](#appearances), [Overlap](#overlap), [Dependencies](#dependencies), [Routes](#routes), [Time axis and calendar](#time-axis-and-calendar), [Blocked time](#blocked-time), [Milestones](#milestones), [Now line](#now-line), [Pan and zoom](#pan-and-zoom), [Selection](#selection), [Interactions](#interactions), [Tooltip](#tooltip), [View](#view), [Linked schedules](#linked-schedules), [Functions on the hook](#functions-on-the-hook), [Findings as data](#findings-as-data), [Move and lane](#move-and-lane), [Stretch, lead-in, lead-out](#stretch-lead-in-lead-out), [Snapping](#snapping), [Placing from outside](#placing-from-outside), [Where a subtask may go](#where-a-subtask-may-go), [Ripple](#ripple) and [Benchmark](#benchmark).
+Used on [Scenarios](#scenarios), [Installation](#installation), [First schedule](#first-schedule), [Lanes](#lanes), [Lane groups](#lane-groups), [Subtasks](#subtasks), [Bar labels](#bar-labels), [Appearances](#appearances), [Overlap](#overlap), [Dependencies](#dependencies), [Routes](#routes), [Time axis and calendar](#time-axis-and-calendar), [Blocked time](#blocked-time), [Milestones](#milestones), [Now line](#now-line), [Pan and zoom](#pan-and-zoom), [Selection](#selection), [Interactions](#interactions), [Tooltip](#tooltip), [View](#view), [Linked schedules](#linked-schedules), [Functions on the hook](#functions-on-the-hook), [Findings as data](#findings-as-data), [Move and lane](#move-and-lane), [Undo](#undo), [Stretch, lead-in, lead-out](#stretch-lead-in-lead-out), [Snapping](#snapping), [Placing from outside](#placing-from-outside), [Where a subtask may go](#where-a-subtask-may-go), [Ripple](#ripple) and [Benchmark](#benchmark).
 
 ##### `SubtaskAppearance`
 
@@ -9201,7 +9600,7 @@ Its table stands on [Subtasks](#subtasks).
 
 Its table stands on [Subtasks](#subtasks).
 
-Used on [Scenarios](#scenarios), [Installation](#installation), [First schedule](#first-schedule), [Lanes](#lanes), [Lane groups](#lane-groups), [Subtasks](#subtasks), [Bar labels](#bar-labels), [Appearances](#appearances), [Overlap](#overlap), [Dependencies](#dependencies), [Routes](#routes), [Time axis and calendar](#time-axis-and-calendar), [Blocked time](#blocked-time), [Milestones](#milestones), [Now line](#now-line), [Pan and zoom](#pan-and-zoom), [Selection](#selection), [Interactions](#interactions), [Tooltip](#tooltip), [View](#view), [Linked schedules](#linked-schedules), [Functions on the hook](#functions-on-the-hook), [Findings as data](#findings-as-data), [Move and lane](#move-and-lane), [Stretch, lead-in, lead-out](#stretch-lead-in-lead-out), [Snapping](#snapping), [Placing from outside](#placing-from-outside), [Where a subtask may go](#where-a-subtask-may-go), [Ripple](#ripple) and [Benchmark](#benchmark).
+Used on [Scenarios](#scenarios), [Installation](#installation), [First schedule](#first-schedule), [Lanes](#lanes), [Lane groups](#lane-groups), [Subtasks](#subtasks), [Bar labels](#bar-labels), [Appearances](#appearances), [Overlap](#overlap), [Dependencies](#dependencies), [Routes](#routes), [Time axis and calendar](#time-axis-and-calendar), [Blocked time](#blocked-time), [Milestones](#milestones), [Now line](#now-line), [Pan and zoom](#pan-and-zoom), [Selection](#selection), [Interactions](#interactions), [Tooltip](#tooltip), [View](#view), [Linked schedules](#linked-schedules), [Functions on the hook](#functions-on-the-hook), [Findings as data](#findings-as-data), [Move and lane](#move-and-lane), [Undo](#undo), [Stretch, lead-in, lead-out](#stretch-lead-in-lead-out), [Snapping](#snapping), [Placing from outside](#placing-from-outside), [Where a subtask may go](#where-a-subtask-may-go), [Ripple](#ripple) and [Benchmark](#benchmark).
 
 ##### `ViolatedDependency`