@umriss-ui/schedule 0.4.0 → 0.5.0

package/docs/llms-full.md

@@ -1,4 +1,4 @@
-# @umriss-ui/schedule 0.4.0
+# @umriss-ui/schedule 0.5.0
 
 > React Gantt-style schedule for data-dense applications - work on lanes over time, with dependencies, blocked time, findings and controlled editing.
 
@@ -22,7 +22,7 @@ Built from: First schedule, Blocked time, Now line, Move and lane, Findings as d
 ```tsx
 import { useState } from "react";
 import { Alert, Badge, Stack, Text } from "@umriss-ui/core";
-import { BlockedTimes, Lane, Schedule, Subtasks, applyIntent, findings } from "@umriss-ui/schedule";
+import { applyIntent, findings, useSchedule } from "@umriss-ui/schedule";
 import type { BlockedTime, Intent, Subtask, Task } from "@umriss-ui/schedule";
 
 /* Data from the operations world, written out here so the example runs on its own. */
@@ -108,6 +108,7 @@ const when = (instant: number) =>
   });
 
 export default function HandOver() {
+  const { Schedule, Lane, Subtasks, BlockedTimes } = useSchedule({ initialView: { domain: [day(16, 6), day(23, 12)] } });
   const [rota, setRota] = useState<readonly Subtask[]>(START);
 
   const onIntent = (intent: Intent) => {
@@ -133,7 +134,6 @@ export default function HandOver() {
       <div data-callout="2">
         <Schedule
           ariaLabel="On-call rota, 16 to 23 March"
-          initialDomain={[day(16, 6), day(23, 12)]}
           height={420}
           now={NOW}
           intents={["lane"]}
@@ -195,7 +195,7 @@ Built from: First schedule, Lane groups, Dependencies, Ripple, Badge, Button.
 ```tsx
 import { useState } from "react";
 import { Badge, Button, Stack, Text } from "@umriss-ui/core";
-import { Dependencies, Lane, LaneGroup, Schedule, Subtasks, applyIntent, ripple, shiftTask } from "@umriss-ui/schedule";
+import { applyIntent, ripple, shiftTask, useSchedule } from "@umriss-ui/schedule";
 import type { Dependency, Intent, Subtask, Task } from "@umriss-ui/schedule";
 
 /* Data from the logistics world, written out here so the example runs on its own. */
@@ -391,6 +391,7 @@ const plateOf = (vehicle: string) => VEHICLES.find((one) => one.id === vehicle)?
 const driverOf = (driver: string) => DRIVERS.find((one) => one.id === driver)?.name ?? driver;
 
 export default function TourPlan() {
+  const { Schedule, Lane, LaneGroup, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [tomorrow(5, 30), tomorrow(15)] } });
   const [plan, setPlan] = useState<readonly Subtask[]>(START);
 
   const apply = (intent: Intent) =>
@@ -418,7 +419,6 @@ export default function TourPlan() {
       <div data-callout="1">
         <Schedule
           ariaLabel="Tours of Wednesday, 18 March"
-          initialDomain={[tomorrow(5, 30), tomorrow(15)]}
           height={470}
           intents={["move"]}
           onIntent={apply}
@@ -479,7 +479,7 @@ Built from: First schedule, Lane groups, Blocked time, Time axis and calendar, W
 ```tsx
 import { useState } from "react";
 import { Alert, Badge, Stack, Text } from "@umriss-ui/core";
-import { BlockedTimes, Lane, LaneGroup, Schedule, Subtasks, applyIntent, findings } from "@umriss-ui/schedule";
+import { applyIntent, findings, useSchedule } from "@umriss-ui/schedule";
 import type { BlockedTime, Intent, Subtask } from "@umriss-ui/schedule";
 
 /* Data from the planning world, written out here so the example runs on its own. */
@@ -631,6 +631,7 @@ const teamOf = (person: string) => PEOPLE.find((one) => one.id === person)?.team
 const nameOf = (person: string) => PEOPLE.find((one) => one.id === person)?.name ?? person;
 
 export default function SprintAroundLeave() {
+  const { Schedule, Lane, LaneGroup, Subtasks, BlockedTimes } = useSchedule({ initialView: { domain: [SPRINT.from, SPRINT.to] } });
   const [work, setWork] = useState<readonly Subtask[]>(START);
 
   const onIntent = (intent: Intent) => {
@@ -652,7 +653,6 @@ export default function SprintAroundLeave() {
       <div data-callout="2">
         <Schedule
           ariaLabel="Sprint 14, work per person"
-          initialDomain={[SPRINT.from, SPRINT.to]}
           calendar={WORKING_DAYS}
           height={570}
           now={NOW}
@@ -716,7 +716,7 @@ Built from: First schedule, Dependencies, Move and lane, Stretch, lead-in, lead-
 ```tsx
 import { useState } from "react";
 import { Checkbox, ContextMenu, MenuItem, MenuSeparator, Stack, Text } from "@umriss-ui/core";
-import { Lane, Schedule, Subtasks, Dependencies, applyIntent, findings, ripple, shiftTask } from "@umriss-ui/schedule";
+import { applyIntent, findings, ripple, shiftTask, useSchedule } from "@umriss-ui/schedule";
 import type { Dependency, Intent, ScheduleInteraction, Subtask, Task } from "@umriss-ui/schedule";
 
 /* Data from the plant world, written out here so the example runs on its own. */
@@ -821,6 +821,7 @@ function applied(plan: Plan, intent: Intent, cascade: boolean): Plan {
 }
 
 export default function ReplanTheDay() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: DAY_OF_PLAN } });
   const [plan, setPlan] = useState<Plan>(START);
   const [cascade, setCascade] = useState(true);
   const [menu, setMenu] = useState<Menu | null>(null);
