@heyramzi/ui 2.23.0 → 3.0.0

package/src/work/kanban-board.svelte.d.ts

@@ -0,0 +1,107 @@
+import type { Snippet } from "svelte";
+import type { KanbanCardContext, KanbanColumn as KanbanColumnDef, KanbanColumnContext, KanbanMove, KanbanSortKey } from "./kanban-types.js";
+interface Props<T, C extends KanbanColumnDef> {
+    /** Plain column defs, or your own type that extends one. Snippets get it back as you passed it. */
+    columns: C[];
+    items: T[];
+    /** The stable id of a card. Used for keys, drag payloads and move events. */
+    getId: (item: T) => string;
+    /** The column id a card belongs to. */
+    getColumn: (item: T) => string;
+    /** Called on drop with what to persist. Awaited, so the caller can save. */
+    onMove: (id: string, move: KanbanMove) => void | Promise<void>;
+    renderCard: Snippet<[T, KanbanCardContext]>;
+    /** Reads a card's manual order key. Required for `sortKey="manual"` ordering. */
+    boardOrder?: (item: T) => string | null | undefined;
+    /** Breaks a tie in manual order: two cards with the same key, or both without one. */
+    manualTiebreak?: (a: T, b: T) => number;
+    /** Extra named sorts, e.g. by title or owner. `manual` is always available. */
+    sortKeys?: KanbanSortKey<T>[];
+    /** The active sort. `"manual"` (default) orders by `boardOrder`, else by the order of `items`. */
+    sortKey?: string;
+    /** Optional column header. Defaults to the label plus a count. */
+    columnHeader?: Snippet<[C, KanbanColumnContext]>;
+    /** Rendered under a column's cards, e.g. a "Show all 12" or an add button. */
+    columnFooter?: Snippet<[C, KanbanColumnContext]>;
+    /**
+     * Wraps a column for a context menu or tooltip: render `column` once and spread the
+     * `props` it hands you, so the trigger lands on the column.
+     */
+    wrapColumn?: Snippet<[C, Snippet<[Record<string, unknown>]>]>;
+    /** Enter or Space on a focused card. Leave out when the card holds its own links and buttons. */
+    onSelect?: (id: string) => void;
+    /** The screen-reader name of a card. Defaults to the card's own text. */
+    getLabel?: (item: T) => string;
+    /** Read after a card's name, as its description. */
+    moveHint?: string;
+    emptyLabel?: string;
+    /** Shows a plus in each default column head that adds a card to that column. */
+    onAdd?: (columnId: string) => void;
+    /** The plus button's accessible name, followed by the column label. */
+    addLabel?: string;
+    /**
+     * Cards a column shows before the rest fold behind "Show N more": a number for every
+     * column, or per column (undefined for no cap). `Infinity` turns the fold off.
+     */
+    limit?: number | ((columnId: string) => number | undefined);
+    /** The fold's open button, given how many cards it holds. */
+    moreLabel?: (hidden: number) => string;
+    /** The fold's close button. */
+    lessLabel?: string;
+    /** The header caret's open and close names, followed by the column label. */
+    expandColumnLabel?: string;
+    collapseColumnLabel?: string;
+    /**
+     * Column ids the header caret opened. Pass one array to every board in a stack of
+     * swimlanes, so the caret opens that column in each. "Show N more" stays per board.
+     */
+    expanded?: string[];
+    onExpandedChange?: (ids: string[]) => void;
+    /** Column ids folded into the rail on the right. Controlled; leave out to let the board remember. */
+    hidden?: string[];
+    onHiddenChange?: (ids: string[]) => void;
+    /** Heading over the rail of hidden columns. */
+    hiddenLabel?: string;
+    /** The rail's button that brings every hidden column back. */
+    showAllLabel?: string;
+    /** Content of one entry in the hidden rail. Defaults to the label and a count. */
+    hiddenItem?: Snippet<[C, {
+        count: number;
+        active: boolean;
+    }]>;
+    /** A capped column is one whose tail is hidden, so its empty space drops on top. Overrides `limit`. */
+    dropAtTop?: (columnId: string) => boolean;
+    /**
+     * Override per-column drop targets. Defaults to each column's `droppable`
+     * flag (true when unset). A column it returns false for never calls
+     * preventDefault, so it is not a drop target.
+     */
+    isDroppable?: (columnId: string) => boolean;
+    /** What a screen reader hears after a card moves with the keyboard. */
+    movedLabel?: (column: C) => string;
+    class?: string;
+}
+declare function $$render<T, C extends KanbanColumnDef = KanbanColumnDef>(): {
+    props: Props<T, C>;
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T, C extends KanbanColumnDef = KanbanColumnDef> {
+    props(): ReturnType<typeof $$render<T, C>>['props'];
+    events(): ReturnType<typeof $$render<T, C>>['events'];
+    slots(): ReturnType<typeof $$render<T, C>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T, C extends KanbanColumnDef = KanbanColumnDef>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T, C>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T, C>['props']>, ReturnType<__sveltets_Render<T, C>['events']>, ReturnType<__sveltets_Render<T, C>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T, C>['bindings']>;
+    } & ReturnType<__sveltets_Render<T, C>['exports']>;
+    <T, C extends KanbanColumnDef = KanbanColumnDef>(internal: unknown, props: ReturnType<__sveltets_Render<T, C>['props']> & {}): ReturnType<__sveltets_Render<T, C>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
+}
+declare const $$Component: $$IsomorphicComponent;
+type $$Component<T, C extends KanbanColumnDef = KanbanColumnDef> = InstanceType<typeof $$Component<T, C>>;
+export default $$Component;

