@umriss-ui/schedule 0.4.0 → 0.5.0

package/dist/schedule.js

@@ -1,323 +1,981 @@
 import "./schedule.css";
-var us = Object.defineProperty;
-var fs = (o, t, e) => t in o ? us(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
-var f = (o, t, e) => fs(o, typeof t != "symbol" ? t + "" : t, e);
-import { jsxs as U, Fragment as Et, jsx as k } from "react/jsx-runtime";
-import { useContext as Be, createContext as Ne, useRef as G, useEffect as K, forwardRef as ps, useState as ft, useId as ms, useLayoutEffect as pt, useImperativeHandle as gs, useSyncExternalStore as ks, useMemo as V } from "react";
-import { toWorkingTimeClamped as W, resolveColours as ys, removedIntervals as vs, localOffset as $t, MINUTE as q, calendarFrom as et, toWallClock as j, DAY as Z, timeStep as ws, workingTimeTicks as bs, HOUR as Gt, LinearScale as Ms, subscribeTheme as Ts } from "@umriss-ui/charts";
-import { useFormats as Ht, useWording as kt, AngleGlyph as Is, VisuallyHidden as me } from "@umriss-ui/core";
-const xe = Ne(null), $e = Ne(null);
-function Ge() {
-  return Be($e);
-}
-function Cs(o) {
-  const t = Be(xe);
+var rs = Object.defineProperty;
+var as = (o, t, e) => t in o ? rs(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
+var f = (o, t, e) => as(o, typeof t != "symbol" ? t + "" : t, e);
+import { localOffset as Pt, toWorkingTimeClamped as H, DAY as U, MINUTE as q, timeStep as ls, workingTimeTicks as ds, calendarFrom as et, toWallClock as j, HOUR as Bt, LinearScale as hs, resolveColours as cs, removedIntervals as us, subscribeTheme as fs, Echoes as ps } from "@umriss-ui/charts";
+import { createContext as Fe, useContext as Oe, useRef as G, useEffect as W, forwardRef as Ee, useId as ms, useState as tt, useLayoutEffect as it, useImperativeHandle as gs, useSyncExternalStore as Re, useMemo as X, createElement as ks } from "react";
+import { jsxs as K, Fragment as Dt, jsx as k } from "react/jsx-runtime";
+import { useFormats as xt, useWording as mt, AngleGlyph as ys, VisuallyHidden as he } from "@umriss-ui/core";
+function nt(o) {
+  return { from: o.from - (o.leadIn ?? 0), to: o.to + (o.leadOut ?? 0) };
+}
+function $t(o, t) {
+  return (o.leaves ?? "leadOut") === "main" ? t.to : t.to + (t.leadOut ?? 0);
+}
+function Gt(o, t) {
+  return (o.arrives ?? "leadIn") === "main" ? t.from : t.from - (t.leadIn ?? 0);
+}
+function ce(o, t) {
+  if (t.kind === "place" || t.subtask !== o.id) return o;
+  switch (t.kind) {
+    case "move":
+    case "stretch":
+      return { ...o, from: t.from, to: t.to };
+    case "leadIn":
+      return { ...o, leadIn: t.leadIn };
+    case "leadOut":
+      return { ...o, leadOut: t.leadOut };
+    case "lane":
+      return { ...o, lane: t.lane };
+  }
+}
+function po(o, t) {
+  return {
+    id: t,
+    task: o.task,
+    lane: o.lane,
+    from: o.from,
+    to: o.to,
+    ...o.leadIn === void 0 ? {} : { leadIn: o.leadIn },
+    ...o.leadOut === void 0 ? {} : { leadOut: o.leadOut }
+  };
+}
+function Ht(o) {
+  const t = [], e = /* @__PURE__ */ new Map();
+  o.forEach((s, n) => {
+    const { from: i, to: r } = nt(s);
+    if (!(i < r)) return;
+    const a = e.get(s.lane) ?? [];
+    a.push({ subtask: s, index: n, from: i, to: r }), e.set(s.lane, a);
+  });
+  for (const [s, n] of e) {
+    n.sort((i, r) => i.from - r.from || i.index - r.index);
+    for (let i = 0; i < n.length; i++) {
+      const r = n[i];
+      for (let a = i + 1; a < n.length; a++) {
+        const d = n[a];
+        if (d.from >= r.to) break;
+        t.push({ lane: s, first: r.subtask.id, second: d.subtask.id, from: d.from, to: Math.min(r.to, d.to) });
+      }
+    }
+  }
+  return t;
+}
+function vs(o) {
+  const t = /* @__PURE__ */ new Map(), e = /* @__PURE__ */ new Map();
+  for (const s of o) {
+    const n = nt(s), i = e.get(s.lane) ?? [];
+    let r = 0;
+    if (n.from < n.to) {
+      for (const a of i) n.from < a.to && a.from < n.to && r++;
+      i.push(n);
+    }
+    e.set(s.lane, i), t.set(s.id, r);
+  }
+  return t;
+}
+function Yt(o, t) {
+  const e = new Map(o.map((n) => [n.id, n])), s = [];
+  for (const n of t) {
+    const i = e.get(n.from), r = e.get(n.to);
+    if (i === void 0 || r === void 0) continue;
+    const a = $t(n, i), d = Gt(n, r), h = a + n.lag - d;
+    h > 0 && s.push({ dependency: n.id, departure: a, arrival: d, shortBy: h });
+  }
+  return s;
+}
+function Ne(o, t) {
+  const e = [];
+  for (const s of o) {
+    const n = nt(s);
+    for (const i of t)
+      i.lane !== s.lane || !(n.from < i.to && i.from < n.to) || e.push({ subtask: s.id, blocked: i.id, lane: i.lane, from: Math.max(n.from, i.from), to: Math.min(n.to, i.to) });
+  }
+  return e;
+}
+function mo(o, t, e = []) {
+  return {
+    overlaps: Ht(o),
+    violatedDependencies: Yt(o, t),
+    inBlockedTime: Ne(o, e)
+  };
+}
+function go(o, t, e) {
+  if (e.kind === "place") return [];
+  const s = new Map(o.map((d) => [d.id, ce(d, e)])), n = /* @__PURE__ */ new Map();
+  for (const d of t) {
+    const h = n.get(d.from) ?? [];
+    h.push(d), n.set(d.from, h);
+  }
+  const i = /* @__PURE__ */ new Map(), r = [e.subtask];
+  let a = (o.length + 1) * (t.length + 1);
+  for (; r.length > 0 && a-- > 0; ) {
+    const d = r.shift(), h = s.get(d);
+    if (h !== void 0)
+      for (const l of n.get(d) ?? []) {
+        if (l.to === e.subtask) continue;
+        const c = s.get(l.to);
+        if (c === void 0) continue;
+        const p = $t(l, h) + l.lag - Gt(l, c);
+        if (!(p > 0)) continue;
+        const m = { kind: "move", subtask: c.id, from: c.from + p, to: c.to + p };
+        s.set(c.id, ce(c, m)), i.set(c.id, m), r.push(c.id);
+      }
+  }
+  return [...i.values()];
+}
+function ws(o, t) {
+  const { step: e, offset: s } = typeof t == "number" ? { step: t, offset: 0 } : t;
+  if (!(e > 0) || !Number.isFinite(o)) return o;
+  const n = Pt(o) + s;
+  return n + Math.round((o - n) / e) * e;
+}
+function ko(o, t, e) {
+  return e === 0 || !Number.isFinite(e) ? [] : o.filter((s) => s.task === t).map((s) => ({ kind: "move", subtask: s.id, from: s.from + e, to: s.to + e }));
+}
+function gt(o) {
+  let t = !1, e = !1, s = !1, n = !1;
+  for (const i of o ?? [])
+    i === "provisional" ? (t = !0, e = !1) : i === "fixed" ? (e = !0, t = !1) : i === "muted" ? s = !0 : i === "open" && (n = !0);
+  return { dashed: t, hatched: e, muted: s, open: n };
+}
+const Pe = Fe(null), Be = Fe(null);
+function xe() {
+  return Oe(Be);
+}
+function bs(o) {
+  const t = Oe(Pe);
   if (t === null)
     throw new Error(`@umriss-ui/schedule: <${o}> must be used inside a <Schedule>.`);
   return t;
 }
-function Yt(o, t, e, n, s) {
-  const i = Cs(o), r = G(null);
-  K(() => (r.current = e(i, t), () => {
-    r.current !== null && s(i, r.current), r.current = null;
-  }), [i]), K(() => {
-    r.current !== null && n(i, r.current, t);
+function zt(o, t, e, s, n) {
+  const i = bs(o), r = G(null);
+  W(() => (r.current = e(i, t), () => {
+    r.current !== null && n(i, r.current), r.current = null;
+  }), [i]), W(() => {
+    r.current !== null && s(i, r.current, t);
   });
 }
-function Ss(o) {
-  Yt("Lane", o, (t, e) => t.registerLane(e), (t, e, n) => t.updateLane(e, n), (t, e) => t.unregisterLane(e));
-}
-function Ls(o) {
-  Yt("LaneGroup", o, (t, e) => t.registerGroup(e), (t, e, n) => t.updateGroup(e, n), (t, e) => t.unregisterGroup(e));
+function Ms(o) {
+  zt("Lane", o, (t, e) => t.registerLane(e), (t, e, s) => t.updateLane(e, s), (t, e) => t.unregisterLane(e));
 }
-function zt(o, t) {
-  Yt(o, t, (e, n) => e.registerLayer(n), (e, n, s) => e.updateLayer(n, s), (e, n) => e.unregisterLayer(n));
+function Ts(o) {
+  zt("LaneGroup", o, (t, e) => t.registerGroup(e), (t, e, s) => t.updateGroup(e, s), (t, e) => t.unregisterGroup(e));
 }
-function yt(o) {
-  let t = !1, e = !1, n = !1, s = !1;
-  for (const i of o ?? [])
-    i === "provisional" ? (t = !0, e = !1) : i === "fixed" ? (e = !0, t = !1) : i === "muted" ? n = !0 : i === "open" && (s = !0);
-  return { dashed: t, hatched: e, muted: n, open: s };
-}
-const As = 24, Ds = 4, _s = 3, At = 4;
-function ge(o) {
-  const { lanes: t, groups: e, collapsed: n, laneHeight: s } = o, i = new Map(e.map((g) => [g.id, g])), r = (g) => g !== void 0 && i.has(g) ? g : void 0, a = /* @__PURE__ */ new Map(), l = (g) => {
-    const I = [];
-    let L = r(g.parent);
-    const R = /* @__PURE__ */ new Set();
-    for (; L !== void 0 && !R.has(L); )
-      R.add(L), I.unshift(L), L = r(i.get(L).parent);
-    return I;
+function Kt(o, t) {
+  zt(o, t, (e, s) => e.registerLayer(s), (e, s, n) => e.updateLayer(s, n), (e, s) => e.unregisterLayer(s));
+}
+const Is = 24, Ss = 4, Ls = 3, St = 4;
+function ue(o) {
+  const { lanes: t, groups: e, collapsed: s, laneHeight: n } = o, i = new Map(e.map((g) => [g.id, g])), r = (g) => g !== void 0 && i.has(g) ? g : void 0, a = /* @__PURE__ */ new Map(), d = (g) => {
+    const T = [];
+    let S = r(g.parent);
+    const E = /* @__PURE__ */ new Set();
+    for (; S !== void 0 && !E.has(S); )
+      E.add(S), T.unshift(S), S = r(i.get(S).parent);
+    return T;
   }, h = /* @__PURE__ */ new Map();
   for (const g of t) {
-    const I = l(g);
-    h.set(g.id, I);
-    for (const L of I) {
-      const R = a.get(L) ?? [];
-      R.push(g.id), a.set(L, R);
+    const T = d(g);
+    h.set(g.id, T);
+    for (const S of T) {
+      const E = a.get(S) ?? [];
+      E.push(g.id), a.set(S, E);
     }
   }
-  const d = [], u = /* @__PURE__ */ new Map();
+  const l = [], c = /* @__PURE__ */ new Map();
   let p = [], m = null, y = 0;
-  const S = (g) => (d.push({ ...g, top: y }), y += g.height, d.length - 1), A = (g) => g.find((I) => n.has(I)), D = () => {
+  const I = (g) => (l.push({ ...g, top: y }), y += g.height, l.length - 1), A = (g) => g.find((T) => s.has(T)), C = () => {
     if (m === null) return;
-    const { row: g, lanes: I } = m, L = d[g], R = Math.max(L.height, I.length * Ds + 2 * At);
-    d[g] = { ...L, height: R }, y += R - L.height;
-    const O = R - 2 * At, H = Math.max(_s, Math.floor(O / I.length));
-    I.forEach((ot, ct) => {
-      const J = h.get(ot) ?? [];
-      u.set(ot, {
-        top: L.top + At + ct * H,
-        height: H,
+    const { row: g, lanes: T } = m, S = l[g], E = Math.max(S.height, T.length * Ss + 2 * St);
+    l[g] = { ...S, height: E }, y += E - S.height;
+    const D = E - 2 * St, P = Math.max(Ls, Math.floor(D / T.length));
+    T.forEach((ot, kt) => {
+      const ct = h.get(ot) ?? [];
+      c.set(ot, {
+        top: S.top + St + kt * P,
+        height: P,
         miniature: !0,
-        group: J[J.length - 1]
+        group: ct[ct.length - 1]
       });
     }), m = null;
   };
   for (const g of t) {
-    const I = (h.get(g.id) ?? []).filter((O) => (a.get(O) ?? []).length > 0), L = A(I);
-    if (m !== null && L === m.group) {
+    const T = (h.get(g.id) ?? []).filter((D) => (a.get(D) ?? []).length > 0), S = A(T);
+    if (m !== null && S === m.group) {
       m.lanes.push(g.id);
       continue;
     }
-    D();
-    const R = I.filter((O, H) => p[H] === O).length;
-    p = p.slice(0, R);
-    for (const O of I.slice(R)) {
-      if (p.push(O), O === L) break;
-      S({
+    C();
+    const E = T.filter((D, P) => p[P] === D).length;
+    p = p.slice(0, E);
+    for (const D of T.slice(E)) {
+      if (p.push(D), D === S) break;
+      I({
         kind: "groupHead",
         lane: void 0,
-        group: O,
+        group: D,
         depth: p.length - 1,
         within: [...p],
-        lanes: (a.get(O) ?? []).length,
-        height: As
+        lanes: (a.get(D) ?? []).length,
+        height: Is
       });
     }
-    if (L !== void 0) {
-      const O = I.indexOf(L), H = S({
+    if (S !== void 0) {
+      const D = T.indexOf(S), P = I({
         kind: "miniature",
         lane: void 0,
-        group: L,
-        depth: O,
-        within: I.slice(0, O + 1),
-        lanes: (a.get(L) ?? []).length,
-        height: s
+        group: S,
+        depth: D,
+        within: T.slice(0, D + 1),
+        lanes: (a.get(S) ?? []).length,
+        height: n
       });
-      m = { group: L, row: H, lanes: [g.id] };
+      m = { group: S, row: P, lanes: [g.id] };
       continue;
     }
-    S({ kind: "lane", lane: g.id, group: I[I.length - 1], depth: I.length, within: I, lanes: 1, height: s }), u.set(g.id, {
-      top: d[d.length - 1].top,
-      height: s,
+    I({ kind: "lane", lane: g.id, group: T[T.length - 1], depth: T.length, within: T, lanes: 1, height: n }), c.set(g.id, {
+      top: l[l.length - 1].top,
+      height: n,
       miniature: !1,
-      group: I[I.length - 1]
+      group: T[T.length - 1]
     });
   }
-  return D(), { rows: d, slots: u, height: y };
+  return C(), { rows: l, slots: c, height: y };
 }
-function Fs(o, t) {
+function As(o, t) {
   if (t.size === 0) return o;
   const e = /* @__PURE__ */ new Set();
-  for (const n of o) t.has(n) || e.add(n);
+  for (const s of o) t.has(s) || e.add(s);
   return e;
 }
 function st(o, t) {
   if (t < 0 || t >= o.height) return null;
-  let e = 0, n = o.rows.length - 1;
-  for (; e <= n; ) {
-    const s = e + n >> 1, i = o.rows[s];
-    if (t < i.top) n = s - 1;
-    else if (t >= i.top + i.height) e = s + 1;
+  let e = 0, s = o.rows.length - 1;
+  for (; e <= s; ) {
+    const n = e + s >> 1, i = o.rows[n];
+    if (t < i.top) s = n - 1;
+    else if (t >= i.top + i.height) e = n + 1;
     else return i;
   }
   return null;
 }
-function Kt(o, t) {
+function Vt(o, t) {
   return o.slots.get(t) ?? null;
 }
-function Os(o, t) {
+function Cs(o, t) {
   const e = st(o, t);
   if (e === null) return null;
   if (e.kind === "lane") return e.lane ?? null;
   if (e.kind === "groupHead") return null;
-  for (const [n, s] of o.slots)
-    if (s.miniature && t >= s.top && t < s.top + s.height) return n;
+  for (const [s, n] of o.slots)
+    if (n.miniature && t >= n.top && t < n.top + n.height) return s;
   return null;
 }
-function nt(o) {
-  return { from: o.from - (o.leadIn ?? 0), to: o.to + (o.leadOut ?? 0) };
-}
-function Ut(o, t) {
-  return (o.leaves ?? "leadOut") === "main" ? t.to : t.to + (t.leadOut ?? 0);
-}
-function Wt(o, t) {
-  return (o.arrives ?? "leadIn") === "main" ? t.from : t.from - (t.leadIn ?? 0);
-}
-function ke(o, t) {
-  if (t.kind === "place" || t.subtask !== o.id) return o;
-  switch (t.kind) {
-    case "move":
-    case "stretch":
-      return { ...o, from: t.from, to: t.to };
-    case "leadIn":
-      return { ...o, leadIn: t.leadIn };
-    case "leadOut":
-      return { ...o, leadOut: t.leadOut };
-    case "lane":
-      return { ...o, lane: t.lane };
-  }
-}
-function uo(o, t) {
-  return {
-    id: t,
-    task: o.task,
-    lane: o.lane,
-    from: o.from,
-    to: o.to,
-    ...o.leadIn === void 0 ? {} : { leadIn: o.leadIn },
-    ...o.leadOut === void 0 ? {} : { leadOut: o.leadOut }
-  };
-}
-const Es = 6, He = 3, rt = 2, ye = 3, ve = 3;
-function B(o, t) {
-  return Math.round(o.scale.toPx(W(t, o.calendar)));
+const _s = 6, $e = 3, rt = 2, fe = 3, pe = 3;
+function N(o, t) {
+  return Math.round(o.scale.toPx(H(t, o.calendar)));
 }
 function dt(o, t) {
-  const e = Kt(o.rows, t);
+  const e = Vt(o.rows, t);
   return e === null ? null : { ...e, top: e.top - o.scrollY };
 }
-function we(o, t) {
-  return Os(o.rows, t + o.scrollY);
+function me(o, t) {
+  return Cs(o.rows, t + o.scrollY);
 }
-function Ye(o, t, e, n, s) {
-  const i = n.miniature ? 0 : Es, r = n.miniature ? 0 : ve * ye, a = Math.max(n.miniature ? 1 : 4, n.height - 2 * i - r), l = n.top - o.scrollY + Math.floor((n.height - a) / 2), h = nt(t);
+function Ge(o, t, e, s, n) {
+  const i = s.miniature ? 0 : _s, r = s.miniature ? 0 : pe * fe, a = Math.max(s.miniature ? 1 : 4, s.height - 2 * i - r), d = s.top - o.scrollY + Math.floor((s.height - a) / 2), h = nt(t);
   return {
     subtask: t,
     lane: e,
-    miniature: n.miniature,
-    depth: s,
-    y: l + (n.miniature ? 0 : Math.min(s, ve) * ye),
+    miniature: s.miniature,
+    depth: n,
+    y: d + (s.miniature ? 0 : Math.min(n, pe) * fe),
     height: a,
-    outerFrom: B(o, h.from),
-    mainFrom: B(o, t.from),
-    mainTo: B(o, t.to),
-    outerTo: B(o, h.to)
+    outerFrom: N(o, h.from),
+    mainFrom: N(o, t.from),
+    mainTo: N(o, t.to),
+    outerTo: N(o, h.to)
   };
 }
-function ze(o, t, e) {
+function He(o, t, e) {
   if (e < o.y || e > o.y + o.height) return null;
-  const n = Math.max(0, (6 - (o.outerTo - o.outerFrom)) / 2);
-  return t < o.outerFrom - n || t > o.outerTo + n ? null : t < o.mainFrom ? "leadIn" : t > o.mainTo ? "leadOut" : "main";
+  const s = Math.max(0, (6 - (o.outerTo - o.outerFrom)) / 2);
+  return t < o.outerFrom - s || t > o.outerTo + s ? null : t < o.mainFrom ? "leadIn" : t > o.mainTo ? "leadOut" : "main";
 }
-function Rs(o, t, e, n = 5) {
+function Ds(o, t, e, s = 5) {
   if (e < o.y || e > o.y + o.height) return null;
-  const s = Math.abs(t - o.mainFrom), i = Math.abs(t - o.mainTo);
-  return Math.min(s, i) > n ? null : s <= i ? "from" : "to";
+  const n = Math.abs(t - o.mainFrom), i = Math.abs(t - o.mainTo);
+  return Math.min(n, i) > s ? null : n <= i ? "from" : "to";
 }
-function Rt(o, t, e) {
+function Ft(o, t, e) {
   return o.outerTo >= 0 && o.outerFrom <= t && o.y + o.height >= 0 && o.y <= e;
 }
-const Ps = 64;
-function Bs(o, t) {
+const Fs = 64;
+function Os(o, t) {
   if (o.miniature) return null;
-  const e = yt(o.subtask.appearance).hatched ? rt + He + 1 : 0, n = Math.max(o.mainFrom + e, 0), s = Math.min(o.mainTo - e, t) - n;
-  return s < Ps ? null : { x: n, width: s, y: o.y, height: o.height };
+  const e = gt(o.subtask.appearance).hatched ? rt + $e + 1 : 0, s = Math.max(o.mainFrom + e, 0), n = Math.min(o.mainTo - e, t) - s;
+  return n < Fs ? null : { x: s, width: n, y: o.y, height: o.height };
 }
-const Ns = 10;
-function be(o, t, e) {
-  const n = Math.round(t.y + t.height / 2);
-  return o === "centre" || e.y === t.y ? n : Math.round(e.y > t.y ? t.y + t.height - 1 : t.y + 1);
+const Es = 10;
+function ge(o, t, e) {
+  const s = Math.round(t.y + t.height / 2);
+  return o === "centre" || e.y === t.y ? s : Math.round(e.y > t.y ? t.y + t.height - 1 : t.y + 1);
 }
-function Pt(o, t, e, n, s) {
-  const i = t.route ?? s.route, r = t.attach ?? s.attach, a = t.ends ?? s.ends, l = B(o, Ut(t, e.subtask)), h = B(o, Wt(t, n.subtask)), d = be(r, e, n), u = be(r, n, e);
+function Ot(o, t, e, s, n) {
+  const i = t.route ?? n.route, r = t.attach ?? n.attach, a = t.ends ?? n.ends, d = N(o, $t(t, e.subtask)), h = N(o, Gt(t, s.subtask)), l = ge(r, e, s), c = ge(r, s, e);
   if (i === "straight")
-    return { dependency: t, kind: i, ends: a, x1: l, y1: d, x2: h, y2: u, c1x: l, c2x: h, points: [l, d, h, u] };
+    return { dependency: t, kind: i, ends: a, x1: d, y1: l, x2: h, y2: c, c1x: d, c2x: h, points: [d, l, h, c] };
   if (i === "orthogonal") {
-    const A = l + Ns, D = d === u ? A : Math.round((A + h) / 2);
-    return { dependency: t, kind: i, ends: a, x1: l, y1: d, x2: h, y2: u, c1x: l, c2x: h, points: d === u ? [l, d, h, u] : [l, d, D, d, D, u, h, u] };
+    const A = d + Es, C = l === c ? A : Math.round((A + h) / 2);
+    return { dependency: t, kind: i, ends: a, x1: d, y1: l, x2: h, y2: c, c1x: d, c2x: h, points: l === c ? [d, l, h, c] : [d, l, C, l, C, c, h, c] };
   }
-  const p = Math.max(14, Math.abs(h - l) / 2), m = l + p, y = h - p, S = [];
+  const p = Math.max(14, Math.abs(h - d) / 2), m = d + p, y = h - p, I = [];
   for (let A = 0; A <= 16; A++) {
-    const D = A / 16, g = 1 - D;
-    S.push(
-      g * g * g * l + 3 * g * g * D * m + 3 * g * D * D * y + D * D * D * h,
-      g * g * g * d + 3 * g * g * D * d + 3 * g * D * D * u + D * D * D * u
+    const C = A / 16, g = 1 - C;
+    I.push(
+      g * g * g * d + 3 * g * g * C * m + 3 * g * C * C * y + C * C * C * h,
+      g * g * g * l + 3 * g * g * C * l + 3 * g * C * C * c + C * C * C * c
     );
   }
-  return { dependency: t, kind: "curve", ends: a, x1: l, y1: d, x2: h, y2: u, c1x: m, c2x: y, points: S };
+  return { dependency: t, kind: "curve", ends: a, x1: d, y1: l, x2: h, y2: c, c1x: m, c2x: y, points: I };
+}
+function Rs(o, t, e) {
+  let s = 1 / 0;
+  const n = o.points;
+  for (let i = 0; i + 3 < n.length; i += 2) {
+    const r = n[i], a = n[i + 1], d = n[i + 2], h = n[i + 3], l = d - r, c = h - a, p = l * l + c * c, m = p === 0 ? 0 : Math.max(0, Math.min(1, ((t - r) * l + (e - a) * c) / p));
+    s = Math.min(s, Math.hypot(t - (r + m * l), e - (a + m * c)));
+  }
+  return s;
+}
+const Ye = [], Ns = 56;
+function Ps(o, t = Ns) {
+  return o > 0 ? Math.min(U, Math.max(15 * q, ls(o * t, 1))) : 15 * q;
+}
+function Bs(o, t, e = Ye) {
+  const [s, n] = ze(o, e);
+  return ds(e, s, n, t, Pt(s)).filter(
+    (i) => i.workingTime >= o[0] && i.workingTime <= o[1]
+  );
 }
-function xs(o, t, e) {
-  let n = 1 / 0;
-  const s = o.points;
-  for (let i = 0; i + 3 < s.length; i += 2) {
-    const r = s[i], a = s[i + 1], l = s[i + 2], h = s[i + 3], d = l - r, u = h - a, p = d * d + u * u, m = p === 0 ? 0 : Math.max(0, Math.min(1, ((t - r) * d + (e - a) * u) / p));
-    n = Math.min(n, Math.hypot(t - (r + m * d), e - (a + m * u)));
+function xs(o, t = Ye) {
+  const [e, s] = ze(o, t), n = [], i = new Date(e);
+  for (i.setHours(0, 0, 0, 0); i.getTime() < s && n.length < 400; ) {
+    const r = i.getTime();
+    i.setDate(i.getDate() + 1);
+    const a = i.getTime();
+    n.push({
+      start: r,
+      end: a,
+      from: H(r, t),
+      to: H(a, t)
+    });
   }
   return n;
 }
-function Xt(o) {
-  const t = [], e = /* @__PURE__ */ new Map();
-  o.forEach((n, s) => {
-    const { from: i, to: r } = nt(n);
-    if (!(i < r)) return;
-    const a = e.get(n.lane) ?? [];
-    a.push({ subtask: n, index: s, from: i, to: r }), e.set(n.lane, a);
-  });
-  for (const [n, s] of e) {
-    s.sort((i, r) => i.from - r.from || i.index - r.index);
-    for (let i = 0; i < s.length; i++) {
-      const r = s[i];
-      for (let a = i + 1; a < s.length; a++) {
-        const l = s[a];
-        if (l.from >= r.to) break;
-        t.push({ lane: n, first: r.subtask.id, second: l.subtask.id, from: l.from, to: Math.min(r.to, l.to) });
+const Lt = [1, 2, 7, 14, 28];
+function $s(o, t) {
+  return Lt.find((e) => e * o >= t) ?? Lt[Lt.length - 1];
+}
+function At(o, t) {
+  return ((Math.round((o - Pt(o)) / U) - 4) % t + t) % t === 0;
+}
+function Gs(o, t, e, s) {
+  const n = o[1] - o[0];
+  if (!(n > 0)) return [o[0], o[1]];
+  const i = Math.min(s.max, Math.max(s.min, n * e)), r = (t - o[0]) / n, a = t - r * i;
+  return [a, a + i];
+}
+function Hs(o, t) {
+  return [o[0] + t, o[1] + t];
+}
+function ze(o, t) {
+  const e = et(t);
+  if (e.intervals.length === 0) return [o[0], o[1]];
+  const s = (n) => Math.max(0, Math.min(e.total, n));
+  return [j(s(o[0]), e), j(s(o[1]), e)];
+}
+const pt = 44;
+class Ys {
+  constructor(t) {
+    f(this, "options", {
+      laneHeight: pt,
+      calendar: [],
+      zoomLimits: { min: Bt, max: 28 * U },
+      snap: "ticks",
+      intents: [],
+      now: null,
+      route: "curve",
+      attach: "centre",
+      ends: "dot"
+    });
+    f(this, "domain", [0, U]);
+    f(this, "scrollY", 0);
+    f(this, "width", 0);
+    f(this, "height", 0);
+    /* What is laid out from top to bottom (`rows.ts`). It is derived here and
+       not in the data, because a row's height comes from a view option; every y
+       in the package reads it. */
+    f(this, "rows", ue({ lanes: [], groups: [], collapsed: /* @__PURE__ */ new Set(), laneHeight: pt }));
+    /** The folded groups, as the scene holds them. */
+    f(this, "collapsed", /* @__PURE__ */ new Set());
+    /** The groups a gesture in flight holds open. Dropped when it ends; the
+        caller's list never learns of it. */
+    f(this, "openForGesture", /* @__PURE__ */ new Set());
+    f(this, "boxes", []);
+    f(this, "boxById", /* @__PURE__ */ new Map());
+    f(this, "paths", []);
+    this.data = t;
+  }
+  /** Takes new options; a new calendar keeps the wall-clock span in view. */
+  setOptions(t) {
+    const e = t.calendar !== this.options.calendar, s = this.options.calendar;
+    if (this.options = t, e) {
+      const n = et(s), i = (r) => {
+        const a = n.intervals.length === 0 ? r : Math.max(0, Math.min(n.total, r));
+        return H(j(a, n), t.calendar) + (r - a);
+      };
+      this.domain = [i(this.domain[0]), i(this.domain[1])];
+    }
+  }
+  /** Puts a span of two wall-clock instants in view. */
+  showWall(t) {
+    this.domain = [H(t[0], this.options.calendar), H(t[1], this.options.calendar)];
+  }
+  viewport() {
+    return {
+      scale: new hs(this.domain, [0, this.width]),
+      calendar: this.options.calendar,
+      laneHeight: this.options.laneHeight,
+      scrollY: this.scrollY,
+      rows: this.rows
+    };
+  }
+  maxScroll() {
+    return Math.max(0, this.rows.height - this.height);
+  }
+  /** The lowest y that still lies on a lane. */
+  lanesBottom() {
+    return this.rows.height - this.scrollY - 1;
+  }
+  /** The fine band's step at the current zoom. */
+  step() {
+    const t = this.domain[1] - this.domain[0];
+    return Ps(this.width > 0 ? t / this.width : t);
+  }
+  /** Lays the rows out, clamps the scroll, and lays the data out anew. */
+  layout() {
+    this.rows = ue({
+      lanes: this.data.lanes,
+      groups: this.data.groups,
+      collapsed: As(this.collapsed, this.openForGesture),
+      laneHeight: this.options.laneHeight
+    }), this.scrollY = Math.max(0, Math.min(this.maxScroll(), this.scrollY));
+    const t = this.viewport();
+    this.boxes = [], this.boxById = /* @__PURE__ */ new Map();
+    for (const e of this.data.subtasks) {
+      const s = Vt(this.rows, e.lane);
+      if (s === null) continue;
+      const n = Ge(t, e, e.lane, s, this.data.depth.get(e.id) ?? 0);
+      this.boxes.push(n), this.boxById.set(e.id, n);
+    }
+    this.paths = [];
+    for (const e of this.data.dependencies) {
+      const s = this.boxById.get(e.from), n = this.boxById.get(e.to);
+      s === void 0 || n === void 0 || this.paths.push(Ot(t, e, s, n, this.options));
+    }
+  }
+  /** The days of the coarse band and the ticks of the fine band, in pixels. */
+  bands() {
+    const t = this.step();
+    if (this.width <= 0) return { days: [], ticks: [], step: t };
+    const e = this.viewport().scale, s = this.options.calendar;
+    return {
+      days: xs(this.domain, s).map((n) => {
+        const i = Math.round(e.toPx(n.from));
+        return { start: n.start, x: i, width: Math.round(e.toPx(n.to)) - i };
+      }),
+      ticks: Bs(this.domain, t, s).map((n) => ({ wallClock: n.wallClock, x: Math.round(e.toPx(n.workingTime)) })),
+      step: t
+    };
+  }
+  /** The now line's x, or null where there is none or it lies outside the plot. */
+  nowX() {
+    const t = this.options.now;
+    if (t === null || this.width <= 0) return null;
+    const e = Math.round(this.viewport().scale.toPx(H(t, this.options.calendar)));
+    return e >= 0 && e <= this.width ? e : null;
+  }
+  hitAt(t, e) {
+    for (let r = this.boxes.length - 1; r >= 0; r--) {
+      const a = this.boxes[r], d = He(a, t, e);
+      if (d !== null) return { kind: "subtask", subtask: a.subtask, part: d };
+    }
+    let s = null, n = 4;
+    for (const r of this.paths) {
+      const a = Rs(r, t, e);
+      a <= n && (n = a, s = r);
+    }
+    if (s !== null) return { kind: "dependency", dependency: s.dependency };
+    const i = me(this.viewport(), e);
+    return i !== null ? { kind: "lane", lane: i } : { kind: "nothing" };
+  }
+  /** The wall-clock time at a plot x; within the calendar's extent. */
+  timeAt(t) {
+    const e = this.viewport().scale.fromPx(t), s = et(this.options.calendar);
+    return s.intervals.length === 0 ? e : j(Math.max(0, Math.min(s.total, e)), s);
+  }
+  /** The lane at a y, strips included: what the pointer is ON.
+  
+        One line, and it stays a line of its own: it is one of the three
+        questions this object answers about a y - this one, `dropLaneIdAt` and
+        `foldedGroupAt` - and a caller that reached through `viewport()` for it
+        would be depending on the layout rather than asking the view. */
+  laneIdAt(t) {
+    return me(this.viewport(), t);
+  }
+  /** The lane a DROP at this y would land on.
+  
+        A **Miniature** is no drop target. A strip is three pixels of a lane's
+        whole day, and a drop aimed at one would be a guess; resting over the
+        group opens it for the gesture instead, and then there is a real lane to
+        aim at. Hover, the tooltip and selection do read a strip - they cost
+        nothing if they are a pixel out. */
+  dropLaneIdAt(t) {
+    const e = st(this.rows, t + this.scrollY);
+    return e === null || e.kind !== "lane" ? null : e.lane ?? null;
+  }
+  /** The folded group a y lies over, or null. */
+  foldedGroupAt(t) {
+    const e = st(this.rows, t + this.scrollY);
+    return e !== null && e.kind === "miniature" ? e.group ?? null : null;
+  }
+  /** Pans by pixels. Says what moved: the span through time, the lanes, or
+      neither - a scroll through the lanes is no news about the time. */
+  pan(t, e) {
+    const s = this.domain[0], n = this.scrollY, i = this.domain[1] - s;
+    this.width > 0 && t !== 0 && (this.domain = Hs(this.domain, t / this.width * i)), this.scrollY = Math.max(0, Math.min(this.maxScroll(), this.scrollY + e));
+    const r = this.domain[0] !== s;
+    return { moved: r || this.scrollY !== n, time: r };
+  }
+  /** Zooms around a plot x; says whether the span changed. */
+  zoomAt(t, e) {
+    if (this.width <= 0 || !Number.isFinite(e)) return !1;
+    const s = this.domain, n = this.viewport().scale.fromPx(t);
+    return this.domain = Gs(this.domain, n, e, this.options.zoomLimits), s[0] !== this.domain[0] || s[1] !== this.domain[1];
+  }
+}
+const zs = "_root_1892z_4 _text_r8i8z_23", Ks = "_corner_1892z_19", Vs = "_dayBand_1892z_23", Ws = "_tickBand_1892z_24", Us = "_day_1892z_23", Xs = "_dayLabel_1892z_50", qs = "_tick_1892z_24", js = "_tickLabel_1892z_71", Js = "_headers_1892z_79", Zs = "_header_1892z_79", Qs = "_headerLabel_1892z_97", tn = "_headerCount_1892z_134", en = "_chevron_1892z_143", sn = "_plot_1892z_201", nn = "_focusRing_1892z_208", on = "_layer_1892z_226", rn = "_grip_1892z_235", an = "_ghostLabel_1892z_245", ln = "_finding_1892z_258", dn = "_refusal_1892z_266", hn = "_tooltip_1892z_270", cn = "_tooltipHead_1892z_289", un = "_tooltipTimes_1892z_294", fn = "_now_1892z_303", pn = "_barLabel_1892z_317", mn = "_barLabelText_1892z_330", v = {
+  root: zs,
+  corner: Ks,
+  dayBand: Vs,
+  tickBand: Ws,
+  day: Us,
+  dayLabel: Xs,
+  tick: qs,
+  tickLabel: js,
+  headers: Js,
+  header: Zs,
+  headerLabel: Qs,
+  headerCount: tn,
+  chevron: en,
+  plot: sn,
+  focusRing: nn,
+  layer: on,
+  grip: rn,
+  ghostLabel: an,
+  finding: ln,
+  refusal: dn,
+  tooltip: hn,
+  tooltipHead: cn,
+  tooltipTimes: un,
+  now: fn,
+  barLabel: pn,
+  barLabelText: mn
+};
+function Ke() {
+  const o = mt();
+  return (t) => {
+    const e = Math.round(t / q), s = Math.floor(e / 60), n = e % 60;
+    return [s > 0 ? o.hoursShort(s) : "", n > 0 || s === 0 ? o.minutesShort(n) : ""].filter(Boolean).join(" ");
+  };
+}
+function gn({ target: o, lane: t }) {
+  const e = xt(), s = mt(), n = Ke(), i = (c) => e.time(new Date(c), !1);
+  if (o.kind === "subtask") {
+    const { subtask: c, task: p } = o, m = [
+      (p == null ? void 0 : p.name) ?? c.task,
+      c.name ?? c.id,
+      `${e.dateShort(new Date(c.from))} ${s.scheduleGhostTimes(i(c.from), i(c.to))}`,
+      ...o.overlapping.map((y) => s.scheduleOverlapWith(y.name ?? y.id)),
+      ...o.violatedDependencies.map((y) => s.scheduleViolatedBy(n(y.shortBy))),
+      ...o.blocked.map((y) => s.scheduleInBlockedTime(y.label))
+    ];
+    return /* @__PURE__ */ K(Dt, { children: [
+      t,
+      `, ${m.join(", ")}`
+    ] });
+  }
+  const { dependency: r, task: a, from: d, to: h, violated: l } = o;
+  return [
+    (a == null ? void 0 : a.name) ?? (a == null ? void 0 : a.id) ?? r.id,
+    `${s.scheduleDependency} ${n(r.lag)}`,
+    s.scheduleRoute((d == null ? void 0 : d.name) ?? r.from, (h == null ? void 0 : h.name) ?? r.to),
+    ...l === void 0 ? [] : [s.scheduleViolatedBy(n(l.shortBy))]
+  ].join(", ");
+}
+function kn({ target: o }) {
+  const t = xt(), e = mt(), s = (l) => t.time(new Date(l), !1), n = Ke();
+  if (o.kind === "subtask") {
+    const { subtask: l, task: c } = o;
+    return /* @__PURE__ */ K(Dt, { children: [
+      /* @__PURE__ */ k("span", { className: v.tooltipHead, children: (c == null ? void 0 : c.name) ?? l.task }),
+      /* @__PURE__ */ k("span", { children: l.name ?? l.id }),
+      /* @__PURE__ */ k("span", { className: v.tooltipTimes, children: e.scheduleGhostTimes(s(l.from), s(l.to)) }),
+      (l.leadIn ?? 0) > 0 && /* @__PURE__ */ k("span", { children: `${e.scheduleLeadIn} ${n(l.leadIn)}` }),
+      (l.leadOut ?? 0) > 0 && /* @__PURE__ */ k("span", { children: `${e.scheduleLeadOut} ${n(l.leadOut)}` }),
+      o.overlapping.map((p) => /* @__PURE__ */ k("span", { className: v.finding, children: e.scheduleOverlapWith(p.name ?? p.id) }, p.id)),
+      o.violatedDependencies.map((p) => /* @__PURE__ */ k("span", { className: v.finding, children: e.scheduleViolatedBy(n(p.shortBy)) }, p.dependency)),
+      o.blocked.map((p) => /* @__PURE__ */ k("span", { className: v.finding, children: e.scheduleInBlockedTime(p.label) }, p.id))
+    ] });
+  }
+  const { dependency: i, task: r, from: a, to: d, violated: h } = o;
+  return /* @__PURE__ */ K(Dt, { children: [
+    /* @__PURE__ */ k("span", { className: v.tooltipHead, children: (r == null ? void 0 : r.name) ?? (r == null ? void 0 : r.id) ?? i.id }),
+    /* @__PURE__ */ k("span", { children: e.scheduleRoute((a == null ? void 0 : a.name) ?? i.from, (d == null ? void 0 : d.name) ?? i.to) }),
+    /* @__PURE__ */ k("span", { children: `${e.scheduleDependency} ${n(i.lag)}` }),
+    h !== void 0 && /* @__PURE__ */ k("span", { className: v.finding, children: e.scheduleViolatedBy(n(h.shortBy)) })
+  ] });
+}
+const yn = [], ke = { min: Bt, max: 28 * U }, vn = [], ye = 20, Ct = 44, wn = Ee(function(t, e) {
+  var de;
+  const {
+    scene: s,
+    ariaLabel: n,
+    height: i = 400,
+    laneHeight: r = pt,
+    headerWidth: a = 160,
+    calendar: d = vn,
+    zoomLimits: h,
+    snap: l = "ticks",
+    intents: c = yn,
+    onIntent: p,
+    canMoveTo: m,
+    onInteraction: y,
+    selectedTask: I,
+    onSelectedTaskChange: A,
+    placing: C,
+    route: g = "curve",
+    attach: T = "centre",
+    ends: S = "dot",
+    label: E,
+    tooltip: D,
+    now: P,
+    className: ot,
+    style: kt,
+    children: ct
+  } = t, yt = ms(), Ut = `${yt}-summary`, Xt = G(null), qt = G(null), jt = G(null), Jt = G(null), Y = xt(), x = mt(), Zt = (h == null ? void 0 : h.min) ?? ke.min, Qt = (h == null ? void 0 : h.max) ?? ke.max, te = typeof l == "object" ? l.step : null, ee = typeof l == "object" ? l.offset : null, se = typeof l == "object" ? null : l, [Ze, Qe] = tt(() => Date.now());
+  W(() => {
+    if (P !== !0) return;
+    const u = setInterval(() => Qe(Date.now()), q);
+    return () => clearInterval(u);
+  }, [P]);
+  const ne = P === !0 ? Ze : typeof P == "number" ? P : null;
+  it(() => {
+    const u = se ?? { step: te ?? 0, offset: ee ?? 0 };
+    s.setOptions({ laneHeight: r, calendar: d, zoomLimits: { min: Zt, max: Qt }, snap: u, intents: c, now: ne, route: g, attach: T, ends: S });
+  }, [s, r, d, Zt, Qt, se, te, ee, c, ne, g, T, S]), W(() => {
+    s.setHandlers({ onIntent: p, canMoveTo: m, onInteraction: y, onSelectedTaskChange: A });
+  }, [s, p, m, y, A]), gs(
+    e,
+    () => ({
+      positionAt: (u, w) => s.positionAt(u, w),
+      clientPointOf: (u, w) => s.clientPointOf(u, w),
+      visibleDomain: () => s.visibleDomain()
+    }),
+    [s]
+  ), W(() => {
+    s.setControlledTask(I);
+  }, [s, I]), W(() => {
+    s.setPlacing(C ?? null);
+  }, [s, C]), W(() => {
+    const u = Xt.current, w = qt.current, L = jt.current, R = Jt.current;
+    if (!u || !w || !L || !R) return;
+    s.bind(u, w, L, R);
+    const _ = w.getBoundingClientRect();
+    s.resize(_.width, _.height);
+    const F = new ResizeObserver((O) => {
+      var ut;
+      const $ = (ut = O[O.length - 1]) == null ? void 0 : ut.contentRect;
+      $ !== void 0 && s.resize($.width, $.height);
+    });
+    F.observe(w);
+    const B = (O) => s.wheel(O);
+    u.addEventListener("wheel", B, { passive: !1 });
+    const z = (O) => {
+      O.key === "Escape" && s.cancelEdit() && O.preventDefault();
+    };
+    return window.addEventListener("keydown", z), () => {
+      window.removeEventListener("keydown", z), u.removeEventListener("wheel", B), F.disconnect(), s.unbind();
+    };
+  }, [s]);
+  const b = Re(s.subscribe, s.getSnapshot, s.getServerSnapshot), ts = (u, w) => {
+    const L = new Date(u);
+    return w >= 200 ? Y.dateLong(L) : w >= 84 ? Y.date(L) : w >= Ct ? Y.dateShort(L) : "";
+  }, es = b.days.reduce((u, w) => Math.max(u, w.width), 0), J = $s(es, Ct), oe = b.step >= U ? J : 1, M = b.ghost, Z = b.spoken, vt = b.summary, ie = (u) => `${Y.dateShort(new Date(u))} ${Y.time(new Date(u), !1)}`, wt = (u) => `${yt}-row-${encodeURIComponent(u.key)}`, ss = X(() => {
+    const u = /* @__PURE__ */ new Map();
+    for (const w of b.headers)
+      for (const L of w.within)
+        w.kind === "groupHead" && L === w.group || u.set(L, [...u.get(L) ?? [], wt(w)]);
+    return u;
+  }, [b.headers, yt]), re = G(null);
+  it(() => {
+    var F;
+    const u = re.current;
+    if (u === null) return;
+    let w = !0;
+    const L = () => {
+      if (!w) return;
+      const B = [...u.querySelectorAll("[data-lane-count]")];
+      for (const O of B) O.hidden = !1;
+      const z = B.some((O) => {
+        const $ = O.previousElementSibling;
+        if (!($ instanceof HTMLElement)) return !1;
+        const ut = parseFloat(getComputedStyle($).lineHeight);
+        return $.scrollWidth > $.clientWidth || $.clientHeight > ut * 1.5;
+      });
+      for (const O of B) O.hidden = z;
+    };
+    L(), (F = document.fonts) == null || F.ready.then(L);
+    const R = new ResizeObserver(L);
+    R.observe(u);
+    const _ = new MutationObserver(L);
+    return _.observe(u, { childList: !0, characterData: !0, subtree: !0 }), () => {
+      w = !1, R.disconnect(), _.disconnect();
+    };
+  }, []);
+  const ns = X(() => new Set((M == null ? void 0 : M.refusedLanes) ?? []), [M == null ? void 0 : M.refusedLanes]), ae = G(null), [bt, os] = tt({ x: 0, y: 0, at: "" }), Mt = M === null ? "" : `${M.x}:${M.y}:${M.from}:${M.to}:${M.overlap}:${M.violated}:${M.refused}:${M.blocked}`;
+  it(() => {
+    const u = ae.current;
+    if (M === null || u === null) return;
+    const w = 4, L = M.y - u.offsetHeight - w, R = M.y + M.height + w, _ = {
+      x: Math.max(2, Math.min(M.x, b.width - u.offsetWidth - 2)),
+      y: L >= 2 ? L : Math.min(R, b.height - u.offsetHeight - 2),
+      at: Mt
+    };
+    os((F) => F.x === _.x && F.y === _.y && F.at === _.at ? F : _);
+  }, [M, Mt, b.width, b.height]);
+  const le = G(null), [Tt, is] = tt({ x: 0, y: 0, at: "" }), V = b.tooltip, It = V === null ? "" : `${V.x}:${V.y}:${V.target.kind}`;
+  return it(() => {
+    const u = le.current;
+    if (V === null || u === null) return;
+    const w = 12, L = (_, F, B) => {
+      const z = _ + w, O = _ - w - F, $ = z + F <= B - 4 || O < 4 ? z : O;
+      return Math.max(4, Math.min($, B - F - 4));
+    }, R = {
+      x: L(V.x, u.offsetWidth, b.width),
+      y: L(V.y, u.offsetHeight, b.height),
+      at: It
+    };
+    is((_) => _.x === R.x && _.y === R.y && _.at === R.at ? _ : R);
+  }, [V, It, b.width, b.height]), /* @__PURE__ */ K(Pe.Provider, { value: s, children: [
+    /* @__PURE__ */ K(
+      "div",
+      {
+        ref: Xt,
+        role: "figure",
+        "aria-label": n,
+        className: ot ? `${v.root} ${ot}` : v.root,
+        style: { height: `${i}px`, gridTemplateColumns: `min(${a}px, 40%) minmax(0, 1fr)`, ...kt },
+        children: [
+          /* @__PURE__ */ k("div", { className: v.corner }),
+          /* @__PURE__ */ k("div", { className: v.dayBand, "aria-hidden": "true", "data-schedule-days": "", "data-schedule-clip": "day band", children: b.days.map((u, w) => {
+            var B;
+            const L = J === 1 || w === 0 || At(u.start, J), R = J === 1 ? u.x + u.width : ((B = b.days.slice(w + 1).find((z) => At(z.start, J))) == null ? void 0 : B.x) ?? b.width, _ = Math.max(0, -u.x), F = Math.min(R, b.width) - Math.max(u.x, 0);
+            return /* @__PURE__ */ k("span", { className: v.day, style: { left: `${u.x}px`, width: `${L ? R - u.x : u.width}px` }, children: /* @__PURE__ */ k("span", { className: v.dayLabel, "data-schedule-overlay": "day label", style: { marginLeft: `${_}px` }, children: L ? ts(u.start, J === 1 ? F : Math.min(F, Ct)) : "" }) }, u.start);
+          }) }),
+          /* @__PURE__ */ k("div", { ref: re, className: v.headers, "data-schedule-headers": "", children: /* @__PURE__ */ k("div", { className: v.headerRun, style: { transform: `translateY(${-b.scrollY}px)` }, children: b.headers.map((u) => /* @__PURE__ */ K(
+            "div",
+            {
+              id: wt(u),
+              className: v.header,
+              style: { height: `${u.height}px`, paddingLeft: `calc(var(--u-space-3) + ${u.depth} * var(--u-space-3))` },
+              "data-lane": u.lane,
+              "data-group": u.group,
+              "data-row": u.kind,
+              "data-schedule-clip": `header ${u.kind}`,
+              "data-refused": u.lane !== void 0 && ns.has(u.lane) ? "" : void 0,
+              children: [
+                u.kind !== "lane" && u.group !== void 0 && /* @__PURE__ */ k(
+                  "button",
+                  {
+                    type: "button",
+                    className: v.chevron,
+                    "data-schedule-overlay": "fold control",
+                    "aria-expanded": u.collapsed === !1,
+                    "aria-controls": (ss.get(u.group) ?? [wt(u)]).join(" "),
+                    "aria-label": `${u.collapsed === !0 ? x.scheduleUnfoldGroup : x.scheduleFoldGroup}: ${typeof u.label == "string" ? u.label : u.group}`,
+                    onClick: () => s.toggleGroup(u.group),
+                    children: /* @__PURE__ */ k(ys, { size: 9, "data-open": u.collapsed === !1 ? "" : void 0 })
+                  }
+                ),
+                /* @__PURE__ */ k("span", { className: v.headerLabel, "data-schedule-overlay": "header label", children: u.label }),
+                u.kind !== "lane" && /* @__PURE__ */ k("span", { className: v.headerCount, "data-schedule-overlay": "lane count", "data-lane-count": u.lanes, children: x.scheduleLaneCount(u.lanes) })
+              ]
+            },
+            u.key
+          )) }) }),
+          /* @__PURE__ */ K(
+            "div",
+            {
+              ref: qt,
+              className: v.plot,
+              "data-schedule-plot": "",
+              "data-schedule-clip": "plot",
+              style: { cursor: b.cursor },
+              tabIndex: 0,
+              role: "application",
+              "aria-roledescription": x.scheduleRoleDescription,
+              "aria-label": n,
+              "aria-describedby": Ut,
+              onKeyDown: (u) => {
+                s.key(u.nativeEvent) && u.preventDefault();
+              },
+              onFocus: (u) => s.focus(bn(u.currentTarget)),
+              onBlur: () => s.blur(),
+              onPointerDown: (u) => s.pointerDown(u.nativeEvent),
+              onPointerMove: (u) => s.pointerMove(u.nativeEvent),
+              onPointerUp: (u) => s.pointerUp(u.nativeEvent),
+              onPointerCancel: (u) => s.pointerCancel(u.nativeEvent),
+              onPointerLeave: () => s.pointerLeave(),
+              onContextMenu: (u) => s.contextMenu(u.nativeEvent),
+              onDragOver: (u) => s.dragOver(u.nativeEvent),
+              onDrop: (u) => s.drop(u.nativeEvent),
+              onDragLeave: (u) => {
+                const w = u.nativeEvent.relatedTarget;
+                (!(w instanceof Node) || !u.currentTarget.contains(w)) && s.dragLeave();
+              },
+              children: [
+                /* @__PURE__ */ k("canvas", { ref: jt, className: v.layer, "aria-hidden": "true" }),
+                /* @__PURE__ */ k("canvas", { ref: Jt, className: v.layer, "aria-hidden": "true" }),
+                b.grips.map((u) => /* @__PURE__ */ k(
+                  "span",
+                  {
+                    "data-grip": u.kind,
+                    "data-schedule-overlay": `${u.kind} grip`,
+                    "aria-hidden": "true",
+                    className: v.grip,
+                    style: { left: `${u.x}px`, top: `${u.y}px`, height: `${u.height}px` }
+                  },
+                  u.kind
+                )),
+                E !== void 0 && b.bars.map((u) => /* @__PURE__ */ k(
+                  "span",
+                  {
+                    className: v.barLabel,
+                    "data-bar-label": u.subtask.id,
+                    "data-schedule-overlay": "bar label",
+                    "data-schedule-may-cover": "",
+                    "data-on": u.dark ? "dark" : "light",
+                    style: { left: `${u.x}px`, top: `${u.y}px`, width: `${u.width}px`, height: `${u.height}px` },
+                    children: /* @__PURE__ */ k("span", { className: v.barLabelText, children: E(u.subtask) })
+                  },
+                  u.subtask.id
+                )),
+                D !== !1 && b.tooltip !== null && /* @__PURE__ */ k(
+                  "span",
+                  {
+                    ref: le,
+                    role: "tooltip",
+                    className: v.tooltip,
+                    "data-schedule-tooltip": "",
+                    "data-schedule-overlay": "tooltip",
+                    style: {
+                      left: `${Tt.x}px`,
+                      top: `${Tt.y}px`,
+                      visibility: Tt.at === It ? void 0 : "hidden"
+                    },
+                    children: typeof D == "function" ? D(b.tooltip.target) : /* @__PURE__ */ k(kn, { target: b.tooltip.target })
+                  }
+                ),
+                M !== null && /* @__PURE__ */ K(
+                  "span",
+                  {
+                    ref: ae,
+                    className: v.ghostLabel,
+                    "data-ghost": "",
+                    "data-schedule-overlay": "ghost label",
+                    "data-findings": [M.overlap ? "overlap" : "", M.violated ? "violated-dependency" : ""].filter(Boolean).join(" "),
+                    "data-refused": M.refused ? "" : void 0,
+                    "data-blocked": M.blocked ? "" : void 0,
+                    style: {
+                      left: `${bt.x}px`,
+                      top: `${bt.y}px`,
+                      visibility: bt.at === Mt ? void 0 : "hidden"
+                    },
+                    children: [
+                      x.scheduleGhostTimes(Y.time(new Date(M.from), !1), Y.time(new Date(M.to), !1)),
+                      M.refused && /* @__PURE__ */ k("span", { className: v.refusal, children: x.scheduleLaneRefused }),
+                      M.blocked && /* @__PURE__ */ k("span", { className: v.refusal, children: x.scheduleBlockedTime }),
+                      M.overlap && /* @__PURE__ */ k("span", { className: v.finding, children: x.scheduleOverlap }),
+                      M.violated && /* @__PURE__ */ k("span", { className: v.finding, children: x.scheduleViolatedDependency })
+                    ]
+                  }
+                ),
+                /* @__PURE__ */ k("span", { className: v.focusRing, "aria-hidden": "true" })
+              ]
+            }
+          ),
+          /* @__PURE__ */ k("div", { className: v.corner }),
+          /* @__PURE__ */ K("div", { className: v.tickBand, "aria-hidden": "true", "data-schedule-ticks": "", "data-schedule-clip": "time band", children: [
+            b.now !== null && /* @__PURE__ */ k("span", { className: v.now, "data-now": "", "data-schedule-overlay": "now mark", style: { left: `${b.now}px` } }),
+            b.ticks.map((u) => /* @__PURE__ */ k("span", { className: v.tick, style: { left: `${u.x}px` }, children: u.x >= ye && u.x <= b.width - ye && (oe === 1 || At(u.wallClock, oe)) && /* @__PURE__ */ k("span", { className: v.tickLabel, "data-schedule-overlay": "time label", children: b.step >= U ? Y.dateShort(new Date(u.wallClock)) : Y.time(new Date(u.wallClock), !1) }) }, u.wallClock))
+          ] }),
+          /* @__PURE__ */ k(he, { "aria-live": "polite", children: Z !== null && /* @__PURE__ */ k(
+            gn,
+            {
+              target: Z.target,
+              lane: Z.lane === null ? null : ((de = s.data.lanes.find((u) => u.id === Z.lane)) == null ? void 0 : de.label) ?? Z.lane
+            },
+            Z.count
+          ) }),
+          /* @__PURE__ */ k(he, { id: Ut, children: `${x.scheduleSummary({ ...vt, from: ie(vt.from), to: ie(vt.to) })} ${x.scheduleKeyHelp}` })
+        ]
       }
-    }
+    ),
+    ct
+  ] });
+});
+function bn(o) {
+  try {
+    return o.matches(":focus-visible");
+  } catch {
+    return !0;
   }
-  return t;
 }
-function $s(o) {
-  const t = /* @__PURE__ */ new Map(), e = /* @__PURE__ */ new Map();
-  for (const n of o) {
-    const s = nt(n), i = e.get(n.lane) ?? [];
-    let r = 0;
-    if (s.from < s.to) {
-      for (const a of i) s.from < a.to && a.from < s.to && r++;
-      i.push(s);
-    }
-    e.set(n.lane, i), t.set(n.id, r);
-  }
-  return t;
+function Mn({ id: o, label: t }) {
+  const e = xe(), s = X(() => ({ id: o, label: t ?? o, ...e === null ? {} : { parent: e } }), [o, t, e]);
+  return Ms(s), null;
 }
-function Vt(o, t) {
-  const e = new Map(o.map((s) => [s.id, s])), n = [];
-  for (const s of t) {
-    const i = e.get(s.from), r = e.get(s.to);
-    if (i === void 0 || r === void 0) continue;
-    const a = Ut(s, i), l = Wt(s, r), h = a + s.lag - l;
-    h > 0 && n.push({ dependency: s.id, departure: a, arrival: l, shortBy: h });
-  }
-  return n;
+function Tn({ id: o, label: t, children: e }) {
+  const s = xe(), n = X(() => ({ id: o, label: t ?? o, ...s === null ? {} : { parent: s } }), [o, t, s]);
+  return Ts(n), /* @__PURE__ */ k(Be.Provider, { value: o, children: e });
 }
-function Ke(o, t) {
-  const e = [];
-  for (const n of o) {
-    const s = nt(n);
-    for (const i of t)
-      i.lane !== n.lane || !(s.from < i.to && i.from < s.to) || e.push({ subtask: n.id, blocked: i.id, lane: i.lane, from: Math.max(s.from, i.from), to: Math.min(s.to, i.to) });
-  }
-  return e;
+function In({ data: o, tasks: t }) {
+  const e = X(() => ({ kind: "subtasks", data: o, tasks: t }), [o, t]);
+  return Kt("Subtasks", e), null;
 }
-function fo(o, t, e = []) {
-  return {
-    overlaps: Xt(o),
-    violatedDependencies: Vt(o, t),
-    inBlockedTime: Ke(o, e)
-  };
+function Sn({ data: o }) {
+  const t = X(() => ({ kind: "dependencies", data: o }), [o]);
+  return Kt("Dependencies", t), null;
+}
+function Ln({ data: o }) {
+  const t = X(() => ({ kind: "blocked", data: o }), [o]);
+  return Kt("BlockedTimes", t), null;
 }
-class Gs {
+class An {
   /** `changed` is called after every registration change. */
   constructor(t) {
     f(this, "nextId", 1);
@@ -381,14 +1039,14 @@ class Gs {
   rebuild() {
     if (!this.dirty) return !1;
     this.dirty = !1;
-    const t = (e) => [...e.keys()].sort((n, s) => n - s).map((n) => e.get(n));
-    this.lanes = t(this.laneEntries), this.groups = t(this.groupEntries), this.laneIndex = new Map(this.lanes.map((e, n) => [e.id, n])), this.layers = t(this.layerEntries), this.subtasks = [], this.dependencies = [], this.blocked = [], this.tasks = /* @__PURE__ */ new Map();
+    const t = (e) => [...e.keys()].sort((s, n) => s - n).map((s) => e.get(s));
+    this.lanes = t(this.laneEntries), this.groups = t(this.groupEntries), this.laneIndex = new Map(this.lanes.map((e, s) => [e.id, s])), this.layers = t(this.layerEntries), this.subtasks = [], this.dependencies = [], this.blocked = [], this.tasks = /* @__PURE__ */ new Map();
     for (const e of this.layers)
       if (e.kind === "subtasks") {
         this.subtasks.push(...e.data);
-        for (const n of e.tasks) this.tasks.set(n.id, n);
+        for (const s of e.tasks) this.tasks.set(s.id, s);
       } else e.kind === "dependencies" ? this.dependencies.push(...e.data) : this.blocked.push(...e.data);
-    return this.subtaskById = new Map(this.subtasks.map((e) => [e.id, e])), this.overlaps = Xt(this.subtasks), this.violatedById = new Map(Vt(this.subtasks, this.dependencies).map((e) => [e.dependency, e])), this.depth = $s(this.subtasks), this.inBlocked = Ke(this.subtasks, this.blocked), !0;
+    return this.subtaskById = new Map(this.subtasks.map((e) => [e.id, e])), this.overlaps = Ht(this.subtasks), this.violatedById = new Map(Yt(this.subtasks, this.dependencies).map((e) => [e.dependency, e])), this.depth = vs(this.subtasks), this.inBlocked = Ne(this.subtasks, this.blocked), !0;
   }
   /** The task a dependency belongs to: its departing subtask's. */
   taskOfDependency(t) {
@@ -399,22 +1057,22 @@ class Gs {
       data knows about it - its task, and the findings it stands in. */
   tooltipTargetFor(t) {
     if (t.kind === "subtask") {
-      const s = t.subtask.id, i = this.overlaps.filter((l) => l.first === s || l.second === s).map((l) => this.subtaskById.get(l.first === s ? l.second : l.first)).filter((l) => l !== void 0), r = this.dependencies.filter((l) => l.from === s || l.to === s).map((l) => this.violatedById.get(l.id)).filter((l) => l !== void 0), a = this.inBlocked.filter((l) => l.subtask === s).map((l) => this.blocked.find((h) => h.id === l.blocked)).filter((l) => l !== void 0);
+      const n = t.subtask.id, i = this.overlaps.filter((d) => d.first === n || d.second === n).map((d) => this.subtaskById.get(d.first === n ? d.second : d.first)).filter((d) => d !== void 0), r = this.dependencies.filter((d) => d.from === n || d.to === n).map((d) => this.violatedById.get(d.id)).filter((d) => d !== void 0), a = this.inBlocked.filter((d) => d.subtask === n).map((d) => this.blocked.find((h) => h.id === d.blocked)).filter((d) => d !== void 0);
       return { kind: "subtask", subtask: t.subtask, task: this.tasks.get(t.subtask.task), overlapping: i, violatedDependencies: r, blocked: a };
     }
     if (t.kind !== "dependency") return null;
-    const e = t.dependency, n = this.taskOfDependency(e);
+    const e = t.dependency, s = this.taskOfDependency(e);
     return {
       kind: "dependency",
       dependency: e,
-      task: n !== null ? this.tasks.get(n) : void 0,
+      task: s !== null ? this.tasks.get(s) : void 0,
       from: this.subtaskById.get(e.from),
       to: this.subtaskById.get(e.to),
       violated: this.violatedById.get(e.id)
     };
   }
 }
-const Hs = {
+const Cn = {
   line: "var(--u-hairline)",
   lineStrong: "var(--u-hairline-strong)",
   text: "var(--u-color-text)",
@@ -428,7 +1086,7 @@ const Hs = {
   /* What text and marks take ON a filled bar - the same token the bar labels
      use in CSS, so a cap and the label beside it are one colour. */
   onAccent: "var(--u-color-on-accent)"
-}, Ue = {
+}, Ve = {
   line: "GrayText",
   lineStrong: "CanvasText",
   text: "CanvasText",
@@ -438,22 +1096,22 @@ const Hs = {
   active: "Highlight",
   now: "GrayText",
   onAccent: "Canvas"
-}, Ys = (o) => o ? Ue : Hs, zs = () => typeof window < "u" && typeof window.matchMedia == "function" && window.matchMedia("(forced-colors: active)").matches;
-function Ks(o, t) {
-  const e = zs(), n = {};
-  for (const r of t.tasks.values()) n[`task:${r.id}`] = e ? Ue.text : r.color;
-  const s = ys(o, { ...Ys(e), ...n }), i = /* @__PURE__ */ new Map();
-  for (const r of t.tasks.values()) i.set(r.id, s[`task:${r.id}`] ?? r.color);
+}, _n = (o) => o ? Ve : Cn, Dn = () => typeof window < "u" && typeof window.matchMedia == "function" && window.matchMedia("(forced-colors: active)").matches;
+function Fn(o, t) {
+  const e = Dn(), s = {};
+  for (const r of t.tasks.values()) s[`task:${r.id}`] = e ? Ve.text : r.color;
+  const n = cs(o, { ..._n(e), ...s }), i = /* @__PURE__ */ new Map();
+  for (const r of t.tasks.values()) i.set(r.id, n[`task:${r.id}`] ?? r.color);
   return {
-    line: s.line,
-    lineStrong: s.lineStrong,
-    text: s.text,
-    muted: s.muted,
-    alarm: s.alarm,
-    surface: s.surface,
-    active: s.active,
-    now: s.now,
-    onAccent: s.onAccent,
+    line: n.line,
+    lineStrong: n.lineStrong,
+    text: n.text,
+    muted: n.muted,
+    alarm: n.alarm,
+    surface: n.surface,
+    active: n.active,
+    now: n.now,
+    onAccent: n.onAccent,
     tasks: i,
     forced: e
   };
@@ -462,9 +1120,9 @@ function lt(o) {
   const t = o.match(/[\d.]+/g);
   return t === null || t.length < 3 ? null : [Number(t[0]), Number(t[1]), Number(t[2])];
 }
-function Me(o) {
+function ve(o) {
   const t = lt(o);
-  return t === null ? 0 : Xe(We(t));
+  return t === null ? 0 : Ue(We(t));
 }
 function We(o) {
   return o.map((t) => {
@@ -472,296 +1130,290 @@ function We(o) {
     return e <= 0.04045 ? e / 12.92 : ((e + 0.055) / 1.055) ** 2.4;
   });
 }
-function Xe([o, t, e]) {
+function Ue([o, t, e]) {
   return 0.2126 * o + 0.7152 * t + 0.0722 * e;
 }
-function Te(o, t) {
-  const e = Me(o), n = Me(t);
-  return (Math.max(e, n) + 0.05) / (Math.min(e, n) + 0.05);
+function we(o, t) {
+  const e = ve(o), s = ve(t);
+  return (Math.max(e, s) + 0.05) / (Math.min(e, s) + 0.05);
 }
-function Ie(o, t, e) {
+function be(o, t, e) {
   if (o === null) return null;
-  const n = typeof window > "u" ? 1 : window.devicePixelRatio || 1, s = Math.round(t * n), i = Math.round(e * n);
-  o.width !== s && (o.width = s), o.height !== i && (o.height = i);
+  const s = typeof window > "u" ? 1 : window.devicePixelRatio || 1, n = Math.round(t * s), i = Math.round(e * s);
+  o.width !== n && (o.width = n), o.height !== i && (o.height = i);
   const r = o.getContext("2d");
-  return r === null ? null : (r.setTransform(n, 0, 0, n, 0, 0), r.clearRect(0, 0, t, e), r);
+  return r === null ? null : (r.setTransform(s, 0, 0, s, 0, 0), r.clearRect(0, 0, t, e), r);
 }
-function Us(o, t) {
-  const { data: e, view: n } = t, s = n.viewport();
-  qs(o, t, s);
-  for (const i of e.blocked) nn(o, t, s, i);
-  js(o, t);
+function On(o, t) {
+  const { data: e, view: s } = t, n = s.viewport();
+  Pn(o, t, n);
+  for (const i of e.blocked) Kn(o, t, n, i);
+  Bn(o, t);
   for (const i of e.layers) {
     if (i.kind === "blocked") continue;
     const r = new Set(i.data);
     if (i.kind === "dependencies")
-      for (const a of n.paths) r.has(a.dependency) && Bt(o, t, a, !1);
+      for (const a of s.paths) r.has(a.dependency) && Et(o, t, a, !1);
     else
-      for (const a of n.boxes) r.has(a.subtask) && qe(o, t, a, 1);
+      for (const a of s.boxes) r.has(a.subtask) && qe(o, t, a, 1);
   }
-  for (const i of e.overlaps) xt(o, t, s, i);
-  for (const i of e.inBlocked) xt(o, t, s, i);
-  sn(o, t, s), an(o, t);
+  for (const i of e.overlaps) Nt(o, t, n, i);
+  for (const i of e.inBlocked) Nt(o, t, n, i);
+  zn(o, t, n), Un(o, t);
 }
-function Ws(o, t) {
-  const { view: e, hover: n } = t, s = e.viewport();
+function En(o, t) {
+  const { view: e, hover: s } = t, n = e.viewport();
   if (t.ghost === null) {
-    if (n.kind === "subtask") {
-      const u = e.boxById.get(n.subtask.id);
-      u !== void 0 && on(o, t, u);
-    } else if (n.kind === "dependency") {
-      const u = e.paths.find((p) => p.dependency === n.dependency);
-      u !== void 0 && Bt(o, t, u, !0);
+    if (s.kind === "subtask") {
+      const c = e.boxById.get(s.subtask.id);
+      c !== void 0 && Vn(o, t, c);
+    } else if (s.kind === "dependency") {
+      const c = e.paths.find((p) => p.dependency === s.dependency);
+      c !== void 0 && Et(o, t, c, !0);
     }
     return;
   }
-  const i = t.ghost, { ghost: r, overlaps: a, violated: l } = i;
-  Xs(o, t, s, i.refusedLanes);
-  const h = Ve(s, r);
+  const i = t.ghost, { ghost: r, overlaps: a, violated: d } = i;
+  Rn(o, t, n, i.refusedLanes);
+  const h = Xe(n, r);
   if (h === null) return;
-  for (const u of a) xt(o, t, s, u);
-  const d = new Set(l.map((u) => u.dependency));
-  for (const u of t.data.dependencies) {
-    if (u.from !== r.id && u.to !== r.id) continue;
-    const p = e.boxById.get(u.from === r.id ? u.to : u.from);
+  for (const c of a) Nt(o, t, n, c);
+  const l = new Set(d.map((c) => c.dependency));
+  for (const c of t.data.dependencies) {
+    if (c.from !== r.id && c.to !== r.id) continue;
+    const p = e.boxById.get(c.from === r.id ? c.to : c.from);
     if (p === void 0) continue;
-    const m = u.from === r.id ? Pt(s, u, h, p, e.options) : Pt(s, u, p, h, e.options);
-    Bt(o, t, m, !0, d.has(u.id));
+    const m = c.from === r.id ? Ot(n, c, h, p, e.options) : Ot(n, c, p, h, e.options);
+    Et(o, t, m, !0, l.has(c.id));
   }
-  qe(o, { ...t, selectedTask: null }, h, 0.55), o.strokeStyle = t.colours.text, o.lineWidth = 1, o.setLineDash([3, 2]), o.strokeRect(h.outerFrom + 0.5, h.y + 0.5, Math.max(1, h.outerTo - h.outerFrom - 1), h.height - 1), o.setLineDash([]), i.tether !== null && Vs(o, t, h, i.tether);
+  qe(o, { ...t, selectedTask: null }, h, 0.55), o.strokeStyle = t.colours.text, o.lineWidth = 1, o.setLineDash([3, 2]), o.strokeRect(h.outerFrom + 0.5, h.y + 0.5, Math.max(1, h.outerTo - h.outerFrom - 1), h.height - 1), o.setLineDash([]), i.tether !== null && Nn(o, t, h, i.tether);
 }
-function Xs(o, t, e, n) {
-  if (n.size === 0) return;
-  const { width: s, height: i } = t.view;
-  for (const r of n) {
+function Rn(o, t, e, s) {
+  if (s.size === 0) return;
+  const { width: n, height: i } = t.view;
+  for (const r of s) {
     const a = dt(e, r);
     if (a === null) continue;
-    const { top: l, height: h } = a;
-    l + h < 0 || l > i || (o.globalAlpha = 0.6, o.fillStyle = t.colours.surface, o.fillRect(0, l, s, h), o.globalAlpha = 1, Ze(o, 0, l, s, h, t.colours.muted, 0.7, je, 1));
-  }
-}
-function Vs(o, t, e, n) {
-  const s = Math.max(e.outerFrom, Math.min(e.outerTo, n.x)), i = Math.max(e.y, Math.min(e.y + e.height, n.y));
-  Math.hypot(n.x - s, n.y - i) < 2 || (o.strokeStyle = t.colours.text, o.lineWidth = 1, o.setLineDash([2, 3]), o.beginPath(), o.moveTo(s + 0.5, i + 0.5), o.lineTo(n.x + 0.5, n.y + 0.5), o.stroke(), o.setLineDash([]));
-}
-function Ve(o, t) {
-  const e = Kt(o.rows, t.lane);
-  return e === null ? null : Ye(o, t, t.lane, e, 0);
-}
-function qs(o, t, e) {
-  const { view: n, colours: s, bands: i } = t, { width: r, height: a } = n;
-  o.lineWidth = 1, o.strokeStyle = s.line, o.beginPath();
-  for (const d of i.ticks)
-    o.moveTo(d.x + 0.5, 0), o.lineTo(d.x + 0.5, a);
-  for (const d of e.rows.rows) {
-    const u = d.top + d.height - e.scrollY - 0.5;
-    u < 0 || u > a || (o.moveTo(0, u), o.lineTo(r, u));
-  }
-  const l = [...e.rows.slots.values()].filter((d) => d.miniature).sort((d, u) => d.top - u.top);
-  l.forEach((d, u) => {
-    const p = l[u + 1];
-    if (p === void 0 || p.top !== d.top + d.height || p.group === d.group) return;
-    const m = d.top + d.height - e.scrollY - 0.5;
+    const { top: d, height: h } = a;
+    d + h < 0 || d > i || (o.globalAlpha = 0.6, o.fillStyle = t.colours.surface, o.fillRect(0, d, n, h), o.globalAlpha = 1, Je(o, 0, d, n, h, t.colours.muted, 0.7, je, 1));
+  }
+}
+function Nn(o, t, e, s) {
+  const n = Math.max(e.outerFrom, Math.min(e.outerTo, s.x)), i = Math.max(e.y, Math.min(e.y + e.height, s.y));
+  Math.hypot(s.x - n, s.y - i) < 2 || (o.strokeStyle = t.colours.text, o.lineWidth = 1, o.setLineDash([2, 3]), o.beginPath(), o.moveTo(n + 0.5, i + 0.5), o.lineTo(s.x + 0.5, s.y + 0.5), o.stroke(), o.setLineDash([]));
+}
+function Xe(o, t) {
+  const e = Vt(o.rows, t.lane);
+  return e === null ? null : Ge(o, t, t.lane, e, 0);
+}
+function Pn(o, t, e) {
+  const { view: s, colours: n, bands: i } = t, { width: r, height: a } = s;
+  o.lineWidth = 1, o.strokeStyle = n.line, o.beginPath();
+  for (const l of i.ticks)
+    o.moveTo(l.x + 0.5, 0), o.lineTo(l.x + 0.5, a);
+  for (const l of e.rows.rows) {
+    const c = l.top + l.height - e.scrollY - 0.5;
+    c < 0 || c > a || (o.moveTo(0, c), o.lineTo(r, c));
+  }
+  const d = [...e.rows.slots.values()].filter((l) => l.miniature).sort((l, c) => l.top - c.top);
+  d.forEach((l, c) => {
+    const p = d[c + 1];
+    if (p === void 0 || p.top !== l.top + l.height || p.group === l.group) return;
+    const m = l.top + l.height - e.scrollY - 0.5;
     m < 0 || m > a || (o.moveTo(0, m), o.lineTo(r, m));
-  }), o.stroke(), o.strokeStyle = s.lineStrong, o.beginPath();
-  for (const d of i.days)
-    o.moveTo(d.x + 0.5, 0), o.lineTo(d.x + 0.5, a);
+  }), o.stroke(), o.strokeStyle = n.lineStrong, o.beginPath();
+  for (const l of i.days)
+    o.moveTo(l.x + 0.5, 0), o.lineTo(l.x + 0.5, a);
   o.stroke();
-  const h = vs(n.options.calendar);
+  const h = us(s.options.calendar);
   if (h.length > 0) {
-    o.strokeStyle = s.muted, o.setLineDash([2, 3]), o.beginPath();
-    for (const d of h) {
-      const u = Math.round(e.scale.toPx(d.workingTime)) + 0.5;
-      u < 0 || u > r || (o.moveTo(u, 0), o.lineTo(u, a));
+    o.strokeStyle = n.muted, o.setLineDash([2, 3]), o.beginPath();
+    for (const l of h) {
+      const c = Math.round(e.scale.toPx(l.workingTime)) + 0.5;
+      c < 0 || c > r || (o.moveTo(c, 0), o.lineTo(c, a));
     }
     o.stroke(), o.setLineDash([]);
   }
 }
-function js(o, t) {
+function Bn(o, t) {
   const e = t.view.nowX();
   e !== null && (o.fillStyle = t.colours.now, o.fillRect(e, 0, 2, t.view.height));
 }
-function Zs(o, t, e, n) {
-  const s = ht(t.colours, t, e.subtask.task, e.subtask.id);
-  o.fillStyle = s;
+function xn(o, t, e, s) {
+  const n = ht(t.colours, t, e.subtask.task, e.subtask.id);
+  o.fillStyle = n;
   for (const [i, r] of [
     [e.outerFrom, e.mainFrom],
     [e.mainTo, e.outerTo]
   ])
-    r <= i || (o.globalAlpha = 0.28 * n, o.fillRect(i, e.y, r - i, e.height));
-  o.globalAlpha = n, o.fillRect(e.mainFrom, e.y, Math.max(1, e.mainTo - e.mainFrom), e.height), o.globalAlpha = 1;
+    r <= i || (o.globalAlpha = 0.28 * s, o.fillRect(i, e.y, r - i, e.height));
+  o.globalAlpha = s, o.fillRect(e.mainFrom, e.y, Math.max(1, e.mainTo - e.mainFrom), e.height), o.globalAlpha = 1;
 }
-function qt(o, t, e) {
+function Wt(o, t, e) {
   if (o.dashed) return { fill: null, onDark: !1 };
-  const n = o.muted ? Js(t, e.surface, 0.5) : t;
-  return { fill: n, onDark: Te(n, e.onAccent) > Te(n, e.text) };
+  const s = o.muted ? $n(t, e.surface, 0.5) : t;
+  return { fill: s, onDark: we(s, e.onAccent) > we(s, e.text) };
 }
-function Js(o, t, e) {
-  const n = lt(o), s = lt(t);
-  if (n === null || s === null) return o;
-  const i = (r) => Math.round(n[r] + (s[r] - n[r]) * e);
+function $n(o, t, e) {
+  const s = lt(o), n = lt(t);
+  if (s === null || n === null) return o;
+  const i = (r) => Math.round(s[r] + (n[r] - s[r]) * e);
   return `rgb(${i(0)}, ${i(1)}, ${i(2)})`;
 }
-function Ce(o, t) {
+function Me(o, t) {
   const e = lt(o);
   if (e === null || t === 0) return o;
-  const n = We(e), s = Xe(n), [i, r, a] = n.map((l) => {
-    const h = l + (s - l) * t, d = h <= 31308e-7 ? h * 12.92 : 1.055 * h ** (1 / 2.4) - 0.055;
-    return Math.round(Math.min(1, Math.max(0, d)) * 255);
+  const s = We(e), n = Ue(s), [i, r, a] = s.map((d) => {
+    const h = d + (n - d) * t, l = h <= 31308e-7 ? h * 12.92 : 1.055 * h ** (1 / 2.4) - 0.055;
+    return Math.round(Math.min(1, Math.max(0, l)) * 255);
   });
   return `rgb(${i}, ${r}, ${a})`;
 }
-function ht(o, t, e, n) {
-  const s = (e === null ? void 0 : o.tasks.get(e)) ?? o.muted;
-  return t.selectedTask === null ? s : e !== t.selectedTask ? o.forced ? o.muted : Ce(s, 1) : o.forced || t.selectedSubtask === null || n === null || n === t.selectedSubtask ? s : Ce(s, 0.5);
+function ht(o, t, e, s) {
+  const n = (e === null ? void 0 : o.tasks.get(e)) ?? o.muted;
+  return t.selectedTask === null ? n : e !== t.selectedTask ? o.forced ? o.muted : Me(n, 1) : o.forced || t.selectedSubtask === null || s === null || s === t.selectedSubtask ? n : Me(n, 0.5);
 }
-const Qs = 2;
-function qe(o, t, e, n) {
-  const { view: s, colours: i } = t;
-  if (!Rt(e, s.width, s.height)) return;
+const Gn = 2;
+function qe(o, t, e, s) {
+  const { view: n, colours: i } = t;
+  if (!Ft(e, n.width, n.height)) return;
   if (e.miniature) {
-    Zs(o, t, e, n);
+    xn(o, t, e, s);
     return;
   }
-  const r = yt(e.subtask.appearance), a = ht(i, t, e.subtask.task, e.subtask.id), l = qt(r, a, i), h = e.y, d = e.height, u = Math.max(1, e.mainTo - e.mainFrom), p = l.onDark ? i.onAccent : i.text;
+  const r = gt(e.subtask.appearance), a = ht(i, t, e.subtask.task, e.subtask.id), d = Wt(r, a, i), h = e.y, l = e.height, c = Math.max(1, e.mainTo - e.mainFrom), p = d.onDark ? i.onAccent : i.text;
   o.lineWidth = 1, o.fillStyle = a, o.strokeStyle = a;
-  for (const [y, S] of [
+  for (const [y, I] of [
     [e.outerFrom, e.mainFrom],
     [e.mainTo, e.outerTo]
   ])
-    S <= y || (o.globalAlpha = 0.28 * n, o.fillRect(y, h, S - y, d), o.globalAlpha = n, o.strokeRect(y + 0.5, h + 0.5, S - y - 1, d - 1));
-  l.fill !== null && (o.globalAlpha = n, o.fillStyle = l.fill, o.fillRect(e.mainFrom, h, u, d));
+    I <= y || (o.globalAlpha = 0.28 * s, o.fillRect(y, h, I - y, l), o.globalAlpha = s, o.strokeRect(y + 0.5, h + 0.5, I - y - 1, l - 1));
+  d.fill !== null && (o.globalAlpha = s, o.fillStyle = d.fill, o.fillRect(e.mainFrom, h, c, l));
   const m = e.subtask.progress;
   if (m !== void 0) {
-    const y = Math.min(4, Math.max(2, Math.round(d / 6))), S = h + d - y - Qs, A = Math.round(u * Math.max(0, Math.min(1, m)));
-    o.fillStyle = l.fill === null ? a : p, o.globalAlpha = 0.3 * n, o.fillRect(e.mainFrom, S, u, y), o.globalAlpha = n, A > 0 && o.fillRect(e.mainFrom, S, A, y);
+    const y = Math.min(4, Math.max(2, Math.round(l / 6))), I = h + l - y - Gn, A = Math.round(c * Math.max(0, Math.min(1, m)));
+    o.fillStyle = d.fill === null ? a : p, o.globalAlpha = 0.3 * s, o.fillRect(e.mainFrom, I, c, y), o.globalAlpha = s, A > 0 && o.fillRect(e.mainFrom, I, A, y);
   }
   if (r.hatched) {
-    const y = Math.max(1, Math.min(He, Math.floor((u - 2 * rt) / 3))), S = u >= 4 * y ? rt : 0, A = d >= 4 * rt ? rt : 0;
-    o.globalAlpha = n, o.fillStyle = p, o.fillRect(e.mainFrom + S, h + A, y, d - 2 * A), o.fillRect(e.mainTo - S - y, h + A, y, d - 2 * A);
+    const y = Math.max(1, Math.min($e, Math.floor((c - 2 * rt) / 3))), I = c >= 4 * y ? rt : 0, A = l >= 4 * rt ? rt : 0;
+    o.globalAlpha = s, o.fillStyle = p, o.fillRect(e.mainFrom + I, h + A, y, l - 2 * A), o.fillRect(e.mainTo - I - y, h + A, y, l - 2 * A);
   }
-  r.open && en(o, e, h, d, i.surface, s.width), r.dashed && (o.globalAlpha = n, o.strokeStyle = a, o.setLineDash([4, 3]), o.strokeRect(e.mainFrom + 0.5, h + 0.5, u - 1, d - 1), o.setLineDash([])), o.globalAlpha = 1, e.depth > 0 && n === 1 && (o.strokeStyle = i.surface, o.strokeRect(e.outerFrom - 0.5, h - 0.5, e.outerTo - e.outerFrom + 1, d + 1));
+  r.open && Yn(o, e, h, l, i.surface, n.width), r.dashed && (o.globalAlpha = s, o.strokeStyle = a, o.setLineDash([4, 3]), o.strokeRect(e.mainFrom + 0.5, h + 0.5, c - 1, l - 1), o.setLineDash([])), o.globalAlpha = 1, e.depth > 0 && s === 1 && (o.strokeStyle = i.surface, o.strokeRect(e.outerFrom - 0.5, h - 0.5, e.outerTo - e.outerFrom + 1, l + 1));
 }
-const je = 6, tn = 16;
-function Ze(o, t, e, n, s, i, r, a, l) {
-  o.save(), o.beginPath(), o.rect(t, e, n, s), o.clip(), o.globalAlpha = 0.5 * r, o.strokeStyle = i, o.lineWidth = l, o.beginPath();
-  for (let h = t - s; h < t + n + s; h += a)
-    o.moveTo(h, e + s), o.lineTo(h + s, e);
+const je = 6, Hn = 16;
+function Je(o, t, e, s, n, i, r, a, d) {
+  o.save(), o.beginPath(), o.rect(t, e, s, n), o.clip(), o.globalAlpha = 0.5 * r, o.strokeStyle = i, o.lineWidth = d, o.beginPath();
+  for (let h = t - n; h < t + s + n; h += a)
+    o.moveTo(h, e + n), o.lineTo(h + n, e);
   o.stroke(), o.restore();
 }
-function en(o, t, e, n, s, i) {
-  const r = t.mainFrom < 0, a = t.mainTo > i, l = Math.max(1, Math.min(t.mainTo, i) - Math.max(t.mainFrom, 0)), h = Math.min(tn, l);
-  r && Se(o, 0, h, e, n, s, 1), a && Se(o, i, -h, e, n, s, 1);
+function Yn(o, t, e, s, n, i) {
+  const r = t.mainFrom < 0, a = t.mainTo > i, d = Math.max(1, Math.min(t.mainTo, i) - Math.max(t.mainFrom, 0)), h = Math.min(Hn, d);
+  r && Te(o, 0, h, e, s, n, 1), a && Te(o, i, -h, e, s, n, 1);
 }
-function Se(o, t, e, n, s, i, r) {
+function Te(o, t, e, s, n, i, r) {
   const a = o.createLinearGradient(t, 0, t + e, 0);
-  a.addColorStop(0, Le(i, r)), a.addColorStop(1, Le(i, 0)), o.globalAlpha = 1, o.fillStyle = a, o.fillRect(Math.min(t, t + e), n, Math.abs(e), s);
+  a.addColorStop(0, Ie(i, r)), a.addColorStop(1, Ie(i, 0)), o.globalAlpha = 1, o.fillStyle = a, o.fillRect(Math.min(t, t + e), s, Math.abs(e), n);
 }
-function Le(o, t) {
+function Ie(o, t) {
   const e = lt(o);
   return e === null ? o : `rgba(${e[0]}, ${e[1]}, ${e[2]}, ${t})`;
 }
-function Bt(o, t, e, n, s) {
-  const { data: i, colours: r } = t, a = i.taskOfDependency(e.dependency), l = s ?? i.violatedById.has(e.dependency.id), h = a !== null && a === t.selectedTask, d = l ? r.alarm : ht(r, t, a, null);
-  if (o.strokeStyle = d, o.fillStyle = d, o.lineWidth = n || h ? 2 : 1.25, o.setLineDash(l ? [4, 3] : []), o.beginPath(), o.moveTo(e.x1, e.y1), e.kind === "curve")
+function Et(o, t, e, s, n) {
+  const { data: i, colours: r } = t, a = i.taskOfDependency(e.dependency), d = n ?? i.violatedById.has(e.dependency.id), h = a !== null && a === t.selectedTask, l = d ? r.alarm : ht(r, t, a, null);
+  if (o.strokeStyle = l, o.fillStyle = l, o.lineWidth = s || h ? 2 : 1.25, o.setLineDash(d ? [4, 3] : []), o.beginPath(), o.moveTo(e.x1, e.y1), e.kind === "curve")
     o.bezierCurveTo(e.c1x, e.y1, e.c2x, e.y2, e.x2, e.y2);
   else
-    for (let u = 2; u + 1 < e.points.length; u += 2) o.lineTo(e.points[u], e.points[u + 1]);
+    for (let c = 2; c + 1 < e.points.length; c += 2) o.lineTo(e.points[c], e.points[c + 1]);
   if (o.stroke(), o.setLineDash([]), e.ends === "dot")
-    for (const [u, p] of [
+    for (const [c, p] of [
       [e.x1, e.y1],
       [e.x2, e.y2]
     ])
-      o.beginPath(), o.arc(u, p, l ? 3 : 2.5, 0, Math.PI * 2), o.fill();
+      o.beginPath(), o.arc(c, p, d ? 3 : 2.5, 0, Math.PI * 2), o.fill();
 }
-function sn(o, t, e) {
-  const { data: n } = t;
-  if (n.violatedById.size !== 0)
-    for (const s of n.violatedById.values()) {
-      const i = n.dependencies.find((u) => u.id === s.dependency), r = i === void 0 ? void 0 : n.subtaskById.get(i.to);
+function zn(o, t, e) {
+  const { data: s } = t;
+  if (s.violatedById.size !== 0)
+    for (const n of s.violatedById.values()) {
+      const i = s.dependencies.find((c) => c.id === n.dependency), r = i === void 0 ? void 0 : s.subtaskById.get(i.to);
       if (r === void 0) continue;
       const a = dt(e, r.lane);
       if (a === null || !a.miniature) continue;
-      const l = st(e.rows, a.top + e.scrollY);
-      if (l === null) continue;
-      const h = B(e, s.arrival), d = Math.max(h + 2, B(e, s.arrival + s.shortBy));
-      Nt(o, t, h, d, l.top - e.scrollY + 1, 3);
+      const d = st(e.rows, a.top + e.scrollY);
+      if (d === null) continue;
+      const h = N(e, n.arrival), l = Math.max(h + 2, N(e, n.arrival + n.shortBy));
+      Rt(o, t, h, l, d.top - e.scrollY + 1, 3);
     }
 }
-function Nt(o, t, e, n, s, i) {
+function Rt(o, t, e, s, n, i) {
   if (!t.colours.forced) {
-    o.fillStyle = t.colours.alarm, o.fillRect(e, s, n - e, i);
+    o.fillStyle = t.colours.alarm, o.fillRect(e, n, s - e, i);
     return;
   }
-  o.strokeStyle = t.colours.alarm, o.lineWidth = i, o.setLineDash([4, 3]), o.beginPath(), o.moveTo(e, s + i / 2), o.lineTo(n, s + i / 2), o.stroke(), o.setLineDash([]);
+  o.strokeStyle = t.colours.alarm, o.lineWidth = i, o.setLineDash([4, 3]), o.beginPath(), o.moveTo(e, n + i / 2), o.lineTo(s, n + i / 2), o.stroke(), o.setLineDash([]);
 }
-function nn(o, t, e, n) {
-  const s = dt(e, n.lane);
-  if (s === null || s.top + s.height < 0 || s.top > t.view.height) return;
-  const i = Math.max(0, B(e, n.from)), r = Math.min(t.view.width, B(e, n.to));
-  r <= i || (o.globalAlpha = 0.1, o.fillStyle = t.colours.muted, o.fillRect(i, s.top, r - i, s.height), o.globalAlpha = 1, Ze(o, i, s.top, r - i, s.height, t.colours.muted, 0.7, je, 1));
+function Kn(o, t, e, s) {
+  const n = dt(e, s.lane);
+  if (n === null || n.top + n.height < 0 || n.top > t.view.height) return;
+  const i = Math.max(0, N(e, s.from)), r = Math.min(t.view.width, N(e, s.to));
+  r <= i || (o.globalAlpha = 0.1, o.fillStyle = t.colours.muted, o.fillRect(i, n.top, r - i, n.height), o.globalAlpha = 1, Je(o, i, n.top, r - i, n.height, t.colours.muted, 0.7, je, 1));
 }
-function xt(o, t, e, n) {
-  const s = dt(e, n.lane);
-  if (s === null) return;
-  const i = B(e, n.from), r = Math.max(i + 2, B(e, n.to));
-  if (o.fillStyle = t.colours.alarm, o.globalAlpha = 0.14, o.fillRect(i, s.top + 1, r - i, Math.max(1, s.height - 2)), o.globalAlpha = 1, Nt(o, t, i, r, s.top + 1, Math.min(3, Math.max(1, s.height - 1))), s.miniature) {
-    const a = st(e.rows, s.top + e.scrollY);
-    a !== null && Nt(o, t, i, r, a.top - e.scrollY + 1, 3);
+function Nt(o, t, e, s) {
+  const n = dt(e, s.lane);
+  if (n === null) return;
+  const i = N(e, s.from), r = Math.max(i + 2, N(e, s.to));
+  if (o.fillStyle = t.colours.alarm, o.globalAlpha = 0.14, o.fillRect(i, n.top + 1, r - i, Math.max(1, n.height - 2)), o.globalAlpha = 1, Rt(o, t, i, r, n.top + 1, Math.min(3, Math.max(1, n.height - 1))), n.miniature) {
+    const a = st(e.rows, n.top + e.scrollY);
+    a !== null && Rt(o, t, i, r, a.top - e.scrollY + 1, 3);
   }
 }
-function on(o, t, e) {
-  const { colours: n } = t, s = yt(e.subtask.appearance), i = qt(s, ht(n, t, e.subtask.task, e.subtask.id), n);
-  if (n.forced) {
-    o.strokeStyle = n.active, o.lineWidth = 2, o.strokeRect(e.outerFrom - 2, e.y - 2, Math.max(1, e.outerTo - e.outerFrom) + 4, e.height + 4);
+function Vn(o, t, e) {
+  const { colours: s } = t, n = gt(e.subtask.appearance), i = Wt(n, ht(s, t, e.subtask.task, e.subtask.id), s);
+  if (s.forced) {
+    o.strokeStyle = s.active, o.lineWidth = 2, o.strokeRect(e.outerFrom - 2, e.y - 2, Math.max(1, e.outerTo - e.outerFrom) + 4, e.height + 4);
     return;
   }
-  o.globalAlpha = rn, o.fillStyle = i.onDark ? n.onAccent : n.text, o.fillRect(e.outerFrom, e.y, Math.max(1, e.outerTo - e.outerFrom), e.height), o.globalAlpha = 1;
+  o.globalAlpha = Wn, o.fillStyle = i.onDark ? s.onAccent : s.text, o.fillRect(e.outerFrom, e.y, Math.max(1, e.outerTo - e.outerFrom), e.height), o.globalAlpha = 1;
 }
-const rn = 0.2;
-function an(o, t) {
+const Wn = 0.2;
+function Un(o, t) {
   const e = t.selectedTask;
   if (e !== null) {
     o.strokeStyle = t.colours.text;
-    for (const n of t.view.boxes) {
-      if (n.subtask.task !== e) continue;
-      const s = n.subtask.id === t.selectedSubtask;
-      o.lineWidth = s ? 2 : 1;
-      const i = s ? 1 : 0.5;
-      o.strokeRect(n.outerFrom - i, n.y - i, n.outerTo - n.outerFrom + 2 * i, n.height + 2 * i);
+    for (const s of t.view.boxes) {
+      if (s.subtask.task !== e) continue;
+      const n = s.subtask.id === t.selectedSubtask;
+      o.lineWidth = n ? 2 : 1;
+      const i = n ? 1 : 0.5;
+      o.strokeRect(s.outerFrom - i, s.y - i, s.outerTo - s.outerFrom + 2 * i, s.height + 2 * i);
     }
   }
 }
-const mt = 32, ln = 18;
-function Ae(o, t) {
-  if (!(t > 2 * mt)) return 0;
-  const e = mt - o, n = o - (t - mt), s = Math.max(e, n);
-  if (s <= 0) return 0;
-  const i = Math.min(1, s / mt), r = ln * i * i;
+const ft = 32, Xn = 18;
+function Se(o, t) {
+  if (!(t > 2 * ft)) return 0;
+  const e = ft - o, s = o - (t - ft), n = Math.max(e, s);
+  if (n <= 0) return 0;
+  const i = Math.min(1, n / ft), r = Xn * i * i;
   return e > 0 ? -r : r;
 }
 function at(o, t, e) {
-  const n = (s, i) => {
-    const r = nt(s);
-    return s.lane === i.lane && r.from < i.to && i.from < r.to;
+  const s = (n, i) => {
+    const r = nt(n);
+    return n.lane === i.lane && r.from < i.to && i.from < r.to;
   };
-  return e.some((s) => n(o, s) && !(t !== null && n(t, s)));
+  return e.some((n) => s(o, n) && !(t !== null && s(t, n)));
 }
-function dn(o, t, e, n) {
-  const s = /* @__PURE__ */ new Set();
-  if (n === void 0) return s;
+function qn(o, t, e, s) {
+  const n = /* @__PURE__ */ new Set();
+  if (s === void 0) return n;
   for (const i of o)
-    i !== e && (n(t, i) || s.add(i));
-  return s;
-}
-function hn(o, t) {
-  const { step: e, offset: n } = typeof t == "number" ? { step: t, offset: 0 } : t;
-  if (!(e > 0) || !Number.isFinite(o)) return o;
-  const s = $t(o) + n;
-  return s + Math.round((o - s) / e) * e;
+    i !== e && (s(t, i) || n.add(i));
+  return n;
 }
-const De = "\0placing", _e = /* @__PURE__ */ new Set();
-function Dt(o) {
+const Le = "\0placing", Ae = /* @__PURE__ */ new Set();
+function _t(o) {
   switch (o.kind) {
     case "subtask":
       return `subtask:${o.subtask.id}:${o.part}`;
@@ -773,8 +1425,8 @@ function Dt(o) {
       return "nothing";
   }
 }
-const Fe = 3, cn = 10, un = 600;
-class fn {
+const Ce = 3, jn = 10, Jn = 600;
+class Zn {
   constructor(t) {
     f(this, "gesture", { kind: "none" });
     f(this, "touches", /* @__PURE__ */ new Map());
@@ -835,45 +1487,45 @@ class fn {
   ghostSummary() {
     const t = this.gesture;
     if (t.kind !== "edit" && t.kind !== "place") return null;
-    const e = Ve(this.host.view.viewport(), t.ghost);
+    const e = Xe(this.host.view.viewport(), t.ghost);
     if (e === null) return null;
-    const n = this.ghostFindings(t.ghost, this.ghostHome(t)), s = t.kind === "edit" && (t.mode === "leadIn" || t.mode === "leadOut"), i = s ? nt(t.ghost) : t.ghost;
+    const s = this.ghostFindings(t.ghost, this.ghostHome(t)), n = t.kind === "edit" && (t.mode === "leadIn" || t.mode === "leadOut"), i = n ? nt(t.ghost) : t.ghost;
     return {
       refused: this.refused,
       refusedLanes: [...t.refused],
       blocked: this.blocked,
-      x: s ? e.outerFrom : e.mainFrom,
+      x: n ? e.outerFrom : e.mainFrom,
       y: e.y,
       height: e.height,
       from: i.from,
       to: i.to,
-      overlap: n.overlaps.length > 0,
-      violated: n.violated.length > 0
+      overlap: s.overlaps.length > 0,
+      violated: s.violated.length > 0
     };
   }
   /* ---------------------------------------------------------------- */
   /* Pointer                                                           */
   /* ---------------------------------------------------------------- */
   local(t, e) {
-    var s;
-    const n = (s = this.host.plotElement()) == null ? void 0 : s.getBoundingClientRect();
-    return { x: t - ((n == null ? void 0 : n.left) ?? 0), y: e - ((n == null ? void 0 : n.top) ?? 0) };
+    var n;
+    const s = (n = this.host.plotElement()) == null ? void 0 : n.getBoundingClientRect();
+    return { x: t - ((s == null ? void 0 : s.left) ?? 0), y: e - ((s == null ? void 0 : s.top) ?? 0) };
   }
-  report(t, e, n, s, i, r) {
-    var l, h;
+  report(t, e, s, n, i, r) {
+    var d, h;
     const a = this.host.view;
-    (h = (l = this.host.handlers()).onInteraction) == null || h.call(l, { type: t, hit: e, clientX: n, clientY: s, time: a.timeAt(i), lane: a.laneIdAt(r) });
+    (h = (d = this.host.handlers()).onInteraction) == null || h.call(d, { type: t, hit: e, clientX: s, clientY: n, time: a.timeAt(i), lane: a.laneIdAt(r) });
   }
   pointerDown(t) {
-    var a, l, h, d, u;
-    const { x: e, y: n } = this.local(t.clientX, t.clientY);
-    if (t.pointerType === "touch" && (this.touches.set(t.pointerId, { x: e, y: n }), this.touches.size >= 2)) {
+    var a, d, h, l, c;
+    const { x: e, y: s } = this.local(t.clientX, t.clientY);
+    if (t.pointerType === "touch" && (this.touches.set(t.pointerId, { x: e, y: s }), this.touches.size >= 2)) {
       this.gesture.kind !== "pinch" && (this.cancelEdit(), this.gesture = { kind: "pinch", distance: this.touchDistance() });
       return;
     }
     if (t.button !== 0) return;
-    const s = (h = (l = (a = t.target) == null ? void 0 : a.closest) == null ? void 0 : l.call(a, "[data-grip]")) == null ? void 0 : h.getAttribute("data-grip"), i = this.host.selectedSubtask(), r = i !== null ? this.host.data.subtaskById.get(i) ?? null : null;
-    t.pointerType === "touch" ? this.gesture = { kind: "pending", pointerId: t.pointerId, x0: e, y0: n, mode: "pan", subtask: null } : (s === "leadIn" || s === "leadOut") && r !== null ? this.gesture = { kind: "pending", pointerId: t.pointerId, x0: e, y0: n, mode: s, subtask: r } : this.gesture = { kind: "pending", pointerId: t.pointerId, x0: e, y0: n, ...this.modeAt(e, n) }, (u = (d = this.host.plotElement()) == null ? void 0 : d.setPointerCapture) == null || u.call(d, t.pointerId);
+    const n = (h = (d = (a = t.target) == null ? void 0 : a.closest) == null ? void 0 : d.call(a, "[data-grip]")) == null ? void 0 : h.getAttribute("data-grip"), i = this.host.selectedSubtask(), r = i !== null ? this.host.data.subtaskById.get(i) ?? null : null;
+    t.pointerType === "touch" ? this.gesture = { kind: "pending", pointerId: t.pointerId, x0: e, y0: s, mode: "pan", subtask: null } : (n === "leadIn" || n === "leadOut") && r !== null ? this.gesture = { kind: "pending", pointerId: t.pointerId, x0: e, y0: s, mode: n, subtask: r } : this.gesture = { kind: "pending", pointerId: t.pointerId, x0: e, y0: s, ...this.modeAt(e, s) }, (c = (l = this.host.plotElement()) == null ? void 0 : l.setPointerCapture) == null || c.call(l, t.pointerId);
   }
   /** A drag over a folded group: resting on one opens it for the GESTURE.
   
@@ -883,13 +1535,13 @@ class fn {
         never written to and no change is reported, because the application did
         not fold anything (ADR-0025). */
   restOver(t) {
-    var s;
-    const e = this.host.view, n = e.foldedGroupAt(t);
-    n !== ((s = this.resting) == null ? void 0 : s.group) && (this.stopResting(), n !== null && (this.resting = {
-      group: n,
+    var n;
+    const e = this.host.view, s = e.foldedGroupAt(t);
+    s !== ((n = this.resting) == null ? void 0 : n.group) && (this.stopResting(), s !== null && (this.resting = {
+      group: s,
       timer: setTimeout(() => {
-        this.resting = null, e.openForGesture = /* @__PURE__ */ new Set([...e.openForGesture, n]), this.host.viewChanged();
-      }, un)
+        this.resting = null, e.openForGesture = /* @__PURE__ */ new Set([...e.openForGesture, s]), this.host.viewChanged();
+      }, Jn)
     }));
   }
   stopResting() {
@@ -911,69 +1563,69 @@ class fn {
       lane is open. Asked at a drop, where the answer has to be current; while
       a drag runs, the held set answers instead. */
   allowed(t, e) {
-    var n, s;
-    return ((s = (n = this.host.handlers()).canMoveTo) == null ? void 0 : s.call(n, t, e)) ?? !0;
+    var s, n;
+    return ((n = (s = this.host.handlers()).canMoveTo) == null ? void 0 : n.call(s, t, e)) ?? !0;
   }
   /** The lanes this work may not go to, for the gesture that is beginning. A
       gesture that cannot change a lane at all asks nothing: the intents the
       caller handles decide whether the question exists. */
   askRefused(t, e) {
-    if (!this.host.view.options.intents.includes(e === null ? "place" : "lane")) return _e;
-    const n = this.host.data.lanes.map((s) => s.id);
-    return dn(n, t, e, this.host.handlers().canMoveTo);
+    if (!this.host.view.options.intents.includes(e === null ? "place" : "lane")) return Ae;
+    const s = this.host.data.lanes.map((n) => n.id);
+    return qn(s, t, e, this.host.handlers().canMoveTo);
   }
   /** What a press at a point would start, given the intents the caller handles. */
   modeAt(t, e) {
-    const n = this.host.view, s = n.options.intents;
-    for (let i = n.boxes.length - 1; i >= 0; i--) {
-      const r = n.boxes[i];
-      if (s.includes("stretch")) {
-        const a = Rs(r, t, e);
+    const s = this.host.view, n = s.options.intents;
+    for (let i = s.boxes.length - 1; i >= 0; i--) {
+      const r = s.boxes[i];
+      if (n.includes("stretch")) {
+        const a = Ds(r, t, e);
         if (a !== null) return { mode: a === "from" ? "stretch-from" : "stretch-to", subtask: r.subtask };
       }
-      if (ze(r, t, e) !== null)
-        return s.includes("move") || s.includes("lane") ? { mode: "move", subtask: r.subtask } : { mode: "pan", subtask: r.subtask };
+      if (He(r, t, e) !== null)
+        return n.includes("move") || n.includes("lane") ? { mode: "move", subtask: r.subtask } : { mode: "pan", subtask: r.subtask };
     }
     return { mode: "pan", subtask: null };
   }
   pointerMove(t) {
-    const { x: e, y: n } = this.local(t.clientX, t.clientY);
-    if (t.pointerType === "touch" && this.touches.has(t.pointerId) && (this.touches.set(t.pointerId, { x: e, y: n }), this.gesture.kind === "pinch")) {
+    const { x: e, y: s } = this.local(t.clientX, t.clientY);
+    if (t.pointerType === "touch" && this.touches.has(t.pointerId) && (this.touches.set(t.pointerId, { x: e, y: s }), this.gesture.kind === "pinch")) {
       const r = this.touchDistance();
       r > 0 && this.gesture.distance > 0 && this.host.view.zoomAt(this.touchCentre(), this.gesture.distance / r) && this.host.viewMoved(!0), this.gesture = { kind: "pinch", distance: r };
       return;
     }
-    const s = this.gesture;
-    if (s.kind === "pending" && s.pointerId === t.pointerId) {
-      if (Math.hypot(e - s.x0, n - s.y0) < (t.pointerType === "touch" ? cn : Fe)) return;
-      if (s.mode === "pan" || s.subtask === null)
-        this.gesture = { kind: "pan", pointerId: s.pointerId, lastX: s.x0, lastY: s.y0 }, this.setCursor("grabbing");
+    const n = this.gesture;
+    if (n.kind === "pending" && n.pointerId === t.pointerId) {
+      if (Math.hypot(e - n.x0, s - n.y0) < (t.pointerType === "touch" ? jn : Ce)) return;
+      if (n.mode === "pan" || n.subtask === null)
+        this.gesture = { kind: "pan", pointerId: n.pointerId, lastX: n.x0, lastY: n.y0 }, this.setCursor("grabbing");
       else {
-        const r = this.host.view.viewport().scale.fromPx(s.x0);
+        const r = this.host.view.viewport().scale.fromPx(n.x0);
         this.gesture = {
           kind: "edit",
-          pointerId: s.pointerId,
-          mode: s.mode,
-          subtask: s.subtask,
+          pointerId: n.pointerId,
+          mode: n.mode,
+          subtask: n.subtask,
           t0: r,
-          ghost: s.subtask,
+          ghost: n.subtask,
           /* Asked here, once, and drawn from the first frame of the drag: the
              lanes that are closed are marked before the pointer reaches one. */
-          refused: s.mode === "move" ? this.askRefused(s.subtask, s.subtask.lane) : _e
-        }, this.setCursor(s.mode === "move" ? "grabbing" : "ew-resize");
+          refused: n.mode === "move" ? this.askRefused(n.subtask, n.subtask.lane) : Ae
+        }, this.setCursor(n.mode === "move" ? "grabbing" : "ew-resize");
       }
     }
     const i = this.gesture;
     if (i.kind === "pan" && i.pointerId === t.pointerId) {
-      const r = this.host.view.pan(i.lastX - e, i.lastY - n);
-      r.moved && this.host.viewMoved(r.time), this.gesture = { ...i, lastX: e, lastY: n };
+      const r = this.host.view.pan(i.lastX - e, i.lastY - s);
+      r.moved && this.host.viewMoved(r.time), this.gesture = { ...i, lastX: e, lastY: s };
       return;
     }
     if (i.kind === "edit" && i.pointerId === t.pointerId) {
-      this.lastClient = { x: t.clientX, y: t.clientY }, this.dragPoint = { x: e, y: n }, this.restOver(n), this.gesture = { ...i, ghost: this.heldGhost(i, e, n) }, this.setCursor(this.refused || this.blocked ? "not-allowed" : i.mode === "move" ? "grabbing" : "ew-resize"), this.host.interactionChanged(), this.autoPan();
+      this.lastClient = { x: t.clientX, y: t.clientY }, this.dragPoint = { x: e, y: s }, this.restOver(s), this.gesture = { ...i, ghost: this.heldGhost(i, e, s) }, this.setCursor(this.refused || this.blocked ? "not-allowed" : i.mode === "move" ? "grabbing" : "ew-resize"), this.host.interactionChanged(), this.autoPan();
       return;
     }
-    i.kind === "none" && (this.byKeyboard = !1, this.hoverAt(t.clientX, t.clientY, e, n));
+    i.kind === "none" && (this.byKeyboard = !1, this.hoverAt(t.clientX, t.clientY, e, s));
   }
   pointerUp(t) {
     var i, r;
@@ -982,18 +1634,18 @@ class fn {
       this.touches.size === 1 && a !== void 0 ? this.gesture = { kind: "pan", pointerId: a[0], lastX: a[1].x, lastY: a[1].y } : this.touches.size === 0 && (this.gesture = { kind: "none" });
       return;
     }
-    const e = this.gesture, { x: n, y: s } = this.local(t.clientX, t.clientY);
+    const e = this.gesture, { x: s, y: n } = this.local(t.clientX, t.clientY);
     if (e.kind === "pending" && e.pointerId === t.pointerId)
-      this.gesture = { kind: "none" }, this.click(t.clientX, t.clientY, n, s);
+      this.gesture = { kind: "none" }, this.click(t.clientX, t.clientY, s, n);
     else if (e.kind === "pan" && e.pointerId === t.pointerId)
-      this.gesture = { kind: "none" }, this.setCursor("default"), this.hoverAt(t.clientX, t.clientY, n, s);
+      this.gesture = { kind: "none" }, this.setCursor("default"), this.hoverAt(t.clientX, t.clientY, s, n);
     else if (e.kind === "edit" && e.pointerId === t.pointerId) {
       this.stopAutoPan(), this.closeGestureFolds(), this.gesture = { kind: "none" };
-      const a = e.ghost.lane === e.subtask.lane || this.allowed(e.subtask, e.ghost.lane), l = this.intentsOf(e.subtask, e.ghost, e.mode).filter(
+      const a = e.ghost.lane === e.subtask.lane || this.allowed(e.subtask, e.ghost.lane), d = this.intentsOf(e.subtask, e.ghost, e.mode).filter(
         (h) => a || h.kind !== "lane"
       );
       this.refused = !1, this.blocked = !1, this.cursor = "default", this.host.interactionChanged();
-      for (const h of l) (r = (i = this.host.handlers()).onIntent) == null || r.call(i, h);
+      for (const h of d) (r = (i = this.host.handlers()).onIntent) == null || r.call(i, h);
     }
   }
   /** While a drag is in flight near an edge, pans along once per frame and
@@ -1005,17 +1657,17 @@ class fn {
       this.panFrame = 0;
       const e = this.gesture;
       if (e.kind !== "edit" && e.kind !== "place") return;
-      const n = this.host.view, { x: s, y: i } = this.local(this.lastClient.x, this.lastClient.y), r = Ae(s, n.width), a = Ae(i, n.height);
+      const s = this.host.view, { x: n, y: i } = this.local(this.lastClient.x, this.lastClient.y), r = Se(n, s.width), a = Se(i, s.height);
       if (r === 0 && a === 0) return;
-      const l = n.pan(r, a);
-      if (l.moved) {
-        if (this.dragPoint = { x: s, y: i }, e.kind === "edit")
-          this.gesture = { ...e, ghost: this.heldGhost(e, s, i) };
+      const d = s.pan(r, a);
+      if (d.moved) {
+        if (this.dragPoint = { x: n, y: i }, e.kind === "edit")
+          this.gesture = { ...e, ghost: this.heldGhost(e, n, i) };
         else {
-          const h = this.placeGhost(e.item, s, i, e.refused);
+          const h = this.placeGhost(e.item, n, i, e.refused);
           this.refused = h.refused, this.blocked = h.blocked, this.gesture = { ...e, ghost: h.ghost ?? e.ghost };
         }
-        this.host.viewMoved(l.time), this.panFrame = requestAnimationFrame(t);
+        this.host.viewMoved(d.time), this.panFrame = requestAnimationFrame(t);
       }
     };
     this.panFrame = requestAnimationFrame(t);
@@ -1032,8 +1684,8 @@ class fn {
       times would be a lie. Nothing is reported: no interaction happened. */
   refreshHover() {
     if (!this.idle || this.hoverKey === "nothing" || this.byKeyboard) return;
-    const { x: t, y: e } = this.hoverPoint, n = this.host.view.hitAt(t, e);
-    this.hover = n, this.hoverKey = Dt(n);
+    const { x: t, y: e } = this.hoverPoint, s = this.host.view.hitAt(t, e);
+    this.hover = s, this.hoverKey = _t(s);
   }
   pointerLeave() {
     this.gesture.kind !== "none" || this.byKeyboard || this.setHover({ kind: "nothing" }, "nothing");
@@ -1046,19 +1698,19 @@ class fn {
   contextMenu(t) {
     if (this.host.handlers().onInteraction === void 0) return;
     t.preventDefault();
-    const { x: e, y: n } = this.local(t.clientX, t.clientY);
-    this.report("contextmenu", this.host.view.hitAt(e, n), t.clientX, t.clientY, e, n);
+    const { x: e, y: s } = this.local(t.clientX, t.clientY);
+    this.report("contextmenu", this.host.view.hitAt(e, s), t.clientX, t.clientY, e, s);
   }
   /** The wheel, as every scrolling area has it (schedule-refinement 02):
       vertical scrolls the lanes, and lets the page scroll on once they are at
       their end; Ctrl or ⌘ zooms - a trackpad pinch arrives as a wheel with
       Ctrl -; horizontal or Shift pans through time. */
   wheel(t) {
-    const e = this.host.view, n = Math.max(0, Math.min(e.width, this.local(t.clientX, t.clientY).x)), s = t.deltaMode === 1 ? 16 : t.deltaMode === 2 ? e.height : 1, i = t.deltaX * s, r = t.deltaY * s;
+    const e = this.host.view, s = Math.max(0, Math.min(e.width, this.local(t.clientX, t.clientY).x)), n = t.deltaMode === 1 ? 16 : t.deltaMode === 2 ? e.height : 1, i = t.deltaX * n, r = t.deltaY * n;
     if (t.ctrlKey || t.metaKey) {
       t.preventDefault();
       const h = Math.abs(r) < 50 ? 0.01 : 15e-4;
-      e.zoomAt(n, Math.exp(r * h)) && this.host.viewMoved(!0);
+      e.zoomAt(s, Math.exp(r * h)) && this.host.viewMoved(!0);
       return;
     }
     if (Math.abs(i) > Math.abs(r) || t.shiftKey) {
@@ -1070,26 +1722,26 @@ class fn {
     const a = r > 0 ? e.maxScroll() - e.scrollY : e.scrollY;
     if (r === 0 || a <= 0) return;
     t.preventDefault();
-    const l = e.pan(0, r);
-    l.moved && this.host.viewMoved(l.time);
+    const d = e.pan(0, r);
+    d.moved && this.host.viewMoved(d.time);
   }
-  click(t, e, n, s) {
-    const i = this.host.view.hitAt(n, s), r = i.kind === "subtask" ? i.subtask.task : i.kind === "dependency" ? this.host.data.taskOfDependency(i.dependency) : null;
-    this.host.select(r, i.kind === "subtask" ? i.subtask.id : null), this.report("click", i, t, e, n, s);
+  click(t, e, s, n) {
+    const i = this.host.view.hitAt(s, n), r = i.kind === "subtask" ? i.subtask.task : i.kind === "dependency" ? this.host.data.taskOfDependency(i.dependency) : null;
+    this.host.select(r, i.kind === "subtask" ? i.subtask.id : null), this.report("click", i, t, e, s, n);
   }
-  hoverAt(t, e, n, s) {
-    const i = this.host.view.hitAt(n, s), r = Dt(i), { mode: a } = this.modeAt(n, s);
-    if (this.setCursor(a === "move" ? "grab" : a === "stretch-from" || a === "stretch-to" ? "ew-resize" : "default"), this.hoverPoint = { x: n, y: s }, r === this.hoverKey) {
+  hoverAt(t, e, s, n) {
+    const i = this.host.view.hitAt(s, n), r = _t(i), { mode: a } = this.modeAt(s, n);
+    if (this.setCursor(a === "move" ? "grab" : a === "stretch-from" || a === "stretch-to" ? "ew-resize" : "default"), this.hoverPoint = { x: s, y: n }, r === this.hoverKey) {
       (i.kind === "subtask" || i.kind === "dependency") && this.host.interactionChanged();
       return;
     }
-    this.setHover(i, r), this.report("hover", i, t, e, n, s);
+    this.setHover(i, r), this.report("hover", i, t, e, s, n);
   }
   /** The keyboard sets the hover: drawn, and its tooltip shown, as the
       pointer's would be - and reported to nobody, since `onInteraction`
       speaks of pointer positions. `nothing` hands the hover back. */
   setKeyboardHover(t, e) {
-    this.byKeyboard = t.kind !== "nothing", this.hoverPoint = e, this.hover = t, this.hoverKey = Dt(t), this.host.interactionChanged();
+    this.byKeyboard = t.kind !== "nothing", this.hoverPoint = e, this.hover = t, this.hoverKey = _t(t), this.host.interactionChanged();
   }
   setHover(t, e) {
     e !== this.hoverKey && (this.hoverKey = e, this.hover = t, this.host.interactionChanged());
@@ -1112,10 +1764,10 @@ class fn {
       dragging and handles the place intent, the drop is accepted and a ghost
       shows where the work would land. */
   dragOver(t, e) {
-    const n = this.host.view;
-    if (e === null || !n.options.intents.includes("place")) return;
-    const { x: s, y: i } = this.local(t.clientX, t.clientY);
-    if (n.laneIdAt(i) === null && n.foldedGroupAt(i) === null) {
+    const s = this.host.view;
+    if (e === null || !s.options.intents.includes("place")) return;
+    const { x: n, y: i } = this.local(t.clientX, t.clientY);
+    if (s.laneIdAt(i) === null && s.foldedGroupAt(i) === null) {
       this.clearPlacing();
       return;
     }
@@ -1125,34 +1777,34 @@ class fn {
          pointer is not over one either, the rule is asked about an item
          whose own lane is empty - which is the truth of it: `canMoveTo`
          is asked ABOUT a lane, and the one this item is on is none. */
-      this.askRefused(this.askedFor(e, this.onLane(i) ?? "", s), null)
-    ), a = this.placeGhost(e, s, i, r);
+      this.askRefused(this.askedFor(e, this.onLane(i) ?? "", n), null)
+    ), a = this.placeGhost(e, n, i, r);
     this.refused = a.refused, this.blocked = a.blocked, this.setCursor(a.refused || a.blocked ? "not-allowed" : "default");
-    const l = this.gesture.kind === "place" ? this.gesture.ghost : null, h = a.ghost ?? (a.refused || a.blocked ? l : null);
-    t.dataTransfer !== null && (t.dataTransfer.dropEffect = h === null ? "none" : "copy"), h !== null && (this.lastClient = { x: t.clientX, y: t.clientY }, this.dragPoint = { x: s, y: i }, this.gesture = { kind: "place", ghost: h, item: e, refused: r }, this.host.interactionChanged(), this.autoPan());
+    const d = this.gesture.kind === "place" ? this.gesture.ghost : null, h = a.ghost ?? (a.refused || a.blocked ? d : null);
+    t.dataTransfer !== null && (t.dataTransfer.dropEffect = h === null ? "none" : "copy"), h !== null && (this.lastClient = { x: t.clientX, y: t.clientY }, this.dragPoint = { x: n, y: i }, this.gesture = { kind: "place", ghost: h, item: e, refused: r }, this.host.interactionChanged(), this.autoPan());
   }
   /** The ghost of a drag from outside at a point on the plot: none off the
       lanes, none where the caller refuses that lane and none where it would
       cover blocked time - which the answer says apart, because they mean
       different things to the drag. */
-  placeGhost(t, e, n, s) {
-    const i = this.onLane(n);
+  placeGhost(t, e, s, n) {
+    const i = this.onLane(s);
     if (i === null) return { ghost: null, refused: !1, blocked: !1 };
-    if (s.has(i)) return { ghost: null, refused: !0, blocked: !1 };
-    const r = { ...this.askedFor(t, i, e), id: De };
+    if (n.has(i)) return { ghost: null, refused: !0, blocked: !1 };
+    const r = { ...this.askedFor(t, i, e), id: Le };
     return at(r, null, this.host.data.blocked) ? { ghost: null, refused: !1, blocked: !0 } : { ghost: r, refused: !1, blocked: !1 };
   }
   /** The dragged item as a subtask, under the caller's key for it - not the
       internal sentinel: the rule is asked about the thing the application says
       it is dragging, and the ghost only afterwards takes the sentinel. */
-  askedFor(t, e, n) {
-    const s = this.snapInside(this.host.view.timeAt(n), this.snapStep());
+  askedFor(t, e, s) {
+    const n = this.snapInside(this.host.view.timeAt(s), this.snapStep());
     return {
       id: t.item,
       task: t.task,
       lane: e,
-      from: s,
-      to: s + t.duration,
+      from: n,
+      to: n + t.duration,
       ...t.leadIn === void 0 ? {} : { leadIn: t.leadIn },
       ...t.leadOut === void 0 ? {} : { leadOut: t.leadOut }
     };
@@ -1164,17 +1816,17 @@ class fn {
     const e = this.gesture;
     if (e.kind !== "place") return;
     t.preventDefault();
-    const { ghost: n, item: s } = e;
-    if (this.stopAutoPan(), this.closeGestureFolds(), this.gesture = { kind: "none" }, this.refused = !1, this.blocked = !1, this.cursor = "default", this.host.interactionChanged(), !this.allowed({ ...n, id: s.item }, n.lane)) return;
+    const { ghost: s, item: n } = e;
+    if (this.stopAutoPan(), this.closeGestureFolds(), this.gesture = { kind: "none" }, this.refused = !1, this.blocked = !1, this.cursor = "default", this.host.interactionChanged(), !this.allowed({ ...s, id: n.item }, s.lane)) return;
     const i = {
       kind: "place",
-      item: s.item,
-      task: n.task,
-      lane: n.lane,
-      from: n.from,
-      to: n.to,
-      ...n.leadIn === void 0 ? {} : { leadIn: n.leadIn },
-      ...n.leadOut === void 0 ? {} : { leadOut: n.leadOut }
+      item: n.item,
+      task: s.task,
+      lane: s.lane,
+      from: s.from,
+      to: s.to,
+      ...s.leadIn === void 0 ? {} : { leadIn: s.leadIn },
+      ...s.leadOut === void 0 ? {} : { leadOut: s.leadOut }
     };
     (a = (r = this.host.handlers()).onIntent) == null || a.call(r, i);
   }
@@ -1196,52 +1848,52 @@ class fn {
       put the work into blocked time it did not already cover, the ghost where
       it last stood. It is held, not clamped: a pointer carried on past the
       blocked time takes the ghost along again. */
-  heldGhost(t, e, n) {
-    const s = this.ghostFor(t, e, n);
-    return this.blocked = at(s, t.subtask, this.host.data.blocked), this.blocked ? t.ghost : s;
+  heldGhost(t, e, s) {
+    const n = this.ghostFor(t, e, s);
+    return this.blocked = at(n, t.subtask, this.host.data.blocked), this.blocked ? t.ghost : n;
   }
-  ghostFor(t, e, n) {
-    const s = this.host.view, i = t.subtask, r = this.snapStep(), a = s.options.intents, l = this.snapInside(s.timeAt(e), r);
+  ghostFor(t, e, s) {
+    const n = this.host.view, i = t.subtask, r = this.snapStep(), a = n.options.intents, d = this.snapInside(n.timeAt(e), r);
     switch (t.mode) {
       case "move": {
         let h = i.from;
-        const d = s.viewport().scale, u = d.fromPx(e) - t.t0;
-        a.includes("move") && Math.abs(u * d.m) >= Fe && (h = this.shifted(i.from, u, r));
+        const l = n.viewport().scale, c = l.fromPx(e) - t.t0;
+        a.includes("move") && Math.abs(c * l.m) >= Ce && (h = this.shifted(i.from, c, r));
         let p = t.ghost.lane;
         if (a.includes("lane")) {
-          const m = this.onLane(n) ?? p;
+          const m = this.onLane(s) ?? p;
           this.refused = t.refused.has(m), this.refused || (p = m);
         } else
           this.refused = !1;
         return { ...i, from: h, to: h + (i.to - i.from), lane: p };
       }
       case "stretch-from":
-        return { ...i, from: Math.min(l, i.to - Math.max(r.step, q)) };
+        return { ...i, from: Math.min(d, i.to - Math.max(r.step, q)) };
       case "stretch-to":
-        return { ...i, to: Math.max(l, i.from + Math.max(r.step, q)) };
+        return { ...i, to: Math.max(d, i.from + Math.max(r.step, q)) };
       case "leadIn":
-        return { ...i, leadIn: Math.max(0, i.from - l) };
+        return { ...i, leadIn: Math.max(0, i.from - d) };
       case "leadOut":
-        return { ...i, leadOut: Math.max(0, l - i.to) };
+        return { ...i, leadOut: Math.max(0, d - i.to) };
     }
   }
   /** A time moved by an amount of WORKING time and snapped: a drag moves
       a start this way, and a key by one step of the raster - one arithmetic,
       so a key proposes exactly what a drag of that length would. */
-  shifted(t, e, n) {
-    const s = et(this.host.view.options.calendar), i = W(t, s) + e, r = s.intervals.length === 0 ? i : j(Math.max(0, Math.min(s.total, i)), s);
-    return this.snapInside(r, n);
+  shifted(t, e, s) {
+    const n = et(this.host.view.options.calendar), i = H(t, n) + e, r = n.intervals.length === 0 ? i : j(Math.max(0, Math.min(n.total, i)), n);
+    return this.snapInside(r, s);
   }
   /** Snapped - and, where the raster lands in time the calendar removes, moved
       on to the seam, where time counts again. An intent never asks for a time
       nobody works. */
   snapInside(t, e) {
-    const n = hn(t, e), s = et(this.host.view.options.calendar);
-    return s.intervals.length === 0 ? n : j(W(n, s), s);
+    const s = ws(t, e), n = et(this.host.view.options.calendar);
+    return n.intervals.length === 0 ? s : j(H(s, n), n);
   }
-  intentsOf(t, e, n) {
-    const s = [], i = this.host.view.options.intents, r = t.id;
-    return n === "move" ? (e.from !== t.from && i.includes("move") && s.push({ kind: "move", subtask: r, from: e.from, to: e.to }), e.lane !== t.lane && i.includes("lane") && s.push({ kind: "lane", subtask: r, lane: e.lane })) : n === "stretch-from" || n === "stretch-to" ? (e.from !== t.from || e.to !== t.to) && s.push({ kind: "stretch", subtask: r, from: e.from, to: e.to }) : n === "leadIn" ? (e.leadIn ?? 0) !== (t.leadIn ?? 0) && s.push({ kind: "leadIn", subtask: r, leadIn: e.leadIn ?? 0 }) : (e.leadOut ?? 0) !== (t.leadOut ?? 0) && s.push({ kind: "leadOut", subtask: r, leadOut: e.leadOut ?? 0 }), s;
+  intentsOf(t, e, s) {
+    const n = [], i = this.host.view.options.intents, r = t.id;
+    return s === "move" ? (e.from !== t.from && i.includes("move") && n.push({ kind: "move", subtask: r, from: e.from, to: e.to }), e.lane !== t.lane && i.includes("lane") && n.push({ kind: "lane", subtask: r, lane: e.lane })) : s === "stretch-from" || s === "stretch-to" ? (e.from !== t.from || e.to !== t.to) && n.push({ kind: "stretch", subtask: r, from: e.from, to: e.to }) : s === "leadIn" ? (e.leadIn ?? 0) !== (t.leadIn ?? 0) && n.push({ kind: "leadIn", subtask: r, leadIn: e.leadIn ?? 0 }) : (e.leadOut ?? 0) !== (t.leadOut ?? 0) && n.push({ kind: "leadOut", subtask: r, leadOut: e.leadOut ?? 0 }), n;
   }
   /** The lane the ghost came from - the only other lane a drag can touch. */
   ghostHome(t) {
@@ -1257,34 +1909,34 @@ class fn {
         keeps a plan of hundreds of tasks fluid while a drag runs, since this is
         computed on every pointer movement. */
   ghostFindings(t, e) {
-    const n = this.host.data, s = (d) => d.lane === t.lane || d.lane === e, r = [...n.subtasks.filter((d) => d.id !== t.id && s(d)), t], a = (d) => d.first === t.id || d.second === t.id, l = n.dependencies.filter((d) => d.from === t.id || d.to === t.id), h = t.id === De ? n.subtasks : n.subtasks.map((d) => d.id === t.id ? t : d);
-    return { overlaps: Xt(r).filter(a), violated: Vt(h, l) };
+    const s = this.host.data, n = (l) => l.lane === t.lane || l.lane === e, r = [...s.subtasks.filter((l) => l.id !== t.id && n(l)), t], a = (l) => l.first === t.id || l.second === t.id, d = s.dependencies.filter((l) => l.from === t.id || l.to === t.id), h = t.id === Le ? s.subtasks : s.subtasks.map((l) => l.id === t.id ? t : l);
+    return { overlaps: Ht(r).filter(a), violated: Yt(h, d) };
   }
 }
-function pn(o, t) {
+function Qn(o, t) {
   const e = /* @__PURE__ */ new Map();
-  for (const n of t) {
-    const s = o.slots.get(n.lane), i = s === void 0 ? null : st(o, s.top);
+  for (const s of t) {
+    const n = o.slots.get(s.lane), i = n === void 0 ? null : st(o, n.top);
     if (i === null) continue;
     const r = o.rows.indexOf(i);
-    e.set(r, [...e.get(r) ?? [], n]);
+    e.set(r, [...e.get(r) ?? [], s]);
   }
-  return [...e.entries()].sort(([n], [s]) => n - s).map(([, n]) => n.sort((s, i) => s.from - i.from || s.to - i.to));
+  return [...e.entries()].sort(([s], [n]) => s - n).map(([, s]) => s.sort((n, i) => n.from - i.from || n.to - i.to));
 }
-const Oe = (o, t) => t < o.from ? o.from - t : t > o.to ? t - o.to : 0;
-function mn(o, t, e, n) {
+const _e = (o, t) => t < o.from ? o.from - t : t > o.to ? t - o.to : 0;
+function to(o, t, e, s) {
   var h;
-  let s = -1, i = -1;
-  for (let d = 0; d < o.length && t !== null && s < 0; d++)
-    i = o[d].findIndex((u) => u.id === t), i >= 0 && (s = d);
-  if (s < 0) {
-    for (const d of o) {
-      const u = d.find((p) => p.to > n[0] && p.from < n[1]);
-      if (u !== void 0) return u;
+  let n = -1, i = -1;
+  for (let l = 0; l < o.length && t !== null && n < 0; l++)
+    i = o[l].findIndex((c) => c.id === t), i >= 0 && (n = l);
+  if (n < 0) {
+    for (const l of o) {
+      const c = l.find((p) => p.to > s[0] && p.from < s[1]);
+      if (c !== void 0) return c;
     }
     return ((h = o[0]) == null ? void 0 : h[0]) ?? null;
   }
-  const r = o[s], a = r[i], l = (n[1] - n[0]) / 10;
+  const r = o[n], a = r[i], d = (s[1] - s[0]) / 10;
   switch (e) {
     case "next":
       return r[i + 1] ?? a;
@@ -1295,30 +1947,30 @@ function mn(o, t, e, n) {
     case "last":
       return r[r.length - 1];
     case "pageNext":
-      return r.find((d, u) => u > i && d.from >= a.from + l) ?? r[r.length - 1];
+      return r.find((l, c) => c > i && l.from >= a.from + d) ?? r[r.length - 1];
     case "pagePrevious":
-      for (let d = i - 1; d >= 0; d--) if (r[d].from <= a.from - l) return r[d];
+      for (let l = i - 1; l >= 0; l--) if (r[l].from <= a.from - d) return r[l];
       return r[0];
     case "up":
     case "down": {
-      const d = o[e === "up" ? s - 1 : s + 1];
-      if (d === void 0) return a;
-      const u = (a.from + a.to) / 2;
-      return d.reduce((p, m) => Oe(m, u) < Oe(p, u) ? m : p);
+      const l = o[e === "up" ? n - 1 : n + 1];
+      if (l === void 0) return a;
+      const c = (a.from + a.to) / 2;
+      return l.reduce((p, m) => _e(m, c) < _e(p, c) ? m : p);
     }
   }
 }
-function gn(o, t, e, n) {
+function eo(o, t, e, s) {
   if (e.kind === "dependency") {
-    const i = o.find((a) => a.id === e.id), r = i === void 0 ? void 0 : n === "out" ? i.to : i.from;
+    const i = o.find((a) => a.id === e.id), r = i === void 0 ? void 0 : s === "out" ? i.to : i.from;
     return r !== void 0 && t.has(r) ? { kind: "subtask", id: r } : e;
   }
-  const s = o.find(
-    (i) => (n === "out" ? i.from : i.to) === e.id && t.has(n === "out" ? i.to : i.from)
+  const n = o.find(
+    (i) => (s === "out" ? i.from : i.to) === e.id && t.has(s === "out" ? i.to : i.from)
   );
-  return s === void 0 ? e : { kind: "dependency", id: s.id };
+  return n === void 0 ? e : { kind: "dependency", id: n.id };
 }
-const kn = 150, yn = {
+const so = 150, no = {
   ArrowRight: "next",
   ArrowLeft: "previous",
   ArrowUp: "up",
@@ -1328,7 +1980,7 @@ const kn = 150, yn = {
   PageDown: "pageNext",
   PageUp: "pagePrevious"
 };
-class vn {
+class oo {
   constructor(t) {
     f(this, "spoken", null);
     f(this, "timer", null);
@@ -1353,33 +2005,33 @@ class vn {
   key(t) {
     const e = this.host.gestures;
     if (t.metaKey || !e.idle) return !1;
-    const n = t.key.toLowerCase() === "t" && !t.ctrlKey && !t.altKey;
-    if (t.key === "]" || t.key === "[" || n) {
+    const s = t.key.toLowerCase() === "t" && !t.ctrlKey && !t.altKey;
+    if (t.key === "]" || t.key === "[" || s) {
       const i = this.active();
       if (i === null) return !1;
-      const r = this.host.data, a = n ? !t.shiftKey : t.key === "]";
-      return this.show(gn(r.dependencies, r.subtaskById, i, a ? "out" : "back")), !0;
+      const r = this.host.data, a = s ? !t.shiftKey : t.key === "]";
+      return this.show(eo(r.dependencies, r.subtaskById, i, a ? "out" : "back")), !0;
     }
     if (t.ctrlKey) return !1;
     if (t.altKey) return this.edit(t);
     if (t.key === "Escape")
       return e.byKeyboard ? (this.blur(), !0) : !1;
     if (t.key === "Enter" || t.key === " ") return this.select();
-    const s = t.shiftKey ? void 0 : yn[t.key];
-    return s === void 0 ? !1 : (this.walk(s), !0);
+    const n = t.shiftKey ? void 0 : no[t.key];
+    return n === void 0 ? !1 : (this.walk(n), !0);
   }
   walk(t) {
-    var l;
-    const { data: e, view: n } = this.host, s = this.active(), i = s === null ? null : s.kind === "subtask" ? s.id : ((l = e.dependencies.find((h) => h.id === s.id)) == null ? void 0 : l.from) ?? null;
-    let r = pn(n.rows, e.subtasks);
+    var d;
+    const { data: e, view: s } = this.host, n = this.active(), i = n === null ? null : n.kind === "subtask" ? n.id : ((d = e.dependencies.find((h) => h.id === n.id)) == null ? void 0 : d.from) ?? null;
+    let r = Qn(s.rows, e.subtasks);
     if (i === null) {
-      const h = r.filter((d) => {
-        const u = n.boxById.get(d[0].id);
-        return u !== void 0 && u.y + u.height > 0 && u.y < n.height;
+      const h = r.filter((l) => {
+        const c = s.boxById.get(l[0].id);
+        return c !== void 0 && c.y + c.height > 0 && c.y < s.height;
       });
       h.length > 0 && (r = h);
     }
-    const a = mn(r, i, t, this.host.visibleDomain());
+    const a = to(r, i, t, this.host.visibleDomain());
     a !== null && this.show({ kind: "subtask", id: a.id });
   }
   /** Space and Enter select as a click does: the whole task, and the subtask. */
@@ -1394,323 +2046,122 @@ class vn {
       end - the intents a drag of that length reports (ADR-0023), and only
       where the caller handles them. Nothing is applied here. */
   edit(t) {
-    var u, p;
-    const e = this.host.gestures.hover, n = t.key === "ArrowRight" ? 1 : t.key === "ArrowLeft" ? -1 : 0;
-    if (n === 0) return !1;
+    var c, p;
+    const e = this.host.gestures.hover, s = t.key === "ArrowRight" ? 1 : t.key === "ArrowLeft" ? -1 : 0;
+    if (s === 0) return !1;
     if (e.kind !== "subtask") return !0;
-    const s = e.subtask, i = this.host.gestures, r = this.host.view.options.intents, a = i.snapStep(), l = a.step > 0 ? a : { step: this.host.view.step(), offset: 0 }, h = this.host.data.blocked;
-    let d = null;
-    if (!t.shiftKey && r.includes("move")) {
-      const m = (S) => ({ ...s, from: S, to: S + (s.to - s.from) });
-      let y = s.from;
-      for (let S = 0; S < 1e3; S++) {
-        const A = i.shifted(y, n * l.step, l);
-        if (A === y || (y = A, !at(m(y), s, h))) break;
-      }
-      y !== s.from && !at(m(y), s, h) && (d = { kind: "move", subtask: s.id, from: y, to: m(y).to });
-    } else if (t.shiftKey && r.includes("stretch")) {
-      const m = Math.max(i.shifted(s.to, n * l.step, l), s.from + Math.max(l.step, q));
-      m !== s.to && !at({ ...s, to: m }, s, h) && (d = { kind: "stretch", subtask: s.id, from: s.from, to: m });
-    }
-    return i.byKeyboard = !0, d !== null && ((p = (u = this.host.handlers()).onIntent) == null || p.call(u, d)), this.scheduleReadout(), !0;
-  }
-  /** The keys stand on this target: brought into view, drawn as the hover. */
-  show(t, e = !0) {
-    const n = this.hitOf(t);
-    if (n === null) return;
-    e && this.reveal(t);
-    const s = this.bounds(t);
-    if (s === null) return;
-    const { view: i } = this.host, r = (a, l) => Math.max(0, Math.min(l, a));
-    this.host.gestures.setKeyboardHover(n, {
-      x: (r(s.x0, i.width) + r(s.x1, i.width)) / 2,
-      y: (r(s.y0, i.height) + r(s.y1, i.height)) / 2
-    }), e && this.scheduleReadout();
-  }
-  hitOf(t) {
-    const e = this.host.data;
-    if (t.kind === "subtask") {
-      const s = e.subtaskById.get(t.id);
-      return s === void 0 ? null : { kind: "subtask", subtask: s, part: "main" };
-    }
-    const n = e.dependencies.find((s) => s.id === t.id);
-    return n === void 0 ? null : { kind: "dependency", dependency: n };
-  }
-  /** Where a target lies on the plot: a subtask's bar, or the span between
-      the two bars a dependency joins. */
-  bounds(t) {
-    const e = this.host.view, n = (a) => e.boxById.get(a);
-    if (t.kind === "subtask") {
-      const a = n(t.id);
-      return a === void 0 ? null : { x0: a.outerFrom, x1: a.outerTo, y0: a.y, y1: a.y + a.height };
-    }
-    const s = this.host.data.dependencies.find((a) => a.id === t.id), i = s === void 0 ? void 0 : n(s.from), r = s === void 0 ? void 0 : n(s.to);
-    return i === void 0 || r === void 0 ? null : {
-      x0: Math.min(i.mainTo, r.mainFrom),
-      x1: Math.max(i.mainTo, r.mainFrom),
-      y0: Math.min(i.y, r.y),
-      y1: Math.max(i.y + i.height, r.y + r.height)
-    };
-  }
-  /** Pans and scrolls just enough to bring a target into view, with a margin
-      at the side it came in from; a target wider than the view shows its
-      start. As a drag at the edge pans along, the keys do. */
-  reveal(t) {
-    const e = this.bounds(t), n = this.host.view;
-    if (e === null || n.width <= 0) return;
-    const s = Math.min(24, n.width / 10), i = e.x0 < 0 ? e.x0 - s : e.x1 > n.width ? Math.max(0, Math.min(e.x1 - n.width + s, e.x0 - s)) : 0, r = e.y0 < 0 ? e.y0 : e.y1 > n.height ? Math.min(e.y1 - n.height, e.y0) : 0;
-    if (i === 0 && r === 0) return;
-    const a = n.pan(i, r);
-    a.moved && this.host.viewMoved(a.time);
-  }
-  /** After the data or the view changed: the keys' target is read anew by its
-      id - its new times, its new place -, and dropped where it is gone. */
-  refresh() {
-    const t = this.active();
-    !this.host.gestures.byKeyboard || t === null || (this.hitOf(t) === null || this.bounds(t) === null ? this.blur() : this.show(t, !1));
-  }
-  /** The readout, written once the keys rest - and only while they still hold
-      the hover: a pointer that took it over in the pause is not spoken for. */
-  scheduleReadout() {
-    this.timer !== null && clearTimeout(this.timer), this.timer = setTimeout(() => {
-      var n;
-      this.timer = null;
-      const t = this.host.gestures.hover;
-      if (!this.host.gestures.byKeyboard) return;
-      const e = this.host.data.tooltipTargetFor(t);
-      e !== null && (this.spoken = { target: e, lane: t.kind === "subtask" ? t.subtask.lane : null, count: (((n = this.spoken) == null ? void 0 : n.count) ?? 0) + 1 }, this.host.spokenChanged());
-    }, kn);
-  }
-  /** Unmount: no readout after it. */
-  stop() {
-    this.timer !== null && clearTimeout(this.timer), this.timer = null;
-  }
-}
-const Je = [], wn = 56;
-function bn(o, t = wn) {
-  return o > 0 ? Math.min(Z, Math.max(15 * q, ws(o * t, 1))) : 15 * q;
-}
-function Mn(o, t, e = Je) {
-  const [n, s] = Qe(o, e);
-  return bs(e, n, s, t, $t(n)).filter(
-    (i) => i.workingTime >= o[0] && i.workingTime <= o[1]
-  );
-}
-function Tn(o, t = Je) {
-  const [e, n] = Qe(o, t), s = [], i = new Date(e);
-  for (i.setHours(0, 0, 0, 0); i.getTime() < n && s.length < 400; ) {
-    const r = i.getTime();
-    i.setDate(i.getDate() + 1);
-    const a = i.getTime();
-    s.push({
-      start: r,
-      end: a,
-      from: W(r, t),
-      to: W(a, t)
-    });
-  }
-  return s;
-}
-const _t = [1, 2, 7, 14, 28];
-function In(o, t) {
-  return _t.find((e) => e * o >= t) ?? _t[_t.length - 1];
-}
-function Ft(o, t) {
-  return ((Math.round((o - $t(o)) / Z) - 4) % t + t) % t === 0;
-}
-function Cn(o, t, e, n) {
-  const s = o[1] - o[0];
-  if (!(s > 0)) return [o[0], o[1]];
-  const i = Math.min(n.max, Math.max(n.min, s * e)), r = (t - o[0]) / s, a = t - r * i;
-  return [a, a + i];
-}
-function Sn(o, t) {
-  return [o[0] + t, o[1] + t];
-}
-function Qe(o, t) {
-  const e = et(t);
-  if (e.intervals.length === 0) return [o[0], o[1]];
-  const n = (s) => Math.max(0, Math.min(e.total, s));
-  return [j(n(o[0]), e), j(n(o[1]), e)];
-}
-const gt = 44;
-class Ln {
-  constructor(t) {
-    f(this, "options", {
-      laneHeight: gt,
-      calendar: [],
-      zoomLimits: { min: Gt, max: 28 * Z },
-      snap: "ticks",
-      intents: [],
-      now: null,
-      route: "curve",
-      attach: "centre",
-      ends: "dot"
-    });
-    f(this, "domain", [0, Z]);
-    f(this, "scrollY", 0);
-    f(this, "width", 0);
-    f(this, "height", 0);
-    /* What is laid out from top to bottom (`rows.ts`). It is derived here and
-       not in the data, because a row's height comes from a view option; every y
-       in the package reads it. */
-    f(this, "rows", ge({ lanes: [], groups: [], collapsed: /* @__PURE__ */ new Set(), laneHeight: gt }));
-    /** The folded groups, as the scene holds them. */
-    f(this, "collapsed", /* @__PURE__ */ new Set());
-    /** The groups a gesture in flight holds open. Dropped when it ends; the
-        caller's list never learns of it. */
-    f(this, "openForGesture", /* @__PURE__ */ new Set());
-    f(this, "boxes", []);
-    f(this, "boxById", /* @__PURE__ */ new Map());
-    f(this, "paths", []);
-    this.data = t;
-  }
-  /** Takes new options; an initial domain in wall-clock time puts the view
-      there, and a new calendar keeps the wall-clock span in view. */
-  setOptions(t, e) {
-    const n = t.calendar !== this.options.calendar, s = this.options.calendar;
-    if (this.options = t, e !== null)
-      this.domain = [W(e[0], t.calendar), W(e[1], t.calendar)];
-    else if (n) {
-      const i = et(s), r = (a) => {
-        const l = i.intervals.length === 0 ? a : Math.max(0, Math.min(i.total, a));
-        return W(j(l, i), t.calendar) + (a - l);
-      };
-      this.domain = [r(this.domain[0]), r(this.domain[1])];
-    }
-  }
-  viewport() {
-    return {
-      scale: new Ms(this.domain, [0, this.width]),
-      calendar: this.options.calendar,
-      laneHeight: this.options.laneHeight,
-      scrollY: this.scrollY,
-      rows: this.rows
-    };
-  }
-  maxScroll() {
-    return Math.max(0, this.rows.height - this.height);
-  }
-  /** The lowest y that still lies on a lane. */
-  lanesBottom() {
-    return this.rows.height - this.scrollY - 1;
-  }
-  /** The fine band's step at the current zoom. */
-  step() {
-    const t = this.domain[1] - this.domain[0];
-    return bn(this.width > 0 ? t / this.width : t);
-  }
-  /** Lays the rows out, clamps the scroll, and lays the data out anew. */
-  layout() {
-    this.rows = ge({
-      lanes: this.data.lanes,
-      groups: this.data.groups,
-      collapsed: Fs(this.collapsed, this.openForGesture),
-      laneHeight: this.options.laneHeight
-    }), this.scrollY = Math.max(0, Math.min(this.maxScroll(), this.scrollY));
-    const t = this.viewport();
-    this.boxes = [], this.boxById = /* @__PURE__ */ new Map();
-    for (const e of this.data.subtasks) {
-      const n = Kt(this.rows, e.lane);
-      if (n === null) continue;
-      const s = Ye(t, e, e.lane, n, this.data.depth.get(e.id) ?? 0);
-      this.boxes.push(s), this.boxById.set(e.id, s);
-    }
-    this.paths = [];
-    for (const e of this.data.dependencies) {
-      const n = this.boxById.get(e.from), s = this.boxById.get(e.to);
-      n === void 0 || s === void 0 || this.paths.push(Pt(t, e, n, s, this.options));
+    const n = e.subtask, i = this.host.gestures, r = this.host.view.options.intents, a = i.snapStep(), d = a.step > 0 ? a : { step: this.host.view.step(), offset: 0 }, h = this.host.data.blocked;
+    let l = null;
+    if (!t.shiftKey && r.includes("move")) {
+      const m = (I) => ({ ...n, from: I, to: I + (n.to - n.from) });
+      let y = n.from;
+      for (let I = 0; I < 1e3; I++) {
+        const A = i.shifted(y, s * d.step, d);
+        if (A === y || (y = A, !at(m(y), n, h))) break;
+      }
+      y !== n.from && !at(m(y), n, h) && (l = { kind: "move", subtask: n.id, from: y, to: m(y).to });
+    } else if (t.shiftKey && r.includes("stretch")) {
+      const m = Math.max(i.shifted(n.to, s * d.step, d), n.from + Math.max(d.step, q));
+      m !== n.to && !at({ ...n, to: m }, n, h) && (l = { kind: "stretch", subtask: n.id, from: n.from, to: m });
     }
+    return i.byKeyboard = !0, l !== null && ((p = (c = this.host.handlers()).onIntent) == null || p.call(c, l)), this.scheduleReadout(), !0;
   }
-  /** The days of the coarse band and the ticks of the fine band, in pixels. */
-  bands() {
-    const t = this.step();
-    if (this.width <= 0) return { days: [], ticks: [], step: t };
-    const e = this.viewport().scale, n = this.options.calendar;
-    return {
-      days: Tn(this.domain, n).map((s) => {
-        const i = Math.round(e.toPx(s.from));
-        return { start: s.start, x: i, width: Math.round(e.toPx(s.to)) - i };
-      }),
-      ticks: Mn(this.domain, t, n).map((s) => ({ wallClock: s.wallClock, x: Math.round(e.toPx(s.workingTime)) })),
-      step: t
-    };
-  }
-  /** The now line's x, or null where there is none or it lies outside the plot. */
-  nowX() {
-    const t = this.options.now;
-    if (t === null || this.width <= 0) return null;
-    const e = Math.round(this.viewport().scale.toPx(W(t, this.options.calendar)));
-    return e >= 0 && e <= this.width ? e : null;
+  /** The keys stand on this target: brought into view, drawn as the hover. */
+  show(t, e = !0) {
+    const s = this.hitOf(t);
+    if (s === null) return;
+    e && this.reveal(t);
+    const n = this.bounds(t);
+    if (n === null) return;
+    const { view: i } = this.host, r = (a, d) => Math.max(0, Math.min(d, a));
+    this.host.gestures.setKeyboardHover(s, {
+      x: (r(n.x0, i.width) + r(n.x1, i.width)) / 2,
+      y: (r(n.y0, i.height) + r(n.y1, i.height)) / 2
+    }), e && this.scheduleReadout();
   }
-  hitAt(t, e) {
-    for (let r = this.boxes.length - 1; r >= 0; r--) {
-      const a = this.boxes[r], l = ze(a, t, e);
-      if (l !== null) return { kind: "subtask", subtask: a.subtask, part: l };
-    }
-    let n = null, s = 4;
-    for (const r of this.paths) {
-      const a = xs(r, t, e);
-      a <= s && (s = a, n = r);
+  hitOf(t) {
+    const e = this.host.data;
+    if (t.kind === "subtask") {
+      const n = e.subtaskById.get(t.id);
+      return n === void 0 ? null : { kind: "subtask", subtask: n, part: "main" };
     }
-    if (n !== null) return { kind: "dependency", dependency: n.dependency };
-    const i = we(this.viewport(), e);
-    return i !== null ? { kind: "lane", lane: i } : { kind: "nothing" };
-  }
-  /** The wall-clock time at a plot x; within the calendar's extent. */
-  timeAt(t) {
-    const e = this.viewport().scale.fromPx(t), n = et(this.options.calendar);
-    return n.intervals.length === 0 ? e : j(Math.max(0, Math.min(n.total, e)), n);
+    const s = e.dependencies.find((n) => n.id === t.id);
+    return s === void 0 ? null : { kind: "dependency", dependency: s };
   }
-  /** The lane at a y, strips included: what the pointer is ON.
-  
-        One line, and it stays a line of its own: it is one of the three
-        questions this object answers about a y - this one, `dropLaneIdAt` and
-        `foldedGroupAt` - and a caller that reached through `viewport()` for it
-        would be depending on the layout rather than asking the view. */
-  laneIdAt(t) {
-    return we(this.viewport(), t);
+  /** Where a target lies on the plot: a subtask's bar, or the span between
+      the two bars a dependency joins. */
+  bounds(t) {
+    const e = this.host.view, s = (a) => e.boxById.get(a);
+    if (t.kind === "subtask") {
+      const a = s(t.id);
+      return a === void 0 ? null : { x0: a.outerFrom, x1: a.outerTo, y0: a.y, y1: a.y + a.height };
+    }
+    const n = this.host.data.dependencies.find((a) => a.id === t.id), i = n === void 0 ? void 0 : s(n.from), r = n === void 0 ? void 0 : s(n.to);
+    return i === void 0 || r === void 0 ? null : {
+      x0: Math.min(i.mainTo, r.mainFrom),
+      x1: Math.max(i.mainTo, r.mainFrom),
+      y0: Math.min(i.y, r.y),
+      y1: Math.max(i.y + i.height, r.y + r.height)
+    };
   }
-  /** The lane a DROP at this y would land on.
-  
-        A **Miniature** is no drop target. A strip is three pixels of a lane's
-        whole day, and a drop aimed at one would be a guess; resting over the
-        group opens it for the gesture instead, and then there is a real lane to
-        aim at. Hover, the tooltip and selection do read a strip - they cost
-        nothing if they are a pixel out. */
-  dropLaneIdAt(t) {
-    const e = st(this.rows, t + this.scrollY);
-    return e === null || e.kind !== "lane" ? null : e.lane ?? null;
+  /** Pans and scrolls just enough to bring a target into view, with a margin
+      at the side it came in from; a target wider than the view shows its
+      start. As a drag at the edge pans along, the keys do. */
+  reveal(t) {
+    const e = this.bounds(t), s = this.host.view;
+    if (e === null || s.width <= 0) return;
+    const n = Math.min(24, s.width / 10), i = e.x0 < 0 ? e.x0 - n : e.x1 > s.width ? Math.max(0, Math.min(e.x1 - s.width + n, e.x0 - n)) : 0, r = e.y0 < 0 ? e.y0 : e.y1 > s.height ? Math.min(e.y1 - s.height, e.y0) : 0;
+    if (i === 0 && r === 0) return;
+    const a = s.pan(i, r);
+    a.moved && this.host.viewMoved(a.time);
   }
-  /** The folded group a y lies over, or null. */
-  foldedGroupAt(t) {
-    const e = st(this.rows, t + this.scrollY);
-    return e !== null && e.kind === "miniature" ? e.group ?? null : null;
+  /** After the data or the view changed: the keys' target is read anew by its
+      id - its new times, its new place -, and dropped where it is gone. */
+  refresh() {
+    const t = this.active();
+    !this.host.gestures.byKeyboard || t === null || (this.hitOf(t) === null || this.bounds(t) === null ? this.blur() : this.show(t, !1));
   }
-  /** Pans by pixels. Says what moved: the span through time, the lanes, or
-      neither - a scroll through the lanes is no news about the time. */
-  pan(t, e) {
-    const n = this.domain[0], s = this.scrollY, i = this.domain[1] - n;
-    this.width > 0 && t !== 0 && (this.domain = Sn(this.domain, t / this.width * i)), this.scrollY = Math.max(0, Math.min(this.maxScroll(), this.scrollY + e));
-    const r = this.domain[0] !== n;
-    return { moved: r || this.scrollY !== s, time: r };
+  /** The readout, written once the keys rest - and only while they still hold
+      the hover: a pointer that took it over in the pause is not spoken for. */
+  scheduleReadout() {
+    this.timer !== null && clearTimeout(this.timer), this.timer = setTimeout(() => {
+      var s;
+      this.timer = null;
+      const t = this.host.gestures.hover;
+      if (!this.host.gestures.byKeyboard) return;
+      const e = this.host.data.tooltipTargetFor(t);
+      e !== null && (this.spoken = { target: e, lane: t.kind === "subtask" ? t.subtask.lane : null, count: (((s = this.spoken) == null ? void 0 : s.count) ?? 0) + 1 }, this.host.spokenChanged());
+    }, so);
   }
-  /** Zooms around a plot x; says whether the span changed. */
-  zoomAt(t, e) {
-    if (this.width <= 0 || !Number.isFinite(e)) return !1;
-    const n = this.domain, s = this.viewport().scale.fromPx(t);
-    return this.domain = Cn(this.domain, s, e, this.options.zoomLimits), n[0] !== this.domain[0] || n[1] !== this.domain[1];
+  /** Unmount: no readout after it. */
+  stop() {
+    this.timer !== null && clearTimeout(this.timer), this.timer = null;
   }
 }
-const Ee = {
+const Q = (o) => JSON.stringify([o.domain ?? null, [...o.folded ?? []].sort()]);
+function io(o, t) {
+  if (t.size === 0 || o.folded === void 0) return o;
+  const e = o.folded.filter((s) => t.has(s));
+  return e.length === o.folded.length ? o : { ...o.domain ? { domain: o.domain } : {}, ...e.length ? { folded: e } : {} };
+}
+function ro(o, t, e = (s) => s) {
+  if (o.length === 0) return null;
+  let s = 1 / 0, n = -1 / 0;
+  for (const a of o)
+    s = Math.min(s, a.from - (a.leadIn ?? 0)), n = Math.max(n, a.to + (a.leadOut ?? 0));
+  s = e(s), n = e(n);
+  const i = Math.min(t.max, Math.max(t.min, n - s)), r = (s + n) / 2;
+  return [r - i / 2, r + i / 2];
+}
+const De = {
   width: 0,
   height: 0,
-  laneHeight: gt,
+  laneHeight: pt,
   scrollY: 0,
   headers: [],
   days: [],
   ticks: [],
-  step: Gt,
+  step: Bt,
   ghost: null,
   grips: [],
   cursor: "default",
@@ -1720,10 +2171,10 @@ const Ee = {
   spoken: null,
   summary: { lanes: 0, subtasks: 0, from: 0, to: 0, overlaps: 0, violated: 0, blocked: 0 }
 };
-class An {
-  constructor() {
-    f(this, "data", new Gs(() => this.viewChanged()));
-    f(this, "view", new Ln(this.data));
+class ao {
+  constructor(t = {}) {
+    f(this, "data", new An(() => this.viewChanged()));
+    f(this, "view", new Ys(this.data));
     f(this, "gestures");
     f(this, "keys");
     f(this, "handlersNow", {});
@@ -1731,11 +2182,24 @@ class An {
     f(this, "controlledTask");
     f(this, "ownTask", null);
     f(this, "selected", null);
-    /** Which **Lane group**s are folded. Controlled where the caller passes a
-        list, kept here otherwise - the shape `selectedTask` has. Folding changes
-        the view and not the plan, so it is no **Intent** (ADR-0025). */
-    f(this, "controlledCollapsed");
-    f(this, "ownCollapsed", []);
+    /** Which **Lane group**s are folded. Folding changes the view and not the
+        plan, so it is no **Intent** (ADR-0025). */
+    f(this, "folded");
+    /** The span the view names, in wall-clock time - null while it names none
+        and the schedule shows the subtasks' extent. */
+    f(this, "domainInView");
+    /** Whether the extent has been put in view since the view stopped naming a
+        span. Once, and not after every change of the data: a bar the planner
+        dragged past the end must not make the whole plan jump. */
+    f(this, "fitted", !1);
+    /** The view as `useSchedule` reads it - a new object only when its content
+        changed. */
+    f(this, "viewNow");
+    f(this, "viewListeners", /* @__PURE__ */ new Set());
+    /** Whether the planner, a setter or a view handed in has changed the view
+        yet. Until then a change is the start losing the groups no LaneGroup
+        declares - where the schedule starts, not a change to report. */
+    f(this, "actedOn", !1);
     f(this, "root", null);
     f(this, "plot", null);
     f(this, "dataCanvas", null);
@@ -1744,7 +2208,7 @@ class An {
     f(this, "frame", 0);
     f(this, "domainFrame", 0);
     f(this, "unsubscribeTheme", null);
-    f(this, "snapshot", Ee);
+    f(this, "snapshot", De);
     f(this, "listeners", /* @__PURE__ */ new Set());
     /* ---------------------------------------------------------------- */
     /* Registration and options                                          */
@@ -1758,11 +2222,34 @@ class An {
     f(this, "registerLayer", (t) => this.data.registerLayer(t));
     f(this, "updateLayer", (t, e) => this.data.updateLayer(t, e));
     f(this, "unregisterLayer", (t) => this.data.unregisterLayer(t));
+    /* ---------------------------------------------------------------- */
+    /* The view (ADR-0047)                                               */
+    /* ---------------------------------------------------------------- */
+    f(this, "subscribeView", (t) => (this.viewListeners.add(t), () => {
+      this.viewListeners.delete(t);
+    }));
+    f(this, "getView", () => this.viewNow);
+    /** Puts a span of two wall-clock instants in view; null shows the
+        subtasks' extent. */
+    f(this, "setDomain", (t) => {
+      this.domainFrame !== 0 && cancelAnimationFrame(this.domainFrame), this.domainFrame = 0, this.actedOn = !0, this.domainInView = t === null ? null : [t[0], t[1]], t === null ? this.fitted = !1 : this.view.showWall(t), this.viewChanged();
+    });
+    /** Folds or unfolds one group. */
+    f(this, "toggleGroup", (t) => {
+      const e = this.viewNow.folded ?? [];
+      this.actedOn = !0, this.folded = e.includes(t) ? e.filter((s) => s !== t) : [...e, t], this.viewChanged();
+    });
+    f(this, "foldAll", () => {
+      this.actedOn = !0, this.folded = this.data.groups.map((t) => t.id), this.viewChanged();
+    });
+    f(this, "unfoldAll", () => {
+      this.actedOn = !0, this.folded = [], this.viewChanged();
+    });
     f(this, "subscribe", (t) => (this.listeners.add(t), () => {
       this.listeners.delete(t);
     }));
     f(this, "getSnapshot", () => this.snapshot);
-    f(this, "getServerSnapshot", () => Ee);
+    f(this, "getServerSnapshot", () => De);
     /* ---------------------------------------------------------------- */
     /* Gestures, as the component hands them in                          */
     /* ---------------------------------------------------------------- */
@@ -1780,33 +2267,36 @@ class An {
     f(this, "key", (t) => this.keys.key(t));
     f(this, "focus", (t) => this.keys.focus(t));
     f(this, "blur", () => this.keys.blur());
-    this.gestures = new fn({
+    this.folded = t.folded ?? [], this.domainInView = t.domain ?? null, this.domainInView !== null && this.view.showWall(this.domainInView), this.viewNow = this.currentView(), this.gestures = new Zn({
       data: this.data,
       view: this.view,
       plotElement: () => this.plot,
       handlers: () => this.handlersNow,
       selectedSubtask: () => this.selected,
-      select: (t, e) => this.select(t, e),
+      select: (e, s) => this.select(e, s),
       viewChanged: () => this.viewChanged(),
-      viewMoved: (t) => {
-        this.viewChanged(), t && this.reportDomain();
+      viewMoved: (e) => {
+        this.viewChanged(), e && this.reportDomain();
       },
       interactionChanged: () => this.interactionChanged()
-    }), this.keys = new vn({
+    }), this.keys = new oo({
       data: this.data,
       view: this.view,
       gestures: this.gestures,
       handlers: () => this.handlersNow,
       visibleDomain: () => this.visibleDomain(),
-      select: (t, e) => this.select(t, e),
-      viewMoved: (t) => {
-        this.viewChanged(), t && this.reportDomain();
+      select: (e, s) => this.select(e, s),
+      viewMoved: (e) => {
+        this.viewChanged(), e && this.reportDomain();
       },
       spokenChanged: () => this.publish()
     });
   }
-  setOptions(t, e) {
-    this.view.setOptions(t, e), this.viewChanged();
+  get acted() {
+    return this.actedOn;
+  }
+  setOptions(t) {
+    this.view.setOptions(t), this.viewChanged();
   }
   setHandlers(t) {
     this.handlersNow = t;
@@ -1815,23 +2305,33 @@ class An {
   setPlacing(t) {
     this.placing = t, t === null && this.gestures.clearPlacing();
   }
-  /** `undefined`: the scene keeps the folded groups itself. */
-  setCollapsedGroups(t) {
-    t !== this.controlledCollapsed && (this.controlledCollapsed = t, this.viewChanged());
+  /** Goes to a view handed in; what it leaves out goes back to its default. */
+  applyView(t) {
+    Q(t) !== Q(this.viewNow) && (this.actedOn = !0, this.folded = t.folded ?? [], this.setDomain(t.domain ?? null));
   }
-  /** The uncontrolled starting point, taken once. */
-  setDefaultCollapsedGroups(t) {
-    this.ownCollapsed = t, this.viewChanged();
+  currentView() {
+    return io(
+      { ...this.domainInView === null ? {} : { domain: this.domainInView }, ...this.folded.length > 0 ? { folded: this.folded } : {} },
+      new Set(this.data.groups.map((t) => t.id))
+    );
   }
-  get collapsedGroups() {
-    return this.controlledCollapsed ?? this.ownCollapsed;
+  publishView() {
+    const t = this.currentView();
+    if (Q(t) !== Q(this.viewNow)) {
+      this.viewNow = t;
+      for (const e of this.viewListeners) e();
+    }
   }
-  /** Folds or unfolds one group. The caller's list is never written to: where
-      the state is controlled, only the report goes out. */
-  toggleGroup(t) {
-    var s, i;
-    const e = this.collapsedGroups, n = e.includes(t) ? e.filter((r) => r !== t) : [...e, t];
-    this.controlledCollapsed === void 0 && (this.ownCollapsed = n), (i = (s = this.handlersNow).onCollapsedGroupsChange) == null || i.call(s, n), this.viewChanged();
+  /** The subtasks' extent within the zoom limits, while the view names no
+      span - and the local day of today while there is no work to show. */
+  fit() {
+    const t = this.view.options.calendar, e = ro(this.data.subtasks, this.view.options.zoomLimits, (n) => H(n, t));
+    if (e !== null) {
+      this.view.domain = e, this.fitted = !0;
+      return;
+    }
+    const s = /* @__PURE__ */ new Date();
+    s.setHours(0, 0, 0, 0), this.view.showWall([s.getTime(), s.getTime() + U]);
   }
   /** `undefined`: the scene keeps the selection itself. */
   setControlledTask(t) {
@@ -1848,15 +2348,15 @@ class An {
     return t !== void 0 && t.task === this.selectedTask ? t.id : null;
   }
   select(t, e) {
-    var s, i;
-    const n = t !== this.selectedTask || e !== this.selected;
-    this.selected = e, t !== this.selectedTask && this.controlledTask === void 0 && (this.ownTask = t), n && ((i = (s = this.handlersNow).onSelectedTaskChange) == null || i.call(s, t, e)), this.interactionChanged();
+    var n, i;
+    const s = t !== this.selectedTask || e !== this.selected;
+    this.selected = e, t !== this.selectedTask && this.controlledTask === void 0 && (this.ownTask = t), s && ((i = (n = this.handlersNow).onSelectedTaskChange) == null || i.call(n, t, e)), this.interactionChanged();
   }
   /* ---------------------------------------------------------------- */
   /* DOM binding                                                       */
   /* ---------------------------------------------------------------- */
-  bind(t, e, n, s) {
-    this.root = t, this.plot = e, this.dataCanvas = n, this.overlayCanvas = s, this.unsubscribeTheme = Ts(() => {
+  bind(t, e, s, n) {
+    this.root = t, this.plot = e, this.dataCanvas = s, this.overlayCanvas = n, this.unsubscribeTheme = fs(() => {
       this.colours = null, this.requestDraw();
     }), this.viewChanged();
   }
@@ -1865,21 +2365,21 @@ class An {
     this.gestures.cancelEdit(), this.keys.stop(), (t = this.unsubscribeTheme) == null || t.call(this), this.unsubscribeTheme = null, this.frame !== 0 && cancelAnimationFrame(this.frame), this.domainFrame !== 0 && cancelAnimationFrame(this.domainFrame), this.frame = this.domainFrame = 0, this.root = this.plot = this.dataCanvas = this.overlayCanvas = null;
   }
   resize(t, e) {
-    const n = Math.max(0, Math.round(t)), s = Math.max(0, Math.round(e));
-    n === this.view.width && s === this.view.height || (this.view.width = n, this.view.height = s, this.viewChanged());
+    const s = Math.max(0, Math.round(t)), n = Math.max(0, Math.round(e));
+    s === this.view.width && n === this.view.height || (this.view.width = s, this.view.height = n, this.viewChanged());
   }
   /* ---------------------------------------------------------------- */
   /* Changes                                                           */
   /* ---------------------------------------------------------------- */
   viewChanged() {
-    this.view.collapsed = new Set(this.collapsedGroups), this.data.rebuild() && (this.colours = null, this.selected !== null && !this.data.subtaskById.has(this.selected) && (this.selected = null)), this.view.layout(), this.gestures.refreshHover(), this.keys.refresh(), this.interactionChanged();
+    this.view.collapsed = new Set(this.folded), this.data.rebuild() && (this.colours = null, this.selected !== null && !this.data.subtaskById.has(this.selected) && (this.selected = null)), this.domainInView === null && !this.fitted && this.fit(), this.publishView(), this.view.layout(), this.gestures.refreshHover(), this.keys.refresh(), this.interactionChanged();
   }
   interactionChanged() {
     this.publish(), this.requestDraw();
   }
   publish() {
-    const t = this.view, e = this.selected !== null ? t.boxById.get(this.selected) : void 0, n = [];
-    e !== void 0 && !e.miniature && !this.gestures.editing && e.subtask.task === this.selectedTask && (t.options.intents.includes("leadIn") && n.push({ kind: "leadIn", x: e.outerFrom, y: e.y, height: e.height }), t.options.intents.includes("leadOut") && n.push({ kind: "leadOut", x: e.outerTo, y: e.y, height: e.height })), this.snapshot = {
+    const t = this.view, e = this.selected !== null ? t.boxById.get(this.selected) : void 0, s = [];
+    e !== void 0 && !e.miniature && !this.gestures.editing && e.subtask.task === this.selectedTask && (t.options.intents.includes("leadIn") && s.push({ kind: "leadIn", x: e.outerFrom, y: e.y, height: e.height }), t.options.intents.includes("leadOut") && s.push({ kind: "leadOut", x: e.outerTo, y: e.y, height: e.height })), this.snapshot = {
       width: t.width,
       height: t.height,
       laneHeight: t.options.laneHeight,
@@ -1887,7 +2387,7 @@ class An {
       headers: this.headers(),
       ...t.bands(),
       ghost: this.gestures.ghostSummary(),
-      grips: n,
+      grips: s,
       cursor: this.gestures.cursor,
       tooltip: this.tooltip(),
       now: t.nowX(),
@@ -1895,25 +2395,25 @@ class An {
       spoken: this.keys.spoken,
       summary: this.summary()
     };
-    for (const s of this.listeners) s();
+    for (const n of this.listeners) n();
   }
   /** One header per row, with what it says and where it sits. The scroll is
       not taken off here: the header column is moved as a whole, as it always
       was, so that a header and its row cannot drift apart by a rounding. */
   headers() {
-    const t = new Map(this.data.lanes.map((s) => [s.id, s.label])), e = new Map(this.data.groups.map((s) => [s.id, s.label])), n = new Set(this.collapsedGroups);
-    return this.view.rows.rows.map((s) => ({
-      key: s.lane ?? s.group ?? "",
-      kind: s.kind,
-      lane: s.lane,
-      group: s.group,
-      label: (s.lane !== void 0 ? t.get(s.lane) : e.get(s.group ?? "")) ?? s.lane ?? s.group ?? "",
-      depth: s.depth,
-      within: s.within,
-      lanes: s.lanes,
-      collapsed: s.group === void 0 ? void 0 : n.has(s.group),
-      top: s.top,
-      height: s.height
+    const t = new Map(this.data.lanes.map((n) => [n.id, n.label])), e = new Map(this.data.groups.map((n) => [n.id, n.label])), s = new Set(this.folded);
+    return this.view.rows.rows.map((n) => ({
+      key: n.lane ?? n.group ?? "",
+      kind: n.kind,
+      lane: n.lane,
+      group: n.group,
+      label: (n.lane !== void 0 ? t.get(n.lane) : e.get(n.group ?? "")) ?? n.lane ?? n.group ?? "",
+      depth: n.depth,
+      within: n.within,
+      lanes: n.lanes,
+      collapsed: n.group === void 0 ? void 0 : s.has(n.group),
+      top: n.top,
+      height: n.height
     }));
   }
   /** The bars a label could stand in: the visible part of every main time,
@@ -1923,27 +2423,27 @@ class An {
     const t = this.view;
     if (t.width <= 0) return [];
     const e = this.colours;
-    return t.boxes.flatMap((n) => {
-      if (!Rt(n, t.width, t.height)) return [];
-      const s = Bs(n, t.width);
-      if (s === null) return [];
-      const i = e === null ? !0 : qt(
-        yt(n.subtask.appearance),
-        ht(e, { selectedTask: this.selectedTask, selectedSubtask: this.selectedSubtask }, n.subtask.task, n.subtask.id),
+    return t.boxes.flatMap((s) => {
+      if (!Ft(s, t.width, t.height)) return [];
+      const n = Os(s, t.width);
+      if (n === null) return [];
+      const i = e === null ? !0 : Wt(
+        gt(s.subtask.appearance),
+        ht(e, { selectedTask: this.selectedTask, selectedSubtask: this.selectedSubtask }, s.subtask.task, s.subtask.id),
         e
       ).onDark;
-      return [{ subtask: n.subtask, ...s, dark: i }];
+      return [{ subtask: s.subtask, ...n, dark: i }];
     });
   }
   /** The findings count the whole plan - an overlap out of view is still one
       to know of -, the subtasks only what is in view. */
   summary() {
-    const t = this.view, [e, n] = this.visibleDomain();
+    const t = this.view, [e, s] = this.visibleDomain();
     return {
       lanes: this.data.lanes.length,
-      subtasks: t.boxes.filter((s) => Rt(s, t.width, t.height)).length,
+      subtasks: t.boxes.filter((n) => Ft(n, t.width, t.height)).length,
       from: e,
-      to: n,
+      to: s,
       overlaps: this.data.overlaps.length,
       violated: this.data.violatedById.size,
       blocked: this.data.inBlocked.length
@@ -1954,45 +2454,39 @@ class An {
     if (!this.gestures.idle) return null;
     const e = this.data.tooltipTargetFor(t);
     if (e === null) return null;
-    const { x: n, y: s } = this.gestures.hoverPoint;
-    return { target: e, x: n, y: s };
+    const { x: s, y: n } = this.gestures.hoverPoint;
+    return { target: e, x: s, y: n };
   }
   /** The visible span, as two wall-clock instants. */
   visibleDomain() {
-    const t = et(this.view.options.calendar), e = (n) => t.intervals.length === 0 ? n : j(Math.max(0, Math.min(t.total, n)), t);
+    const t = et(this.view.options.calendar), e = (s) => t.intervals.length === 0 ? s : j(Math.max(0, Math.min(t.total, s)), t);
     return [e(this.view.domain[0]), e(this.view.domain[1])];
   }
-  /** Reported once per frame, however many wheel steps a planner turns - and
-      only for their gestures: a span handed in from outside is not news to the
-      caller who handed it in, and reporting it would let two schedules
-      synchronised with each other feed one another for ever. */
+  /** A pan or zoom of the planner's goes into the view once per frame,
+      however many wheel steps they turn. */
   reportDomain() {
-    var t, e;
-    if (typeof requestAnimationFrame != "function") {
-      (e = (t = this.handlersNow).onDomainChange) == null || e.call(t, this.visibleDomain());
-      return;
-    }
-    this.domainFrame === 0 && (this.domainFrame = requestAnimationFrame(() => {
-      var n, s;
-      this.domainFrame = 0, (s = (n = this.handlersNow).onDomainChange) == null || s.call(n, this.visibleDomain());
-    }));
+    const t = () => {
+      this.domainFrame = 0, this.actedOn = !0, this.domainInView = this.visibleDomain(), this.publishView();
+    };
+    if (typeof requestAnimationFrame != "function") return t();
+    this.domainFrame === 0 && (this.domainFrame = requestAnimationFrame(t));
   }
   /** The time and the lane at a client point, or null outside the plot. */
   positionAt(t, e) {
     var r;
-    const n = (r = this.plot) == null ? void 0 : r.getBoundingClientRect();
-    if (n === void 0) return null;
-    const s = t - n.left, i = e - n.top;
-    return s < 0 || i < 0 || s > n.width || i > n.height ? null : { time: this.view.timeAt(s), lane: this.view.laneIdAt(i) };
+    const s = (r = this.plot) == null ? void 0 : r.getBoundingClientRect();
+    if (s === void 0) return null;
+    const n = t - s.left, i = e - s.top;
+    return n < 0 || i < 0 || n > s.width || i > s.height ? null : { time: this.view.timeAt(n), lane: this.view.laneIdAt(i) };
   }
   /** The client point of a time, on a lane's middle where one is named, or
       null while the schedule is not on screen. */
   clientPointOf(t, e) {
     var a;
-    const n = (a = this.plot) == null ? void 0 : a.getBoundingClientRect();
-    if (n === void 0) return null;
-    const s = this.view.viewport(), i = e === void 0 ? null : dt(s, e), r = i === null ? 0 : i.top + i.height / 2;
-    return { x: n.left + B(s, t), y: n.top + r };
+    const s = (a = this.plot) == null ? void 0 : a.getBoundingClientRect();
+    if (s === void 0) return null;
+    const n = this.view.viewport(), i = e === void 0 ? null : dt(n, e), r = i === null ? 0 : i.top + i.height / 2;
+    return { x: s.left + N(n, t), y: s.top + r };
   }
   requestDraw() {
     this.frame !== 0 || this.dataCanvas === null || typeof requestAnimationFrame != "function" || (this.frame = requestAnimationFrame(() => {
@@ -2001,9 +2495,9 @@ class An {
   }
   draw() {
     if (this.root === null) return;
-    this.colours === null && (this.colours = Ks(this.root, this.data), this.publish());
-    const { width: t, height: e } = this.view, n = Ie(this.dataCanvas, t, e), s = Ie(this.overlayCanvas, t, e);
-    if (n === null || s === null || t === 0) return;
+    this.colours === null && (this.colours = Fn(this.root, this.data), this.publish());
+    const { width: t, height: e } = this.view, s = be(this.dataCanvas, t, e), n = be(this.overlayCanvas, t, e);
+    if (s === null || n === null || t === 0) return;
     const i = {
       data: this.data,
       view: this.view,
@@ -2014,478 +2508,49 @@ class An {
       hover: this.gestures.hover,
       ghost: this.gestures.ghostDrawing()
     };
-    Us(n, i), Ws(s, i);
-  }
-}
-const Dn = "_root_1892z_4 _text_r8i8z_23", _n = "_corner_1892z_19", Fn = "_dayBand_1892z_23", On = "_tickBand_1892z_24", En = "_day_1892z_23", Rn = "_dayLabel_1892z_50", Pn = "_tick_1892z_24", Bn = "_tickLabel_1892z_71", Nn = "_headers_1892z_79", xn = "_header_1892z_79", $n = "_headerLabel_1892z_97", Gn = "_headerCount_1892z_134", Hn = "_chevron_1892z_143", Yn = "_plot_1892z_201", zn = "_focusRing_1892z_208", Kn = "_layer_1892z_226", Un = "_grip_1892z_235", Wn = "_ghostLabel_1892z_245", Xn = "_finding_1892z_258", Vn = "_refusal_1892z_266", qn = "_tooltip_1892z_270", jn = "_tooltipHead_1892z_289", Zn = "_tooltipTimes_1892z_294", Jn = "_now_1892z_303", Qn = "_barLabel_1892z_317", to = "_barLabelText_1892z_330", w = {
-  root: Dn,
-  corner: _n,
-  dayBand: Fn,
-  tickBand: On,
-  day: En,
-  dayLabel: Rn,
-  tick: Pn,
-  tickLabel: Bn,
-  headers: Nn,
-  header: xn,
-  headerLabel: $n,
-  headerCount: Gn,
-  chevron: Hn,
-  plot: Yn,
-  focusRing: zn,
-  layer: Kn,
-  grip: Un,
-  ghostLabel: Wn,
-  finding: Xn,
-  refusal: Vn,
-  tooltip: qn,
-  tooltipHead: jn,
-  tooltipTimes: Zn,
-  now: Jn,
-  barLabel: Qn,
-  barLabelText: to
-};
-function ts() {
-  const o = kt();
-  return (t) => {
-    const e = Math.round(t / q), n = Math.floor(e / 60), s = e % 60;
-    return [n > 0 ? o.hoursShort(n) : "", s > 0 || n === 0 ? o.minutesShort(s) : ""].filter(Boolean).join(" ");
-  };
-}
-function eo({ target: o, lane: t }) {
-  const e = Ht(), n = kt(), s = ts(), i = (u) => e.time(new Date(u), !1);
-  if (o.kind === "subtask") {
-    const { subtask: u, task: p } = o, m = [
-      (p == null ? void 0 : p.name) ?? u.task,
-      u.name ?? u.id,
-      `${e.dateShort(new Date(u.from))} ${n.scheduleGhostTimes(i(u.from), i(u.to))}`,
-      ...o.overlapping.map((y) => n.scheduleOverlapWith(y.name ?? y.id)),
-      ...o.violatedDependencies.map((y) => n.scheduleViolatedBy(s(y.shortBy))),
-      ...o.blocked.map((y) => n.scheduleInBlockedTime(y.label))
-    ];
-    return /* @__PURE__ */ U(Et, { children: [
-      t,
-      `, ${m.join(", ")}`
-    ] });
-  }
-  const { dependency: r, task: a, from: l, to: h, violated: d } = o;
-  return [
-    (a == null ? void 0 : a.name) ?? (a == null ? void 0 : a.id) ?? r.id,
-    `${n.scheduleDependency} ${s(r.lag)}`,
-    n.scheduleRoute((l == null ? void 0 : l.name) ?? r.from, (h == null ? void 0 : h.name) ?? r.to),
-    ...d === void 0 ? [] : [n.scheduleViolatedBy(s(d.shortBy))]
-  ].join(", ");
-}
-function so({ target: o }) {
-  const t = Ht(), e = kt(), n = (d) => t.time(new Date(d), !1), s = ts();
-  if (o.kind === "subtask") {
-    const { subtask: d, task: u } = o;
-    return /* @__PURE__ */ U(Et, { children: [
-      /* @__PURE__ */ k("span", { className: w.tooltipHead, children: (u == null ? void 0 : u.name) ?? d.task }),
-      /* @__PURE__ */ k("span", { children: d.name ?? d.id }),
-      /* @__PURE__ */ k("span", { className: w.tooltipTimes, children: e.scheduleGhostTimes(n(d.from), n(d.to)) }),
-      (d.leadIn ?? 0) > 0 && /* @__PURE__ */ k("span", { children: `${e.scheduleLeadIn} ${s(d.leadIn)}` }),
-      (d.leadOut ?? 0) > 0 && /* @__PURE__ */ k("span", { children: `${e.scheduleLeadOut} ${s(d.leadOut)}` }),
-      o.overlapping.map((p) => /* @__PURE__ */ k("span", { className: w.finding, children: e.scheduleOverlapWith(p.name ?? p.id) }, p.id)),
-      o.violatedDependencies.map((p) => /* @__PURE__ */ k("span", { className: w.finding, children: e.scheduleViolatedBy(s(p.shortBy)) }, p.dependency)),
-      o.blocked.map((p) => /* @__PURE__ */ k("span", { className: w.finding, children: e.scheduleInBlockedTime(p.label) }, p.id))
-    ] });
-  }
-  const { dependency: i, task: r, from: a, to: l, violated: h } = o;
-  return /* @__PURE__ */ U(Et, { children: [
-    /* @__PURE__ */ k("span", { className: w.tooltipHead, children: (r == null ? void 0 : r.name) ?? (r == null ? void 0 : r.id) ?? i.id }),
-    /* @__PURE__ */ k("span", { children: e.scheduleRoute((a == null ? void 0 : a.name) ?? i.from, (l == null ? void 0 : l.name) ?? i.to) }),
-    /* @__PURE__ */ k("span", { children: `${e.scheduleDependency} ${s(i.lag)}` }),
-    h !== void 0 && /* @__PURE__ */ k("span", { className: w.finding, children: e.scheduleViolatedBy(s(h.shortBy)) })
-  ] });
-}
-const no = [], Re = { min: Gt, max: 28 * Z }, oo = [], Pe = 20, Ot = 44, po = ps(function(t, e) {
-  var pe;
-  const {
-    ariaLabel: n,
-    initialDomain: s,
-    height: i = 400,
-    laneHeight: r = gt,
-    headerWidth: a = 160,
-    calendar: l = oo,
-    zoomLimits: h,
-    snap: d = "ticks",
-    intents: u = no,
-    onIntent: p,
-    canMoveTo: m,
-    onInteraction: y,
-    selectedTask: S,
-    onSelectedTaskChange: A,
-    collapsedGroups: D,
-    defaultCollapsedGroups: g,
-    onCollapsedGroupsChange: I,
-    onDomainChange: L,
-    placing: R,
-    route: O = "curve",
-    attach: H = "centre",
-    ends: ot = "dot",
-    label: ct,
-    tooltip: J,
-    now: it,
-    className: jt,
-    style: es,
-    children: ss
-  } = t, [v] = ft(() => new An()), vt = ms(), Zt = `${vt}-summary`, Jt = G(null), Qt = G(null), te = G(null), ee = G(null), Y = Ht(), x = kt(), [wt, bt] = s, se = (h == null ? void 0 : h.min) ?? Re.min, ne = (h == null ? void 0 : h.max) ?? Re.max, oe = G(null), ie = typeof d == "object" ? d.step : null, re = typeof d == "object" ? d.offset : null, ae = typeof d == "object" ? null : d, [ns, os] = ft(() => Date.now());
-  K(() => {
-    if (it !== !0) return;
-    const c = setInterval(() => os(Date.now()), q);
-    return () => clearInterval(c);
-  }, [it]);
-  const le = it === !0 ? ns : typeof it == "number" ? it : null;
-  pt(() => {
-    const c = `${wt}|${bt}`, b = oe.current !== c;
-    oe.current = c;
-    const C = ae ?? { step: ie ?? 0, offset: re ?? 0 };
-    v.setOptions(
-      { laneHeight: r, calendar: l, zoomLimits: { min: se, max: ne }, snap: C, intents: u, now: le, route: O, attach: H, ends: ot },
-      b ? [wt, bt] : null
-    );
-  }, [v, wt, bt, r, l, se, ne, ae, ie, re, u, le, O, H, ot]), K(() => {
-    v.setHandlers({ onIntent: p, canMoveTo: m, onInteraction: y, onSelectedTaskChange: A, onCollapsedGroupsChange: I, onDomainChange: L });
-  }, [v, p, m, y, A, I, L]);
-  const is = G(g);
-  K(() => {
-    const c = is.current;
-    c !== void 0 && v.setDefaultCollapsedGroups(c);
-  }, [v]), K(() => {
-    v.setCollapsedGroups(D);
-  }, [v, D]), gs(
-    e,
-    () => ({
-      positionAt: (c, b) => v.positionAt(c, b),
-      clientPointOf: (c, b) => v.clientPointOf(c, b),
-      visibleDomain: () => v.visibleDomain()
-    }),
-    [v]
-  ), K(() => {
-    v.setControlledTask(S);
-  }, [v, S]), K(() => {
-    v.setPlacing(R ?? null);
-  }, [v, R]), K(() => {
-    const c = Jt.current, b = Qt.current, C = te.current, P = ee.current;
-    if (!c || !b || !C || !P) return;
-    v.bind(c, b, C, P);
-    const _ = b.getBoundingClientRect();
-    v.resize(_.width, _.height);
-    const F = new ResizeObserver((E) => {
-      var ut;
-      const $ = (ut = E[E.length - 1]) == null ? void 0 : ut.contentRect;
-      $ !== void 0 && v.resize($.width, $.height);
-    });
-    F.observe(b);
-    const N = (E) => v.wheel(E);
-    c.addEventListener("wheel", N, { passive: !1 });
-    const z = (E) => {
-      E.key === "Escape" && v.cancelEdit() && E.preventDefault();
-    };
-    return window.addEventListener("keydown", z), () => {
-      window.removeEventListener("keydown", z), c.removeEventListener("wheel", N), F.disconnect(), v.unbind();
-    };
-  }, [v]);
-  const M = ks(v.subscribe, v.getSnapshot, v.getServerSnapshot), rs = (c, b) => {
-    const C = new Date(c);
-    return b >= 200 ? Y.dateLong(C) : b >= 84 ? Y.date(C) : b >= Ot ? Y.dateShort(C) : "";
-  }, as = M.days.reduce((c, b) => Math.max(c, b.width), 0), Q = In(as, Ot), de = M.step >= Z ? Q : 1, T = M.ghost, tt = M.spoken, Mt = M.summary, he = (c) => `${Y.dateShort(new Date(c))} ${Y.time(new Date(c), !1)}`, Tt = (c) => `${vt}-row-${encodeURIComponent(c.key)}`, ls = V(() => {
-    const c = /* @__PURE__ */ new Map();
-    for (const b of M.headers)
-      for (const C of b.within)
-        b.kind === "groupHead" && C === b.group || c.set(C, [...c.get(C) ?? [], Tt(b)]);
-    return c;
-  }, [M.headers, vt]), ce = G(null);
-  pt(() => {
-    var F;
-    const c = ce.current;
-    if (c === null) return;
-    let b = !0;
-    const C = () => {
-      if (!b) return;
-      const N = [...c.querySelectorAll("[data-lane-count]")];
-      for (const E of N) E.hidden = !1;
-      const z = N.some((E) => {
-        const $ = E.previousElementSibling;
-        if (!($ instanceof HTMLElement)) return !1;
-        const ut = parseFloat(getComputedStyle($).lineHeight);
-        return $.scrollWidth > $.clientWidth || $.clientHeight > ut * 1.5;
-      });
-      for (const E of N) E.hidden = z;
-    };
-    C(), (F = document.fonts) == null || F.ready.then(C);
-    const P = new ResizeObserver(C);
-    P.observe(c);
-    const _ = new MutationObserver(C);
-    return _.observe(c, { childList: !0, characterData: !0, subtree: !0 }), () => {
-      b = !1, P.disconnect(), _.disconnect();
+    On(s, i), En(n, i);
+  }
+}
+function yo(o = {}) {
+  const { initialView: t, onViewChange: e } = o, [s] = tt(() => new ao(t)), [n] = tt(() => new ps()), [i] = tt(() => {
+    const c = Ee((p, m) => ks(wn, { ...p, scene: s, ref: m }));
+    return c.displayName = "Schedule", {
+      Schedule: c,
+      Lane: Mn,
+      LaneGroup: Tn,
+      Subtasks: In,
+      Dependencies: Sn,
+      BlockedTimes: Ln,
+      setDomain: s.setDomain,
+      toggleGroup: s.toggleGroup,
+      foldAll: s.foldAll,
+      unfoldAll: s.unfoldAll
     };
-  }, []);
-  const ds = V(() => new Set((T == null ? void 0 : T.refusedLanes) ?? []), [T == null ? void 0 : T.refusedLanes]), ue = G(null), [It, hs] = ft({ x: 0, y: 0, at: "" }), Ct = T === null ? "" : `${T.x}:${T.y}:${T.from}:${T.to}:${T.overlap}:${T.violated}:${T.refused}:${T.blocked}`;
-  pt(() => {
-    const c = ue.current;
-    if (T === null || c === null) return;
-    const b = 4, C = T.y - c.offsetHeight - b, P = T.y + T.height + b, _ = {
-      x: Math.max(2, Math.min(T.x, M.width - c.offsetWidth - 2)),
-      y: C >= 2 ? C : Math.min(P, M.height - c.offsetHeight - 2),
-      at: Ct
-    };
-    hs((F) => F.x === _.x && F.y === _.y && F.at === _.at ? F : _);
-  }, [T, Ct, M.width, M.height]);
-  const fe = G(null), [St, cs] = ft({ x: 0, y: 0, at: "" }), X = M.tooltip, Lt = X === null ? "" : `${X.x}:${X.y}:${X.target.kind}`;
-  return pt(() => {
-    const c = fe.current;
-    if (X === null || c === null) return;
-    const b = 12, C = (_, F, N) => {
-      const z = _ + b, E = _ - b - F, $ = z + F <= N - 4 || E < 4 ? z : E;
-      return Math.max(4, Math.min($, N - F - 4));
-    }, P = {
-      x: C(X.x, c.offsetWidth, M.width),
-      y: C(X.y, c.offsetHeight, M.height),
-      at: Lt
-    };
-    cs((_) => _.x === P.x && _.y === P.y && _.at === P.at ? _ : P);
-  }, [X, Lt, M.width, M.height]), /* @__PURE__ */ U(xe.Provider, { value: v, children: [
-    /* @__PURE__ */ U(
-      "div",
-      {
-        ref: Jt,
-        role: "figure",
-        "aria-label": n,
-        className: jt ? `${w.root} ${jt}` : w.root,
-        style: { height: `${i}px`, gridTemplateColumns: `min(${a}px, 40%) minmax(0, 1fr)`, ...es },
-        children: [
-          /* @__PURE__ */ k("div", { className: w.corner }),
-          /* @__PURE__ */ k("div", { className: w.dayBand, "aria-hidden": "true", "data-schedule-days": "", "data-schedule-clip": "day band", children: M.days.map((c, b) => {
-            var N;
-            const C = Q === 1 || b === 0 || Ft(c.start, Q), P = Q === 1 ? c.x + c.width : ((N = M.days.slice(b + 1).find((z) => Ft(z.start, Q))) == null ? void 0 : N.x) ?? M.width, _ = Math.max(0, -c.x), F = Math.min(P, M.width) - Math.max(c.x, 0);
-            return /* @__PURE__ */ k("span", { className: w.day, style: { left: `${c.x}px`, width: `${C ? P - c.x : c.width}px` }, children: /* @__PURE__ */ k("span", { className: w.dayLabel, "data-schedule-overlay": "day label", style: { marginLeft: `${_}px` }, children: C ? rs(c.start, Q === 1 ? F : Math.min(F, Ot)) : "" }) }, c.start);
-          }) }),
-          /* @__PURE__ */ k("div", { ref: ce, className: w.headers, "data-schedule-headers": "", children: /* @__PURE__ */ k("div", { className: w.headerRun, style: { transform: `translateY(${-M.scrollY}px)` }, children: M.headers.map((c) => /* @__PURE__ */ U(
-            "div",
-            {
-              id: Tt(c),
-              className: w.header,
-              style: { height: `${c.height}px`, paddingLeft: `calc(var(--u-space-3) + ${c.depth} * var(--u-space-3))` },
-              "data-lane": c.lane,
-              "data-group": c.group,
-              "data-row": c.kind,
-              "data-schedule-clip": `header ${c.kind}`,
-              "data-refused": c.lane !== void 0 && ds.has(c.lane) ? "" : void 0,
-              children: [
-                c.kind !== "lane" && c.group !== void 0 && /* @__PURE__ */ k(
-                  "button",
-                  {
-                    type: "button",
-                    className: w.chevron,
-                    "data-schedule-overlay": "fold control",
-                    "aria-expanded": c.collapsed === !1,
-                    "aria-controls": (ls.get(c.group) ?? [Tt(c)]).join(" "),
-                    "aria-label": `${c.collapsed === !0 ? x.scheduleUnfoldGroup : x.scheduleFoldGroup}: ${typeof c.label == "string" ? c.label : c.group}`,
-                    onClick: () => v.toggleGroup(c.group),
-                    children: /* @__PURE__ */ k(Is, { size: 9, "data-open": c.collapsed === !1 ? "" : void 0 })
-                  }
-                ),
-                /* @__PURE__ */ k("span", { className: w.headerLabel, "data-schedule-overlay": "header label", children: c.label }),
-                c.kind !== "lane" && /* @__PURE__ */ k("span", { className: w.headerCount, "data-schedule-overlay": "lane count", "data-lane-count": c.lanes, children: x.scheduleLaneCount(c.lanes) })
-              ]
-            },
-            c.key
-          )) }) }),
-          /* @__PURE__ */ U(
-            "div",
-            {
-              ref: Qt,
-              className: w.plot,
-              "data-schedule-plot": "",
-              "data-schedule-clip": "plot",
-              style: { cursor: M.cursor },
-              tabIndex: 0,
-              role: "application",
-              "aria-roledescription": x.scheduleRoleDescription,
-              "aria-label": n,
-              "aria-describedby": Zt,
-              onKeyDown: (c) => {
-                v.key(c.nativeEvent) && c.preventDefault();
-              },
-              onFocus: (c) => v.focus(io(c.currentTarget)),
-              onBlur: () => v.blur(),
-              onPointerDown: (c) => v.pointerDown(c.nativeEvent),
-              onPointerMove: (c) => v.pointerMove(c.nativeEvent),
-              onPointerUp: (c) => v.pointerUp(c.nativeEvent),
-              onPointerCancel: (c) => v.pointerCancel(c.nativeEvent),
-              onPointerLeave: () => v.pointerLeave(),
-              onContextMenu: (c) => v.contextMenu(c.nativeEvent),
-              onDragOver: (c) => v.dragOver(c.nativeEvent),
-              onDrop: (c) => v.drop(c.nativeEvent),
-              onDragLeave: (c) => {
-                const b = c.nativeEvent.relatedTarget;
-                (!(b instanceof Node) || !c.currentTarget.contains(b)) && v.dragLeave();
-              },
-              children: [
-                /* @__PURE__ */ k("canvas", { ref: te, className: w.layer, "aria-hidden": "true" }),
-                /* @__PURE__ */ k("canvas", { ref: ee, className: w.layer, "aria-hidden": "true" }),
-                M.grips.map((c) => /* @__PURE__ */ k(
-                  "span",
-                  {
-                    "data-grip": c.kind,
-                    "data-schedule-overlay": `${c.kind} grip`,
-                    "aria-hidden": "true",
-                    className: w.grip,
-                    style: { left: `${c.x}px`, top: `${c.y}px`, height: `${c.height}px` }
-                  },
-                  c.kind
-                )),
-                ct !== void 0 && M.bars.map((c) => /* @__PURE__ */ k(
-                  "span",
-                  {
-                    className: w.barLabel,
-                    "data-bar-label": c.subtask.id,
-                    "data-schedule-overlay": "bar label",
-                    "data-schedule-may-cover": "",
-                    "data-on": c.dark ? "dark" : "light",
-                    style: { left: `${c.x}px`, top: `${c.y}px`, width: `${c.width}px`, height: `${c.height}px` },
-                    children: /* @__PURE__ */ k("span", { className: w.barLabelText, children: ct(c.subtask) })
-                  },
-                  c.subtask.id
-                )),
-                J !== !1 && M.tooltip !== null && /* @__PURE__ */ k(
-                  "span",
-                  {
-                    ref: fe,
-                    role: "tooltip",
-                    className: w.tooltip,
-                    "data-schedule-tooltip": "",
-                    "data-schedule-overlay": "tooltip",
-                    style: {
-                      left: `${St.x}px`,
-                      top: `${St.y}px`,
-                      visibility: St.at === Lt ? void 0 : "hidden"
-                    },
-                    children: typeof J == "function" ? J(M.tooltip.target) : /* @__PURE__ */ k(so, { target: M.tooltip.target })
-                  }
-                ),
-                T !== null && /* @__PURE__ */ U(
-                  "span",
-                  {
-                    ref: ue,
-                    className: w.ghostLabel,
-                    "data-ghost": "",
-                    "data-schedule-overlay": "ghost label",
-                    "data-findings": [T.overlap ? "overlap" : "", T.violated ? "violated-dependency" : ""].filter(Boolean).join(" "),
-                    "data-refused": T.refused ? "" : void 0,
-                    "data-blocked": T.blocked ? "" : void 0,
-                    style: {
-                      left: `${It.x}px`,
-                      top: `${It.y}px`,
-                      visibility: It.at === Ct ? void 0 : "hidden"
-                    },
-                    children: [
-                      x.scheduleGhostTimes(Y.time(new Date(T.from), !1), Y.time(new Date(T.to), !1)),
-                      T.refused && /* @__PURE__ */ k("span", { className: w.refusal, children: x.scheduleLaneRefused }),
-                      T.blocked && /* @__PURE__ */ k("span", { className: w.refusal, children: x.scheduleBlockedTime }),
-                      T.overlap && /* @__PURE__ */ k("span", { className: w.finding, children: x.scheduleOverlap }),
-                      T.violated && /* @__PURE__ */ k("span", { className: w.finding, children: x.scheduleViolatedDependency })
-                    ]
-                  }
-                ),
-                /* @__PURE__ */ k("span", { className: w.focusRing, "aria-hidden": "true" })
-              ]
-            }
-          ),
-          /* @__PURE__ */ k("div", { className: w.corner }),
-          /* @__PURE__ */ U("div", { className: w.tickBand, "aria-hidden": "true", "data-schedule-ticks": "", "data-schedule-clip": "time band", children: [
-            M.now !== null && /* @__PURE__ */ k("span", { className: w.now, "data-now": "", "data-schedule-overlay": "now mark", style: { left: `${M.now}px` } }),
-            M.ticks.map((c) => /* @__PURE__ */ k("span", { className: w.tick, style: { left: `${c.x}px` }, children: c.x >= Pe && c.x <= M.width - Pe && (de === 1 || Ft(c.wallClock, de)) && /* @__PURE__ */ k("span", { className: w.tickLabel, "data-schedule-overlay": "time label", children: M.step >= Z ? Y.dateShort(new Date(c.wallClock)) : Y.time(new Date(c.wallClock), !1) }) }, c.wallClock))
-          ] }),
-          /* @__PURE__ */ k(me, { "aria-live": "polite", children: tt !== null && /* @__PURE__ */ k(
-            eo,
-            {
-              target: tt.target,
-              lane: tt.lane === null ? null : ((pe = v.data.lanes.find((c) => c.id === tt.lane)) == null ? void 0 : pe.label) ?? tt.lane
-            },
-            tt.count
-          ) }),
-          /* @__PURE__ */ k(me, { id: Zt, children: `${x.scheduleSummary({ ...Mt, from: he(Mt.from), to: he(Mt.to) })} ${x.scheduleKeyHelp}` })
-        ]
-      }
-    ),
-    ss
-  ] });
-});
-function io(o) {
-  try {
-    return o.matches(":focus-visible");
-  } catch {
-    return !0;
-  }
-}
-function mo({ id: o, label: t }) {
-  const e = Ge(), n = V(() => ({ id: o, label: t ?? o, ...e === null ? {} : { parent: e } }), [o, t, e]);
-  return Ss(n), null;
-}
-function go({ id: o, label: t, children: e }) {
-  const n = Ge(), s = V(() => ({ id: o, label: t ?? o, ...n === null ? {} : { parent: n } }), [o, t, n]);
-  return Ls(s), /* @__PURE__ */ k($e.Provider, { value: o, children: e });
-}
-function ko({ data: o, tasks: t }) {
-  const e = V(() => ({ kind: "subtasks", data: o, tasks: t }), [o, t]);
-  return zt("Subtasks", e), null;
-}
-function yo({ data: o }) {
-  const t = V(() => ({ kind: "dependencies", data: o }), [o]);
-  return zt("Dependencies", t), null;
-}
-function vo({ data: o }) {
-  const t = V(() => ({ kind: "blocked", data: o }), [o]);
-  return zt("BlockedTimes", t), null;
-}
-function wo(o, t, e) {
-  if (e.kind === "place") return [];
-  const n = new Map(o.map((l) => [l.id, ke(l, e)])), s = /* @__PURE__ */ new Map();
-  for (const l of t) {
-    const h = s.get(l.from) ?? [];
-    h.push(l), s.set(l.from, h);
-  }
-  const i = /* @__PURE__ */ new Map(), r = [e.subtask];
-  let a = (o.length + 1) * (t.length + 1);
-  for (; r.length > 0 && a-- > 0; ) {
-    const l = r.shift(), h = n.get(l);
-    if (h !== void 0)
-      for (const d of s.get(l) ?? []) {
-        if (d.to === e.subtask) continue;
-        const u = n.get(d.to);
-        if (u === void 0) continue;
-        const p = Ut(d, h) + d.lag - Wt(d, u);
-        if (!(p > 0)) continue;
-        const m = { kind: "move", subtask: u.id, from: u.from + p, to: u.to + p };
-        n.set(u.id, ke(u, m)), i.set(u.id, m), r.push(u.id);
-      }
-  }
-  return [...i.values()];
-}
-function bo(o, t, e) {
-  return e === 0 || !Number.isFinite(e) ? [] : o.filter((n) => n.task === t).map((n) => ({ kind: "move", subtask: n.id, from: n.from + e, to: n.to + e }));
+  }), r = Re(s.subscribeView, s.getView, s.getView), a = t === void 0 ? null : Q(t), d = G(a);
+  it(() => {
+    if (t === void 0 || a === null || a === d.current) return;
+    d.current = a;
+    const c = n.has(a);
+    n.handed(a), c || s.applyView(t);
+  }, [a]);
+  const h = Q(r), l = G(h);
+  return W(() => {
+    l.current !== h && (l.current = h, s.acted && (n.reported(h), e == null || e(r)));
+  }, [h]), X(() => ({ ...i, view: r }), [i, r]);
 }
 export {
-  vo as BlockedTimes,
-  yo as Dependencies,
-  mo as Lane,
-  go as LaneGroup,
-  po as Schedule,
-  ko as Subtasks,
-  ke as applyIntent,
-  Wt as arrival,
-  Ut as departure,
-  fo as findings,
-  Ke as inBlockedTime,
+  ce as applyIntent,
+  Gt as arrival,
+  $t as departure,
+  mo as findings,
+  Ne as inBlockedTime,
   nt as occupied,
-  Xt as overlaps,
-  yt as resolveAppearance,
-  wo as ripple,
-  bo as shiftTask,
-  hn as snapTime,
-  uo as subtaskFromPlace,
-  Vt as violatedDependencies
+  Ht as overlaps,
+  gt as resolveAppearance,
+  go as ripple,
+  ko as shiftTask,
+  ws as snapTime,
+  po as subtaskFromPlace,
+  yo as useSchedule,
+  Yt as violatedDependencies
 };