@@ -844,7 +845,6 @@ export default function ReplanTheDay() {
       <div data-callout="2">
         <Schedule
           ariaLabel="Plan of Tuesday, 17 March, in the planner's hands"
-          initialDomain={DAY_OF_PLAN}
           height={380}
           intents={["move", "lane", "stretch", "leadIn", "leadOut"]}
           onIntent={apply}
@@ -906,7 +906,7 @@ What an application installs and hands over before the first plan.
 Install the schedule with its two peers and hand it plain data: lanes, tasks, subtasks and dependencies. It draws them and reports what a planner wants to change.
 
 ```ts
-import { Schedule, Lane, Subtasks, Dependencies } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 ```
 
 ```sh
@@ -928,7 +928,7 @@ The schedule reports, the application decides. It draws the data it is given and
 Two people, one project, one dependency: lanes in JSX, the rest as plain arrays handed to `Subtasks` and `Dependencies`.
 
 ```tsx
-import { Dependencies, Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+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();
@@ -944,8 +944,9 @@ const subtasks: Subtask[] = [
 const dependencies: Dependency[] = [{ id: "handover", from: "design", to: "build", lag: min(15) }];
 
 export default function SmallestSchedule() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(8), at(16)] } });
   return (
-    <Schedule ariaLabel="Tuesday, design and build" initialDomain={[at(8), at(16)]} height={150}>
+    <Schedule ariaLabel="Tuesday, design and build" height={150}>
       <Lane id="noah" label="Noah Fischer" />
       <Lane id="arjun" label="Arjun Mehta" />
       <Dependencies data={dependencies} />
@@ -965,7 +966,6 @@ From `ScheduleProps` — the full table stands on [First schedule](#/schedule/ty
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| [`initialDomain`](#/schedule/ScheduleProps-initialDomain) *required* | `readonly [number, number]` | — | The time in view when the schedule mounts, as two wall-clock instants. Pan and zoom take it from there; a new pair of values puts it back. |
 | [`height`](#/schedule/ScheduleProps-height) | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's. |
 | [`children`](#/schedule/ScheduleProps-children) | `ReactNode` | — | `Lane`, `Dependencies` and `Subtasks`, in the order they are to stand and be drawn. |
 
@@ -1024,12 +1024,24 @@ From `Dependency` — the full table stands on [Dependencies](#/dependencies/typ
 | [`to`](#/dependencies/Dependency-to) *required* | `string` | — | The id of the subtask it arrives at. |
 | [`lag`](#/dependencies/Dependency-lag) *required* | `number` | — | The least time between the two anchors; zero where the successor may begin as soon as the predecessor ends. |
 
+From `ScheduleOptions` — the full table stands on [View](#/view/type-ScheduleOptions).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`initialView`](#/view/ScheduleOptions-initialView) | [`ScheduleView`](#/view/type-ScheduleView) | — | The view to start from, and to go to whenever one differing in content from the last is handed in - the same view again changes nothing, and what it leaves out is reset; one the schedule reported itself, handed back late, is its own state coming back and not gone to. The schedule remembers none: where a view is kept is the application's decision. |
+
+From `ScheduleView` — the full table stands on [View](#/view/type-ScheduleView).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`domain`](#/view/ScheduleView-domain) | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`. |
+
 ### First schedule
 
 Work on lanes over time, with a day band above and time ticks that follow the zoom (also called a Gantt chart, resource plan or timeline). Reach for it when a planner needs to see who or what is busy when, and what does not fit.
 
 ```ts
-import { Schedule, Lane, Subtasks, Dependencies } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/schedule/
@@ -1047,7 +1059,7 @@ The plot is one tab stop. The keys walk the subtasks as the pointer would hover
 Vehicles as lanes, tours as tasks: each leg is a subtask with loading as its lead-in, each handover a dependency with a transfer time.
 
 ```tsx
-import { Lane, Schedule, Subtasks, Dependencies } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task, Dependency } from "@umriss-ui/schedule";
 
 /* Two findings stand in this plan on purpose: two tours claim van FP 214 K at
@@ -1091,8 +1103,9 @@ const HANDOVERS: readonly Dependency[] = [
 ];
 
 export default function FirstSchedule() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: DAY } });
   return (
-    <Schedule ariaLabel="Tours of Tuesday, 17 March" initialDomain={DAY} height={240}>
+    <Schedule ariaLabel="Tours of Tuesday, 17 March" height={240}>
       {VEHICLES.map((vehicle) => (
         <Lane key={vehicle.id} id={vehicle.id} label={vehicle.label} />
       ))}
@@ -1108,7 +1121,7 @@ export default function FirstSchedule() {
 With nothing planned yet, `Subtasks` gets an empty array: the lanes and the time axis still stand, ready for the first drop.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task } from "@umriss-ui/schedule";
 
 const at = (day: number, hours: number) => new Date(2026, 2, day, hours).getTime();
@@ -1123,8 +1136,9 @@ const PEOPLE = [
 ];
 
 export default function NoWorkYet() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(23, 8), at(27, 18)] } });
   return (
-    <Schedule ariaLabel="Sprint 15, nothing planned yet" initialDomain={[at(23, 8), at(27, 18)]} height={170}>
+    <Schedule ariaLabel="Sprint 15, nothing planned yet" height={170}>
       {PEOPLE.map((person) => (
         <Lane key={person.id} id={person.id} label={person.label} />
       ))}
@@ -1139,7 +1153,7 @@ export default function NoWorkYet() {
 The full case: seven stations, six orders and their transports, the present marked and every order named in its bars.
 
 ```tsx
-import { Dependencies, Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Dependency, Subtask, Task } from "@umriss-ui/schedule";
 
 /* Data from the plant world, written out here so the example runs on its own. */
@@ -1216,10 +1230,10 @@ const NAMES = new Map(ORDERS.map((order) => [order.id, order.name ?? order.id]))
 const HALF_PAST_TEN = new Date(2026, 2, 17, 10, 30).getTime();
 
 export default function MachinePlan() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: DAY_OF_PLAN } });
   return (
     <Schedule
       ariaLabel="Machine shop, Tuesday 17 March"
-      initialDomain={DAY_OF_PLAN}
       height={380}
       now={HALF_PAST_TEN}
       label={(step) => NAMES.get(step.task) ?? step.task}
@@ -1264,8 +1278,7 @@ Under forced colours the plot paints itself in the system colours: the work in t
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| `initialDomain` *required* | `readonly [number, number]` | — | The time in view when the schedule mounts, as two wall-clock instants. Pan and zoom take it from there; a new pair of values puts it back.<br>Shown in: [A day of tours](#/schedule/first-schedule), [Start from an empty plan](#/schedule/no-work-yet), [Plan a day in the machine shop](#/schedule/machine-plan) and 74 more |
-| `height` | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's.<br>Shown in: [A day of tours](#/schedule/first-schedule), [Start from an empty plan](#/schedule/no-work-yet), [Plan a day in the machine shop](#/schedule/machine-plan) and 74 more |
+| `height` | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's.<br>Shown in: [A day of tours](#/schedule/first-schedule), [Start from an empty plan](#/schedule/no-work-yet), [Plan a day in the machine shop](#/schedule/machine-plan) and 75 more |
 | `laneHeight` | `number` | `44` | Height of one lane in pixels.<br>Shown in: [Scroll more lanes than fit (Lanes)](#/lane/many-lanes) |
 | `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)](#/lane/lane-headers), [Scroll more lanes than fit (Lanes)](#/lane/many-lanes), [Group lanes under a head (Lane groups)](#/lane-groups/a-group) and 1 more |
 | `calendar` | [`CalendarInput`](#type-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/working-calendar), [Plan in office hours only (Time axis and calendar)](#/time-axis/office-hours), [Plan the sprint around leave (Scenarios)](#/scenarios/plan-the-sprint-around-leave) |
@@ -1275,9 +1288,6 @@ Under forced colours the plot paints itself in the system colours: the work in t
 | `canMoveTo` | `(subtask: `[`Subtask`](#/subtasks/type-Subtask)`, 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-it-may-go/lanes-that-fit), [Apply the same rule to work dragged in (Where a subtask may go)](#/where-it-may-go/dragged-in), [Keep work out of someone's leave (Where a subtask may go)](#/where-it-may-go/around-leave) 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/control-the-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/control-the-selection) |
-| `defaultCollapsedGroups` | `readonly string[]` | — | Which groups are folded when the schedule mounts, where the schedule keeps the state itself. Ignored while `collapsedGroups` is given.<br>Shown in: [Start with groups folded (Lane groups)](#/lane-groups/start-with-groups-folded) |
-| `collapsedGroups` | `readonly string[]` | — | The **Lane group**s that are folded, controlled. Leave it out and the schedule keeps them itself, starting from `defaultCollapsedGroups`. Folding changes the view and not the plan, which is why it is no intent: a caller that applies every intent it receives must never find a fold among them ([ADR-0025](https://github.com/romanhaendler/umriss-ui/blob/main/docs/adr/0025-a-lane-group-is-structure-over-lanes-never-a-lane.md)). A folded outer group hides the inner ones without their entries leaving the list, so unfolding it gives back the view that was there.<br>Shown in: [Fold groups from outside (Lane groups)](#/lane-groups/controlled), [Read a folded group (Lane groups)](#/lane-groups/the-miniature) |
-| `onCollapsedGroupsChange` | `(groups: readonly string[]) => void` | — | Called with the whole list when the planner folds or unfolds a group.<br>Shown in: [Fold groups from outside (Lane groups)](#/lane-groups/controlled), [Read a folded group (Lane groups)](#/lane-groups/the-miniature) |
 | `placing` | [`PlacingItem`](#type-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/drag-from-the-backlog), [Apply the same rule to work dragged in (Where a subtask may go)](#/where-it-may-go/dragged-in) |
 | `route` | [`DependencyRoute`](#type-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/straight), [Orthogonal (Routes)](#/routes/orthogonal), [Per dependency (Routes)](#/routes/per-dependency) |
 | `attach` | [`DependencyAttachment`](#type-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/attach), [Mark the ends with a dot (Dependencies)](#/dependencies/ends), [Draw one handover its own way (Dependencies)](#/dependencies/one-handover-drawn-its-own-way) and 3 more |
@@ -1285,7 +1295,7 @@ Under forced colours the plot paints itself in the system colours: the work in t
 | `label` | `(subtask: `[`Subtask`](#/subtasks/type-Subtask)`) => 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](#/schedule/machine-plan), [Plan a sprint for a team (Subtasks)](#/subtasks/a-sprint), [Write into the bars (Bar labels)](#/bar-labels/bar-labels) and 7 more |
 | `tooltip` | `false \| ((target: `[`ScheduleTooltipTarget`](#/tooltip/type-ScheduleTooltipTarget)`) => 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: [Write your own tooltip content (Tooltip)](#/tooltip/own-tooltip), [Show a detail panel instead (Tooltip)](#/tooltip/detail-panel-instead), [Say what a bar covers and a line joins (Tooltip)](#/tooltip/say-what-a-bar-covers-and-a-line-joins) |
 | `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](#/schedule/machine-plan), [Mark the present (Now line)](#/now-line/now-line), [Follow the clock (Now line)](#/now-line/follow-the-clock) and 2 more |
-| `children` | `ReactNode` | — | `Lane`, `Dependencies` and `Subtasks`, in the order they are to stand and be drawn.<br>Shown in: [A day of tours](#/schedule/first-schedule), [Start from an empty plan](#/schedule/no-work-yet), [Plan a day in the machine shop](#/schedule/machine-plan) and 74 more |
+| `children` | `ReactNode` | — | `Lane`, `Dependencies` and `Subtasks`, in the order they are to stand and be drawn.<br>Shown in: [A day of tours](#/schedule/first-schedule), [Start from an empty plan](#/schedule/no-work-yet), [Plan a day in the machine shop](#/schedule/machine-plan) and 75 more |
 
 ###### Events
 
@@ -1293,13 +1303,12 @@ Under forced colours the plot paints itself in the system colours: the work in t
 |---|---|---|---|
 | `onIntent` | `(intent: `[`Intent`](#type-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/the-miniature), [Cut the nights out of the axis (Time axis and calendar)](#/time-axis/working-calendar), [Plan work around someone's leave (Blocked time)](#/blocked-time/drag-around) and 18 more |
 | `onInteraction` | `(interaction: `[`ScheduleInteraction`](#/interactions/type-ScheduleInteraction)`) => 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/report-the-pointer), [Open a context menu (Interactions)](#/interactions/open-a-context-menu), [Show a detail panel instead (Tooltip)](#/tooltip/detail-panel-instead) and 2 more |
-| `onDomainChange` | `(domain: readonly [number, number]) => void` | — | The visible time span after the planner panned or zoomed, as two wall-clock instants - for keeping a second schedule or a chart in step. A span handed in through `initialDomain` is not reported back.<br>Shown in: [Keep two schedules in step (Linked schedules)](#/linked-schedules/in-step), [Read a rota beside the incidents (Linked schedules)](#/linked-schedules/rota-beside-incidents), [Place a mark of your own (The handle)](#/handle/place-a-mark) |
 
 ###### Accessibility
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| `ariaLabel` *required* | `string` | — | What the schedule shows, for a screen reader: "Plan of week 38".<br>Shown in: [A day of tours](#/schedule/first-schedule), [Start from an empty plan](#/schedule/no-work-yet), [Plan a day in the machine shop](#/schedule/machine-plan) and 74 more |
+| `ariaLabel` *required* | `string` | — | What the schedule shows, for a screen reader: "Plan of week 38".<br>Shown in: [A day of tours](#/schedule/first-schedule), [Start from an empty plan](#/schedule/no-work-yet), [Plan a day in the machine shop](#/schedule/machine-plan) and 75 more |
 
 ###### Styling
 
@@ -1521,7 +1530,7 @@ What the schedule draws: work on lanes, and everything a bar says besides its co
 One row per person, vehicle or room, named by its header and kept in the order it is declared, however many there are (also called resources).
 
 ```ts
-import { Lane } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/lane/
@@ -1538,7 +1547,7 @@ A `label` is content, not a string: here the vehicle with its plate, and a badge
 
 ```tsx
 import { Badge, Stack, Text } from "@umriss-ui/core";
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task } from "@umriss-ui/schedule";
 
 const at = (hours: number) => new Date(2026, 2, 17, hours).getTime();
@@ -1551,8 +1560,9 @@ const LEGS: Subtask[] = [
 ];
 
 export default function LaneHeaders() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(6), at(12)] } });
   return (
-    <Schedule ariaLabel="Two vans of the North depot" initialDomain={[at(6), at(12)]} height={150} headerWidth={210}>
+    <Schedule ariaLabel="Two vans of the North depot" height={150} headerWidth={210}>
       <Lane
         id="v1"
         label={
@@ -1587,7 +1597,7 @@ export default function LaneHeaders() {
 Twenty vans in 300 pixels: the lanes scroll with their headers, while the time bands and the header column hold still.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task } from "@umriss-ui/schedule";
 
 /* `height` is the whole schedule, both bands included; `laneHeight` and
@@ -1613,10 +1623,10 @@ const ROUNDS: Subtask[] = VANS.map((van, i) => ({
 }));
 
 export default function ManyLanes() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(6), at(14)] } });
   return (
     <Schedule
       ariaLabel="Twenty vans, Tuesday morning"
-      initialDomain={[at(6), at(14)]}
       height={300}
       laneHeight={32}
       headerWidth={110}
@@ -1644,15 +1654,15 @@ The keys of [First schedule](#/schedule/keyboard-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](#/lane/lane-headers), [Scroll more lanes than fit](#/lane/many-lanes), [The smallest schedule (Installation)](#/installation/smallest-schedule) and 74 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](#/lane/lane-headers), [Scroll more lanes than fit](#/lane/many-lanes), [The smallest schedule (Installation)](#/installation/smallest-schedule) and 74 more |
+| `id` *required* | `string` | — | The identity subtasks name in their `lane`.<br>Shown in: [What a lane header says](#/lane/lane-headers), [Scroll more lanes than fit](#/lane/many-lanes), [The smallest schedule (Installation)](#/installation/smallest-schedule) and 75 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](#/lane/lane-headers), [Scroll more lanes than fit](#/lane/many-lanes), [The smallest schedule (Installation)](#/installation/smallest-schedule) and 75 more |
 
 ### Lane groups
 
 Teams, depots or regions over the lanes, to any depth, folded into one row when a planner wants only the part they work on.
 
 ```ts
-import { LaneGroup, Lane } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/lane-groups/
@@ -1661,7 +1671,7 @@ A group is structure, never a lane: nothing sits on it, no finding is reported f
 
 Folded, a group shows a miniature: every lane in it as a thin strip with its work in the tasks' colours. Dependencies still arrive at the right strip, findings are marked on the row, and a strip can be hovered and selected. Labels, appearances and grips need room and wait for the group to open.
 
-Folding is a view state and never an intent. `collapsedGroups` and `onCollapsedGroupsChange` hand it to the application; left out, the schedule keeps it.
+Folding is part of the schedule's view and never an intent: `folded` in `initialView` starts with groups folded, `toggleGroup`, `foldAll` and `unfoldAll` fold from outside, and `onViewChange` reports every fold - see [View](#/view).
 
 #### Examples
 
@@ -1670,7 +1680,7 @@ Folding is a view state and never an intent. `collapsedGroups` and `onCollapsedG
 Wrap lanes in a `LaneGroup`: a slim head names the team and counts its lanes, and its chevron folds it.
 
 ```tsx
-import { Lane, LaneGroup, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task } from "@umriss-ui/schedule";
 
 /* Declared by composition: a lane never names its group, so moving a person
@@ -1692,8 +1702,9 @@ const WORK: Subtask[] = [
 ];
 
 export default function AGroup() {
+  const { Schedule, Lane, LaneGroup, Subtasks } = useSchedule({ initialView: { domain: [at(6), at(15)] } });
   return (
-    <Schedule ariaLabel="Two developers in a team, a designer and a tester outside it" initialDomain={[at(6), at(15)]} height={240} headerWidth={200}>
+    <Schedule ariaLabel="Two developers in a team, a designer and a tester outside it" height={240} headerWidth={200}>
       <LaneGroup id="developers" label="Developers">
         <Lane id="arjun" label="Arjun Mehta" />
         <Lane id="chloe" label="Chloe Durand" />
@@ -1711,7 +1722,7 @@ export default function AGroup() {
 A depot holds a fleet of vans and a truck; an inner group keeps its fold while the outer one closes.
 
 ```tsx
-import { Lane, LaneGroup, Schedule, Subtasks } from "@umriss-ui/schedule";
+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();
@@ -1734,8 +1745,9 @@ const LEGS: Subtask[] = [
 ];
 
 export default function Nesting() {
+  const { Schedule, Lane, LaneGroup, Subtasks } = useSchedule({ initialView: { domain: [at(6), at(15)] } });
   return (
-    <Schedule ariaLabel="North depot with its vans and a truck, and a van from Riverside" initialDomain={[at(6), at(15)]} height={330} headerWidth={200}>
+    <Schedule ariaLabel="North depot with its vans and a truck, and a van from Riverside" height={330} headerWidth={200}>
       <LaneGroup id="north" label="North depot">
         <LaneGroup id="vans" label="Vans">
           <Lane id="fp-214" label={`Van ${plate("FP 214 K")}`} />
@@ -1753,17 +1765,15 @@ export default function Nesting() {
 
 ##### Fold groups from outside
 
-Pass `collapsedGroups` and `onCollapsedGroupsChange` to own the fold: store it with the planner's preferences, or fold two views together.
+`foldAll`, `unfoldAll` and `toggleGroup` fold from outside, and `view.folded` says what is folded - start from `initialView`, keep what `onViewChange` reports.
 
 ```tsx
-import { useState } from "react";
 import { Button, Stack, Text } from "@umriss-ui/core";
-import { Lane, LaneGroup, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task } from "@umriss-ui/schedule";
 
-/* The shape `selectedTask` has: left out, the schedule keeps the state
-   itself. A fold is not an intent - it says what is on screen, nothing about
-   the plan. */
+/* The fold is part of the schedule's view, not of the plan: no intent, and
+   nothing the application has to hold for the chevrons to work. */
 
 const at = (hours: number, minutes = 0) => new Date(2026, 2, 17, hours, minutes).getTime();
 
@@ -1776,28 +1786,21 @@ const WORK: Subtask[] = [
   { id: "s4", task: "release", lane: "leila", from: at(13), to: at(14, 30) },
 ];
 
-const ALL = ["payments", "discovery"];
-
-export default function Controlled() {
-  const [folded, setFolded] = useState<readonly string[]>(["discovery"]);
+export default function FoldFromOutside() {
+  const { Schedule, Lane, LaneGroup, Subtasks, view, foldAll, unfoldAll } = useSchedule({ initialView: { domain: [at(6), at(15)], folded: ["discovery"] } });
+  const folded = view.folded ?? [];
 
   return (
     <Stack gap={3}>
       <Stack direction="row" gap={2}>
-        <Button size="sm" variant="secondary" onClick={() => setFolded(ALL)} data-fold-all>
+        <Button size="sm" variant="secondary" onClick={foldAll} data-fold-all>
           Fold everything
         </Button>
-        <Button size="sm" variant="secondary" onClick={() => setFolded([])} data-unfold-all>
+        <Button size="sm" variant="secondary" onClick={unfoldAll} data-unfold-all>
           Unfold everything
         </Button>
       </Stack>
-      <Schedule
-        ariaLabel="Two teams rolling out a release, folded from outside"
-        initialDomain={[at(6), at(15)]}
-        height={280}
-        collapsedGroups={folded}
-        onCollapsedGroupsChange={setFolded}
-      >
+      <Schedule ariaLabel="Two teams rolling out a release, folded from outside" height={280}>
         <LaneGroup id="payments" label="Payments">
           <Lane id="priya" label="Priya Raman" />
           <Lane id="jonas" label="Jonas Keller" />
@@ -1822,12 +1825,12 @@ Folded, the depot shows each van as a thin strip: handovers still arrive, the do
 
 ```tsx
 import { useState } from "react";
-import { Lane, LaneGroup, Schedule, Subtasks, Dependencies, applyIntent, findings } from "@umriss-ui/schedule";
+import { applyIntent, findings, useSchedule } from "@umriss-ui/schedule";
 import { Stack, Text } from "@umriss-ui/core";
 import type { Subtask, Task, Dependency } from "@umriss-ui/schedule";
 
 /* A drag held over the folded depot opens it for the gesture and shuts it
-   again when the drag ends; the application's own list is never written to.
+   again when the drag ends; the schedule's view never learns of it.
    `findings()` is computed from the data, so the count below is the same
    folded or not. */
 
@@ -1862,7 +1865,7 @@ const HANDOVERS: Dependency[] = [
 const FOUND = findings(LEGS, HANDOVERS);
 
 export default function TheMiniature() {
-  const [folded, setFolded] = useState<readonly string[]>(["north"]);
+  const { Schedule, Lane, LaneGroup, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(6), at(16)], folded: ["north"] } });
   const [legs, setLegs] = useState<readonly Subtask[]>(LEGS);
   const [last, setLast] = useState("Hold a bar over the folded depot");
 
@@ -1870,10 +1873,7 @@ export default function TheMiniature() {
     <Stack gap={3}>
       <Schedule
         ariaLabel="A depot that folds into one row"
-        initialDomain={[at(6), at(16)]}
         height={240}
-        collapsedGroups={folded}
-        onCollapsedGroupsChange={setFolded}
         intents={["move", "lane"]}
         onIntent={(intent) => {
           if (intent.kind === "place") return;
@@ -1903,14 +1903,15 @@ export default function TheMiniature() {
 
 ##### Start with groups folded
 
-`defaultCollapsedGroups` folds groups when the schedule mounts and leaves the rest to the planner: Discovery starts folded, and its chevron opens it.
+`folded` in `initialView` folds groups when the schedule mounts and leaves the rest to the planner: Discovery starts folded, and its chevron opens it.
 
 ```tsx
-import { Lane, LaneGroup, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task } from "@umriss-ui/schedule";
 
-/* Uncontrolled: the schedule keeps the fold from here on. To store it or
-   steer it, pass `collapsedGroups` instead. */
+/* The schedule keeps the fold from here on. To store it, keep what
+   `onViewChange` reports; to steer it, use the setters `useSchedule` hands
+   back. */
 
 const at = (hours: number, minutes = 0) => new Date(2026, 2, 17, hours, minutes).getTime();
 
@@ -1924,13 +1925,9 @@ const WORK: Subtask[] = [
 ];
 
 export default function StartWithGroupsFolded() {
+  const { Schedule, Lane, LaneGroup, Subtasks } = useSchedule({ initialView: { domain: [at(6), at(15)], folded: ["discovery"] } });
   return (
-    <Schedule
-      ariaLabel="Two teams rolling out a release, Discovery folded at the start"
-      initialDomain={[at(6), at(15)]}
-      height={280}
-      defaultCollapsedGroups={["discovery"]}
-    >
+    <Schedule ariaLabel="Two teams rolling out a release, Discovery folded at the start" height={280}>
       <LaneGroup id="payments" label="Payments">
         <Lane id="priya" label="Priya Raman" />
         <Lane id="jonas" label="Jonas Keller" />
@@ -1960,9 +1957,9 @@ The keys of [First schedule](#/schedule/keyboard-schedule) apply here.
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| `id` *required* | `string` | — | The group's identity - what `collapsedGroups` names. It is never a lane: no subtask sits on it, no finding is reported for it, and no intent names it ([ADR-0025](https://github.com/romanhaendler/umriss-ui/blob/main/docs/adr/0025-a-lane-group-is-structure-over-lanes-never-a-lane.md)).<br>Shown in: [Group lanes under a head](#/lane-groups/a-group), [Nest groups to any depth](#/lane-groups/nesting), [Fold groups from outside](#/lane-groups/controlled) and 4 more |
-| `label` | `ReactNode` | `id` | What the group's header says - the team, the depot, the region. Real text, read by a screen reader.<br>Shown in: [Group lanes under a head](#/lane-groups/a-group), [Nest groups to any depth](#/lane-groups/nesting), [Fold groups from outside](#/lane-groups/controlled) and 4 more |
-| `children` | `ReactNode` | — | `Lane`s and further `LaneGroup`s, to any depth.<br>Shown in: [Group lanes under a head](#/lane-groups/a-group), [Nest groups to any depth](#/lane-groups/nesting), [Fold groups from outside](#/lane-groups/controlled) and 4 more |
+| `id` *required* | `string` | — | The group's identity - what the view's `folded` names. It is never a lane: no subtask sits on it, no finding is reported for it, and no intent names it ([ADR-0025](https://github.com/romanhaendler/umriss-ui/blob/main/docs/adr/0025-a-lane-group-is-structure-over-lanes-never-a-lane.md)).<br>Shown in: [Group lanes under a head](#/lane-groups/a-group), [Nest groups to any depth](#/lane-groups/nesting), [Fold groups from outside](#/lane-groups/fold-from-outside) and 5 more |
+| `label` | `ReactNode` | `id` | What the group's header says - the team, the depot, the region. Real text, read by a screen reader.<br>Shown in: [Group lanes under a head](#/lane-groups/a-group), [Nest groups to any depth](#/lane-groups/nesting), [Fold groups from outside](#/lane-groups/fold-from-outside) and 5 more |
+| `children` | `ReactNode` | — | `Lane`s and further `LaneGroup`s, to any depth.<br>Shown in: [Group lanes under a head](#/lane-groups/a-group), [Nest groups to any depth](#/lane-groups/nesting), [Fold groups from outside](#/lane-groups/fold-from-outside) and 5 more |
 
 #### Known limits
 
@@ -1975,7 +1972,7 @@ What umriss deliberately does not build, and why: [ADR-0032](https://romanhaendl
 The bars: a main time with an optional lead-in before it and lead-out after it, in the colour of the task they belong to (also called bookings or assignments).
 
 ```ts
-import { Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/subtasks/
@@ -1989,7 +1986,7 @@ Lead-in and lead-out are durations beside the main time, not times of their own:
 Loading before a round and unloading after it: `leadIn` and `leadOut` are durations beside the main time, drawn faint in the same colour.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+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();
@@ -2004,8 +2001,9 @@ const ROUNDS: Subtask[] = [
 ];
 
 export default function LeadInAndLeadOut() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(6), at(14, 30)] } });
   return (
-    <Schedule ariaLabel="Three rounds of one van" initialDomain={[at(6), at(14, 30)]} height={110}>
+    <Schedule ariaLabel="Three rounds of one van" height={110}>
       <Lane id="van" label="Van FP 214 K" />
       <Subtasks data={ROUNDS} tasks={TOURS} />
     </Schedule>
@@ -2018,7 +2016,7 @@ export default function LeadInAndLeadOut() {
 Every subtask of a task shares its `color`, and the meaning is yours: here the two projects due this week are in the danger colour.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task } from "@umriss-ui/schedule";
 
 /* A subtask whose task is missing from `tasks` is drawn muted: it is on the
@@ -2041,8 +2039,9 @@ const WORK: Subtask[] = [
 ];
 
 export default function TaskColours() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(16, 6), at(20, 20)] } });
   return (
-    <Schedule ariaLabel="Projects due this week among the rest" initialDomain={[at(16, 6), at(20, 20)]} height={150}>
+    <Schedule ariaLabel="Projects due this week among the rest" height={150}>
       <Lane id="chloe" label="Chloe Durand" />
       <Lane id="eva" label="Eva Novak" />
       <Subtasks data={WORK} tasks={PROJECTS} />
@@ -2056,7 +2055,7 @@ export default function TaskColours() {
 Work items straight from the team's tracker: the person is the lane, the project the task, and `name` is what the tooltip calls each one.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask } from "@umriss-ui/schedule";
 
 /* Data from the planning world, written out here so the example runs on its own. */
@@ -2146,8 +2145,9 @@ const SUBTASKS: Subtask[] = WORK.map((item): Subtask => ({
 const SPRINT_14: readonly [number, number] = [new Date(2026, 2, 9, 6).getTime(), new Date(2026, 2, 21).getTime()];
 
 export default function ASprint() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: SPRINT_14 } });
   return (
-    <Schedule ariaLabel="Sprint 14, 9 to 20 March" initialDomain={SPRINT_14} height={500} label={(s) => s.name ?? s.id}>
+    <Schedule ariaLabel="Sprint 14, 9 to 20 March" height={500} label={(s) => s.name ?? s.id}>
       {PEOPLE.map((person) => (
         <Lane key={person.id} id={person.id} label={person.name} />
       ))}
@@ -2167,20 +2167,20 @@ The keys of [First schedule](#/schedule/keyboard-schedule) apply here.
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| `data` *required* | `readonly `[`Subtask`](#type-Subtask)`[]` | — | The subtasks, as the caller holds them. The schedule never changes one.<br>Shown in: [Main time, lead-in and lead-out](#/subtasks/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [Plan a sprint for a team](#/subtasks/a-sprint) and 74 more |
-| `tasks` *required* | `readonly `[`Task`](#type-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/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [Plan a sprint for a team](#/subtasks/a-sprint) and 74 more |
+| `data` *required* | `readonly `[`Subtask`](#type-Subtask)`[]` | — | The subtasks, as the caller holds them. The schedule never changes one.<br>Shown in: [Main time, lead-in and lead-out](#/subtasks/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [Plan a sprint for a team](#/subtasks/a-sprint) and 75 more |
+| `tasks` *required* | `readonly `[`Task`](#type-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/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [Plan a sprint for a team](#/subtasks/a-sprint) and 75 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/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [Plan a sprint for a team](#/subtasks/a-sprint) and 71 more |
-| `task` *required* | `string` | — | The id of the task it belongs to.<br>Shown in: [Main time, lead-in and lead-out](#/subtasks/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [The smallest schedule (Installation)](#/installation/smallest-schedule) and 67 more |
-| `lane` *required* | `string` | — | The id of the lane it sits on.<br>Shown in: [Main time, lead-in and lead-out](#/subtasks/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [The smallest schedule (Installation)](#/installation/smallest-schedule) and 67 more |
-| `from` *required* | `number` | — | Start of the main time.<br>Shown in: [Main time, lead-in and lead-out](#/subtasks/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [The smallest schedule (Installation)](#/installation/smallest-schedule) and 67 more |
-| `to` *required* | `number` | — | End of the main time.<br>Shown in: [Main time, lead-in and lead-out](#/subtasks/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [The smallest schedule (Installation)](#/installation/smallest-schedule) and 67 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/lead-in-and-lead-out), [The smallest schedule (Installation)](#/installation/smallest-schedule), [A day of tours (First schedule)](#/schedule/first-schedule) and 24 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/lead-in-and-lead-out), [The smallest schedule (Installation)](#/installation/smallest-schedule), [A day of tours (First schedule)](#/schedule/first-schedule) and 21 more |
+| `id` *required* | `string` | — | The caller's identity of the subtask.<br>Shown in: [Main time, lead-in and lead-out](#/subtasks/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [Plan a sprint for a team](#/subtasks/a-sprint) and 72 more |
+| `task` *required* | `string` | — | The id of the task it belongs to.<br>Shown in: [Main time, lead-in and lead-out](#/subtasks/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [The smallest schedule (Installation)](#/installation/smallest-schedule) and 68 more |
+| `lane` *required* | `string` | — | The id of the lane it sits on.<br>Shown in: [Main time, lead-in and lead-out](#/subtasks/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [The smallest schedule (Installation)](#/installation/smallest-schedule) and 68 more |
+| `from` *required* | `number` | — | Start of the main time.<br>Shown in: [Main time, lead-in and lead-out](#/subtasks/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [The smallest schedule (Installation)](#/installation/smallest-schedule) and 68 more |
+| `to` *required* | `number` | — | End of the main time.<br>Shown in: [Main time, lead-in and lead-out](#/subtasks/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [The smallest schedule (Installation)](#/installation/smallest-schedule) and 68 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/lead-in-and-lead-out), [The smallest schedule (Installation)](#/installation/smallest-schedule), [A day of tours (First schedule)](#/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/lead-in-and-lead-out), [The smallest schedule (Installation)](#/installation/smallest-schedule), [A day of tours (First schedule)](#/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/a-sprint), [Write into the bars (Bar labels)](#/bar-labels/bar-labels), [Join the stops of a tour (Dependencies)](#/dependencies/stops-of-a-tour) and 25 more |
 | `appearance` | `readonly `[`SubtaskAppearance`](#type-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/a-sprint), [Provisional (Appearances)](#/appearances/provisional), [Fixed (Appearances)](#/appearances/fixed) and 3 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/progress), [Several at once (Appearances)](#/appearances/combinations) |
@@ -2189,9 +2189,9 @@ The keys of [First schedule](#/schedule/keyboard-schedule) apply here.
 
 | 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/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [The smallest schedule (Installation)](#/installation/smallest-schedule) and 66 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/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [The smallest schedule (Installation)](#/installation/smallest-schedule) and 66 more |
-| `name` | `string` | — | What the task is called, where the schedule names it.<br>Shown in: [Main time, lead-in and lead-out](#/subtasks/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [The smallest schedule (Installation)](#/installation/smallest-schedule) and 66 more |
+| `id` *required* | `string` | — | The caller's identity of the task.<br>Shown in: [Main time, lead-in and lead-out](#/subtasks/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [The smallest schedule (Installation)](#/installation/smallest-schedule) and 67 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/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [The smallest schedule (Installation)](#/installation/smallest-schedule) and 67 more |
+| `name` | `string` | — | What the task is called, where the schedule names it.<br>Shown in: [Main time, lead-in and lead-out](#/subtasks/lead-in-and-lead-out), [Colour by what the task means](#/subtasks/task-colours), [The smallest schedule (Installation)](#/installation/smallest-schedule) and 67 more |
 
 ##### Types on this page
 
@@ -2208,7 +2208,7 @@ type SubtaskAppearance = "provisional" | "fixed" | "muted" | "open";
 A line of text inside each bar: cut off where the bar is too narrow, left out where it would say nothing, and held at the view's edge while the bar runs on.
 
 ```ts
-import { Schedule } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/bar-labels/
@@ -2222,7 +2222,7 @@ The text lies on the main time, not on the lead-in. Its colour follows the bar:
 `label` returns the text for each bar: here the work item's name, cut where the bar is narrow and left out of the short reviews.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task } from "@umriss-ui/schedule";
 
 /* Pan into the afternoon: a bar that begins before the view keeps its text at
@@ -2253,10 +2253,10 @@ const WORK: readonly Subtask[] = [
 ];
 
 export default function BarLabels() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: DAY } });
   return (
     <Schedule
       ariaLabel="Tuesday, 17 March, with the work items written in"
-      initialDomain={DAY}
       height={196}
       label={(subtask) => subtask.name ?? subtask.id}
     >
@@ -2279,7 +2279,6 @@ From `ScheduleProps` — the full table stands on [First schedule](#/schedule/ty
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| [`initialDomain`](#/schedule/ScheduleProps-initialDomain) *required* | `readonly [number, number]` | — | The time in view when the schedule mounts, as two wall-clock instants. Pan and zoom take it from there; a new pair of values puts it back. |
 | [`height`](#/schedule/ScheduleProps-height) | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's. |
 | [`label`](#/schedule/ScheduleProps-label) | `(subtask: `[`Subtask`](#/subtasks/type-Subtask)`) => 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. |
 | [`children`](#/schedule/ScheduleProps-children) | `ReactNode` | — | `Lane`, `Dependencies` and `Subtasks`, in the order they are to stand and be drawn. |
@@ -2325,12 +2324,24 @@ From `Task` — the full table stands on [Subtasks](#/subtasks/type-Task).
 | [`color`](#/subtasks/Task-color) *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/Task-name) | `string` | — | What the task is called, where the schedule names it. |
 
+From `ScheduleOptions` — the full table stands on [View](#/view/type-ScheduleOptions).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`initialView`](#/view/ScheduleOptions-initialView) | [`ScheduleView`](#/view/type-ScheduleView) | — | The view to start from, and to go to whenever one differing in content from the last is handed in - the same view again changes nothing, and what it leaves out is reset; one the schedule reported itself, handed back late, is its own state coming back and not gone to. The schedule remembers none: where a view is kept is the application's decision. |
+
+From `ScheduleView` — the full table stands on [View](#/view/type-ScheduleView).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`domain`](#/view/ScheduleView-domain) | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`. |
+
 ### Appearances
 
 What a bar says besides its colour: provisional, fixed, muted, running on past the view, and how far the work has got. Each takes one channel of the drawing, so several on one bar stay readable.
 
 ```ts
-import { Subtasks, resolveAppearance } from "@umriss-ui/schedule";
+import { useSchedule, resolveAppearance } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/appearances/
@@ -2346,7 +2357,7 @@ Demo page: https://romanhaendler.github.io/umriss-ui/schedule/appearances/
 Work pencilled in but not agreed: `"provisional"` leaves the bar hollow with a dashed outline, never pale like a lead-in.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+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();
@@ -2360,8 +2371,9 @@ const WORK: Subtask[] = [
 ];
 
 export default function Provisional() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(6, 30), at(11)] } });
   return (
-    <Schedule ariaLabel="Agreed work above, provisional work below" initialDomain={[at(6, 30), at(11)]} height={144}>
+    <Schedule ariaLabel="Agreed work above, provisional work below" height={144}>
       <Lane id="released" label="Agreed, with lead-in" />
       <Lane id="draft" label="Provisional" />
       <Subtasks data={WORK} tasks={PROJECTS} />
@@ -2375,7 +2387,7 @@ export default function Provisional() {
 A delivery slot the customer booked may not move: `"fixed"` sets a cap inside each end and keeps the face clear for the label.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+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();
@@ -2388,10 +2400,10 @@ const LEGS: Subtask[] = [
 ];
 
 export default function Fixed() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(6, 30), at(11)] } });
   return (
     <Schedule
       ariaLabel="A round that may move above, a booked slot below"
-      initialDomain={[at(6, 30), at(11)]}
       height={144}
       label={(leg) => (leg.id === "nailed" ? "T-05 · booked slot" : "T-05")}
     >
@@ -2408,7 +2420,7 @@ export default function Fixed() {
 Another team's work, shown for context: `"muted"` mixes the colour into the surface at full height, so it cannot pass for a lead-in.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+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();
@@ -2422,10 +2434,10 @@ const WORK: Subtask[] = [
 ];
 
 export default function Muted() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(6, 30), at(11)] } });
   return (
     <Schedule
       ariaLabel="Our team's work above, another team's below"
-      initialDomain={[at(6, 30), at(11)]}
       height={144}
       label={() => "Checkout migration"}
     >
@@ -2442,7 +2454,7 @@ export default function Muted() {
 `progress` from 0 to 1 draws a rail inside the main time; left out, the bar claims nothing - which is not zero per cent.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+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();
@@ -2456,8 +2468,9 @@ const WORK: Subtask[] = [
 ];
 
 export default function Progress() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(6, 30), at(11)] } });
   return (
-    <Schedule ariaLabel="Work claiming nothing above, work at 65 per cent below" initialDomain={[at(6, 30), at(11)]} height={144}>
+    <Schedule ariaLabel="Work claiming nothing above, work at 65 per cent below" height={144}>
       <Lane id="unclaimed" label="Says nothing" />
       <Lane id="started" label="65 per cent done" />
       <Subtasks data={WORK} tasks={PROJECTS} />
@@ -2471,7 +2484,7 @@ export default function Progress() {
 An incident still being worked runs past the view: `"open"` fades the bar at whichever edge it passes, and only there.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task } from "@umriss-ui/schedule";
 
 /* The middle bar is wholly in view and carries no fade; zoom out until it
@@ -2488,8 +2501,9 @@ const WORK: Subtask[] = [
 ];
 
 export default function Open() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(6, 30), at(11)] } });
   return (
-    <Schedule ariaLabel="Work running past the view at either edge" initialDomain={[at(6, 30), at(11)]} height={188}>
+    <Schedule ariaLabel="Work running past the view at either edge" height={188}>
       <Lane id="runs-on" label="Runs on" />
       <Lane id="whole" label="Wholly in view" />
       <Lane id="began" label="Began before" />
@@ -2504,7 +2518,7 @@ export default function Open() {
 Muted, fixed and open on one bar stay three statements, each in its own channel; of `"provisional"` and `"fixed"` the later one wins.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task } from "@umriss-ui/schedule";
 
 /* A hollow bar lies on the surface, so its label takes the page's text
@@ -2552,10 +2566,10 @@ const LANES = [
 ];
 
 export default function Combinations() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(6, 30), at(11)] } });
   return (
     <Schedule
       ariaLabel="Bars carrying several appearances at once"
-      initialDomain={[at(6, 30), at(11)]}
       height={230}
       label={(leg) => NAMES[leg.id] ?? leg.id}
     >
@@ -2578,7 +2592,6 @@ From `ScheduleProps` — the full table stands on [First schedule](#/schedule/ty
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| [`initialDomain`](#/schedule/ScheduleProps-initialDomain) *required* | `readonly [number, number]` | — | The time in view when the schedule mounts, as two wall-clock instants. Pan and zoom take it from there; a new pair of values puts it back. |
 | [`height`](#/schedule/ScheduleProps-height) | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's. |
 | [`label`](#/schedule/ScheduleProps-label) | `(subtask: `[`Subtask`](#/subtasks/type-Subtask)`) => 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. |
 | [`children`](#/schedule/ScheduleProps-children) | `ReactNode` | — | `Lane`, `Dependencies` and `Subtasks`, in the order they are to stand and be drawn. |
@@ -2625,12 +2638,24 @@ From `Task` — the full table stands on [Subtasks](#/subtasks/type-Task).
 | [`color`](#/subtasks/Task-color) *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/Task-name) | `string` | — | What the task is called, where the schedule names it. |
 
+From `ScheduleOptions` — the full table stands on [View](#/view/type-ScheduleOptions).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`initialView`](#/view/ScheduleOptions-initialView) | [`ScheduleView`](#/view/type-ScheduleView) | — | The view to start from, and to go to whenever one differing in content from the last is handed in - the same view again changes nothing, and what it leaves out is reset; one the schedule reported itself, handed back late, is its own state coming back and not gone to. The schedule remembers none: where a view is kept is the application's decision. |
+
+From `ScheduleView` — the full table stands on [View](#/view/type-ScheduleView).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`domain`](#/view/ScheduleView-domain) | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`. |
+
 ### Overlap
 
 Two subtasks claiming one lane at the same time (also called a double booking or conflict): both drawn, offset and marked, never packed into sub-lanes.
 
 ```ts
-import { Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/overlap/
@@ -2644,7 +2669,7 @@ The later bar is offset a few pixels and edged, and the shared time is marked ac
 Both bars stay where their times put them: the later one is offset and edged, and the shared time is marked across the lane.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+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();
@@ -2661,8 +2686,9 @@ const WORK: Subtask[] = [
 ];
 
 export default function DoubleBooking() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(8), at(16)] } });
   return (
-    <Schedule ariaLabel="Kofi booked on two projects at once" initialDomain={[at(8), at(16)]} height={150}>
+    <Schedule ariaLabel="Kofi booked on two projects at once" height={150}>
       <Lane id="kofi" label="Kofi Mensah" />
       <Lane id="hana" label="Hana Sato" />
       <Subtasks data={WORK} tasks={PROJECTS} />
@@ -2676,7 +2702,7 @@ export default function DoubleBooking() {
 Unloading and the next loading occupy the vehicle too: where a `leadOut` runs into the next `leadIn`, that is an overlap.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+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();
@@ -2693,8 +2719,9 @@ const LEGS: Subtask[] = [
 ];
 
 export default function LeadOutMeetsLeadIn() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(6, 30), at(11, 30)] } });
   return (
-    <Schedule ariaLabel="Two rounds of one van, touching at unloading and loading" initialDomain={[at(6, 30), at(11, 30)]} height={110}>
+    <Schedule ariaLabel="Two rounds of one van, touching at unloading and loading" height={110}>
       <Lane id="fp-402" label="Van FP 402 R" />
       <Subtasks data={LEGS} tasks={TOURS} />
     </Schedule>
@@ -2707,7 +2734,7 @@ export default function LeadOutMeetsLeadIn() {
 Each further bar steps down a little, three levels deep at most, and every one stays inside its own lane.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+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();
@@ -2726,8 +2753,9 @@ const WORK: Subtask[] = [
 ];
 
 export default function ThreeAtOnce() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(7), at(14)] } });
   return (
-    <Schedule ariaLabel="Priya on three incidents at once" initialDomain={[at(7), at(14)]} height={150}>
+    <Schedule ariaLabel="Priya on three incidents at once" height={150}>
       <Lane id="priya" label="Priya Raman" />
       <Lane id="jonas" label="Jonas Keller" />
       <Subtasks data={WORK} tasks={INCIDENTS} />
@@ -2750,7 +2778,6 @@ From `ScheduleProps` — the full table stands on [First schedule](#/schedule/ty
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| [`initialDomain`](#/schedule/ScheduleProps-initialDomain) *required* | `readonly [number, number]` | — | The time in view when the schedule mounts, as two wall-clock instants. Pan and zoom take it from there; a new pair of values puts it back. |
 | [`height`](#/schedule/ScheduleProps-height) | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's. |
 | [`children`](#/schedule/ScheduleProps-children) | `ReactNode` | — | `Lane`, `Dependencies` and `Subtasks`, in the order they are to stand and be drawn. |
 
@@ -2794,6 +2821,18 @@ From `Task` — the full table stands on [Subtasks](#/subtasks/type-Task).
 | [`color`](#/subtasks/Task-color) *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/Task-name) | `string` | — | What the task is called, where the schedule names it. |
 
+From `ScheduleOptions` — the full table stands on [View](#/view/type-ScheduleOptions).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`initialView`](#/view/ScheduleOptions-initialView) | [`ScheduleView`](#/view/type-ScheduleView) | — | The view to start from, and to go to whenever one differing in content from the last is handed in - the same view again changes nothing, and what it leaves out is reset; one the schedule reported itself, handed back late, is its own state coming back and not gone to. The schedule remembers none: where a view is kept is the application's decision. |
+
+From `ScheduleView` — the full table stands on [View](#/view/type-ScheduleView).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`domain`](#/view/ScheduleView-domain) | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`. |
+
 #### Known limits
 
 - No stacked layout on request yet: an overlap is always drawn offset, as the finding it is.
@@ -2805,7 +2844,7 @@ What umriss deliberately does not build, and why: [ADR-0032](https://romanhaendl
 Lines from one subtask's end to the next one's start within a task, with the lag that must pass between them (also called links or predecessors). A lag that does not fit is marked, not repaired.
 
 ```ts
-import { Dependencies } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/dependencies/
@@ -2821,7 +2860,7 @@ Nothing moves to make a dependency fit. [Ripple](#/ripple) computes the moves th
 Each stop is a subtask, and the drive to the next is a dependency whose `lag` is the driving time.
 
 ```tsx
-import { Dependencies, Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+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();
@@ -2847,8 +2886,9 @@ const DRIVES: Dependency[] = [
 ];
 
 export default function StopsOfATour() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(7), at(10)] } });
   return (
-    <Schedule ariaLabel="Two morning tours with their stops" initialDomain={[at(7), at(10)]} height={150}>
+    <Schedule ariaLabel="Two morning tours with their stops" height={150}>
       <Lane id="fp-214" label="Van FP 214 K" />
       <Lane id="fp-377" label="E-van FP 377 K" />
       <Dependencies data={DRIVES} />
@@ -2863,7 +2903,7 @@ export default function StopsOfATour() {
 By default the lag runs from the end of unloading to the start of loading; `leaves` and `arrives` set to `"main"` skip both.
 
 ```tsx
-import { Lane, Schedule, Subtasks, Dependencies } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task, Dependency } from "@umriss-ui/schedule";
 
 /* The anchor decides whether the dependency is violated, so it should say
@@ -2890,8 +2930,9 @@ const HANDOVERS: Dependency[] = [
 ];
 
 export default function Anchors() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(6, 30), at(16, 30)] } });
   return (
-    <Schedule ariaLabel="Two handovers with different anchors" initialDomain={[at(6, 30), at(16, 30)]} height={150}>
+    <Schedule ariaLabel="Two handovers with different anchors" height={150}>
       <Lane id="truck" label="Truck FP 520 E" />
       <Lane id="van" label="Van FP 290 E" />
       <Dependencies data={HANDOVERS} />
@@ -2907,7 +2948,7 @@ export default function Anchors() {
 
 ```tsx
 import { Stack, Text } from "@umriss-ui/core";
-import { Lane, Schedule, Subtasks, Dependencies } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task, Dependency, DependencyAttachment } from "@umriss-ui/schedule";
 
 /* Picture only: `attach` changes no finding. Within one lane there is no
@@ -2933,12 +2974,13 @@ const HANDOVERS: Dependency[] = [
 ];
 
 function Variant({ attach }: { attach: DependencyAttachment }) {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(6, 30), at(13, 30)] } });
   return (
     <Stack gap={1}>
       <Text size="xs" tone="muted" mono>
         attach=&quot;{attach}&quot;
       </Text>
-      <Schedule ariaLabel={`A release through three engineers, lines from the ${attach}`} initialDomain={[at(6, 30), at(13, 30)]} height={188} attach={attach}>
+      <Schedule ariaLabel={`A release through three engineers, lines from the ${attach}`} height={188} attach={attach}>
         <Lane id="priya" label="Priya Raman" />
         <Lane id="ada" label="Ada Mwangi" />
         <Lane id="sam" label="Sam Okafor" />
@@ -2965,7 +3007,7 @@ export default function Attach() {
 
 ```tsx
 import { Stack, Text } from "@umriss-ui/core";
-import { Lane, Schedule, Subtasks, Dependencies } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task, Dependency, DependencyEnds } from "@umriss-ui/schedule";
 
 /* Picture only, like `route` and `attach`; a single dependency may say
@@ -2988,12 +3030,13 @@ const HANDOVERS: Dependency[] = [
 ];
 
 function Variant({ ends }: { ends: DependencyEnds }) {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(6, 30), at(11, 30)] } });
   return (
     <Stack gap={1}>
       <Text size="xs" tone="muted" mono>
         ends=&quot;{ends}&quot;
       </Text>
-      <Schedule ariaLabel={`Design, build and test, ends ${ends}`} initialDomain={[at(6, 30), at(11, 30)]} height={188} attach="nearest" ends={ends}>
+      <Schedule ariaLabel={`Design, build and test, ends ${ends}`} height={188} attach="nearest" ends={ends}>
         <Lane id="noah" label="Noah Fischer" />
         <Lane id="arjun" label="Arjun Mehta" />
         <Lane id="eva" label="Eva Novak" />
@@ -3019,7 +3062,7 @@ export default function Ends() {
 The transfer at the depot takes forty minutes and the plan leaves twenty-five: the line turns dashed in the finding colour, and nothing moves.
 
 ```tsx
-import { Lane, Schedule, Subtasks, Dependencies } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task, Dependency } from "@umriss-ui/schedule";
 
 /* Whether the van waits or the truck leaves earlier is the planner's
@@ -3038,8 +3081,9 @@ const LEGS: Subtask[] = [
 const HANDOVERS: Dependency[] = [{ id: "transfer", from: "line-haul", to: "round", lag: min(40) }];
 
 export default function ViolatedDependency() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(6, 30), at(11)] } });
   return (
-    <Schedule ariaLabel="A handover from the truck to the van that is too short" initialDomain={[at(6, 30), at(11)]} height={150}>
+    <Schedule ariaLabel="A handover from the truck to the van that is too short" height={150}>
       <Lane id="truck" label="Truck FP 118 R" />
       <Lane id="van" label="Van FP 214 K" />
       <Dependencies data={HANDOVERS} />
@@ -3054,7 +3098,7 @@ export default function ViolatedDependency() {
 A dependency's own `attach` and `ends` override the schedule's for that one line: here the sign-off joins the middles and marks its ends, the rest stay quiet.
 
 ```tsx
-import { Lane, Schedule, Subtasks, Dependencies } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task, Dependency } from "@umriss-ui/schedule";
 
 /* Picture only, like the schedule's own `attach` and `ends`: the finding
@@ -3080,8 +3124,9 @@ const HANDOVERS: Dependency[] = [
 ];
 
 export default function OneHandoverDrawnItsOwnWay() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(6, 30), at(12, 30)] } });
   return (
-    <Schedule ariaLabel="Design, build, test and a sign-off drawn its own way" initialDomain={[at(6, 30), at(12, 30)]} height={188} attach="nearest" ends="none">
+    <Schedule ariaLabel="Design, build, test and a sign-off drawn its own way" height={188} attach="nearest" ends="none">
       <Lane id="noah" label="Noah Fischer" />
       <Lane id="arjun" label="Arjun Mehta" />
       <Lane id="eva" label="Eva Novak" />
@@ -3173,7 +3218,7 @@ What umriss deliberately does not build, and why: [ADR-0032](https://romanhaendl
 The shape of a dependency's line: a curve that leaves and arrives forwards, a straight line, or orthogonal segments. Set it for the schedule, or for one dependency.
 
 ```ts
-import { Dependencies } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/routes/
@@ -3185,7 +3230,7 @@ Demo page: https://romanhaendler.github.io/umriss-ui/schedule/routes/
 The default: each line leaves forwards and arrives forwards, so it shows which way the work goes, even when it loops back up.
 
 ```tsx
-import { Dependencies, Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+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();
@@ -3207,8 +3252,9 @@ const HANDOVERS: Dependency[] = [
 ];
 
 export default function Curve() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(6, 30), at(13, 30)] } });
   return (
-    <Schedule ariaLabel="Search results, from layout to polish, curved lines" initialDomain={[at(6, 30), at(13, 30)]} height={188}>
+    <Schedule ariaLabel="Search results, from layout to polish, curved lines" height={188}>
       <Lane id="noah" label="Noah Fischer" />
       <Lane id="chloe" label="Chloe Durand" />
       <Lane id="eva" label="Eva Novak" />
@@ -3224,7 +3270,7 @@ export default function Curve() {
 `route="straight"` draws the shortest line between the two ends, calm in a plan read from a distance.
 
 ```tsx
-import { Dependencies, Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+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();
@@ -3246,8 +3292,9 @@ const HANDOVERS: Dependency[] = [
 ];
 
 export default function Straight() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(6, 30), at(13, 30)] } });
   return (
-    <Schedule ariaLabel="Search results, from layout to polish, straight lines" initialDomain={[at(6, 30), at(13, 30)]} height={188} route="straight" attach="nearest">
+    <Schedule ariaLabel="Search results, from layout to polish, straight lines" height={188} route="straight" attach="nearest">
       <Lane id="noah" label="Noah Fischer" />
       <Lane id="chloe" label="Chloe Durand" />
       <Lane id="eva" label="Eva Novak" />
@@ -3263,7 +3310,7 @@ export default function Straight() {
 `route="orthogonal"` leaves the bar, runs across and comes in again, like a flow chart.
 
 ```tsx
-import { Dependencies, Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+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();
@@ -3285,8 +3332,9 @@ const HANDOVERS: Dependency[] = [
 ];
 
 export default function Orthogonal() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(6, 30), at(13, 30)] } });
   return (
-    <Schedule ariaLabel="Search results, from layout to polish, orthogonal lines" initialDomain={[at(6, 30), at(13, 30)]} height={188} route="orthogonal" attach="nearest">
+    <Schedule ariaLabel="Search results, from layout to polish, orthogonal lines" height={188} route="orthogonal" attach="nearest">
       <Lane id="noah" label="Noah Fischer" />
       <Lane id="chloe" label="Chloe Durand" />
       <Lane id="eva" label="Eva Novak" />
@@ -3302,7 +3350,7 @@ export default function Orthogonal() {
 A `route` on a single dependency overrides the schedule's: here only the loop back up to the designer is drawn orthogonal.
 
 ```tsx
-import { Dependencies, Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+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();
@@ -3325,8 +3373,9 @@ const HANDOVERS: Dependency[] = [
 ];
 
 export default function PerDependency() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(6, 30), at(13, 30)] } });
   return (
-    <Schedule ariaLabel="Search results, from layout to polish, straight lines but one" initialDomain={[at(6, 30), at(13, 30)]} height={188} route="straight" attach="nearest">
+    <Schedule ariaLabel="Search results, from layout to polish, straight lines but one" height={188} route="straight" attach="nearest">
       <Lane id="noah" label="Noah Fischer" />
       <Lane id="chloe" label="Chloe Durand" />
       <Lane id="eva" label="Eva Novak" />
@@ -3347,7 +3396,6 @@ From `ScheduleProps` — the full table stands on [First schedule](#/schedule/ty
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| [`initialDomain`](#/schedule/ScheduleProps-initialDomain) *required* | `readonly [number, number]` | — | The time in view when the schedule mounts, as two wall-clock instants. Pan and zoom take it from there; a new pair of values puts it back. |
 | [`height`](#/schedule/ScheduleProps-height) | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's. |
 | [`route`](#/schedule/ScheduleProps-route) | [`DependencyRoute`](#/schedule/type-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. |
 | [`attach`](#/schedule/ScheduleProps-attach) | [`DependencyAttachment`](#/schedule/type-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. |
@@ -3408,6 +3456,18 @@ From `Dependency` — the full table stands on [Dependencies](#/dependencies/typ
 | [`lag`](#/dependencies/Dependency-lag) *required* | `number` | — | The least time between the two anchors; zero where the successor may begin as soon as the predecessor ends. |
 | [`route`](#/dependencies/Dependency-route) | [`DependencyRoute`](#/dependencies/type-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. |
 
+From `ScheduleOptions` — the full table stands on [View](#/view/type-ScheduleOptions).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`initialView`](#/view/ScheduleOptions-initialView) | [`ScheduleView`](#/view/type-ScheduleView) | — | The view to start from, and to go to whenever one differing in content from the last is handed in - the same view again changes nothing, and what it leaves out is reset; one the schedule reported itself, handed back late, is its own state coming back and not gone to. The schedule remembers none: where a view is kept is the application's decision. |
+
+From `ScheduleView` — the full table stands on [View](#/view/type-ScheduleView).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`domain`](#/view/ScheduleView-domain) | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`. |
+
 ## Time
 
 The axis the work stands on: the calendar, blocked time, the now line, and moving through it.
@@ -3417,7 +3477,7 @@ The axis the work stands on: the calendar, blocked time, the now line, and movin
 A day band that names the days and a time band whose ticks follow the zoom, from quarter hours to days. A working calendar cuts the hours nobody works out of the axis.
 
 ```ts
-import { Schedule } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/time-axis/
@@ -3431,7 +3491,7 @@ The calendar is a list of intervals in which time counts, nothing more; deriving
 A week of the on-call rota: the day band names each day, and the time band's step follows the zoom.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task } from "@umriss-ui/schedule";
 
 /* Data from the operations world, written out here so the example runs on its own. */
@@ -3486,8 +3546,9 @@ const DUTIES: Subtask[] = ONCALL.map((duty) => ({ id: duty.id, task: duty.rotati
 const WEEK: readonly [number, number] = [new Date(2026, 2, 16).getTime(), new Date(2026, 2, 23, 12).getTime()];
 
 export default function AWeek() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: WEEK } });
   return (
-    <Schedule ariaLabel="On-call rota, 16 to 23 March" initialDomain={WEEK} height={420}>
+    <Schedule ariaLabel="On-call rota, 16 to 23 March" height={420}>
       {ENGINEERS.map((engineer) => (
         <Lane key={engineer.id} id={engineer.id} label={engineer.name} />
       ))}
@@ -3503,7 +3564,7 @@ The depot works 06:00 to 22:00: `calendar` lists those hours, the nights leave t
 
 ```tsx
 import { useState } from "react";
-import { Lane, Schedule, Subtasks, Dependencies, applyIntent } from "@umriss-ui/schedule";
+import { applyIntent, useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task, Dependency } from "@umriss-ui/schedule";
 
 /* Three days in the width of two; a dotted line marks each seam. Deriving the
@@ -3527,11 +3588,11 @@ const HANDOVERS: Dependency[] = [
 ];
 
 export default function WorkingCalendar() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(0, 6), at(2, 22)] } });
   const [legs, setLegs] = useState<readonly Subtask[]>(LEGS);
   return (
     <Schedule
       ariaLabel="Three days at East Gate depot, nights removed"
-      initialDomain={[at(0, 6), at(2, 22)]}
       calendar={OPENING_HOURS}
       height={220}
       intents={["move"]}
@@ -3552,7 +3613,7 @@ export default function WorkingCalendar() {
 Weekdays 09:00 to 17:00 as the `calendar`: a two-week sprint reads as ten working days, with the evenings and the weekend gone.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 
 /* Data from the planning world, written out here so the example runs on its own. */
 
@@ -3639,10 +3700,10 @@ const WEB_TEAM = PEOPLE.filter((person) => person.team === "Web");
 const ON_THE_WEB_TEAM = new Set(WEB_TEAM.map((person) => person.id));
 
 export default function OfficeHours() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(9, 9), at(20, 17)] } });
   return (
     <Schedule
       ariaLabel="Sprint 14 of the web team, office hours only"
-      initialDomain={[at(9, 9), at(20, 17)]}
       calendar={OFFICE_HOURS}
       height={280}
       label={(item) => item.name ?? item.id}
@@ -3670,7 +3731,6 @@ From `ScheduleProps` — the full table stands on [First schedule](#/schedule/ty
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| [`initialDomain`](#/schedule/ScheduleProps-initialDomain) *required* | `readonly [number, number]` | — | The time in view when the schedule mounts, as two wall-clock instants. Pan and zoom take it from there; a new pair of values puts it back. |
 | [`height`](#/schedule/ScheduleProps-height) | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's. |
 | [`calendar`](#/schedule/ScheduleProps-calendar) | [`CalendarInput`](#/schedule/type-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. |
 | [`intents`](#/schedule/ScheduleProps-intents) | `readonly `[`IntentKind`](#/schedule/type-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)). |
@@ -3739,12 +3799,24 @@ From `Dependency` — the full table stands on [Dependencies](#/dependencies/typ
 | [`to`](#/dependencies/Dependency-to) *required* | `string` | — | The id of the subtask it arrives at. |
 | [`lag`](#/dependencies/Dependency-lag) *required* | `number` | — | The least time between the two anchors; zero where the successor may begin as soon as the predecessor ends. |
 
+From `ScheduleOptions` — the full table stands on [View](#/view/type-ScheduleOptions).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`initialView`](#/view/ScheduleOptions-initialView) | [`ScheduleView`](#/view/type-ScheduleView) | — | The view to start from, and to go to whenever one differing in content from the last is handed in - the same view again changes nothing, and what it leaves out is reset; one the schedule reported itself, handed back late, is its own state coming back and not gone to. The schedule remembers none: where a view is kept is the application's decision. |
+
+From `ScheduleView` — the full table stands on [View](#/view/type-ScheduleView).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`domain`](#/view/ScheduleView-domain) | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`. |
+
 ### Blocked time
 
 Leave, maintenance and other time a lane is not available: hatched behind the work, a finding where work covers it, and closed to a drag.
 
 ```ts
-import { BlockedTimes, findings } from "@umriss-ui/schedule";
+import { useSchedule, findings } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/blocked-time/
@@ -3761,7 +3833,7 @@ A person on leave, a server in maintenance: `BlockedTimes` hatches that time on
 
 ```tsx
 import { Stack, Text } from "@umriss-ui/core";
-import { BlockedTimes, Lane, Schedule, Subtasks, findings } from "@umriss-ui/schedule";
+import { findings, useSchedule } from "@umriss-ui/schedule";
 import type { BlockedTime, Subtask, Task } from "@umriss-ui/schedule";
 
 /* Blocked time is data beside the work: one list, each interval naming its
@@ -3805,11 +3877,12 @@ const time = (instant: number) =>
   new Date(instant).toLocaleString("en-GB", { weekday: "short", hour: "2-digit", minute: "2-digit" });
 
 export default function Leave() {
+  const { Schedule, Lane, Subtasks, BlockedTimes } = useSchedule({ initialView: { domain: [day(0, 6), day(5, 0)] } });
   const found = findings(WORK, [], BLOCKED);
 
   return (
     <Stack gap={3}>
-      <Schedule ariaLabel="Team plan, week of 16 March" initialDomain={[day(0, 6), day(5, 0)]} height={240}>
+      <Schedule ariaLabel="Team plan, week of 16 March" height={240}>
         {PEOPLE.map((person) => (
           <Lane key={person.id} id={person.id} label={person.label} />
         ))}
@@ -3837,7 +3910,7 @@ A drag does not put work into blocked time: the ghost stays where it was allowed
 ```tsx
 import { useState } from "react";
 import { Stack, Text } from "@umriss-ui/core";
-import { BlockedTimes, Lane, Schedule, Subtasks, applyIntent } from "@umriss-ui/schedule";
+import { applyIntent, useSchedule } from "@umriss-ui/schedule";
 import type { BlockedTime, Intent, Subtask, Task } from "@umriss-ui/schedule";
 
 /* Blocked time is part of where a subtask may go. Drag the review towards
@@ -3862,6 +3935,7 @@ const START: readonly Subtask[] = [
 const BLOCKED: readonly BlockedTime[] = [{ id: "anna-leave", lane: "anna", from: day(2, 0), to: day(4, 0), label: "Leave" }];
 
 export default function DragAround() {
+  const { Schedule, Lane, Subtasks, BlockedTimes } = useSchedule({ initialView: { domain: [day(0, 6), day(5, 0)] } });
   const [work, setWork] = useState<readonly Subtask[]>(START);
   const [last, setLast] = useState("Drag the design review into Anna's leave");
 
@@ -3875,7 +3949,6 @@ export default function DragAround() {
     <Stack gap={3}>
       <Schedule
         ariaLabel="Two people, one on leave"
-        initialDomain={[day(0, 6), day(5, 0)]}
         height={150}
         intents={["move", "lane"]}
         onIntent={onIntent}
@@ -3899,7 +3972,7 @@ The team's holidays, sick days and training become `BlockedTimes`, and [`finding
 
 ```tsx
 import { Stack, Text } from "@umriss-ui/core";
-import { BlockedTimes, Lane, Schedule, Subtasks, findings } from "@umriss-ui/schedule";
+import { findings, useSchedule } from "@umriss-ui/schedule";
 import type { BlockedTime } from "@umriss-ui/schedule";
 
 /* Data from the planning world, written out here so the example runs on its own. */
@@ -4006,10 +4079,11 @@ const NAME = new Map(WORK.map((item) => [item.id, item.name]));
 const PERSON = new Map(PEOPLE.map((person) => [person.id, person.name]));
 
 export default function TeamLeave() {
+  const { Schedule, Lane, Subtasks, BlockedTimes } = useSchedule({ initialView: { domain: SPRINT_14 } });
   const clashes = findings(WORK, [], BLOCKED).inBlockedTime;
   return (
     <Stack gap={3}>
-      <Schedule ariaLabel="Sprint 14 with the team's leave" initialDomain={SPRINT_14} height={500}>
+      <Schedule ariaLabel="Sprint 14 with the team's leave" height={500}>
         {PEOPLE.map((person) => (
           <Lane key={person.id} id={person.id} label={person.name} />
         ))}
@@ -4057,7 +4131,7 @@ The keys of [First schedule](#/schedule/keyboard-schedule) apply here.
 A line across the lanes at the present moment, so that whatever should have happened by now stands to its left. It follows the clock, or stays at a fixed instant for a replay.
 
 ```ts
-import { Schedule } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/now-line/
@@ -4069,7 +4143,7 @@ Demo page: https://romanhaendler.github.io/umriss-ui/schedule/now-line/
 Pass an instant to `now` and a line crosses the lanes there: a dispatcher at 10:30 sees which tours are under way.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task } from "@umriss-ui/schedule";
 
 /* Data from the logistics world, written out here so the example runs on its own. */
@@ -4216,8 +4290,9 @@ const ROUNDS: Subtask[] = TOURS.map((tour) => ({
 }));
 
 export default function NowLine() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(5, 30), at(18)] } });
   return (
-    <Schedule ariaLabel="Today's tours, with the present" initialDomain={[at(5, 30), at(18)]} height={420} now={NOW}>
+    <Schedule ariaLabel="Today's tours, with the present" height={420} now={NOW}>
       {VEHICLES.map((vehicle) => (
         <Lane key={vehicle.id} id={vehicle.id} label={vehicle.plate} />
       ))}
@@ -4232,7 +4307,7 @@ export default function NowLine() {
 `now` on its own reads the clock and moves on by the minute, so a plan left open on a wall screen stays true.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task } from "@umriss-ui/schedule";
 
 const HOUR = 60 * 60_000;
@@ -4255,8 +4330,9 @@ const DUTIES: Subtask[] = [
 ];
 
 export default function FollowTheClock() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [current - 6 * HOUR, current + 6 * HOUR] } });
   return (
-    <Schedule ariaLabel="Today's on-call rota, with the present" initialDomain={[current - 6 * HOUR, current + 6 * HOUR]} height={188} now>
+    <Schedule ariaLabel="Today's on-call rota, with the present" height={188} now>
       <Lane id="ada" label="Ada Mwangi" />
       <Lane id="tomasz" label="Tomasz Nowak" />
       <Lane id="leila" label="Leila Haddad" />
@@ -4276,7 +4352,6 @@ From `ScheduleProps` — the full table stands on [First schedule](#/schedule/ty
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| [`initialDomain`](#/schedule/ScheduleProps-initialDomain) *required* | `readonly [number, number]` | — | The time in view when the schedule mounts, as two wall-clock instants. Pan and zoom take it from there; a new pair of values puts it back. |
 | [`height`](#/schedule/ScheduleProps-height) | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's. |
 | [`now`](#/schedule/ScheduleProps-now) | `boolean \| number` | `false` | A line marking the present across the lanes: `true` follows the clock by the minute, an instant fixes it there. |
 | [`children`](#/schedule/ScheduleProps-children) | `ReactNode` | — | `Lane`, `Dependencies` and `Subtasks`, in the order they are to stand and be drawn. |
@@ -4320,19 +4395,31 @@ From `Task` — the full table stands on [Subtasks](#/subtasks/type-Task).
 | [`color`](#/subtasks/Task-color) *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/Task-name) | `string` | — | What the task is called, where the schedule names it. |
 
+From `ScheduleOptions` — the full table stands on [View](#/view/type-ScheduleOptions).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`initialView`](#/view/ScheduleOptions-initialView) | [`ScheduleView`](#/view/type-ScheduleView) | — | The view to start from, and to go to whenever one differing in content from the last is handed in - the same view again changes nothing, and what it leaves out is reset; one the schedule reported itself, handed back late, is its own state coming back and not gone to. The schedule remembers none: where a view is kept is the application's decision. |
+
+From `ScheduleView` — the full table stands on [View](#/view/type-ScheduleView).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`domain`](#/view/ScheduleView-domain) | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`. |
+
 ### Pan and zoom
 
 Moving through a plan with the gestures of any scrolling surface: drag, wheel, Ctrl with the wheel, and a pinch. Only the view moves; the plan stays as it is.
 
 ```ts
-import { Schedule } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/pan-and-zoom/
 
 Dragging the background pans through time and through the lanes. The wheel scrolls the lanes and hands the scroll back to the page at their end; Shift with the wheel pans through time; Ctrl or ⌘ with the wheel, or a pinch, zooms around the pointer.
 
-Nothing is reported and no intent is raised: pan and zoom change the visible span and nothing else ([ADR-0001](https://github.com/romanhaendler/umriss-ui/blob/main/docs/adr/0001-affine-scale-contract.md)). `onDomainChange` reports the span for a second view to follow - see [Linked schedules](#/linked-schedules).
+No intent is raised: pan and zoom change the visible span and nothing else ([ADR-0001](https://github.com/romanhaendler/umriss-ui/blob/main/docs/adr/0001-affine-scale-contract.md)). The span is part of the schedule's view, which `onViewChange` reports at most once per frame - see [View](#/view) and [Linked schedules](#/linked-schedules).
 
 #### Examples
 
@@ -4341,7 +4428,7 @@ Nothing is reported and no intent is raised: pan and zoom change the visible spa
 Drag, wheel, Ctrl with the wheel and a pinch need nothing switched on; `zoomLimits` only bounds the span, here two hours to two days.
 
 ```tsx
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task } from "@umriss-ui/schedule";
 
 /* Without `zoomLimits` the span may run from an hour to twenty-eight days. */
@@ -4369,10 +4456,10 @@ const WORK: Subtask[] = [
 ];
 
 export default function PanAndZoom() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(5, 30), at(18)] } });
   return (
     <Schedule
       ariaLabel="A plan to pan and zoom"
-      initialDomain={[at(5, 30), at(18)]}
       height={196}
       zoomLimits={{ min: 2 * HOUR, max: 48 * HOUR }}
     >
@@ -4400,7 +4487,6 @@ From `ScheduleProps` — the full table stands on [First schedule](#/schedule/ty
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| [`initialDomain`](#/schedule/ScheduleProps-initialDomain) *required* | `readonly [number, number]` | — | The time in view when the schedule mounts, as two wall-clock instants. Pan and zoom take it from there; a new pair of values puts it back. |
 | [`height`](#/schedule/ScheduleProps-height) | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's. |
 | [`zoomLimits`](#/schedule/ScheduleProps-zoomLimits) | [`ZoomLimits`](#/schedule/type-ZoomLimits) | one hour to 28 days | The narrowest and widest time span zoom may reach, in milliseconds. |
 | [`children`](#/schedule/ScheduleProps-children) | `ReactNode` | — | `Lane`, `Dependencies` and `Subtasks`, in the order they are to stand and be drawn. |
@@ -4445,6 +4531,18 @@ From `Task` — the full table stands on [Subtasks](#/subtasks/type-Task).
 | [`color`](#/subtasks/Task-color) *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/Task-name) | `string` | — | What the task is called, where the schedule names it. |
 
+From `ScheduleOptions` — the full table stands on [View](#/view/type-ScheduleOptions).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`initialView`](#/view/ScheduleOptions-initialView) | [`ScheduleView`](#/view/type-ScheduleView) | — | The view to start from, and to go to whenever one differing in content from the last is handed in - the same view again changes nothing, and what it leaves out is reset; one the schedule reported itself, handed back late, is its own state coming back and not gone to. The schedule remembers none: where a view is kept is the application's decision. |
+
+From `ScheduleView` — the full table stands on [View](#/view/type-ScheduleView).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`domain`](#/view/ScheduleView-domain) | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`. |
+
 ## Reading
 
 What a planner takes out of the picture: what is selected, what the pointer is on, and what a second view makes of it.
@@ -4454,7 +4552,7 @@ What a planner takes out of the picture: what is selected, what the pointer is o
 A click on a bar selects its whole task on every lane, so a planner sees every part of one job at once (also called highlighting). Reach for it when a list or a detail panel beside the plan should follow what was picked.
 
 ```ts
-import { Schedule } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/selection/
@@ -4472,7 +4570,7 @@ The selection also steps the rest back, so a planner sees at once what they are
 Click a leg and the whole consignment is outlined on every vehicle: the leg you clicked in full colour, its other legs halfway to grey, all other work grey. Click the empty plot to clear it.
 
 ```tsx
-import { Dependencies, Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+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();
@@ -4497,8 +4595,9 @@ const TRANSFERS: readonly Dependency[] = [
 ];
 
 export default function SelectATask() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(5, 30), at(13, 30)] } });
   return (
-    <Schedule ariaLabel="Two consignments at North depot" initialDomain={[at(5, 30), at(13, 30)]} height={140}>
+    <Schedule ariaLabel="Two consignments at North depot" height={140}>
       <Lane id="truck-118" label="Truck FP 118 R" />
       <Lane id="van-214" label="Van FP 214 K" />
       <Dependencies data={TRANSFERS} />
@@ -4515,7 +4614,7 @@ Hold `selectedTask` in your state to show the selection elsewhere; `onSelectedTa
 ```tsx
 import { useState } from "react";
 import { Stack, Text } from "@umriss-ui/core";
-import { Dependencies, Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+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();
@@ -4554,6 +4653,7 @@ const TRANSFERS: readonly Dependency[] = [
 ];
 
 export default function ControlTheSelection() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: DAY } });
   const [selected, setSelected] = useState<string | null>("c-2043");
   const [leg, setLeg] = useState<string | null>(null);
   const consignment = CONSIGNMENTS.find((c) => c.id === selected);
@@ -4562,7 +4662,6 @@ export default function ControlTheSelection() {
     <Stack gap={3}>
       <Schedule
         ariaLabel="Legs at North depot on Tuesday, 17 March"
-        initialDomain={DAY}
         height={284}
         selectedTask={selected}
         onSelectedTaskChange={(task, subtask) => {
@@ -4607,7 +4706,6 @@ From `ScheduleProps` — the full table stands on [First schedule](#/schedule/ty
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| [`initialDomain`](#/schedule/ScheduleProps-initialDomain) *required* | `readonly [number, number]` | — | The time in view when the schedule mounts, as two wall-clock instants. Pan and zoom take it from there; a new pair of values puts it back. |
 | [`height`](#/schedule/ScheduleProps-height) | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's. |
 | [`selectedTask`](#/schedule/ScheduleProps-selectedTask) | `string \| null` | — | The selected task, controlled. Leave it out and the schedule keeps the selection itself. |
 | [`onSelectedTaskChange`](#/schedule/ScheduleProps-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. |
@@ -4668,6 +4766,18 @@ From `Dependency` — the full table stands on [Dependencies](#/dependencies/typ
 | [`to`](#/dependencies/Dependency-to) *required* | `string` | — | The id of the subtask it arrives at. |
 | [`lag`](#/dependencies/Dependency-lag) *required* | `number` | — | The least time between the two anchors; zero where the successor may begin as soon as the predecessor ends. |
 
+From `ScheduleOptions` — the full table stands on [View](#/view/type-ScheduleOptions).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`initialView`](#/view/ScheduleOptions-initialView) | [`ScheduleView`](#/view/type-ScheduleView) | — | The view to start from, and to go to whenever one differing in content from the last is handed in - the same view again changes nothing, and what it leaves out is reset; one the schedule reported itself, handed back late, is its own state coming back and not gone to. The schedule remembers none: where a view is kept is the application's decision. |
+
+From `ScheduleView` — the full table stands on [View](#/view/type-ScheduleView).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`domain`](#/view/ScheduleView-domain) | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`. |
+
 #### Known limits
 
 - One task at a time: there is no multiple selection.
@@ -4679,7 +4789,7 @@ What umriss deliberately does not build, and why: [ADR-0032](https://romanhaendl
 Reports what the pointer does on the plan - hover, click, right-click - with what it hit and the time and lane under it. Reach for it to open a menu, fill a detail panel or write a status line.
 
 ```ts
-import { Schedule } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/interactions/
@@ -4697,7 +4807,7 @@ While `onInteraction` is set, a right-click opens no browser menu: your applicat
 ```tsx
 import { useState } from "react";
 import { Stack, Text } from "@umriss-ui/core";
-import { Dependencies, Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Dependency, ScheduleInteraction, Subtask, Task } from "@umriss-ui/schedule";
 
 const at = (hours: number, minutes = 0) => new Date(2026, 2, 17, hours, minutes).getTime();
@@ -4730,13 +4840,13 @@ const describe = (interaction: ScheduleInteraction): string => {
 };
 
 export default function ReportThePointer() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(5, 30), at(18)] } });
   const [last, setLast] = useState("Move the pointer over the plan");
 
   return (
     <Stack gap={3}>
       <Schedule
         ariaLabel="One consignment on a truck and a van"
-        initialDomain={[at(5, 30), at(18)]}
         height={152}
         onInteraction={(interaction) => setLast(describe(interaction))}
       >
@@ -4760,7 +4870,7 @@ On a `contextmenu` interaction, open `ContextMenu` from @umriss-ui/core at `clie
 ```tsx
 import { useState } from "react";
 import { ContextMenu, MenuItem } from "@umriss-ui/core";
-import { Lane, Schedule, Subtasks, applyIntent } from "@umriss-ui/schedule";
+import { applyIntent, useSchedule } from "@umriss-ui/schedule";
 import type { ScheduleInteraction, Subtask, Task } from "@umriss-ui/schedule";
 
 /* Data from the operations world, written out here so the example runs on its own. */
@@ -4823,6 +4933,7 @@ const START: readonly Subtask[] = ONCALL.map((duty) => ({
 }));
 
 export default function OpenAContextMenu() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [day(16, 6), day(23, 12)] } });
   const [rota, setRota] = useState<readonly Subtask[]>(START);
   const [menu, setMenu] = useState<{ interaction: ScheduleInteraction; duty: Subtask } | null>(null);
 
@@ -4836,7 +4947,6 @@ export default function OpenAContextMenu() {
     <>
       <Schedule
         ariaLabel="On-call rota, 16 to 23 March"
-        initialDomain={[day(16, 6), day(23, 12)]}
         height={420}
         onInteraction={onInteraction}
       >
@@ -4912,7 +5022,7 @@ type ScheduleHit =
 Names what the pointer rests on - a subtask with its times and findings, a dependency with its lag - without a click (also called a hover card). Replace its content when your application knows more than the schedule.
 
 ```ts
-import { Schedule } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/tooltip/
@@ -4928,7 +5038,7 @@ The keyboard's active subtask shows the same tooltip as the pointer.
 Rest the pointer on a leg: the tooltip names the consignment, its times, loading and unloading, and every finding on it.
 
 ```tsx
-import { Dependencies, Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+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();
@@ -4960,8 +5070,9 @@ const TRANSFERS: readonly Dependency[] = [
 ];
 
 export default function DefaultTooltip() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(5, 30), at(18)] } });
   return (
-    <Schedule ariaLabel="Three vehicles with the default tooltip" initialDomain={[at(5, 30), at(18)]} height={196}>
+    <Schedule ariaLabel="Three vehicles with the default tooltip" height={196}>
       {VEHICLES.map((vehicle) => (
         <Lane key={vehicle.id} id={vehicle.id} label={vehicle.label} />
       ))}
@@ -4978,7 +5089,7 @@ Pass `tooltip` a function to show what only your application knows - here the lo
 
 ```tsx
 import { Badge, Stack, Text } from "@umriss-ui/core";
-import { Dependencies, Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { Dependency, ScheduleTooltipTarget, Subtask, Task } from "@umriss-ui/schedule";
 
 const at = (hours: number, minutes = 0) => new Date(2026, 2, 17, hours, minutes).getTime();
@@ -5030,10 +5141,10 @@ function LoadTooltip({ target }: { target: ScheduleTooltipTarget }) {
 }
 
 export default function OwnTooltip() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(5, 30), at(18)] } });
   return (
     <Schedule
       ariaLabel="Three vehicles with the load in the tooltip"
-      initialDomain={[at(5, 30), at(18)]}
       height={196}
       tooltip={(target) => <LoadTooltip target={target} />}
     >
@@ -5054,7 +5165,7 @@ Set `tooltip={false}` when a panel of your own shows the item under the pointer,
 ```tsx
 import { useState } from "react";
 import { Badge, Card, CardBody, Stack, Text } from "@umriss-ui/core";
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { ScheduleInteraction } from "@umriss-ui/schedule";
 
 /* Data from the planning world, written out here so the example runs on its own. */
@@ -5141,6 +5252,7 @@ const WEB = PEOPLE.filter((person) => person.team === "Web");
 const WEB_WORK = WORK.filter((item) => WEB.some((person) => person.id === item.lane));
 
 export default function DetailPanelInstead() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [day(9), day(21)] } });
   const [item, setItem] = useState<WorkItem | null>(null);
 
   const onInteraction = (interaction: ScheduleInteraction) => {
@@ -5153,7 +5265,6 @@ export default function DetailPanelInstead() {
     <Stack gap={3}>
       <Schedule
         ariaLabel="Sprint 14 of the web team"
-        initialDomain={[day(9), day(21)]}
         height={260}
         tooltip={false}
         onInteraction={onInteraction}
@@ -5196,7 +5307,7 @@ The target says what is hovered: a bar brings its `subtask` and the `blocked` ti
 
 ```tsx
 import { Stack, Text } from "@umriss-ui/core";
-import { BlockedTimes, Dependencies, Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { BlockedTime, Dependency, ScheduleTooltipTarget, Subtask, Task } from "@umriss-ui/schedule";
 
 const at = (hours: number, minutes = 0) => new Date(2026, 2, 17, hours, minutes).getTime();
@@ -5250,8 +5361,9 @@ function Covers({ target }: { target: ScheduleTooltipTarget }) {
 }
 
 export default function SayWhatABarCoversAndALineJoins() {
+  const { Schedule, Lane, Subtasks, Dependencies, BlockedTimes } = useSchedule({ initialView: { domain: [at(6, 30), at(15, 30)] } });
   return (
-    <Schedule ariaLabel="Design, build and test, with leave under the build" initialDomain={[at(6, 30), at(15, 30)]} height={188} tooltip={(target) => <Covers target={target} />}>
+    <Schedule ariaLabel="Design, build and test, with leave under the build" height={188} tooltip={(target) => <Covers target={target} />}>
       <Lane id="noah" label="Noah Fischer" />
       <Lane id="arjun" label="Arjun Mehta" />
       <Lane id="eva" label="Eva Novak" />
@@ -5284,17 +5396,163 @@ The keys of [First schedule](#/schedule/keyboard-schedule) apply here.
 | `to` | [`Subtask`](#/subtasks/type-Subtask)` \| undefined` | — | The subtask it reaches.<br>Shown in: [Say what a bar covers and a line joins](#/tooltip/say-what-a-bar-covers-and-a-line-joins) |
 | `violated` | [`ViolatedDependency`](#/findings/type-ViolatedDependency)` \| undefined` | — | Its finding, where it is violated.<br>Shown in: [Write your own tooltip content](#/tooltip/own-tooltip) |
 
+### View
+
+How the planner is looking at the plan - the span in view and the folded lane groups - as one value to keep and hand back.
+
+```ts
+import { useSchedule } from "@umriss-ui/schedule";
+```
+
+Demo page: https://romanhaendler.github.io/umriss-ui/schedule/view/
+
+The schedule keeps its view itself and puts it nowhere, not in the address and not in any storage. `view` on what [`useSchedule`](#/api/useSchedule) hands back holds it, and `onViewChange` reports every change of it - a pan or zoom at most once per frame; keep it where the application keeps things and hand it back through `initialView`.
+
+A view that differs in content from the last one handed in applies at once, and what it leaves out goes back to its default; the same one again changes nothing. Without a span the schedule shows the extent of its subtasks, within `zoomLimits`. A group no `LaneGroup` declares falls out.
+
+`setDomain`, `toggleGroup`, `foldAll` and `unfoldAll` change the view from outside - a button of the application's own that shows the whole plan or folds every team. The selection is not part of the view (`selectedTask`).
+
+#### Examples
+
+##### Keep and restore a view
+
+`onViewChange` reports the span and the folded groups as one view; keep it - here in the browser's storage, so it outlives a reload - and hand it back through `initialView`. Pan, zoom, fold, keep, reload, restore.
+
+```tsx
+import { useState } from "react";
+import { Button, Stack, Text } from "@umriss-ui/core";
+import { useSchedule } from "@umriss-ui/schedule";
+import type { ScheduleView, 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 START: ScheduleView = { domain: [at(6), at(16)] };
+const KEPT = "umriss-schedule-demo-view";
+
+/* Storage can be missing or refuse - a private window, a blocked site. The
+   view is then simply not kept. */
+function readKept(): ScheduleView | null {
+  try {
+    const stored = localStorage.getItem(KEPT);
+    return stored === null ? null : (JSON.parse(stored) as ScheduleView);
+  } catch {
+    return null;
+  }
+}
+
+function keep(view: ScheduleView): void {
+  try {
+    localStorage.setItem(KEPT, JSON.stringify(view));
+  } catch {
+    /* Not kept; the schedule works on regardless. */
+  }
+}
+
+const TEAMS: Task[] = [
+  { id: "portal", name: "Member portal", color: "light-dark(#7c3aed, #a98bfa)" },
+  { id: "billing", name: "Billing run", color: "light-dark(#0d9488, #3cc7b8)" },
+];
+
+const WORK: Subtask[] = [
+  { id: "p1", task: "portal", lane: "noah", from: at(7), to: at(9, 30), leadOut: min(15) },
+  { id: "p2", task: "portal", lane: "arjun", from: at(10), to: at(13), leadIn: min(30) },
+  { id: "b1", task: "billing", lane: "mei", from: at(8), to: at(11) },
+  { id: "b2", task: "billing", lane: "lukas", from: at(11, 30), to: at(14, 30), leadIn: min(15) },
+];
+
+export default function KeepAndRestore() {
+  /* The application holds the view the schedule reports; handing it another
+     one is all it takes to restore. */
+  const [view, setView] = useState<ScheduleView>(START);
+  const [kept, setKept] = useState<ScheduleView | null>(readKept);
+  const { Schedule, Lane, LaneGroup, Subtasks, setDomain } = useSchedule({ initialView: view, onViewChange: setView });
+
+  return (
+    <Stack gap={3}>
+      <Schedule ariaLabel="Two teams on Tuesday, 17 March" height={290}>
+        <LaneGroup id="product" label="Product">
+          <Lane id="noah" label="Noah Fischer" />
+          <Lane id="arjun" label="Arjun Mehta" />
+        </LaneGroup>
+        <LaneGroup id="finance" label="Finance">
+          <Lane id="mei" label="Mei Tanaka" />
+          <Lane id="lukas" label="Lukas Brandt" />
+        </LaneGroup>
+        <Subtasks data={WORK} tasks={TEAMS} />
+      </Schedule>
+      <Stack gap={1}>
+        <Text as="span" size="sm" tone="secondary">
+          What the application would keep
+        </Text>
+        {/* JSON has no space to break at: without this it ran past a phone's card. */}
+        <Text as="code" size="sm" mono data-role="view" style={{ overflowWrap: "anywhere" }}>
+          {JSON.stringify(view)}
+        </Text>
+      </Stack>
+      <Stack direction="row" gap={2} wrap>
+        <Button
+          size="sm"
+          onClick={() => {
+            keep(view);
+            setKept(view);
+          }}
+          data-keep
+        >
+          Keep this view
+        </Button>
+        <Button size="sm" variant="ghost" disabled={kept === null} onClick={() => kept && setView(kept)} data-restore>
+          Restore the kept view
+        </Button>
+        <Button size="sm" variant="ghost" onClick={() => setDomain(null)} data-whole-plan>
+          Show the whole plan
+        </Button>
+      </Stack>
+    </Stack>
+  );
+}
+```
+
+#### When to use something else
+
+- Two schedules on the same hours → Linked schedules
+
+#### Keyboard
+
+The keys of [First schedule](#/schedule/keyboard-schedule) apply here.
+
+#### API
+
+##### `ScheduleOptions`
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| `initialView` | [`ScheduleView`](#type-ScheduleView) | — | The view to start from, and to go to whenever one differing in content from the last is handed in - the same view again changes nothing, and what it leaves out is reset; one the schedule reported itself, handed back late, is its own state coming back and not gone to. The schedule remembers none: where a view is kept is the application's decision.<br>Shown in: [Keep and restore a view](#/view/keep-and-restore), [The smallest schedule (Installation)](#/installation/smallest-schedule), [A day of tours (First schedule)](#/schedule/first-schedule) and 75 more |
+
+###### Events
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| `onViewChange` | `(view: `[`ScheduleView`](#type-ScheduleView)`) => void` | — | Every change of the view, once, always the whole view - the one to keep, or to hand another schedule as its `initialView`. A pan or zoom is reported at most once per frame. Not called for the view the schedule starts with.<br>Shown in: [Keep and restore a view](#/view/keep-and-restore), [Keep two schedules in step (Linked schedules)](#/linked-schedules/in-step), [Read a rota beside the incidents (Linked schedules)](#/linked-schedules/rota-beside-incidents) |
+
+##### `ScheduleView`
+
+| 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/keep-and-restore), [The smallest schedule (Installation)](#/installation/smallest-schedule), [A day of tours (First schedule)](#/schedule/first-schedule) and 75 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/fold-from-outside), [Read a folded group (Lane groups)](#/lane-groups/the-miniature), [Start with groups folded (Lane groups)](#/lane-groups/start-with-groups-folded) |
+
 ### Linked schedules
 
 Keeps two schedules on the same hours: pan or zoom one and the other follows (also called synchronised views). Reach for it when two sets of lanes stand apart on a screen but belong to the same time.
 
 ```ts
-import { Schedule } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/linked-schedules/
 
-`onDomainChange` reports the visible span after a pan or zoom, at most once per frame. A span handed in as `initialDomain` is not reported back, so two schedules never feed each other.
+Each schedule has its own [`useSchedule`](#/api/useSchedule). Hand both the view one of them reports, through `initialView`: a view that differs from the last one handed in applies at once, without a remount, and the same one again changes nothing, so the two never feed each other.
 
 While a drag is in flight the two can stand a frame apart; they settle as soon as it ends.
 
@@ -5302,13 +5560,13 @@ While a drag is in flight the two can stand a frame apart; they settle as soon a
 
 ##### Keep two schedules in step
 
-Hand the span `onDomainChange` reports to both schedules' `initialDomain`: pan or zoom either one and the other follows.
+Hand the view `onViewChange` reports to both schedules' `initialView`: pan or zoom either one and the other follows - no `key`, no remount.
 
 ```tsx
 import { useState } from "react";
 import { Stack, Text } from "@umriss-ui/core";
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
-import type { Subtask, Task } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
+import type { ScheduleView, 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;
@@ -5343,27 +5601,34 @@ const LEGS: readonly Subtask[] = [
 ];
 
 const on = (lanes: readonly { id: string }[]) => LEGS.filter((leg) => lanes.some((lane) => lane.id === leg.lane));
+const DIESEL_LEGS = on(DIESEL);
+const ELECTRIC_LEGS = on(ELECTRIC);
 
 const time = (instant: number) => new Date(instant).toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" });
 
 export default function InStep() {
-  const [domain, setDomain] = useState<readonly [number, number]>([at(5, 30), at(18)]);
+  /* One view for both: each schedule reports its own, and goes to the other's
+     because it differs from the last one handed in. */
+  const [view, setView] = useState<ScheduleView>({ domain: [at(5, 30), at(18)] });
+  const diesel = useSchedule({ initialView: view, onViewChange: setView });
+  const electric = useSchedule({ initialView: view, onViewChange: setView });
+  const span = view.domain ?? [at(5, 30), at(18)];
   return (
     <Stack gap={2}>
-      <Schedule ariaLabel="Diesel vehicles on Tuesday, 17 March" initialDomain={domain} height={240} onDomainChange={setDomain}>
+      <diesel.Schedule ariaLabel="Diesel vehicles on Tuesday, 17 March" height={240}>
         {DIESEL.map((vehicle) => (
-          <Lane key={vehicle.id} id={vehicle.id} label={vehicle.label} />
+          <diesel.Lane key={vehicle.id} id={vehicle.id} label={vehicle.label} />
         ))}
-        <Subtasks data={on(DIESEL)} tasks={CONSIGNMENTS} />
-      </Schedule>
-      <Schedule ariaLabel="Electric vans, the same hours" initialDomain={domain} height={152} onDomainChange={setDomain}>
+        <diesel.Subtasks data={DIESEL_LEGS} tasks={CONSIGNMENTS} />
+      </diesel.Schedule>
+      <electric.Schedule ariaLabel="Electric vans, the same hours" height={152}>
         {ELECTRIC.map((vehicle) => (
-          <Lane key={vehicle.id} id={vehicle.id} label={vehicle.label} />
+          <electric.Lane key={vehicle.id} id={vehicle.id} label={vehicle.label} />
         ))}
-        <Subtasks data={on(ELECTRIC)} tasks={CONSIGNMENTS} />
-      </Schedule>
+        <electric.Subtasks data={ELECTRIC_LEGS} tasks={CONSIGNMENTS} />
+      </electric.Schedule>
       <Text size="xs" mono tone="muted" data-span>
-        {time(domain[0])} – {time(domain[1])}
+        {time(span[0])} – {time(span[1])}
       </Text>
     </Stack>
   );
@@ -5377,8 +5642,8 @@ Two schedules with different lanes over one span: who was on call, above the inc
 ```tsx
 import { useState } from "react";
 import { Stack } from "@umriss-ui/core";
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
-import type { Subtask, Task } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
+import type { ScheduleView, Subtask, Task } from "@umriss-ui/schedule";
 
 /* Data from the operations world, written out here so the example runs on its own. */
 
@@ -5505,20 +5770,22 @@ const PAGED: readonly Subtask[] = INCIDENTS.map((incident) => ({
 const HIT = SERVICES.filter((service) => PAGED.some((incident) => incident.lane === service.id));
 
 export default function RotaBesideIncidents() {
-  const [domain, setDomain] = useState<readonly [number, number]>([day(16, 6), day(17, 14)]);
+  const [view, setView] = useState<ScheduleView>({ domain: [day(16, 6), day(17, 14)] });
+  const rota = useSchedule({ initialView: view, onViewChange: setView });
+  const incidents = useSchedule({ initialView: view, onViewChange: setView });
   return (
     <Stack gap={2}>
-      <Schedule ariaLabel="Who was on call" initialDomain={domain} height={140} onDomainChange={setDomain}>
-        <Lane id="primary" label="Primary" />
-        <Lane id="secondary" label="Secondary" />
-        <Subtasks data={DUTIES} tasks={PEOPLE} />
-      </Schedule>
-      <Schedule ariaLabel="Incidents, the same hours" initialDomain={domain} height={290} onDomainChange={setDomain}>
+      <rota.Schedule ariaLabel="Who was on call" height={140}>
+        <rota.Lane id="primary" label="Primary" />
+        <rota.Lane id="secondary" label="Secondary" />
+        <rota.Subtasks data={DUTIES} tasks={PEOPLE} />
+      </rota.Schedule>
+      <incidents.Schedule ariaLabel="Incidents, the same hours" height={290}>
         {HIT.map((service) => (
-          <Lane key={service.id} id={service.id} label={service.name} />
+          <incidents.Lane key={service.id} id={service.id} label={service.name} />
         ))}
-        <Subtasks data={PAGED} tasks={SEVERITIES} />
-      </Schedule>
+        <incidents.Subtasks data={PAGED} tasks={SEVERITIES} />
+      </incidents.Schedule>
     </Stack>
   );
 }
@@ -5538,16 +5805,9 @@ From `ScheduleProps` — the full table stands on [First schedule](#/schedule/ty
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| [`initialDomain`](#/schedule/ScheduleProps-initialDomain) *required* | `readonly [number, number]` | — | The time in view when the schedule mounts, as two wall-clock instants. Pan and zoom take it from there; a new pair of values puts it back. |
 | [`height`](#/schedule/ScheduleProps-height) | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's. |
 | [`children`](#/schedule/ScheduleProps-children) | `ReactNode` | — | `Lane`, `Dependencies` and `Subtasks`, in the order they are to stand and be drawn. |
 
-###### Events
-
-| Prop | Type | Default | Description |
-|---|---|---|---|
-| [`onDomainChange`](#/schedule/ScheduleProps-onDomainChange) | `(domain: readonly [number, number]) => void` | — | The visible time span after the planner panned or zoomed, as two wall-clock instants - for keeping a second schedule or a chart in step. A span handed in through `initialDomain` is not reported back. |
-
 ###### Accessibility
 
 | Prop | Type | Default | Description |
@@ -5589,9 +5849,27 @@ From `Task` — the full table stands on [Subtasks](#/subtasks/type-Task).
 | [`color`](#/subtasks/Task-color) *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/Task-name) | `string` | — | What the task is called, where the schedule names it. |
 
+From `ScheduleOptions` — the full table stands on [View](#/view/type-ScheduleOptions).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`initialView`](#/view/ScheduleOptions-initialView) | [`ScheduleView`](#/view/type-ScheduleView) | — | The view to start from, and to go to whenever one differing in content from the last is handed in - the same view again changes nothing, and what it leaves out is reset; one the schedule reported itself, handed back late, is its own state coming back and not gone to. The schedule remembers none: where a view is kept is the application's decision. |
+
+###### Events
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`onViewChange`](#/view/ScheduleOptions-onViewChange) | `(view: `[`ScheduleView`](#/view/type-ScheduleView)`) => void` | — | Every change of the view, once, always the whole view - the one to keep, or to hand another schedule as its `initialView`. A pan or zoom is reported at most once per frame. Not called for the view the schedule starts with. |
+
+From `ScheduleView` — the full table stands on [View](#/view/type-ScheduleView).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`domain`](#/view/ScheduleView-domain) | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`. |
+
 #### Known limits
 
-- Only the span is shared - not the selection, the hover or the vertical scroll.
+- 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://romanhaendler.github.io/umriss-ui/what-umriss-ui-is-not/).
 
@@ -5600,14 +5878,14 @@ What umriss deliberately does not build, and why: [ADR-0032](https://romanhaendl
 Converts between a point on the screen and a time on a lane, so marks of your own - a cut-off, a delivery window, a pin - stand at the right place beside the plan.
 
 ```ts
-import { Schedule } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/handle/
 
 The handle holds three functions and nothing else: `clientPointOf(time, lane?)`, `positionAt(clientX, clientY)` and `visibleDomain()`. Everything else the schedule does is props.
 
-Place your marks again whenever `onDomainChange` reports a new span.
+Place your marks again whenever `view.domain` changes.
 
 #### Examples
 
@@ -5618,7 +5896,7 @@ Place your marks again whenever `onDomainChange` reports a new span.
 ```tsx
 import { useEffect, useRef, useState } from "react";
 import { Stack, Text } from "@umriss-ui/core";
-import { Lane, Schedule, Subtasks } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 import type { ScheduleHandle, Subtask, Task } from "@umriss-ui/schedule";
 
 const at = (hours: number, minutes = 0) => new Date(2026, 2, 17, hours, minutes).getTime();
@@ -5648,9 +5926,9 @@ const CUT_OFF = at(14);
 const clock = (time: number) => new Date(time).toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" });
 
 export default function PlaceAMark() {
+  const { Schedule, Lane, Subtasks, view } = useSchedule({ initialView: { domain: [at(5, 30), at(18)] } });
   const plan = useRef<ScheduleHandle>(null);
   const host = useRef<HTMLDivElement>(null);
-  const [domain, setDomain] = useState<readonly [number, number]>([at(5, 30), at(18)]);
   const [pin, setPin] = useState<number | null>(null);
   const [under, setUnder] = useState("Move the pointer over the plan");
 
@@ -5659,7 +5937,7 @@ export default function PlaceAMark() {
     const point = plan.current?.clientPointOf(CUT_OFF);
     const left = host.current?.getBoundingClientRect().left;
     setPin(point == null || left === undefined ? null : point.x - left);
-  }, [domain]);
+  }, [view.domain]);
 
   return (
     <Stack gap={2}>
@@ -5673,9 +5951,7 @@ export default function PlaceAMark() {
       <Schedule
         ref={plan}
         ariaLabel="Three vehicles with a cut-off of the application's own"
-        initialDomain={domain}
         height={196}
-        onDomainChange={setDomain}
         onInteraction={(interaction) => {
           /* The interaction carries time and lane already; `positionAt` is for
              listeners of your own, which have only a point. */
@@ -5710,7 +5986,6 @@ From `ScheduleProps` — the full table stands on [First schedule](#/schedule/ty
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| [`initialDomain`](#/schedule/ScheduleProps-initialDomain) *required* | `readonly [number, number]` | — | The time in view when the schedule mounts, as two wall-clock instants. Pan and zoom take it from there; a new pair of values puts it back. |
 | [`height`](#/schedule/ScheduleProps-height) | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's. |
 | [`children`](#/schedule/ScheduleProps-children) | `ReactNode` | — | `Lane`, `Dependencies` and `Subtasks`, in the order they are to stand and be drawn. |
 
@@ -5719,7 +5994,6 @@ From `ScheduleProps` — the full table stands on [First schedule](#/schedule/ty
 | Prop | Type | Default | Description |
 |---|---|---|---|
 | [`onInteraction`](#/schedule/ScheduleProps-onInteraction) | `(interaction: `[`ScheduleInteraction`](#/interactions/type-ScheduleInteraction)`) => 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. |
-| [`onDomainChange`](#/schedule/ScheduleProps-onDomainChange) | `(domain: readonly [number, number]) => void` | — | The visible time span after the planner panned or zoomed, as two wall-clock instants - for keeping a second schedule or a chart in step. A span handed in through `initialDomain` is not reported back. |
 
 ###### Accessibility
 
@@ -5768,6 +6042,18 @@ From `ScheduleInteraction` — the full table stands on [Interactions](#/interac
 | [`clientX`](#/interactions/ScheduleInteraction-clientX) *required* | `number` | — | The pointer's horizontal client coordinate - where a `ContextMenu` opens. |
 | [`clientY`](#/interactions/ScheduleInteraction-clientY) *required* | `number` | — | The pointer's vertical client coordinate. |
 
+From `ScheduleOptions` — the full table stands on [View](#/view/type-ScheduleOptions).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`initialView`](#/view/ScheduleOptions-initialView) | [`ScheduleView`](#/view/type-ScheduleView) | — | The view to start from, and to go to whenever one differing in content from the last is handed in - the same view again changes nothing, and what it leaves out is reset; one the schedule reported itself, handed back late, is its own state coming back and not gone to. The schedule remembers none: where a view is kept is the application's decision. |
+
+From `ScheduleView` — the full table stands on [View](#/view/type-ScheduleView).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`domain`](#/view/ScheduleView-domain) | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`. |
+
 ### Findings as data
 
 Lists what is wrong with a plan - double bookings on a lane, dependencies that do not fit, work in blocked time - from the same data the schedule draws. Reach for it to list, count or filter the problems beside the picture.
@@ -5790,7 +6076,7 @@ Lead-in and lead-out count as occupied time; touching at a shared edge is no ove
 
 ```tsx
 import { Stack, Text } from "@umriss-ui/core";
-import { BlockedTimes, Dependencies, Lane, Schedule, Subtasks, findings } from "@umriss-ui/schedule";
+import { findings, useSchedule } from "@umriss-ui/schedule";
 import type { BlockedTime, Dependency, Subtask, Task } from "@umriss-ui/schedule";
 
 const day = (d: number, hours = 9) => new Date(2026, 2, d, hours).getTime();
@@ -5816,11 +6102,12 @@ const when = (instant: number) => new Date(instant).toLocaleString("en-GB", { we
 const hours = (ms: number) => Math.round(ms / 3_600_000);
 
 export default function ListTheFindings() {
+  const { Schedule, Lane, Subtasks, Dependencies, BlockedTimes } = useSchedule({ initialView: { domain: [day(16, 0), day(21, 0)] } });
   const found = findings(WORK, HANDOVERS, LEAVE);
 
   return (
     <Stack gap={3}>
-      <Schedule ariaLabel="Three people's week with its findings" initialDomain={[day(16, 0), day(21, 0)]} height={184}>
+      <Schedule ariaLabel="Three people's week with its findings" height={184}>
         <Lane id="noah" label="Noah Fischer" />
         <Lane id="chloe" label="Chloe Durand" />
         <Lane id="arjun" label="Arjun Mehta" />
@@ -5856,7 +6143,7 @@ When all three lists [`findings`](#/api/findings) returns are empty, say so plai
 
 ```tsx
 import { EmptyState, Stack } from "@umriss-ui/core";
-import { Lane, Schedule, Subtasks, findings } from "@umriss-ui/schedule";
+import { findings, useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task } from "@umriss-ui/schedule";
 
 const day = (d: number, hours = 9) => new Date(2026, 2, d, hours).getTime();
@@ -5869,12 +6156,13 @@ const WORK: readonly Subtask[] = [
 ];
 
 export default function NothingToFix() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [day(16, 0), day(21, 0)] } });
   const found = findings(WORK, []);
   const count = found.overlaps.length + found.violatedDependencies.length + found.inBlockedTime.length;
 
   return (
     <Stack gap={3}>
-      <Schedule ariaLabel="Two developers' week, without findings" initialDomain={[day(16, 0), day(21, 0)]} height={140}>
+      <Schedule ariaLabel="Two developers' week, without findings" height={140}>
         <Lane id="hana" label="Hana Sato" />
         <Lane id="kofi" label="Kofi Mensah" />
         <Subtasks data={WORK} tasks={PROJECTS} />
@@ -5891,7 +6179,7 @@ export default function NothingToFix() {
 
 ```tsx
 import { Badge, Stack } from "@umriss-ui/core";
-import { Dependencies, Lane, Schedule, Subtasks, overlaps, violatedDependencies } from "@umriss-ui/schedule";
+import { overlaps, useSchedule, violatedDependencies } 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();
@@ -5921,6 +6209,7 @@ const TRANSFERS: readonly Dependency[] = [
 ];
 
 export default function CountPerKind() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(5, 30), at(18)] } });
   const doubleBooked = overlaps(LEGS).length;
   const late = violatedDependencies(LEGS, TRANSFERS).length;
 
@@ -5930,7 +6219,7 @@ export default function CountPerKind() {
         <Badge tone={doubleBooked > 0 ? "warning" : "success"}>{doubleBooked} double-booked</Badge>
         <Badge tone={late > 0 ? "warning" : "success"}>{late} transfers too short</Badge>
       </Stack>
-      <Schedule ariaLabel="The day's legs with their findings counted" initialDomain={[at(5, 30), at(18)]} height={196}>
+      <Schedule ariaLabel="The day's legs with their findings counted" height={196}>
         {VEHICLES.map((vehicle) => (
           <Lane key={vehicle.id} id={vehicle.id} label={vehicle.label} />
         ))}
@@ -5992,7 +6281,7 @@ Direct manipulation that changes nothing by itself: the schedule reports, the ap
 Drag a bar to a new time or onto another lane (also called drag-and-drop rescheduling). A ghost shows where it would land and what that would cause; the drop reports the change for your application to apply.
 
 ```ts
-import { Schedule, applyIntent } from "@umriss-ui/schedule";
+import { useSchedule, applyIntent } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/move-and-lane/
@@ -6011,7 +6300,7 @@ List `move` in `intents` and apply what `onIntent` reports with [`applyIntent`](
 
 ```tsx
 import { useState } from "react";
-import { Lane, Schedule, Subtasks, applyIntent } from "@umriss-ui/schedule";
+import { applyIntent, useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task } from "@umriss-ui/schedule";
 
 const day = (d: number, hours = 9) => new Date(2026, 2, d, hours).getTime();
@@ -6024,11 +6313,11 @@ const START: readonly Subtask[] = [
 ];
 
 export default function MoveInTime() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [day(16, 0), day(21, 0)] } });
   const [work, setWork] = useState(START);
   return (
     <Schedule
       ariaLabel="Two people's work this week"
-      initialDomain={[day(16, 0), day(21, 0)]}
       height={140}
       intents={["move"]}
       onIntent={(intent) => setWork((current) => current.map((item) => applyIntent(item, intent)))}
@@ -6048,7 +6337,7 @@ Add `lane` to `intents`: a drop reports a move and a lane change separately, and
 ```tsx
 import { useState } from "react";
 import { Stack, Text } from "@umriss-ui/core";
-import { Dependencies, Lane, Schedule, Subtasks, applyIntent } from "@umriss-ui/schedule";
+import { applyIntent, useSchedule } from "@umriss-ui/schedule";
 import type { Dependency, Intent, Subtask, Task } from "@umriss-ui/schedule";
 
 const at = (hours: number, minutes = 0) => new Date(2026, 2, 17, hours, minutes).getTime();
@@ -6084,6 +6373,7 @@ const TRANSFERS: readonly Dependency[] = [
 ];
 
 export default function MoveToAnotherLane() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(5, 30), at(18)] } });
   const [legs, setLegs] = useState(LEGS);
   const [last, setLast] = useState<Intent | null>(null);
 
@@ -6091,7 +6381,6 @@ export default function MoveToAnotherLane() {
     <Stack gap={3}>
       <Schedule
         ariaLabel="Five vehicles on Tuesday, 17 March, editable"
-        initialDomain={[at(5, 30), at(18)]}
         height={284}
         intents={["move", "lane"]}
         onIntent={(intent) => {
@@ -6120,7 +6409,7 @@ Your `onIntent` decides: here it applies a drop only when [`overlaps`](#/api/ove
 ```tsx
 import { useRef, useState } from "react";
 import { Stack, Text } from "@umriss-ui/core";
-import { Lane, Schedule, Subtasks, applyIntent, overlaps } from "@umriss-ui/schedule";
+import { applyIntent, overlaps, useSchedule } from "@umriss-ui/schedule";
 import type { Intent, Subtask } from "@umriss-ui/schedule";
 
 /* Data from the planning world, written out here so the example runs on its own. */
@@ -6207,6 +6496,7 @@ const WEB = PEOPLE.filter((person) => person.team === "Web" && WORK.some((item)
 const START: readonly Subtask[] = WORK.filter((item) => WEB.some((person) => person.id === item.lane));
 
 export default function RefuseADoubleBooking() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [day(9), day(21)] } });
   const [work, setWork] = useState<readonly Subtask[]>(START);
   /* A drop onto another lane at another time reports two intents in one
      tick; each is decided on the plan the one before it left. */
@@ -6231,7 +6521,6 @@ export default function RefuseADoubleBooking() {
     <Stack gap={3}>
       <Schedule
         ariaLabel="Sprint 14 of the web team, editable"
-        initialDomain={[day(9), day(21)]}
         height={240}
         intents={["move", "lane"]}
         onIntent={onIntent}
@@ -6270,7 +6559,6 @@ From `ScheduleProps` — the full table stands on [First schedule](#/schedule/ty
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| [`initialDomain`](#/schedule/ScheduleProps-initialDomain) *required* | `readonly [number, number]` | — | The time in view when the schedule mounts, as two wall-clock instants. Pan and zoom take it from there; a new pair of values puts it back. |
 | [`height`](#/schedule/ScheduleProps-height) | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's. |
 | [`intents`](#/schedule/ScheduleProps-intents) | `readonly `[`IntentKind`](#/schedule/type-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)). |
 | [`children`](#/schedule/ScheduleProps-children) | `ReactNode` | — | `Lane`, `Dependencies` and `Subtasks`, in the order they are to stand and be drawn. |
@@ -6337,6 +6625,18 @@ From `Dependency` — the full table stands on [Dependencies](#/dependencies/typ
 | [`to`](#/dependencies/Dependency-to) *required* | `string` | — | The id of the subtask it arrives at. |
 | [`lag`](#/dependencies/Dependency-lag) *required* | `number` | — | The least time between the two anchors; zero where the successor may begin as soon as the predecessor ends. |
 
+From `ScheduleOptions` — the full table stands on [View](#/view/type-ScheduleOptions).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`initialView`](#/view/ScheduleOptions-initialView) | [`ScheduleView`](#/view/type-ScheduleView) | — | The view to start from, and to go to whenever one differing in content from the last is handed in - the same view again changes nothing, and what it leaves out is reset; one the schedule reported itself, handed back late, is its own state coming back and not gone to. The schedule remembers none: where a view is kept is the application's decision. |
+
+From `ScheduleView` — the full table stands on [View](#/view/type-ScheduleView).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`domain`](#/view/ScheduleView-domain) | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`. |
+
 From `Overlap` — the full table stands on [Findings as data](#/findings/type-Overlap).
 
 | Prop | Type | Default | Description |
@@ -6357,7 +6657,7 @@ What umriss deliberately does not build, and why: [ADR-0032](https://romanhaendl
 Change how long work takes, or how long its preparation and its wrap-up take, by dragging an edge (also called resizing). Each part changes on its own and is reported for your application to apply.
 
 ```ts
-import { Schedule, applyIntent } from "@umriss-ui/schedule";
+import { useSchedule, applyIntent } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/stretch/
@@ -6374,7 +6674,7 @@ With `stretch` in `intents`, either edge of a bar drags to a new start or end; t
 
 ```tsx
 import { useState } from "react";
-import { Lane, Schedule, Subtasks, applyIntent } from "@umriss-ui/schedule";
+import { applyIntent, useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task } from "@umriss-ui/schedule";
 
 const day = (d: number, hours = 9) => new Date(2026, 2, d, hours).getTime();
@@ -6387,11 +6687,11 @@ const START: readonly Subtask[] = [
 ];
 
 export default function StretchTheMainTime() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [day(16, 0), day(21, 0)] } });
   const [work, setWork] = useState(START);
   return (
     <Schedule
       ariaLabel="Two estimates to adjust"
-      initialDomain={[day(16, 0), day(21, 0)]}
       height={140}
       intents={["stretch"]}
       onIntent={(intent) => setWork((current) => current.map((item) => applyIntent(item, intent)))}
@@ -6410,7 +6710,7 @@ Add `leadIn` and `leadOut`: a selected tour shows a grip for its loading and its
 
 ```tsx
 import { useState } from "react";
-import { Lane, Schedule, Subtasks, applyIntent } from "@umriss-ui/schedule";
+import { applyIntent, 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();
@@ -6425,12 +6725,12 @@ const START: Subtask[] = [
 ];
 
 export default function ChangeLeadInAndLeadOut() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(6), at(13, 30)] } });
   const [tours, setTours] = useState(START);
 
   return (
     <Schedule
       ariaLabel="Two tours from North depot"
-      initialDomain={[at(6), at(13, 30)]}
       height={150}
       intents={["stretch", "leadIn", "leadOut"]}
       onIntent={(intent) => setTours((current) => current.map((tour) => applyIntent(tour, intent)))}
@@ -6457,7 +6757,6 @@ From `ScheduleProps` — the full table stands on [First schedule](#/schedule/ty
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| [`initialDomain`](#/schedule/ScheduleProps-initialDomain) *required* | `readonly [number, number]` | — | The time in view when the schedule mounts, as two wall-clock instants. Pan and zoom take it from there; a new pair of values puts it back. |
 | [`height`](#/schedule/ScheduleProps-height) | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's. |
 | [`intents`](#/schedule/ScheduleProps-intents) | `readonly `[`IntentKind`](#/schedule/type-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)). |
 | [`children`](#/schedule/ScheduleProps-children) | `ReactNode` | — | `Lane`, `Dependencies` and `Subtasks`, in the order they are to stand and be drawn. |
@@ -6509,6 +6808,18 @@ From `Task` — the full table stands on [Subtasks](#/subtasks/type-Task).
 | [`color`](#/subtasks/Task-color) *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/Task-name) | `string` | — | What the task is called, where the schedule names it. |
 
+From `ScheduleOptions` — the full table stands on [View](#/view/type-ScheduleOptions).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`initialView`](#/view/ScheduleOptions-initialView) | [`ScheduleView`](#/view/type-ScheduleView) | — | The view to start from, and to go to whenever one differing in content from the last is handed in - the same view again changes nothing, and what it leaves out is reset; one the schedule reported itself, handed back late, is its own state coming back and not gone to. The schedule remembers none: where a view is kept is the application's decision. |
+
+From `ScheduleView` — the full table stands on [View](#/view/type-ScheduleView).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`domain`](#/view/ScheduleView-domain) | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`. |
+
 #### Known limits
 
 - A main time never becomes shorter than one raster step, or a minute without a raster.
@@ -6520,7 +6831,7 @@ What umriss deliberately does not build, and why: [ADR-0032](https://romanhaendl
 Makes a drag land on a raster - the axis' own step, a fixed duration, or a pattern with an offset - so dropped work starts on a time a planner can read.
 
 ```ts
-import { Schedule, snapTime } from "@umriss-ui/schedule";
+import { useSchedule, snapTime } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/snapping/
@@ -6537,7 +6848,7 @@ Without `snap`, a drag lands on the fine band's step: quarter hours when zoomed
 
 ```tsx
 import { useState } from "react";
-import { Lane, Schedule, Subtasks, applyIntent } from "@umriss-ui/schedule";
+import { applyIntent, 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();
@@ -6547,11 +6858,11 @@ const TOURS: readonly Task[] = [{ id: "river", name: "Riverside depot tours", co
 const START: readonly Subtask[] = [{ id: "T-04", task: "river", lane: "van-402", from: at(7, 30), to: at(12, 10) }];
 
 export default function SnapToTheTicks() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(6), at(16)] } });
   const [tours, setTours] = useState(START);
   return (
     <Schedule
       ariaLabel="A tour on the default raster"
-      initialDomain={[at(6), at(16)]}
       height={100}
       intents={["move"]}
       onIntent={(intent) => setTours((current) => current.map((tour) => applyIntent(tour, intent)))}
@@ -6569,7 +6880,7 @@ Give `snap` a number of milliseconds - here half a day - and every drag lands on
 
 ```tsx
 import { useState } from "react";
-import { Lane, Schedule, Subtasks, applyIntent } from "@umriss-ui/schedule";
+import { applyIntent, useSchedule } from "@umriss-ui/schedule";
 import type { Subtask, Task } from "@umriss-ui/schedule";
 
 const day = (d: number, hours = 0) => new Date(2026, 2, d, hours).getTime();
@@ -6583,11 +6894,11 @@ const START: readonly Subtask[] = [
 ];
 
 export default function SnapToADuration() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [day(16), day(21)] } });
   const [work, setWork] = useState(START);
   return (
     <Schedule
       ariaLabel="Work planned in half days"
-      initialDomain={[day(16), day(21)]}
       height={140}
       snap={HALF_DAY}
       intents={["move", "stretch"]}
@@ -6607,7 +6918,7 @@ A `snap` raster with a step and an offset: eight-hour watches handed over at 06:
 
 ```tsx
 import { useState } from "react";
-import { Lane, Schedule, Subtasks, applyIntent } from "@umriss-ui/schedule";
+import { applyIntent, useSchedule } from "@umriss-ui/schedule";
 import type { SnapRaster, Subtask, Task } from "@umriss-ui/schedule";
 
 const at = (hours: number, minutes = 0) => new Date(2026, 2, 17, hours, minutes).getTime();
@@ -6621,11 +6932,11 @@ const ENGINEERS: readonly Task[] = [{ id: "ada", name: "Ada Mwangi", color: "lig
 const START: readonly Subtask[] = [{ id: "watch-1", task: "ada", lane: "primary", from: at(6), to: at(14) }];
 
 export default function SnapToHandovers() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(4), at(24)] } });
   const [watches, setWatches] = useState(START);
   return (
     <Schedule
       ariaLabel="An on-call watch on the handover raster"
-      initialDomain={[at(4), at(24)]}
       height={110}
       snap={HANDOVERS}
       intents={["move"]}
@@ -6644,7 +6955,7 @@ export default function SnapToHandovers() {
 
 ```tsx
 import { useState } from "react";
-import { Lane, Schedule, Subtasks, applyIntent } from "@umriss-ui/schedule";
+import { applyIntent, 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();
@@ -6654,11 +6965,11 @@ const ENGINEERS: readonly Task[] = [{ id: "sam", name: "Sam Okafor", color: "lig
 const START: readonly Subtask[] = [{ id: "window-1", task: "sam", lane: "notifications", from: at(13, 5), to: at(13, 50), name: "Maintenance window" }];
 
 export default function NoSnapping() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(10), at(18)] } });
   const [windows, setWindows] = useState(START);
   return (
     <Schedule
       ariaLabel="A maintenance window placed freely"
-      initialDomain={[at(10), at(18)]}
       height={100}
       snap={false}
       intents={["move"]}
@@ -6681,7 +6992,6 @@ From `ScheduleProps` — the full table stands on [First schedule](#/schedule/ty
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| [`initialDomain`](#/schedule/ScheduleProps-initialDomain) *required* | `readonly [number, number]` | — | The time in view when the schedule mounts, as two wall-clock instants. Pan and zoom take it from there; a new pair of values puts it back. |
 | [`height`](#/schedule/ScheduleProps-height) | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's. |
 | [`snap`](#/schedule/ScheduleProps-snap) | `"ticks" \| number \| `[`SnapRaster`](#/schedule/type-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. |
 | [`intents`](#/schedule/ScheduleProps-intents) | `readonly `[`IntentKind`](#/schedule/type-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)). |
@@ -6732,12 +7042,24 @@ From `Task` — the full table stands on [Subtasks](#/subtasks/type-Task).
 | [`color`](#/subtasks/Task-color) *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/Task-name) | `string` | — | What the task is called, where the schedule names it. |
 
+From `ScheduleOptions` — the full table stands on [View](#/view/type-ScheduleOptions).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`initialView`](#/view/ScheduleOptions-initialView) | [`ScheduleView`](#/view/type-ScheduleView) | — | The view to start from, and to go to whenever one differing in content from the last is handed in - the same view again changes nothing, and what it leaves out is reset; one the schedule reported itself, handed back late, is its own state coming back and not gone to. The schedule remembers none: where a view is kept is the application's decision. |
+
+From `ScheduleView` — the full table stands on [View](#/view/type-ScheduleView).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`domain`](#/view/ScheduleView-domain) | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`. |
+
 ### Placing from outside
 
 Drag work that is not on the plan yet - from a backlog or a list of unassigned jobs - onto a lane, with the browser's own drag and drop. The drop reports where it should go; your application creates it.
 
 ```ts
-import { Schedule, subtaskFromPlace } from "@umriss-ui/schedule";
+import { useSchedule, subtaskFromPlace } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/placing/
@@ -6755,7 +7077,7 @@ Set `placing` on your list's `dragstart` and clear it on `dragend`; the drop rep
 ```tsx
 import { useState } from "react";
 import { Card, Stack, Text } from "@umriss-ui/core";
-import { Dependencies, Lane, Schedule, Subtasks, applyIntent, subtaskFromPlace } from "@umriss-ui/schedule";
+import { applyIntent, subtaskFromPlace, useSchedule } from "@umriss-ui/schedule";
 import type { Dependency, Intent, PlacingItem, Subtask, Task } from "@umriss-ui/schedule";
 
 const at = (hours: number, minutes = 0) => new Date(2026, 2, 17, hours, minutes).getTime();
@@ -6789,6 +7111,7 @@ const BACKLOG: readonly (PlacingItem & { label: string })[] = [
 ];
 
 export default function DragFromTheBacklog() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(5, 30), at(18)] } });
   const [plan, setPlan] = useState<{ work: readonly Subtask[]; placed: number; last: string }>({
     work: TODAY,
     placed: 0,
@@ -6831,7 +7154,6 @@ export default function DragFromTheBacklog() {
       </Stack>
       <Schedule
         ariaLabel="Today's plan of three people, with the backlog beside it"
-        initialDomain={[at(5, 30), at(18)]}
         height={196}
         intents={["place", "move", "lane"]}
         placing={placing}
@@ -6865,7 +7187,6 @@ From `ScheduleProps` — the full table stands on [First schedule](#/schedule/ty
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| [`initialDomain`](#/schedule/ScheduleProps-initialDomain) *required* | `readonly [number, number]` | — | The time in view when the schedule mounts, as two wall-clock instants. Pan and zoom take it from there; a new pair of values puts it back. |
 | [`height`](#/schedule/ScheduleProps-height) | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's. |
 | [`intents`](#/schedule/ScheduleProps-intents) | `readonly `[`IntentKind`](#/schedule/type-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)). |
 | [`placing`](#/schedule/ScheduleProps-placing) | [`PlacingItem`](#/schedule/type-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. |
@@ -6931,12 +7252,24 @@ From `Dependency` — the full table stands on [Dependencies](#/dependencies/typ
 | [`to`](#/dependencies/Dependency-to) *required* | `string` | — | The id of the subtask it arrives at. |
 | [`lag`](#/dependencies/Dependency-lag) *required* | `number` | — | The least time between the two anchors; zero where the successor may begin as soon as the predecessor ends. |
 
+From `ScheduleOptions` — the full table stands on [View](#/view/type-ScheduleOptions).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`initialView`](#/view/ScheduleOptions-initialView) | [`ScheduleView`](#/view/type-ScheduleView) | — | The view to start from, and to go to whenever one differing in content from the last is handed in - the same view again changes nothing, and what it leaves out is reset; one the schedule reported itself, handed back late, is its own state coming back and not gone to. The schedule remembers none: where a view is kept is the application's decision. |
+
+From `ScheduleView` — the full table stands on [View](#/view/type-ScheduleView).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`domain`](#/view/ScheduleView-domain) | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`. |
+
 ### Where a subtask may go
 
 Marks the lanes and times a piece of work may not go to as soon as a drag begins, and holds the ghost where it is allowed. Reach for it when rules of your domain - equipment, skills, leave - limit where work can stand.
 
 ```ts
-import { Schedule, BlockedTimes } from "@umriss-ui/schedule";
+import { useSchedule } from "@umriss-ui/schedule";
 ```
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/where-it-may-go/
@@ -6956,7 +7289,7 @@ A refusal costs only what it refuses - a drop across a closed lane still reports
 ```tsx
 import { useState } from "react";
 import { Stack, Text } from "@umriss-ui/core";
-import { Lane, Schedule, Subtasks, applyIntent } from "@umriss-ui/schedule";
+import { applyIntent, useSchedule } from "@umriss-ui/schedule";
 import type { Intent, Subtask, Task } from "@umriss-ui/schedule";
 
 const at = (hours: number, minutes = 0) => new Date(2026, 2, 17, hours, minutes).getTime();
@@ -6982,6 +7315,7 @@ const START: Subtask[] = [
 const mayGo = (subtask: Subtask, lane: string) => subtask.task !== "chilled" || COOLED.includes(lane);
 
 export default function LanesThatFit() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(6, 30), at(15)] } });
   const [work, setWork] = useState<readonly Subtask[]>(START);
   const [last, setLast] = useState("Drag the vaccines onto the dry van");
 
@@ -6997,7 +7331,6 @@ export default function LanesThatFit() {
     <Stack gap={3}>
       <Schedule
         ariaLabel="Two cooled vans and a dry van"
-        initialDomain={[at(6, 30), at(15)]}
         height={190}
         intents={["move", "lane"]}
         canMoveTo={mayGo}
@@ -7023,7 +7356,7 @@ export default function LanesThatFit() {
 ```tsx
 import { useState } from "react";
 import { Card, Stack, Text } from "@umriss-ui/core";
-import { Lane, Schedule, Subtasks, subtaskFromPlace } from "@umriss-ui/schedule";
+import { subtaskFromPlace, useSchedule } from "@umriss-ui/schedule";
 import type { Intent, PlacingItem, Subtask, Task } from "@umriss-ui/schedule";
 
 const at = (hours: number, minutes = 0) => new Date(2026, 2, 17, hours, minutes).getTime();
@@ -7054,6 +7387,7 @@ const WAITING: PlacingItem & { label: string } = {
 };
 
 export default function DraggedIn() {
+  const { Schedule, Lane, Subtasks } = useSchedule({ initialView: { domain: [at(6, 30), at(15)] } });
   const [work, setWork] = useState<readonly Subtask[]>(START);
   const [placing, setPlacing] = useState<PlacingItem | null>(null);
   const [last, setLast] = useState("Drag the chilled delivery onto the dry van");
@@ -7083,7 +7417,6 @@ export default function DraggedIn() {
       </Card>
       <Schedule
         ariaLabel="A chilled delivery waiting beside two cooled vans and a dry van"
-        initialDomain={[at(6, 30), at(15)]}
         height={190}
         intents={["place"]}
         placing={placing}
@@ -7110,7 +7443,7 @@ Blocked time refuses a place in time where `canMoveTo` refuses a lane; both hold
 ```tsx
 import { useState } from "react";
 import { Stack, Text } from "@umriss-ui/core";
-import { BlockedTimes, Lane, Schedule, Subtasks, applyIntent } from "@umriss-ui/schedule";
+import { applyIntent, useSchedule } from "@umriss-ui/schedule";
 import type { BlockedTime, Intent, Subtask } from "@umriss-ui/schedule";
 
 /* Data from the planning world, written out here so the example runs on its own. */
@@ -7227,6 +7560,7 @@ const START_ROLE = new Map(START.map((item) => [item.id, roleOf(item.lane)]));
 const mayGo = (item: Subtask, lane: string) => START_ROLE.get(item.id) === roleOf(lane);
 
 export default function AroundLeave() {
+  const { Schedule, Lane, Subtasks, BlockedTimes } = useSchedule({ initialView: { domain: [day(9), day(21)] } });
   const [work, setWork] = useState<readonly Subtask[]>(START);
   const [last, setLast] = useState("Drag Freya's store screenshots into her holiday");
 
@@ -7240,7 +7574,6 @@ export default function AroundLeave() {
     <Stack gap={3}>
       <Schedule
         ariaLabel="The apps team this week, with leave"
-        initialDomain={[day(9), day(21)]}
         height={236}
         intents={["move", "lane"]}
         canMoveTo={mayGo}
@@ -7274,7 +7607,6 @@ From `ScheduleProps` — the full table stands on [First schedule](#/schedule/ty
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| [`initialDomain`](#/schedule/ScheduleProps-initialDomain) *required* | `readonly [number, number]` | — | The time in view when the schedule mounts, as two wall-clock instants. Pan and zoom take it from there; a new pair of values puts it back. |
 | [`height`](#/schedule/ScheduleProps-height) | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's. |
 | [`intents`](#/schedule/ScheduleProps-intents) | `readonly `[`IntentKind`](#/schedule/type-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)). |
 | [`canMoveTo`](#/schedule/ScheduleProps-canMoveTo) | `(subtask: `[`Subtask`](#/subtasks/type-Subtask)`, 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`. |
@@ -7341,6 +7673,18 @@ From `BlockedTime` — the full table stands on [Blocked time](#/blocked-time/ty
 | [`to`](#/blocked-time/BlockedTime-to) *required* | `number` | — | Where it ends. |
 | [`label`](#/blocked-time/BlockedTime-label) | `string` | — | Why the lane is blocked - "Leave", "Maintenance" -, where the schedule names it. |
 
+From `ScheduleOptions` — the full table stands on [View](#/view/type-ScheduleOptions).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`initialView`](#/view/ScheduleOptions-initialView) | [`ScheduleView`](#/view/type-ScheduleView) | — | The view to start from, and to go to whenever one differing in content from the last is handed in - the same view again changes nothing, and what it leaves out is reset; one the schedule reported itself, handed back late, is its own state coming back and not gone to. The schedule remembers none: where a view is kept is the application's decision. |
+
+From `ScheduleView` — the full table stands on [View](#/view/type-ScheduleView).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`domain`](#/view/ScheduleView-domain) | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`. |
+
 #### Known limits
 
 - A rule that changes while a drag runs is noticed at the drop, not before.
@@ -7370,7 +7714,7 @@ Demo page: https://romanhaendler.github.io/umriss-ui/schedule/ripple/
 ```tsx
 import { useState } from "react";
 import { Button, Stack, Text } from "@umriss-ui/core";
-import { Dependencies, Lane, Schedule, Subtasks, applyIntent, ripple } from "@umriss-ui/schedule";
+import { applyIntent, ripple, useSchedule } from "@umriss-ui/schedule";
 import type { Dependency, MoveIntent, Subtask, Task } from "@umriss-ui/schedule";
 
 const at = (hours: number, minutes = 0) => new Date(2026, 2, 17, hours, minutes).getTime();
@@ -7396,6 +7740,7 @@ const DRIVES: readonly Dependency[] = [
 const LATE: MoveIntent = { kind: "move", subtask: "stop-1", from: at(8, 10), to: at(8, 20) };
 
 export default function PushTheLaterStops() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(7, 15), at(10, 30)] } });
   const [stops, setStops] = useState<readonly Subtask[]>(START);
   /* Nothing to push until the first stop runs late. */
   const late = stops.some((s) => s.id === LATE.subtask && s.from === LATE.from);
@@ -7403,7 +7748,7 @@ export default function PushTheLaterStops() {
 
   return (
     <Stack gap={3}>
-      <Schedule ariaLabel="Tour T-01 on van FP 214 K" initialDomain={[at(7, 15), at(10, 30)]} height={100}>
+      <Schedule ariaLabel="Tour T-01 on van FP 214 K" height={100}>
         <Lane id="van-214" label="Van FP 214 K" />
         <Dependencies data={DRIVES} />
         <Subtasks data={stops} tasks={TOURS} />
@@ -7438,7 +7783,7 @@ export default function PushTheLaterStops() {
 ```tsx
 import { useState } from "react";
 import { Button, Stack } from "@umriss-ui/core";
-import { Dependencies, Lane, Schedule, Subtasks, applyIntent, shiftTask } from "@umriss-ui/schedule";
+import { applyIntent, shiftTask, 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();
@@ -7465,13 +7810,14 @@ const DRIVES: readonly Dependency[] = [
 ];
 
 export default function MoveAWholeTour() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [at(7), at(10, 30)] } });
   const [stops, setStops] = useState<readonly Subtask[]>(START);
   const move = (by: number) =>
     setStops((current) => shiftTask(current, "T-01", by).reduce((data, one) => data.map((s) => applyIntent(s, one)), current));
 
   return (
     <Stack gap={3}>
-      <Schedule ariaLabel="Two tours from North depot" initialDomain={[at(7), at(10, 30)]} height={140}>
+      <Schedule ariaLabel="Two tours from North depot" height={140}>
         <Lane id="van-214" label="Van FP 214 K" />
         <Lane id="van-377" label="E-van FP 377 K" />
         <Dependencies data={DRIVES} />
@@ -7496,7 +7842,7 @@ Run [`ripple`](#/api/ripple) inside `onIntent` and apply its moves with the drop
 
 ```tsx
 import { useState } from "react";
-import { Dependencies, Lane, Schedule, Subtasks, applyIntent, ripple } from "@umriss-ui/schedule";
+import { applyIntent, ripple, useSchedule } from "@umriss-ui/schedule";
 import type { Dependency, Intent, Subtask, Task } from "@umriss-ui/schedule";
 
 const day = (d: number, hours = 9) => new Date(2026, 2, d, hours).getTime();
@@ -7516,6 +7862,7 @@ const HANDOVERS: readonly Dependency[] = [
 ];
 
 export default function RippleOnEveryDrag() {
+  const { Schedule, Lane, Subtasks, Dependencies } = useSchedule({ initialView: { domain: [day(16, 0), day(24, 0)] } });
   const [work, setWork] = useState<readonly Subtask[]>(START);
 
   const onIntent = (intent: Intent) =>
@@ -7527,7 +7874,6 @@ export default function RippleOnEveryDrag() {
   return (
     <Schedule
       ariaLabel="Design, build and test of the shop search, rippling"
-      initialDomain={[day(16, 0), day(24, 0)]}
       height={184}
       intents={["move", "stretch"]}
       onIntent={onIntent}
@@ -7552,7 +7898,6 @@ From `ScheduleProps` — the full table stands on [First schedule](#/schedule/ty
 
 | Prop | Type | Default | Description |
 |---|---|---|---|
-| [`initialDomain`](#/schedule/ScheduleProps-initialDomain) *required* | `readonly [number, number]` | — | The time in view when the schedule mounts, as two wall-clock instants. Pan and zoom take it from there; a new pair of values puts it back. |
 | [`height`](#/schedule/ScheduleProps-height) | `number` | `400` | Height in CSS pixels, both bands included. The width is the host's. |
 | [`intents`](#/schedule/ScheduleProps-intents) | `readonly `[`IntentKind`](#/schedule/type-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)). |
 | [`children`](#/schedule/ScheduleProps-children) | `ReactNode` | — | `Lane`, `Dependencies` and `Subtasks`, in the order they are to stand and be drawn. |
@@ -7617,6 +7962,18 @@ From `Dependency` — the full table stands on [Dependencies](#/dependencies/typ
 | [`to`](#/dependencies/Dependency-to) *required* | `string` | — | The id of the subtask it arrives at. |
 | [`lag`](#/dependencies/Dependency-lag) *required* | `number` | — | The least time between the two anchors; zero where the successor may begin as soon as the predecessor ends. |
 
+From `ScheduleOptions` — the full table stands on [View](#/view/type-ScheduleOptions).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`initialView`](#/view/ScheduleOptions-initialView) | [`ScheduleView`](#/view/type-ScheduleView) | — | The view to start from, and to go to whenever one differing in content from the last is handed in - the same view again changes nothing, and what it leaves out is reset; one the schedule reported itself, handed back late, is its own state coming back and not gone to. The schedule remembers none: where a view is kept is the application's decision. |
+
+From `ScheduleView` — the full table stands on [View](#/view/type-ScheduleView).
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| [`domain`](#/view/ScheduleView-domain) | `readonly [number, number]` | — | The span in view, as two wall-clock instants. Absent, the schedule shows the extent of its subtasks, within `zoomLimits`. |
+
 #### Known limits
 
 - No dependency types, slack or critical path: the schedule is no project-planning engine ([ADR-0032](https://romanhaendler.github.io/umriss-ui/what-umriss-ui-is-not/)).
@@ -7634,56 +7991,20 @@ Everything `@umriss-ui/schedule` exports, with its signature. A component's prop
 
 Demo page: https://romanhaendler.github.io/umriss-ui/schedule/api/
 
-#### Components
-
-##### `BlockedTimes`
-
-[Blocked time](#/blocked-time) – A layer of blocked time. Wherever it is declared, it is drawn behind every
-subtask and dependency: it is a property of the lane, not something on it.
-
-Used on [Scenarios](#/), [Blocked time](#/blocked-time), [Tooltip](#/tooltip), [Findings as data](#/findings) and [Where a subtask may go](#/where-it-may-go).
-
-##### `Dependencies`
-
-[Dependencies](#/dependencies) – Lines from one subtask's end to the next one's start within a task, with the lag that must pass between them (also called links or predecessors). A lag that does not fit is marked, not repaired.
-
-Used on [Scenarios](#/), [Installation](#/installation), [First schedule](#/schedule), [Lane groups](#/lane-groups), [Dependencies](#/dependencies), [Routes](#/routes), [Time axis and calendar](#/time-axis), [Selection](#/selection), [Interactions](#/interactions), [Tooltip](#/tooltip), [Findings as data](#/findings), [Move and lane](#/move-and-lane), [Placing from outside](#/placing) and [Ripple](#/ripple).
-
-##### `Lane`
-
-[Lanes](#/lane) – One lane: a person, a vehicle, a room. The lanes run top to bottom in the order
-they are declared - whichever group they are declared in.
-
-Used on [Scenarios](#/), [Installation](#/installation), [First schedule](#/schedule), [Lanes](#/lane), [Lane groups](#/lane-groups), [Subtasks](#/subtasks), [Bar labels](#/bar-labels), [Appearances](#/appearances), [Overlap](#/overlap), [Dependencies](#/dependencies), [Routes](#/routes), [Time axis and calendar](#/time-axis), [Blocked time](#/blocked-time), [Now line](#/now-line), [Pan and zoom](#/pan-and-zoom), [Selection](#/selection), [Interactions](#/interactions), [Tooltip](#/tooltip), [Linked schedules](#/linked-schedules), [The handle](#/handle), [Findings as data](#/findings), [Move and lane](#/move-and-lane), [Stretch, lead-in, lead-out](#/stretch), [Snapping](#/snapping), [Placing from outside](#/placing), [Where a subtask may go](#/where-it-may-go) and [Ripple](#/ripple).
-
-##### `LaneGroup`
-
-[Lane groups](#/lane-groups) – A group of lanes: structure over them, and never a lane itself.
+#### Hooks
 
-It gives its id to its children through context, so a lane never names its
-group and a group reads in JSX as it reads in the organisation. Folded, it becomes
-one row showing a **Miniature** of everything in it; open, it shows a slim
-head above its lanes. Which groups are folded is `collapsedGroups` on
-`Schedule` - a view state, never an **Intent**.
+##### `useSchedule`
 
-Used on [Scenarios](#/) and [Lane groups](#/lane-groups).
+Declares a schedule: hands back `Schedule` and the parts declared inside it
+- `Lane`, `LaneGroup`, `Subtasks`, `Dependencies`, `BlockedTimes` -, its
+`view` and the setters `setDomain`, `toggleGroup`, `foldAll` and
+`unfoldAll`. A ref on `Schedule` still gives the `ScheduleHandle`.
 
-##### `Schedule`
-
-[First schedule](#/schedule) – A plan of subtasks on lanes over time - people, vehicles, rooms - with
-dependencies between them. The contents are declared as children (`Lane`,
-`LaneGroup`, `Subtasks`, `Dependencies`, `BlockedTimes`); the planner pans,
-zooms and drags, and every drag ends as an **Intent** through `onIntent`.
-The data changes only where the caller applies it; without `intents` the
-schedule is read-only. A ref gives the `ScheduleHandle`.
-
-Used on [Scenarios](#/), [Installation](#/installation), [First schedule](#/schedule), [Lanes](#/lane), [Lane groups](#/lane-groups), [Subtasks](#/subtasks), [Bar labels](#/bar-labels), [Appearances](#/appearances), [Overlap](#/overlap), [Dependencies](#/dependencies), [Routes](#/routes), [Time axis and calendar](#/time-axis), [Blocked time](#/blocked-time), [Now line](#/now-line), [Pan and zoom](#/pan-and-zoom), [Selection](#/selection), [Interactions](#/interactions), [Tooltip](#/tooltip), [Linked schedules](#/linked-schedules), [The handle](#/handle), [Findings as data](#/findings), [Move and lane](#/move-and-lane), [Stretch, lead-in, lead-out](#/stretch), [Snapping](#/snapping), [Placing from outside](#/placing), [Where a subtask may go](#/where-it-may-go) and [Ripple](#/ripple).
-
-##### `Subtasks`
-
-[Subtasks](#/subtasks) – The bars: a main time with an optional lead-in before it and lead-out after it, in the colour of the task they belong to (also called bookings or assignments).
+```ts
+function useSchedule(options?: ScheduleOptions): ScheduleParts;
+```
 
-Used on [Scenarios](#/), [Installation](#/installation), [First schedule](#/schedule), [Lanes](#/lane), [Lane groups](#/lane-groups), [Subtasks](#/subtasks), [Bar labels](#/bar-labels), [Appearances](#/appearances), [Overlap](#/overlap), [Dependencies](#/dependencies), [Routes](#/routes), [Time axis and calendar](#/time-axis), [Blocked time](#/blocked-time), [Now line](#/now-line), [Pan and zoom](#/pan-and-zoom), [Selection](#/selection), [Interactions](#/interactions), [Tooltip](#/tooltip), [Linked schedules](#/linked-schedules), [The handle](#/handle), [Findings as data](#/findings), [Move and lane](#/move-and-lane), [Stretch, lead-in, lead-out](#/stretch), [Snapping](#/snapping), [Placing from outside](#/placing), [Where a subtask may go](#/where-it-may-go) and [Ripple](#/ripple).
+Used on [Scenarios](#/), [Installation](#/installation), [First schedule](#/schedule), [Lanes](#/lane), [Lane groups](#/lane-groups), [Subtasks](#/subtasks), [Bar labels](#/bar-labels), [Appearances](#/appearances), [Overlap](#/overlap), [Dependencies](#/dependencies), [Routes](#/routes), [Time axis and calendar](#/time-axis), [Blocked time](#/blocked-time), [Now line](#/now-line), [Pan and zoom](#/pan-and-zoom), [Selection](#/selection), [Interactions](#/interactions), [Tooltip](#/tooltip), [View](#/view), [Linked schedules](#/linked-schedules), [The handle](#/handle), [Findings as data](#/findings), [Move and lane](#/move-and-lane), [Stretch, lead-in, lead-out](#/stretch), [Snapping](#/snapping), [Placing from outside](#/placing), [Where a subtask may go](#/where-it-may-go) and [Ripple](#/ripple).
 
 #### Functions
 
@@ -8072,6 +8393,29 @@ Its table stands on [Interactions](#/interactions/type-ScheduleInteraction).
 
 Used on [Scenarios](#/), [Interactions](#/interactions) and [Tooltip](#/tooltip).
 
+##### `ScheduleOptions`
+
+Its table stands on [View](#/view/type-ScheduleOptions).
+
+##### `ScheduleParts`
+
+What `useSchedule` hands back: the schedule and what is declared inside
+it, its view and the setters that change it.
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| `Schedule` *required* | `ForwardRefExoticComponent<`[`ScheduleProps`](#/schedule/type-ScheduleProps)` & RefAttributes<`[`ScheduleHandle`](#type-ScheduleHandle)`>>` | — | The schedule. One per `useSchedule`: a second schedule is a second call.<br>Shown in: [The smallest schedule (Installation)](#/installation/smallest-schedule), [A day of tours (First schedule)](#/schedule/first-schedule), [Start from an empty plan (First schedule)](#/schedule/no-work-yet) and 75 more |
+| `Lane` *required* | `typeof Lane` | — | <br>Shown in: [The smallest schedule (Installation)](#/installation/smallest-schedule), [A day of tours (First schedule)](#/schedule/first-schedule), [Start from an empty plan (First schedule)](#/schedule/no-work-yet) and 75 more |
+| `LaneGroup` *required* | `typeof LaneGroup` | — | <br>Shown in: [Group lanes under a head (Lane groups)](#/lane-groups/a-group), [Nest groups to any depth (Lane groups)](#/lane-groups/nesting), [Fold groups from outside (Lane groups)](#/lane-groups/fold-from-outside) and 5 more |
+| `Subtasks` *required* | `typeof Subtasks` | — | <br>Shown in: [The smallest schedule (Installation)](#/installation/smallest-schedule), [A day of tours (First schedule)](#/schedule/first-schedule), [Start from an empty plan (First schedule)](#/schedule/no-work-yet) and 75 more |
+| `Dependencies` *required* | `typeof Dependencies` | — | <br>Shown in: [The smallest schedule (Installation)](#/installation/smallest-schedule), [A day of tours (First schedule)](#/schedule/first-schedule), [Plan a day in the machine shop (First schedule)](#/schedule/machine-plan) and 27 more |
+| `BlockedTimes` *required* | `typeof BlockedTimes` | — | <br>Shown in: [Block out leave and maintenance (Blocked time)](#/blocked-time/leave), [Plan work around someone's leave (Blocked time)](#/blocked-time/drag-around), [Check a sprint against the leave calendar (Blocked time)](#/blocked-time/team-leave) and 5 more |
+| `view` *required* | [`ScheduleView`](#/view/type-ScheduleView) | — | 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/fold-from-outside), [Place a mark of your own (The handle)](#/handle/place-a-mark) |
+| `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/keep-and-restore) |
+| `toggleGroup` *required* | `(id: string) => void` | — | Folds or unfolds one **Lane group**. |
+| `foldAll` *required* | `() => void` | — | Folds every group.<br>Shown in: [Fold groups from outside (Lane groups)](#/lane-groups/fold-from-outside) |
+| `unfoldAll` *required* | `() => void` | — | Unfolds every group.<br>Shown in: [Fold groups from outside (Lane groups)](#/lane-groups/fold-from-outside) |
+
 ##### `ScheduleProps`
 
 Its table stands on [First schedule](#/schedule/type-ScheduleProps).
@@ -8082,6 +8426,12 @@ Its table stands on [Tooltip](#/tooltip/type-ScheduleTooltipTarget).
 
 Used on [Tooltip](#/tooltip).
 
+##### `ScheduleView`
+
+Its table stands on [View](#/view/type-ScheduleView).
+
+Used on [View](#/view) and [Linked schedules](#/linked-schedules).
+
 ##### `SnapRaster`
 
 A raster: a step, and where it starts after local midnight.
@@ -8108,7 +8458,7 @@ Stretch the main time at one or both of its edges.
 
 Its table stands on [Subtasks](#/subtasks/type-Subtask).
 
-Used on [Scenarios](#/), [Installation](#/installation), [First schedule](#/schedule), [Lanes](#/lane), [Lane groups](#/lane-groups), [Subtasks](#/subtasks), [Bar labels](#/bar-labels), [Appearances](#/appearances), [Overlap](#/overlap), [Dependencies](#/dependencies), [Routes](#/routes), [Time axis and calendar](#/time-axis), [Blocked time](#/blocked-time), [Now line](#/now-line), [Pan and zoom](#/pan-and-zoom), [Selection](#/selection), [Interactions](#/interactions), [Tooltip](#/tooltip), [Linked schedules](#/linked-schedules), [The handle](#/handle), [Findings as data](#/findings), [Move and lane](#/move-and-lane), [Stretch, lead-in, lead-out](#/stretch), [Snapping](#/snapping), [Placing from outside](#/placing), [Where a subtask may go](#/where-it-may-go) and [Ripple](#/ripple).
+Used on [Scenarios](#/), [Installation](#/installation), [First schedule](#/schedule), [Lanes](#/lane), [Lane groups](#/lane-groups), [Subtasks](#/subtasks), [Bar labels](#/bar-labels), [Appearances](#/appearances), [Overlap](#/overlap), [Dependencies](#/dependencies), [Routes](#/routes), [Time axis and calendar](#/time-axis), [Blocked time](#/blocked-time), [Now line](#/now-line), [Pan and zoom](#/pan-and-zoom), [Selection](#/selection), [Interactions](#/interactions), [Tooltip](#/tooltip), [View](#/view), [Linked schedules](#/linked-schedules), [The handle](#/handle), [Findings as data](#/findings), [Move and lane](#/move-and-lane), [Stretch, lead-in, lead-out](#/stretch), [Snapping](#/snapping), [Placing from outside](#/placing), [Where a subtask may go](#/where-it-may-go) and [Ripple](#/ripple).
 
 ##### `SubtaskAppearance`
 
@@ -8126,7 +8476,7 @@ Its table stands on [Subtasks](#/subtasks/type-SubtasksProps).
 
 Its table stands on [Subtasks](#/subtasks/type-Task).
 
-Used on [Scenarios](#/), [Installation](#/installation), [First schedule](#/schedule), [Lanes](#/lane), [Lane groups](#/lane-groups), [Subtasks](#/subtasks), [Bar labels](#/bar-labels), [Appearances](#/appearances), [Overlap](#/overlap), [Dependencies](#/dependencies), [Routes](#/routes), [Time axis and calendar](#/time-axis), [Blocked time](#/blocked-time), [Now line](#/now-line), [Pan and zoom](#/pan-and-zoom), [Selection](#/selection), [Interactions](#/interactions), [Tooltip](#/tooltip), [Linked schedules](#/linked-schedules), [The handle](#/handle), [Findings as data](#/findings), [Move and lane](#/move-and-lane), [Stretch, lead-in, lead-out](#/stretch), [Snapping](#/snapping), [Placing from outside](#/placing), [Where a subtask may go](#/where-it-may-go) and [Ripple](#/ripple).
+Used on [Scenarios](#/), [Installation](#/installation), [First schedule](#/schedule), [Lanes](#/lane), [Lane groups](#/lane-groups), [Subtasks](#/subtasks), [Bar labels](#/bar-labels), [Appearances](#/appearances), [Overlap](#/overlap), [Dependencies](#/dependencies), [Routes](#/routes), [Time axis and calendar](#/time-axis), [Blocked time](#/blocked-time), [Now line](#/now-line), [Pan and zoom](#/pan-and-zoom), [Selection](#/selection), [Interactions](#/interactions), [Tooltip](#/tooltip), [View](#/view), [Linked schedules](#/linked-schedules), [The handle](#/handle), [Findings as data](#/findings), [Move and lane](#/move-and-lane), [Stretch, lead-in, lead-out](#/stretch), [Snapping](#/snapping), [Placing from outside](#/placing), [Where a subtask may go](#/where-it-may-go) and [Ripple](#/ripple).
 
 ##### `ViolatedDependency`