package/src/work/kanban-board.svelte.test.ts

@@ -0,0 +1,89 @@
+import { createRawSnippet, flushSync, mount, tick, unmount } from "svelte";
+import { describe, expect, it } from "vite-plus/test";
+import KanbanBoard from "./kanban-board.svelte";
+import type { KanbanMove } from "./kanban-types.js";
+
+type Task = { id: string; columnId: string; title: string; boardOrder: string };
+
+const columns = [
+  { id: "todo", label: "To do" },
+  { id: "doing", label: "In progress" },
+  { id: "done", label: "Done" },
+];
+
+const renderCard = createRawSnippet((task: () => Task) => ({
+  render: () => `<p>${task().title}</p>`,
+}));
+
+function render() {
+  const props = $state({
+    columns,
+    items: [
+      { id: "k1", columnId: "todo", title: "Draft notes", boardOrder: "a0" },
+      { id: "k2", columnId: "doing", title: "Ship flow", boardOrder: "a0" },
+    ] as Task[],
+    getId: (t: Task) => t.id,
+    getColumn: (t: Task) => t.columnId,
+    boardOrder: (t: Task) => t.boardOrder,
+    renderCard,
+    onMove: (id: string, move: KanbanMove) => {
+      props.items = props.items.map((t) =>
+        t.id === id ? { ...t, columnId: move.columnId, boardOrder: move.boardOrder ?? "" } : t,
+      );
+    },
+  });
+  const target = document.createElement("div");
+  document.body.appendChild(target);
+  const app = mount(KanbanBoard<Task>, { target, props });
+  flushSync();
+  return {
+    target,
+    card: (id: string) => target.querySelector<HTMLElement>(`[data-kanban-card="${id}"]`),
+    done: () => {
+      void unmount(app);
+      target.remove();
+    },
+  };
+}
+
+// Waits out the board's await of onMove and its tick, then Svelte's flush.
+async function settle() {
+  for (let i = 0; i < 4; i++) await tick();
+  flushSync();
+}
+
+describe("KanbanBoard keyboard move", () => {
+  it("keeps focus on the moved card in its new column and announces the move", async () => {
+    const { target, card, done } = render();
+    const before = card("k1");
+    before?.focus();
+    before?.dispatchEvent(
+      new KeyboardEvent("keydown", { key: "ArrowRight", altKey: true, bubbles: true }),
+    );
+    await settle();
+
+    const moved = card("k1");
+    expect(moved?.closest('[aria-label="In progress"]')).not.toBeNull();
+    expect(document.activeElement).toBe(moved);
+    expect(target.querySelector('[role="status"]')?.textContent).toBe("Moved to In progress");
+    done();
+  });
+
+  it("names a card by its own text and describes it with the move hint", () => {
+    const { card, done } = render();
+    const el = card("k1");
+    expect(el?.hasAttribute("aria-label")).toBe(false);
+    expect(el?.getAttribute("aria-labelledby")).toBe(el?.id);
+    const hint = document.getElementById(el?.getAttribute("aria-describedby") ?? "");
+    expect(hint?.textContent).toBe("Press Alt plus Left or Right arrow to move between columns.");
+    done();
+  });
+
+  it("puts every card inside a list", () => {
+    const { target, done } = render();
+    for (const item of target.querySelectorAll('[role="listitem"]')) {
+      expect(item.parentElement?.getAttribute("role")).toBe("list");
+    }
+    done();
+  });
+});

package/src/work/kanban-column-head.svelte.d.ts

@@ -0,0 +1,40 @@
+import type { Snippet } from "svelte";
+import type { KanbanColumn as KanbanColumnDef, KanbanColumnContext } from "./kanban-types.js";
+declare function $$render<C extends KanbanColumnDef>(): {
+    props: {
+        column: C;
+        context: KanbanColumnContext;
+        /** The board's `columnHeader`. Left out, the head is GroupHead. */
+        columnHeader?: Snippet<[C, KanbanColumnContext]>;
+        onAdd?: (columnId: string) => void;
+        addLabel: string;
+        /** The column holds more cards than its cap, so the caret shows. */
+        foldable: boolean;
+        /** The caret has the column open in every lane. */
+        columnOpen: boolean;
+        onToggle: () => void;
+        expandColumnLabel: string;
+        collapseColumnLabel: string;
+    };
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<C extends KanbanColumnDef> {
+    props(): ReturnType<typeof $$render<C>>['props'];
+    events(): ReturnType<typeof $$render<C>>['events'];
+    slots(): ReturnType<typeof $$render<C>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <C extends KanbanColumnDef>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<C>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<C>['props']>, ReturnType<__sveltets_Render<C>['events']>, ReturnType<__sveltets_Render<C>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<C>['bindings']>;
+    } & ReturnType<__sveltets_Render<C>['exports']>;
+    <C extends KanbanColumnDef>(internal: unknown, props: ReturnType<__sveltets_Render<C>['props']> & {}): ReturnType<__sveltets_Render<C>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const $$Component: $$IsomorphicComponent;
+type $$Component<C extends KanbanColumnDef> = InstanceType<typeof $$Component<C>>;
+export default $$Component;

package/src/work/kanban-column.svelte

@@ -65,40 +65,57 @@
 </div>
 
 <style>
-	/* Columns split the board's width equally, never under 240px (the board scrolls instead)
-	   nor over 420px (a 2-line card title stays near 55 characters a line). At 280px four
-	   columns needed 1168px, so a docs page at 1440 cut the Done column off; 240px fits four
-	   in the 1008px a 1440 page leaves, and a card's meta row still fits on one line. */
-	.kanban-column {
-		flex: 1 1 0;
-		min-width: var(--kanban-column-min, 240px);
-		max-width: var(--kanban-column-max, 420px);
-		transition: opacity var(--duration-quick) var(--ease-smooth-out);
-	}
+	@layer theme, base, components, utilities;
 
-	/* A board under 40rem wide (a phone, a side panel) shows one column and a peek of the next, as 82vw did on a phone. */
-	@container kanban-board (width < 40rem) {
+	@layer components {
+		/* Equal columns, 240px to 420px (the board scrolls below that): four fit the 1008px a
+		   1440 page leaves, and a 2-line title stays near 55 characters a line. */
 		.kanban-column {
-			flex: 0 0 88cqw;
-			min-width: 0;
-			max-width: 88cqw;
-			scroll-snap-align: start;
+			flex: 1 1 0;
+			min-width: var(--kanban-column-min, 240px);
+			max-width: var(--kanban-column-max, 420px);
+			transition: opacity var(--duration-quick) var(--ease-smooth-out);
 		}
-	}
 
-	.kanban-column-collapsing,
-	.kanban-column-expanding {
-		will-change: opacity;
-		overflow: hidden;
-	}
+		/* A board under 40rem wide (a phone, a side panel) shows one column and a peek of the next, as 82vw did on a phone. */
+		@container kanban-board (width < 40rem) {
+			.kanban-column {
+				flex: 0 0 88cqw;
+				min-width: 0;
+				max-width: 88cqw;
+				scroll-snap-align: start;
+			}
+		}
 
-	.kanban-column-collapsing {
-		pointer-events: none;
-		animation: column-fold var(--duration-slow) var(--ease-smooth-out) forwards;
-	}
+		.kanban-column-collapsing,
+		.kanban-column-expanding {
+			will-change: opacity;
+			overflow: hidden;
+		}
+
+		.kanban-column-collapsing {
+			pointer-events: none;
+			animation: column-fold var(--duration-slow) var(--ease-smooth-out) forwards;
+		}
+
+		.kanban-column-expanding {
+			animation: column-unfold var(--duration-slow) var(--ease-smooth-out) both;
+		}
 
-	.kanban-column-expanding {
-		animation: column-unfold var(--duration-slow) var(--ease-smooth-out) both;
+		@media (prefers-reduced-motion: reduce) {
+			.kanban-column-expanding {
+				animation: none;
+			}
+
+			.kanban-column-collapsing {
+				animation: none;
+				opacity: 0;
+				flex: 0 0 0;
+				min-width: 0;
+				max-width: 0;
+				margin-inline-end: -1rem;
+			}
+		}
 	}
 
 	/* One end only: the other is the column's resting width, whatever the container gave it.
@@ -124,19 +141,4 @@
 			margin-inline-end: -1rem;
 		}
 	}
-
-	@media (prefers-reduced-motion: reduce) {
-		.kanban-column-expanding {
-			animation: none;
-		}
-
-		.kanban-column-collapsing {
-			animation: none;
-			opacity: 0;
-			flex: 0 0 0;
-			min-width: 0;
-			max-width: 0;
-			margin-inline-end: -1rem;
-		}
-	}
 </style>

package/src/work/kanban-column.svelte.d.ts

@@ -0,0 +1,20 @@
+import type { Snippet } from "svelte";
+import type { HTMLAttributes } from "svelte/elements";
+interface Props extends HTMLAttributes<HTMLDivElement> {
+    /** Any CSS color. Only shows while a card is held over the column. */
+    hue?: string;
+    active?: boolean;
+    collapsing?: boolean;
+    expanding?: boolean;
+    ariaLabel?: string;
+    header: Snippet;
+    children: Snippet;
+    ondragover?: (e: DragEvent) => void;
+    ondragleave?: (e: DragEvent) => void;
+    ondrop?: (e: DragEvent) => void;
+    class?: string;
+    bodyClass?: string;
+}
+declare const $$Component: import("svelte").Component<Props, {}, "">;
+type $$Component = ReturnType<typeof $$Component>;
+export default $$Component;

package/src/work/kanban-fold-chevron.svelte

@@ -13,22 +13,26 @@
 
 <span
 	class={cn("kanban-fold-chevron [&>svg]:size-full", open && "kanban-fold-chevron-open", className)}
-	aria-hidden="true"><CaretDown weight="bold" /></span
+	aria-hidden="true"><CaretDown aria-hidden="true" weight="bold" /></span
 >
 
 <style>
-	.kanban-fold-chevron {
-		display: inline-flex;
-		transition: transform var(--duration-fast) var(--ease-smooth-out);
-	}
-
-	.kanban-fold-chevron-open {
-		transform: scaleY(-1);
-	}
+	@layer theme, base, components, utilities;
 
-	@media (prefers-reduced-motion: reduce) {
+	@layer components {
 		.kanban-fold-chevron {
-			transition: none;
+			display: inline-flex;
+			transition: transform var(--duration-fast) var(--ease-smooth-out);
+		}
+
+		.kanban-fold-chevron-open {
+			transform: scaleY(-1);
+		}
+
+		@media (prefers-reduced-motion: reduce) {
+			.kanban-fold-chevron {
+				transition: none;
+			}
 		}
 	}
 </style>

package/src/work/kanban-fold-chevron.svelte.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    /** Flips the caret to point up. */
+    open: boolean;
+    class?: string;
+}
+declare const $$Component: import("svelte").Component<Props, {}, "">;
+type $$Component = ReturnType<typeof $$Component>;
+export default $$Component;

package/src/work/kanban-hidden-rail.svelte

@@ -34,7 +34,7 @@
 				"size-2.5 transition-transform duration-fast ease-smooth-out motion-reduce:transition-none [&>svg]:size-full",
 				!rail.railOpen && "-rotate-90",
 			)}
-			aria-hidden="true"><CaretDown weight="bold" /></span
+			aria-hidden="true"><CaretDown aria-hidden="true" weight="bold" /></span
 		>
 		{hiddenLabel}
 	</Button>
@@ -96,6 +96,7 @@
 </div>
 
 <style>
+	/* Unlayered: the row's transition-[background-color,outline-color] utility would otherwise drop the fade out. */
 	.kanban-rail-item-leaving {
 		pointer-events: none;
 		opacity: 0;

package/src/work/kanban-hidden-rail.svelte.d.ts

@@ -0,0 +1,39 @@
+import type { Snippet } from "svelte";
+import type { KanbanRailState } from "./kanban-rail-state.svelte.js";
+import type { KanbanColumn as KanbanColumnDef } from "./kanban-types.js";
+declare function $$render<C extends KanbanColumnDef>(): {
+    props: {
+        /** The columns folded into the rail, in board order. */
+        columns: C[];
+        rail: KanbanRailState;
+        /** How many cards a column holds. */
+        countOf: (columnId: string) => number;
+        hiddenLabel: string;
+        showAllLabel: string;
+        hiddenItem?: Snippet<[C, {
+            count: number;
+            active: boolean;
+        }]>;
+    };
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<C extends KanbanColumnDef> {
+    props(): ReturnType<typeof $$render<C>>['props'];
+    events(): ReturnType<typeof $$render<C>>['events'];
+    slots(): ReturnType<typeof $$render<C>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <C extends KanbanColumnDef>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<C>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<C>['props']>, ReturnType<__sveltets_Render<C>['events']>, ReturnType<__sveltets_Render<C>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<C>['bindings']>;
+    } & ReturnType<__sveltets_Render<C>['exports']>;
+    <C extends KanbanColumnDef>(internal: unknown, props: ReturnType<__sveltets_Render<C>['props']> & {}): ReturnType<__sveltets_Render<C>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const $$Component: $$IsomorphicComponent;
+type $$Component<C extends KanbanColumnDef> = InstanceType<typeof $$Component<C>>;
+export default $$Component;

package/src/work/kanban-keyboard.ts

@@ -11,6 +11,9 @@ export type KanbanKeyboardConfig<T, C extends KanbanColumnDef> = {
   moveAndPin: (id: string, move: KanbanMove) => void | Promise<void>;
 };
 
+/** A keyboard move: the column the card went to, and the caller's `onMove` result. */
+export type KanbanKeyboardMove<C> = { column: C; done: void | Promise<void> };
+
 /** The card's keydown handler: Enter or Space selects, Alt + arrow moves. */
 export function createCardKeyDown<T, C extends KanbanColumnDef>(
   config: KanbanKeyboardConfig<T, C>,
@@ -19,9 +22,9 @@ export function createCardKeyDown<T, C extends KanbanColumnDef>(
 
   /**
    * Alt + ArrowLeft/Right moves the focused card to the next droppable column, so
-   * keyboard and screen-reader users get drag's onMove contract.
+   * keyboard and screen-reader users get drag's onMove contract. Returns the move, if one ran.
    */
-  return function onCardKeyDown(e: KeyboardEvent, id: string): void {
+  return function onCardKeyDown(e: KeyboardEvent, id: string): KanbanKeyboardMove<C> | undefined {
     const { onSelect, items, getId, getColumn, columns, sortKey, dropAtTop, boardOrder } = input();
     if (onSelect && e.target === e.currentTarget && (e.key === "Enter" || e.key === " ")) {
       e.preventDefault();
@@ -45,7 +48,7 @@ export function createCardKeyDown<T, C extends KanbanColumnDef>(
         const index = atTop ? 0 : column.length;
         const before = column[index - 1];
         const after = column[index];
-        void moveAndPin(id, {
+        const done = moveAndPin(id, {
           columnId: target.id,
           ...(boardOrder
             ? { boardOrder: boardOrderAt(column, index, (entry) => boardOrder(entry)) }
@@ -53,10 +56,9 @@ export function createCardKeyDown<T, C extends KanbanColumnDef>(
           beforeId: before === undefined ? null : getId(before),
           afterId: after === undefined ? null : getId(after),
         });
-      } else {
-        void moveAndPin(id, { columnId: target.id });
+        return { column: target, done };
       }
-      return;
+      return { column: target, done: moveAndPin(id, { columnId: target.id }) };
     }
   };
 }

package/src/work/task-gantt.svelte

@@ -2,6 +2,8 @@
 	import { workLooks } from "../components/work-parts/looks.js";
 	import type { Snippet } from "svelte";
 	import { cn } from "../lib/utils.js";
+	import LiveRegion from "../lib/live-region.svelte";
+	import { focusAfterRender } from "../lib/focus.js";
 	import { dayNumber, isoFromDay, todayIso } from "./dates.js";
 	import GanttGrid from "./gantt/gantt-grid.svelte";
 	import GanttGroupRow from "./gantt/gantt-group-row.svelte";
@@ -54,9 +56,11 @@
 		groups?: KanbanColumnDef[];
 		getGroup?: (item: T) => string;
 		/** Called after a bar is dragged, resized or nudged. Leave it out for a read-only chart. */
-		onChange?: (id: string, change: GanttChange) => void | Promise<void>;
+		onDatesChange?: (id: string, change: GanttChange) => void | Promise<void>;
 		/** Called on a click or Enter that did not move the bar. */
 		onSelect?: (id: string) => void;
+		/** What a screen reader hears after an arrow key moves a bar, given its new dates. */
+		movedLabel?: (dates: string) => string;
 		/** The left column for a row. Defaults to the title. */
 		renderLabel?: Snippet<[T, GanttLabelContext]>;
 		/** First and last day shown. Default: the tasks' span, padded, starting on a Monday. */
@@ -90,8 +94,9 @@
 		getDependsOn,
 		groups,
 		getGroup,
-		onChange,
+		onDatesChange,
 		onSelect,
+		movedLabel = (dates) => `Now ${dates}`,
 		renderLabel,
 		from,
 		to,
@@ -115,6 +120,7 @@
 	let corner = $state<HTMLDivElement>();
 	let drag = $state<Drag | null>(null);
 	let hoveredId = $state<string | null>(null);
+	let live: LiveRegion | undefined = $state();
 	let scrolledToToday = false;
 	// svelte-ignore state_referenced_locally
 	let folded = $state(new Set(collapsed));
@@ -171,6 +177,12 @@
 		return rangeLabel(span, dayFormat);
 	}
 
+	// A chart sorted by date can reorder the moved bar, and a moved node loses focus.
+	async function onKeyMove(id: string, span: Span): Promise<void> {
+		void live?.announce(movedLabel(describe(span)));
+		await focusAfterRender(scroller, `[data-bar="${CSS.escape(id)}"]`);
+	}
+
 	// Open on today, a third of the way in, so past work and what's next both show.
 	$effect(() => {
 		if (!scroller || scrolledToToday) return;
@@ -236,10 +248,11 @@
 							tipBelow={row.order === 0 && !groups}
 							{drag}
 							setDrag={(next) => (drag = next)}
-							onhover={hover}
+							onHover={hover}
 							onToggle={toggle}
-							{onChange}
+							{onDatesChange}
 							{onSelect}
+							onKeyMove={(id, span) => void onKeyMove(id, span)}
 							{renderLabel}
 							{describe}
 						/>
@@ -248,4 +261,5 @@
 			</div>
 		</div>
 	</div>
+	<LiveRegion bind:this={live} />
 </div>