@kitlangton/knobs 0.2.0 → 0.4.0-next.0

package/dist/dev/{chunk-693jd1gj.js → chunk-pmkvb9ep.js}

@@ -1,10 +1,11 @@
 import {
+  isTypingTarget,
   GRADIENT_SAMPLES,
   Spring,
   springEasing,
   springCss2,
   storageKey
-} from "./chunk-gezhc24g.js";
+} from "./chunk-7xgkerd2.js";
 
 // src/panel/icons.ts
 var ICONS = {
@@ -62,147 +63,6 @@ function writeSession(id, patch) {
   } catch {}
 }
 
-// src/panel/motion.ts
-var FILL = { omega: 30, zeta: 0.88 };
-var LEAD = { omega: 34, zeta: 0.86 }, TRAIL = { omega: 25, zeta: 1 }, trailScale = (blur) => 0.6 + 0.4 * clamp(blur, 0, 2);
-
-class Edges {
-  start;
-  end;
-  constructor(start = 0, end = 0) {
-    this.start = new Spring(start, LEAD.omega, LEAD.zeta, 0.05), this.end = new Spring(end, LEAD.omega, LEAD.zeta, 0.05);
-  }
-  to(start, end, delay = 0, trail = 1) {
-    if ((start !== this.start.target || end !== this.end.target) && delay <= 0) {
-      let forward = start + end > this.start.target + this.end.target, [lead, tail] = forward ? [this.end, this.start] : [this.start, this.end];
-      lead.omega = LEAD.omega, lead.zeta = LEAD.zeta, tail.omega = TRAIL.omega / trail, tail.zeta = TRAIL.zeta;
-    }
-    return this.start.set(start, delay), this.end.set(end, delay), this;
-  }
-  shift(ds, de) {
-    return this.start.x += ds, this.start.target += ds, this.end.x += de, this.end.target += de, this;
-  }
-  snap(start, end) {
-    return this.start.snap(start), this.end.snap(end), this;
-  }
-  step(dt) {
-    return this.start.step(dt), this.end.step(dt), this;
-  }
-  get resting() {
-    return this.start.resting && this.end.resting;
-  }
-  get velocity() {
-    return (this.start.v + this.end.v) / 2;
-  }
-}
-var POP_MS = 360;
-function popScale(t, peak = 0.04) {
-  if (t <= 0 || t >= POP_MS)
-    return 1;
-  let u = t / 55;
-  return 1 + peak * u * Math.exp(1 - u);
-}
-
-class VelocityTracker {
-  samples = [];
-  add(x, y, t = performance.now()) {
-    this.samples.push({ t, x, y });
-    while (this.samples.length > 2 && t - this.samples[0].t > 100)
-      this.samples.shift();
-  }
-  reset() {
-    this.samples = [];
-  }
-  get velocity() {
-    let s = this.samples;
-    if (s.length < 2)
-      return [0, 0];
-    let a = s[0], b = s[s.length - 1], dt = (b.t - a.t) / 1000;
-    if (dt <= 0 || performance.now() - b.t > 60)
-      return [0, 0];
-    return [(b.x - a.x) / dt, (b.y - a.y) / dt];
-  }
-}
-var clamp = (x, a, b) => Math.min(b, Math.max(a, x));
-
-class Roll {
-  from;
-  to = 0;
-  inherited = 0;
-  start = 0;
-  duration = 0;
-  constructor(position) {
-    this.from = this.to = position;
-  }
-  get target() {
-    return this.to;
-  }
-  sample(now) {
-    let t = now - this.start;
-    if (this.duration <= 0 || t >= this.duration)
-      return { position: this.to, velocity: 0 };
-    if (t <= 0)
-      return { position: this.from, velocity: 0 };
-    let seconds = this.duration / 1000, tau = t / this.duration, d = this.from - this.to, e = Math.exp(-10 * tau);
-    return {
-      position: this.to + (d + (this.inherited + 10 * d) * tau) * e,
-      velocity: e * (this.inherited - 10 * (this.inherited + 10 * d) * tau) / seconds
-    };
-  }
-  set(target, duration, now, delay = 0) {
-    let { position, velocity } = this.sample(now);
-    if (duration <= 0)
-      return this.snap(target);
-    let seconds = duration / 1000, distance = position - target, limit = Math.max(Math.abs(distance), 1) * 12 / seconds;
-    return this.inherited = clamp(delay > 0 ? 0 : velocity, -limit, limit) * seconds, this.from = position, this.to = target, this.start = now + delay, this.duration = duration, this;
-  }
-  snap(position) {
-    return this.from = this.to = position, this.duration = 0, this.inherited = 0, this;
-  }
-  resting(now) {
-    return this.duration <= 0 || now - this.start >= this.duration;
-  }
-  span(now) {
-    if (this.resting(now))
-      return [this.to, this.to];
-    return [Math.min(this.from, this.to), Math.max(this.from, this.to)];
-  }
-}
-function rollTarget(position, digit, trend) {
-  let target = Math.floor(position / 10) * 10 + digit;
-  if (trend > 0 && target < position - 0.001)
-    target += 10;
-  else if (trend < 0 && target > position + 0.001)
-    target -= 10;
-  else if (trend === 0)
-    target += Math.round((position - target) / 10) * 10;
-  return target;
-}
-var numeral = (position) => String((position % 10 + 10) % 10);
-function entranceOffset(elapsed, duration, hold = 0.14) {
-  if (duration <= 0 || elapsed >= duration)
-    return 0;
-  let p = clamp((elapsed / duration - hold) / (1 - hold), 0, 1);
-  return (1 + 10 * p) * Math.exp(-10 * p);
-}
-
-// src/panel/flash.ts
-var FLASH_MS = 320, flashes = /* @__PURE__ */ new WeakMap;
-function flash(button, wake) {
-  if (!button || button.hidden)
-    return;
-  flashes.set(button, button.ownerDocument.defaultView?.performance.now() ?? performance.now()), button.dataset.kFlash = button.dataset.kFlash === "a" ? "b" : "a", wake?.();
-}
-function flashOf(button, now) {
-  let at = flashes.get(button);
-  if (at === void 0)
-    return 0;
-  let p = (now - at) / 320;
-  if (p >= 1 || p < 0)
-    return 0;
-  return (1 - p) ** 3;
-}
-
 // src/panel/rolling-css.ts
 var rolling_css_default = `.rn-root {
   display: inline-block;
@@ -393,8 +253,428 @@ var problemsPreset = {
   }
 };
 
+// src/panel/motion.ts
+var FILL = { omega: 30, zeta: 0.88 };
+var LEAD = { omega: 34, zeta: 0.86 }, TRAIL = { omega: 25, zeta: 1 }, trailScale = (blur) => 0.6 + 0.4 * clamp(blur, 0, 2);
+
+class Edges {
+  start;
+  end;
+  constructor(start = 0, end = 0) {
+    this.start = new Spring(start, LEAD.omega, LEAD.zeta, 0.05), this.end = new Spring(end, LEAD.omega, LEAD.zeta, 0.05);
+  }
+  to(start, end, delay = 0, trail = 1) {
+    if ((start !== this.start.target || end !== this.end.target) && delay <= 0) {
+      let forward = start + end > this.start.target + this.end.target, [lead, tail] = forward ? [this.end, this.start] : [this.start, this.end];
+      lead.omega = LEAD.omega, lead.zeta = LEAD.zeta, tail.omega = TRAIL.omega / trail, tail.zeta = TRAIL.zeta;
+    }
+    return this.start.set(start, delay), this.end.set(end, delay), this;
+  }
+  shift(ds, de) {
+    return this.start.x += ds, this.start.target += ds, this.end.x += de, this.end.target += de, this;
+  }
+  snap(start, end) {
+    return this.start.snap(start), this.end.snap(end), this;
+  }
+  step(dt) {
+    return this.start.step(dt), this.end.step(dt), this;
+  }
+  get resting() {
+    return this.start.resting && this.end.resting;
+  }
+  get velocity() {
+    return (this.start.v + this.end.v) / 2;
+  }
+}
+var POP_MS = 360;
+function popScale(t, peak = 0.04) {
+  if (t <= 0 || t >= POP_MS)
+    return 1;
+  let u = t / 55;
+  return 1 + peak * u * Math.exp(1 - u);
+}
+var settleScale = (t) => popScale(t, 0.14);
+
+class VelocityTracker {
+  samples = [];
+  add(x, y, t = performance.now()) {
+    this.samples.push({ t, x, y });
+    while (this.samples.length > 2 && t - this.samples[0].t > 100)
+      this.samples.shift();
+  }
+  reset() {
+    this.samples = [];
+  }
+  get velocity() {
+    let s = this.samples;
+    if (s.length < 2)
+      return [0, 0];
+    let a = s[0], b = s[s.length - 1], dt = (b.t - a.t) / 1000;
+    if (dt <= 0 || performance.now() - b.t > 60)
+      return [0, 0];
+    return [(b.x - a.x) / dt, (b.y - a.y) / dt];
+  }
+}
+var clamp = (x, a, b) => Math.min(b, Math.max(a, x));
+
+class Roll {
+  from;
+  to = 0;
+  inherited = 0;
+  start = 0;
+  duration = 0;
+  constructor(position) {
+    this.from = this.to = position;
+  }
+  get target() {
+    return this.to;
+  }
+  sample(now) {
+    let t = now - this.start;
+    if (this.duration <= 0 || t >= this.duration)
+      return { position: this.to, velocity: 0 };
+    if (t <= 0)
+      return { position: this.from, velocity: 0 };
+    let seconds = this.duration / 1000, tau = t / this.duration, d = this.from - this.to, e = Math.exp(-10 * tau);
+    return {
+      position: this.to + (d + (this.inherited + 10 * d) * tau) * e,
+      velocity: e * (this.inherited - 10 * (this.inherited + 10 * d) * tau) / seconds
+    };
+  }
+  set(target, duration, now, delay = 0) {
+    let { position, velocity } = this.sample(now);
+    if (duration <= 0)
+      return this.snap(target);
+    let seconds = duration / 1000, distance = position - target, limit = Math.max(Math.abs(distance), 1) * 12 / seconds;
+    return this.inherited = clamp(delay > 0 ? 0 : velocity, -limit, limit) * seconds, this.from = position, this.to = target, this.start = now + delay, this.duration = duration, this;
+  }
+  snap(position) {
+    return this.from = this.to = position, this.duration = 0, this.inherited = 0, this;
+  }
+  resting(now) {
+    return this.duration <= 0 || now - this.start >= this.duration;
+  }
+  span(now) {
+    if (this.resting(now))
+      return [this.to, this.to];
+    return [Math.min(this.from, this.to), Math.max(this.from, this.to)];
+  }
+}
+function rollTarget(position, digit, trend) {
+  let target = Math.floor(position / 10) * 10 + digit;
+  if (trend > 0 && target < position - 0.001)
+    target += 10;
+  else if (trend < 0 && target > position + 0.001)
+    target -= 10;
+  else if (trend === 0)
+    target += Math.round((position - target) / 10) * 10;
+  return target;
+}
+var numeral = (position) => String((position % 10 + 10) % 10);
+function entranceOffset(elapsed, duration, hold = 0.14) {
+  if (duration <= 0 || elapsed >= duration)
+    return 0;
+  let p = clamp((elapsed / duration - hold) / (1 - hold), 0, 1);
+  return (1 + 10 * p) * Math.exp(-10 * p);
+}
+
+// src/panel/flash.ts
+var FLASH_MS = 320, flashes = /* @__PURE__ */ new WeakMap;
+function flash(button, wake) {
+  if (!button || button.hidden)
+    return;
+  flashes.set(button, button.ownerDocument.defaultView?.performance.now() ?? performance.now()), button.dataset.kFlash = button.dataset.kFlash === "a" ? "b" : "a", wake?.();
+}
+function flashOf(button, now) {
+  let at = flashes.get(button);
+  if (at === void 0)
+    return 0;
+  let p = (now - at) / 320;
+  if (p >= 1 || p < 0)
+    return 0;
+  return (1 - p) ** 3;
+}
+
+// src/panel/feel.ts
+var clamp2 = (x, a, b) => Math.min(b, Math.max(a, x)), smooth = (a, b, x) => {
+  let t = clamp2((x - a) / (b - a), 0, 1);
+  return t * t * (3 - 2 * t);
+}, PRECISION = [
+  [24, 44],
+  [76, 96],
+  [126, 146]
+], offRow = (y, top, bottom) => Math.max(0, top - y, y - bottom), precisionDepth = (off) => PRECISION.reduce((n, [a, b]) => n + smooth(a, b, Math.abs(off)), 0), precisionRate = (off) => 2 ** -precisionDepth(off), RULER = [
+  [20, 5, 0.2],
+  [40, 4, 0.17],
+  [80, 3, 0.14]
+], RULER_NEAR = 36, RULER_FADE = 120, rulerLevels = (steps) => {
+  let n = 0;
+  while (n < 3 && 10 * 2 ** (n + 1) <= steps)
+    n++;
+  return n;
+}, rulerAlpha = (depth, level) => clamp2(depth - (level - 1), 0, 1), rulerDepth = (rate, levels) => rate >= 1 ? 0 : clamp2(-Math.log2(rate), 0, levels), THIN = 1.7, THINNEST = 0.85, thinOf = (scale) => Math.max(0.85, 1 - 1.7 * Math.max(0, scale - 1));
+var roundOf = (give) => clamp2(Math.abs(give) / 4, 0, 1), stretchOf = (give, length) => ({
+  scale: length > 0 ? 1 + Math.abs(give) / length : 1,
+  anchor: give < 0 ? 1 : 0
+}), stretchAt = (at, give, length) => {
+  let { scale, anchor } = stretchOf(give, length), o = anchor * length;
+  return o + (at - o) * scale;
+}, giveRoom = (room, most) => Math.max(0.5, Math.min(most, room)), DETENTS = {
+  default: { hold: 4, ramp: 6 },
+  base: { hold: 4, ramp: 6 },
+  round: { hold: 2.5, ramp: 4 }
+}, detentScale = (rate) => clamp2(rate, 0, 1) ** 1.5, reach = (d, k = 1) => {
+  let { hold, ramp } = DETENTS[d.kind];
+  return { h: hold * k, r: ramp * k };
+};
+function detentsOf(width, min, max, o) {
+  let span = max - min;
+  if (!(span > 0) || !(width > 0))
+    return [];
+  let list = [], add = (value, kind) => {
+    if (value === void 0 || !Number.isFinite(value) || value < min || value > max)
+      return;
+    let at = (value - min) / span * width, room = (d) => {
+      let a = reach(d), b = DETENTS[kind];
+      return a.h + a.r + b.hold + b.ramp;
+    };
+    if (list.some((d) => Math.abs(d.at - at) < room(d)))
+      return;
+    list.push({ at, value, kind });
+  };
+  add(o.value, "default"), add(o.base, "base");
+  for (let v of o.round ?? [])
+    add(v, "round");
+  return list;
+}
+var roundValues = (min, max) => {
+  let mid = Number(((min + max) / 2).toPrecision(12));
+  return min < 0 && max > 0 && mid !== 0 ? [0, mid] : [mid];
+};
+function warp(x, list, k = 1) {
+  for (let d of list) {
+    let { h, r } = reach(d, k), u = x - d.at, a = Math.abs(u);
+    if (a >= h + r)
+      continue;
+    if (a <= h)
+      return d.at;
+    return d.at + Math.sign(u) * (a - h) * (h + r) / r;
+  }
+  return x;
+}
+function unwarp(shown, x, list, k = 1) {
+  for (let d of list) {
+    let { h, r } = reach(d, k), v = shown - d.at, a = Math.abs(v);
+    if (a >= h + r)
+      continue;
+    if (a === 0)
+      return d.at + clamp2(x - d.at, -h, h);
+    return d.at + Math.sign(v) * (h + a * r / (h + r));
+  }
+  return shown;
+}
+var REARM = 2;
+
+class Notches {
+  list;
+  held = -1;
+  armed;
+  constructor(list, x) {
+    this.list = list;
+    this.armed = list.map((d) => Math.abs(x - d.at) > REARM), this.held = list.findIndex((d) => warp(x, [d]) === d.at);
+  }
+  move(x, k = 1) {
+    let shown = warp(x, this.list, k), held = this.list.findIndex((d) => d.at === shown), caught;
+    if (this.list.forEach((d, i) => {
+      let { h, r } = reach(d, k);
+      if (Math.abs(x - d.at) > Math.max(h + r, REARM))
+        this.armed[i] = !0;
+    }), held >= 0 && held !== this.held && this.armed[held])
+      caught = this.list[held], this.armed[held] = !1;
+    return this.held = held, caught ? { shown, caught } : { shown };
+  }
+}
+
+// src/panel/scope.ts
+function escapeTo(level, inCard = !0) {
+  if (level === "row")
+    return inCard ? "card" : "panel";
+  if (level === "card")
+    return "panel";
+  return "none";
+}
+function commandScope(level, selection = !1) {
+  if (selection)
+    return "selection";
+  if (level === "row")
+    return "row";
+  if (level === "card")
+    return "group";
+  return "all";
+}
+function scopeLabel(verb, scope) {
+  return `${verb} ${scope === "selection" ? "selected" : scope === "row" ? "this" : scope === "group" ? "group" : "all"}`;
+}
+function crumbTrail(path) {
+  let out = [];
+  for (let level of ["card", "row", "editor"]) {
+    let label = path[level]?.trim();
+    if (label)
+      out.push({ level, label });
+  }
+  return out;
+}
+function escTarget(trail, title) {
+  if (!trail.length)
+    return;
+  return trail.at(-2)?.label ?? (title.trim() || "panel");
+}
+function fitCrumbs(widths, room, sep, more, hint = 0) {
+  let n = widths.length;
+  if (!n)
+    return { from: 0, hint: !1 };
+  let span = (from) => {
+    let w = 0;
+    for (let i = from;i < n; i++)
+      w += widths[i] + (i > from ? sep : 0);
+    return from > 0 ? w + more + sep : w;
+  }, from = 0;
+  while (from < n - 1 && span(from) > room)
+    from++;
+  let used = span(from);
+  return { from, hint: hint > 0 && used + sep + hint <= room };
+}
+function digitOption(key, count) {
+  if (!/^[1-9]$/.test(key))
+    return;
+  let i = Number(key) - 1;
+  return i < count ? i : void 0;
+}
+function digitHints(count, showing) {
+  let n = Math.min(9, count);
+  if (n <= 0)
+    return [];
+  if (showing)
+    return Array.from({ length: n }, (_, i) => String(i + 1));
+  return [n === 1 ? "1" : `1–${n}`];
+}
+
+// src/panel/crumbs.ts
+var glide2 = springEasing(2 * Math.PI / 0.3, 1), CRUMB_GLIDE = `${glide2.ms}ms ${glide2.easing}`, SLIDE = 5, GAP = 6, HINT_GAP = 10, SEP = "›";
+function createCrumbs(o) {
+  let doc = o.header.ownerDocument, element = doc.createElement("div");
+  element.className = "knobs-crumbs", element.setAttribute("aria-hidden", "true"), o.header.append(element);
+  let live = /* @__PURE__ */ new Map, trail = [], esc, hinting = !1, ctx, width = (text) => {
+    if (ctx === void 0)
+      ctx = doc.createElement("canvas").getContext("2d");
+    if (!ctx)
+      return text.length * 6;
+    let cs = getComputedStyle(element);
+    return ctx.font = `${cs.fontWeight} ${cs.fontSize} ${cs.fontFamily}`, ctx.measureText(text).width;
+  }, titleEnd = (head) => {
+    let t = o.title.getBoundingClientRect();
+    if (!o.title.textContent)
+      return { x: t.left - head.left, right: t.right - head.left, t };
+    let range = doc.createRange();
+    range.selectNodeContents(o.title);
+    let r = range.getBoundingClientRect();
+    return { x: Math.min(r.right, t.right) - head.left + GAP, right: t.right - head.left, t };
+  }, build = () => {
+    if (!trail.length)
+      return { pieces: [], xs: [] };
+    let head = o.header.getBoundingClientRect(), { x, right } = titleEnd(head), sepW = width(SEP) + GAP * 2, escText = esc ? `esc ↑ ${esc}` : "", fit = fitCrumbs(trail.map((c) => width(c.label)), Math.max(0, right - x - sepW), sepW, width("…"), escText ? width(escText) + HINT_GAP - sepW : 0), pieces = [{ key: "sep:lead", text: SEP, kind: "sep" }];
+    if (fit.from > 0)
+      pieces.push({ key: "more", text: "…", kind: "more" }, { key: "sep:more", text: SEP, kind: "sep" });
+    if (trail.forEach((c, i) => {
+      if (i < fit.from)
+        return;
+      if (i > fit.from)
+        pieces.push({ key: `sep:${c.level}`, text: SEP, kind: "sep" });
+      pieces.push({
+        key: `${c.level}:${c.label}`,
+        text: c.label,
+        kind: "crumb",
+        level: c.level,
+        deep: i === trail.length - 1
+      });
+    }), escText && fit.hint)
+      pieces.push({ key: `esc:${esc}`, text: escText, kind: "esc" });
+    let xs = [], at = x;
+    for (let p of pieces) {
+      if (p.kind === "esc")
+        at += HINT_GAP - GAP;
+      xs.push(at), at += width(p.text) + (p.kind === "sep" ? GAP : p.kind === "esc" ? 0 : GAP);
+    }
+    return { pieces, xs };
+  }, place = () => {
+    let head = o.header.getBoundingClientRect(), t = o.title.getBoundingClientRect();
+    element.style.top = `${(t.top - head.top + t.height / 2).toFixed(2)}px`;
+  }, leave = (key, node, x) => {
+    if (live.delete(key), node.dataset.leaving = "", node.style.opacity = "0", !o.reduced())
+      node.style.translate = `${(x - SLIDE).toFixed(2)}px -50%`;
+    setTimeout(() => node.remove(), 320);
+  }, render = () => {
+    place();
+    let { pieces, xs } = build(), keep = new Set(pieces.map((p) => p.key));
+    for (let [key, node] of live)
+      if (!keep.has(key))
+        leave(key, node, parseFloat(node.dataset.x ?? "0"));
+    let reduced = o.reduced();
+    pieces.forEach((p, i) => {
+      let x = xs[i], node = live.get(p.key);
+      if (!node) {
+        if (node = doc.createElement("span"), node.className = `knobs-crumb-${p.kind}`, node.textContent = p.text, p.level)
+          node.dataset.level = p.level;
+        node.style.opacity = "0", node.style.translate = `${(x + (reduced ? 0 : SLIDE)).toFixed(2)}px -50%`, element.append(node), live.set(p.key, node), node.getBoundingClientRect();
+      }
+      node.dataset.x = String(x), node.toggleAttribute("data-deep", Boolean(p.deep)), node.style.translate = `${x.toFixed(2)}px -50%`, node.style.opacity = p.kind === "esc" && !hinting ? "0" : "1";
+    }), o.wake();
+  }, onDown = (event) => {
+    if (!event.target.closest?.("[data-level]"))
+      return;
+    event.preventDefault(), event.stopPropagation();
+  }, onClick = (event) => {
+    let node = event.target.closest?.("[data-level]");
+    if (!node || "leaving" in node.dataset)
+      return;
+    event.stopPropagation(), o.jump(node.dataset.level);
+  };
+  element.addEventListener("pointerdown", onDown), element.addEventListener("mousedown", onDown), element.addEventListener("click", onClick);
+  let size = "", sizes = typeof ResizeObserver > "u" ? void 0 : new ResizeObserver(() => {
+    let r = o.title.getBoundingClientRect(), next = `${r.width}|${r.height}|${o.title.textContent}`;
+    if (next === size)
+      return;
+    if (size = next, trail.length)
+      render();
+  });
+  return sizes?.observe(o.header), sizes?.observe(o.title), {
+    element,
+    set(next, nextEsc) {
+      if (next.length === trail.length && next.every((c, i) => c.level === trail[i].level && c.label === trail[i].label) && nextEsc === esc)
+        return;
+      trail = next, esc = nextEsc, render();
+    },
+    hint(on) {
+      if (on === hinting)
+        return;
+      hinting = on;
+      for (let [key, node] of live)
+        if (key.startsWith("esc:"))
+          node.style.opacity = on ? "1" : "0";
+      o.wake();
+    },
+    layout() {
+      if (trail.length)
+        render();
+    },
+    dispose() {
+      sizes?.disconnect(), element.remove();
+    }
+  };
+}
+
 // src/panel/styles.ts
-var lead = springEasing(LEAD.omega, LEAD.zeta), trail = springEasing(TRAIL.omega, TRAIL.zeta), fill = springEasing(FILL.omega, FILL.zeta), LEAD_T = `${lead.ms}ms var(--k-lead)`, TRAIL_T = `calc(${trail.ms}ms * (.6 + .4 * clamp(0, var(--k-blur), 2))) var(--k-trail)`, FILL_T = "calc(var(--k-fill-ms) * 1ms * clamp(var(--k-blur),.1,2)) var(--k-fill-ease)", SLIDE_T = "calc(var(--k-fill-ms) * 1ms) var(--k-fill-ease)", snappy = springEasing(2 * Math.PI / 0.25, 1), snappyOut = springEasing(2 * Math.PI / 0.2, 1), BLOOM_IN = `${snappy.ms}ms ${snappy.easing}`, BLOOM_OUT = `${snappyOut.ms}ms ${snappyOut.easing}`, DELAY = "var(--k-delay,0ms)", POINTER_ROW = ".knobs-panel[data-k-row-hover]:not([data-keyboard])", DELAYED = ".knobs-fill,.knobs-handle,.knobs-seg-pill,.knobs-toggle,.knobs-toggle i,.knobs-arm,.knobs-curve,.knobs-swatch,.knobs-strip-thumb,.knobs-pad>i,.knobs-ease-handle,.knobs-range-track,.knobs-range-fill,.knobs-range-thumb,.knobs-dial-hand,.knobs-grad,.knobs-grad-mini,.knobs-grad-mini>i,.knobs-grad-stop,.knobs-graph-pt", GRAD_N = GRADIENT_SAMPLES, gradStops = (at) => Array.from({ length: GRAD_N }, (_, i) => `var(--kgrad-${i}) ${at(i)}`).join(","), GRAD_STRIP = `linear-gradient(to right,${gradStops((i) => `calc(var(--kg-r) + (100% - var(--kg-r) * 2) * ${Number((i / (GRAD_N - 1)).toFixed(5))})`)})`, GRAD_MINI = `linear-gradient(to right,${gradStops((i) => `${Number((i / (GRAD_N - 1) * 100).toFixed(3))}%`)})`, GRAD_PROPS = Array.from({ length: GRAD_N }, (_, i) => `@property --kgrad-${i}{syntax:"<color>";inherits:false;initial-value:transparent}`).join(`
+var lead = springEasing(LEAD.omega, LEAD.zeta), trail = springEasing(TRAIL.omega, TRAIL.zeta), fill = springEasing(FILL.omega, FILL.zeta), LEAD_T = `${lead.ms}ms var(--k-lead)`, TRAIL_T = `calc(${trail.ms}ms * (.6 + .4 * clamp(0, var(--k-blur), 2))) var(--k-trail)`, FILL_T = "calc(var(--k-fill-ms) * 1ms * clamp(var(--k-blur),.1,2)) var(--k-fill-ease)", SLIDE_T = "calc(var(--k-fill-ms) * 1ms) var(--k-fill-ease)", snappy = springEasing(2 * Math.PI / 0.25, 1), snappyOut = springEasing(2 * Math.PI / 0.2, 1), BLOOM_IN = `${snappy.ms}ms ${snappy.easing}`, BLOOM_OUT = `${snappyOut.ms}ms ${snappyOut.easing}`, DELAY = "var(--k-delay,0ms)", armed = springEasing(2 * Math.PI / 0.3, 1), ARMED_T = `${armed.ms}ms ${armed.easing}`, POINTER_ROW = ".knobs-panel[data-k-row-hover]:not([data-keyboard])", DELAYED = ".knobs-fill,.knobs-handle,.knobs-seg-pill,.knobs-toggle,.knobs-toggle i,.knobs-arm,.knobs-curve,.knobs-swatch,.knobs-strip-thumb,.knobs-pad>i,.knobs-ease-handle,.knobs-range-track,.knobs-range-fill,.knobs-range-thumb,.knobs-dial-hand,.knobs-grad,.knobs-grad-mini,.knobs-grad-mini>i,.knobs-grad-stop,.knobs-graph-pt", GRAD_N = GRADIENT_SAMPLES, gradStops = (at) => Array.from({ length: GRAD_N }, (_, i) => `var(--kgrad-${i}) ${at(i)}`).join(","), GRAD_STRIP = `linear-gradient(to right,${gradStops((i) => `calc(var(--kg-r) + (100% - var(--kg-r) * 2) * ${Number((i / (GRAD_N - 1)).toFixed(5))})`)})`, GRAD_MINI = `linear-gradient(to right,${gradStops((i) => `${Number((i / (GRAD_N - 1) * 100).toFixed(3))}%`)})`, GRAD_PROPS = Array.from({ length: GRAD_N }, (_, i) => `@property --kgrad-${i}{syntax:"<color>";inherits:false;initial-value:transparent}`).join(`
 `), COLOR_TOKENS = [
   "bg",
   "surface",
@@ -433,6 +713,7 @@ ${register(["width"], "<length-percentage>", "288px")}
 @property --k-head-s{syntax:"<number>";inherits:true;initial-value:0}
 @property --k-head-v{syntax:"<number>";inherits:true;initial-value:0}
 @property --kc-value-size{syntax:"<length>";inherits:true;initial-value:11.5px}
+@property --k-armed{syntax:"<number>";inherits:false;initial-value:0}
 @property --kr-lo{syntax:"<number>";inherits:true;initial-value:0}
 @property --kpt-sel{syntax:"<number>";inherits:false;initial-value:1}
 @property --kgs-sel{syntax:"<number>";inherits:false;initial-value:1}
@@ -454,6 +735,8 @@ ${GRAD_PROPS}
   --k-font-weight:400;--k-title-weight:600;--k-thumb:#fff;--k-lift:1;--k-frame:card;
   --k-row-gap:0px;--k-hover-in:0;--k-hover-out:120;--k-fill-base:var(--k-surface-hi);--k-fill-rest-mix:20%;--k-fill-hover-mix:var(--k-fill-rest-mix);--k-fill-active-mix:30%;--k-chrome:1;--k-handle:var(--k-accent);--k-handle-inset:0px;--k-handle-rest:0;--k-step-resist:0.25;--k-motion-blur:0;--k-range-blur:.5;--k-curve-blur:.5;--k-group-transform:uppercase;--k-value-font:var(--k-font);
   --k-lead:${lead.easing};--k-trail:${trail.easing};--k-fill-ease:${fill.easing};--k-fill-ms:${fill.ms};
+  --k-lens-ms:180;--k-lens-lead:1;--k-lens-wash:.9;--k-lens-line:.65;--k-lens-panel-wash:.35;--k-lens-inset:0px;--k-lens-panel-inset:0px;
+  --k-armed-edge:.1;--k-armed-glow:0;--k-armed-glow-a:0;--k-title-rest:.6;--k-esc-hint-ms:1800;
 }
 /* Glass edges are hairlines: --k-rim-width is one device pixel at common pixel ratios. */
 @media(min-resolution:1.5dppx){:where(:root,:host){--k-rim-width:.67px}}
@@ -519,7 +802,7 @@ ${GRAD_PROPS}
 .knobs-panel,.knobs-chip,.knobs-menu{letter-spacing:normal;word-spacing:normal;text-transform:none;text-indent:0;text-shadow:none;text-decoration:none;font-style:normal;font-variant:normal;font-feature-settings:normal;font-kerning:auto;white-space:normal;direction:ltr;margin:0;float:none}
 :where(.knobs-panel,.knobs-chip) :where(*,*::before,*::after){box-sizing:border-box}
 .knobs-panel .rn-slot{box-sizing:content-box}
-.knobs-panel [hidden],.knobs-chip[hidden]{display:none!important}
+.knobs-panel [hidden],.knobs-panel[hidden],.knobs-chip[hidden]{display:none!important}
 .knobs-mono{font-family:var(--k-mono);font-variant-numeric:tabular-nums}
 
 /* The chip: a round cog button, or a capsule with a label beside the cog. */
@@ -546,13 +829,17 @@ ${GRAD_PROPS}
 .knobs-panel,.knobs-chip{--k-token-t:calc(var(--k-fill-ms) * 1ms) var(--k-fill-ease)}
 :root[data-knobs-scrub] .knobs-chip{--k-token-t:0s}
 :root[data-knobs-scrub] .knobs-panel{transition:none}
-@media(prefers-reduced-motion:reduce){.knobs-chip{--k-token-t:0s}.knobs-panel.knobs-panel{transition:none}}
+@media(prefers-reduced-motion:reduce){.knobs-chip{--k-token-t:0s}.knobs-panel.knobs-panel{transition:--k-armed .16s linear}}
+.knobs-panel[data-k-armed]{--k-armed:1}
 /* Panel material: --k-glass (0 opaque … 1 clearest) thins the surface over a blurred, saturated
    backdrop, toned toward the theme (--k-glass-tone dims it under dark panels) so text keeps its
    contrast. Its edge is a hairline (--k-edge, --k-rim-width wide) and a hairline of light (--k-rim)
    catches its top. */
-.knobs-panel{-webkit-user-select:none;user-select:none;transition:${TOKEN_TRANSITIONS};position:fixed;z-index:2147480001;width:var(--k-width);max-width:calc(100vw - 16px);max-height:calc(100dvh - 16px);overflow:auto;padding:var(--k-pad);
-  background:color-mix(in srgb,var(--k-bg) calc(100% - var(--k-glass) * 20%),transparent);border:1px solid transparent;border-radius:var(--k-panel-radius);box-shadow:var(--k-shadow),0 0 0 var(--k-rim-width) var(--k-edge),inset 0 var(--k-rim-width) 0 var(--k-rim);scrollbar-width:thin;
+.knobs-panel{-webkit-user-select:none;user-select:none;transition:${TOKEN_TRANSITIONS},--k-armed ${ARMED_T};position:fixed;z-index:2147480001;width:var(--k-width);max-width:calc(100vw - 16px);max-height:calc(100dvh - 16px);overflow:auto;padding:var(--k-pad);
+  background:color-mix(in srgb,var(--k-bg) calc(100% - var(--k-glass) * 20%),transparent);border:1px solid transparent;border-radius:var(--k-panel-radius);box-shadow:var(--k-shadow),0 0 0 var(--k-rim-width) var(--ka-edge),inset 0 var(--k-rim-width) 0 var(--k-rim),var(--ka-glow);scrollbar-width:thin;
+  /* Armed (focus inside: keys come here), the edge takes the accent and a faint glow lifts it. */
+  --ka-edge:color-mix(in srgb,var(--k-accent) calc(var(--k-armed) * var(--k-armed-edge) * 100%),var(--k-edge));
+  --ka-glow:0 0 calc(var(--k-armed-glow) * 1px) color-mix(in srgb,var(--k-accent) calc(var(--k-armed) * var(--k-armed-glow-a) * var(--k-chrome,1) * 100%),transparent);
   --k-backdrop:blur(calc(var(--k-glass) * 24px)) saturate(calc(1 + var(--k-glass) * .8)) brightness(calc(1 + (var(--k-glass-tone) - 1) * var(--k-glass)));
   -webkit-backdrop-filter:var(--k-backdrop);backdrop-filter:var(--k-backdrop);
   animation:knobs-in .16s var(--k-ease);}
@@ -570,7 +857,7 @@ ${GRAD_PROPS}
 .knobs-morph::after{box-shadow:var(--k-shadow);opacity:var(--p)}
 /* Meanwhile the chip is just its label, fading on the shape. */
 .knobs-chip.knobs-chip[data-morph]{visibility:visible;pointer-events:auto;transform:none;transition:none;background:transparent;border-color:transparent;box-shadow:none}
-.knobs-panel.knobs-inline{position:relative;z-index:auto;left:auto!important;top:auto!important;max-width:100%;max-height:none;box-shadow:0 0 0 var(--k-rim-width) color-mix(in srgb,var(--k-edge) calc(var(--k-chrome) * 100%),transparent),inset 0 var(--k-rim-width) 0 color-mix(in srgb,var(--k-rim) calc(var(--k-chrome) * 100%),transparent);animation:none;
+.knobs-panel.knobs-inline{position:relative;z-index:auto;left:auto!important;top:auto!important;max-width:100%;max-height:none;box-shadow:0 0 0 var(--k-rim-width) color-mix(in srgb,var(--ka-edge) calc(var(--k-chrome) * 100%),transparent),inset 0 var(--k-rim-width) 0 color-mix(in srgb,var(--k-rim) calc(var(--k-chrome) * 100%),transparent),var(--ka-glow);animation:none;
   /* --k-chrome 0: an embedded panel sheds its card (background, border, rim) for the host's column,
      border width too, so its rows line up with the column's edges. */
   border-width:calc(var(--k-chrome) * 1px);
@@ -589,7 +876,7 @@ ${GRAD_PROPS}
 :is(.knobs-panel,.knobs-menu) :is(:focus,:focus-visible):where(:not(.knobs-accessory *)){outline:none}
 
 /* Header */
-.knobs-panel header{display:flex;align-items:center;justify-content:space-between;gap:6px;cursor:grab;touch-action:none;padding:0 var(--k-inset) var(--k-section-gap);min-height:var(--k-icon-btn)}
+.knobs-panel header{position:relative;display:flex;align-items:center;justify-content:space-between;gap:6px;cursor:grab;touch-action:none;padding:0 var(--k-inset) var(--k-section-gap);min-height:var(--k-icon-btn)}
 .knobs-panel.knobs-inline header,.knobs-panel.knobs-inline header:active{cursor:default}
 /* The title row stays pinned while the rows scroll under it, in the panel (it scrolls once it's
    bounded) or, with .knobs-pin-ancestor (which also makes the panel overflow:visible), in the
@@ -616,7 +903,21 @@ ${GRAD_PROPS}
   .knobs-panel[data-gpu-active="true"]:not(.knobs-page)>header::after{display:none}
 }
 .knobs-panel header:active{cursor:grabbing}
-.knobs-panel header strong{flex:1;min-width:0;font-weight:var(--k-title-weight);font-size:var(--k-text-title);letter-spacing:-.01em;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;transition:opacity .2s var(--k-ease)}
+.knobs-panel header strong{flex:1;min-width:0;font-weight:var(--k-title-weight);font-size:var(--k-text-title);letter-spacing:-.01em;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;transition:opacity .2s var(--k-ease),color ${ARMED_T};
+  color:color-mix(in srgb,var(--k-text) calc(var(--k-title-rest) * 100%),var(--k-label))}
+/* At rest a panel's title is a little quiet; armed (keys come here) it's at full strength. */
+.knobs-panel[data-k-armed] header strong{color:var(--k-text)}
+/* The scope line beside the title (crumbs.ts): where keys go, and for a moment where Esc goes. */
+.knobs-crumbs{position:absolute;left:0;top:50%;height:0;pointer-events:none;white-space:nowrap;font-size:var(--k-text-meta);font-weight:var(--k-label-weight);line-height:1.2;letter-spacing:0;text-transform:none}
+.knobs-crumbs>*{position:absolute;left:0;top:0;translate:0 -50%;color:var(--k-dim);transition:opacity .2s var(--k-ease),translate ${CRUMB_GLIDE},color .2s var(--k-ease)}
+.knobs-crumbs>[data-leaving]{transition:opacity .14s cubic-bezier(.4,0,1,1),translate .14s cubic-bezier(.4,0,1,1)}
+.knobs-crumbs>.knobs-crumb-crumb{pointer-events:auto;cursor:pointer}
+.knobs-crumbs>.knobs-crumb-crumb[data-deep]{color:var(--k-text)}
+.knobs-crumbs>.knobs-crumb-crumb:not([data-deep]):hover{color:var(--k-label)}
+.knobs-crumbs>.knobs-crumb-sep{color:color-mix(in srgb,var(--k-dim) 70%,transparent)}
+.knobs-crumbs>.knobs-crumb-esc{font-family:var(--k-mono);font-size:var(--k-text-cap);transition:opacity .35s var(--k-ease),translate ${CRUMB_GLIDE}}
+@media(prefers-reduced-motion:reduce){.knobs-panel .knobs-crumbs>*{transition:opacity .15s linear!important}}
+.knobs-panel[data-gpu-active="true"] .knobs-crumbs>*{color:transparent!important}
 /* Holding \\ shows the values from before the last change; the title dims meanwhile. */
 .knobs-panel[data-comparing] header strong{opacity:.4}
 .knobs-head-actions{display:flex;align-items:center;margin-right:calc((var(--k-icon-size) - var(--k-icon-btn)) / 2)}
@@ -714,6 +1015,23 @@ ${GRAD_PROPS}
 .knobs-card{position:relative;margin-bottom:var(--k-section-gap);border-radius:var(--k-radius);background:var(--k-surface);overflow:hidden}
 .knobs-card:last-child{margin-bottom:0}
 .knobs-card>*{position:relative;min-height:var(--k-row);transition:background var(--k-hover-t),opacity .2s}
+.knobs-panel [data-tab-opacity]{transition:none!important}
+/* Rubber-band ends (drawStretch in give.ts): past a limit a control stretches about its far end
+   and thins a little, its stretching corners rounding off; a row draws past its card's edge
+   meanwhile (keeping the card's corners where it has them), and its text stays put. */
+.knobs-stretching{scale:var(--k-sx) var(--k-sy);transform-origin:var(--k-sox) var(--k-soy)}
+.knobs-card[data-k-stretch]{overflow:visible}
+.knobs-card>:first-child{--k-rt:1}
+.knobs-card>:last-child{--k-rb:1}
+.knobs-card>.knobs-stretching{--k-r:var(--k-radius);border-radius:calc(var(--k-r) * var(--k-rt,0)) calc(var(--k-r) * var(--k-rt,0)) calc(var(--k-r) * var(--k-rb,0)) calc(var(--k-r) * var(--k-rb,0))}
+.knobs-card>.knobs-stretching[data-stretch="end"]{border-top-right-radius:calc(var(--k-r) * max(var(--k-rt,0),var(--k-sf)));border-bottom-right-radius:calc(var(--k-r) * max(var(--k-rb,0),var(--k-sf)))}
+.knobs-card>.knobs-stretching[data-stretch="start"]{border-top-left-radius:calc(var(--k-r) * max(var(--k-rt,0),var(--k-sf)));border-bottom-left-radius:calc(var(--k-r) * max(var(--k-rb,0),var(--k-sf)))}
+.knobs-stretching>:is(.knobs-track,.knobs-range-track){border-radius:inherit}
+.knobs-slider.knobs-stretching :is(.knobs-label,.knobs-value),.knobs-range.knobs-stretching .knobs-range-text{scale:calc(1 / var(--k-sx)) calc(1 / var(--k-sy))}
+.knobs-slider.knobs-stretching .knobs-label{transform-origin:calc(var(--k-ox) - var(--k-inset)) 0}
+.knobs-panel .knobs-slider.knobs-stretching .knobs-value{transform-origin:calc(var(--k-ox) - var(--k-w) + var(--k-inset) + 100%) 0}
+.knobs-range.knobs-stretching .knobs-range-text{transform-origin:var(--k-sox) 50%}
+.knobs-stretching>:is(.knobs-strip-thumb,.knobs-pad-puck,.knobs-pad-home){transform:scale(calc(1 / var(--k-sx)),calc(1 / var(--k-sy)))}
 .knobs-card>:hover,.knobs-card>.knobs-active{background:var(--k-row-hover)}
 .knobs-card>*+*::before{content:"";position:absolute;z-index:1;left:0;right:0;top:0;height:1px;transform:scaleY(.5);transform-origin:top;background:var(--k-line);pointer-events:none;transition:opacity .15s}
 .knobs-card>::after{content:"";position:absolute;z-index:2;inset:0;background:var(--k-surface-hi);opacity:0;pointer-events:none;transition:opacity .15s,box-shadow .15s}
@@ -726,6 +1044,13 @@ ${GRAD_PROPS}
 /* One wash at a time: while the pointer has a row (and keys haven't taken over since), a focus
    wash elsewhere steps aside. */
 ${POINTER_ROW} :is(.knobs-card>*,.knobs-sub,.knobs-x-head):not(:hover)::after{opacity:0}
+/* The focus lens (lens.ts) marks the level keys act on, and replaces the washes above: one shape,
+   a soft wash and a hairline edge, placed from script (--kl-w, --kl-l). */
+.knobs-panel[data-k-lens] :is(.knobs-card>*,.knobs-sub,.knobs-x-head,.knobs-card,.knobs-tile)::after{opacity:0!important}
+.knobs-lens{position:absolute;left:0;top:0;z-index:2;width:0;height:0;opacity:0;pointer-events:none;box-sizing:border-box;contain:strict;will-change:transform,opacity;
+  background:color-mix(in srgb,var(--k-surface-hi) calc(var(--kl-w,0) * 100%),transparent);
+  box-shadow:inset 0 0 0 var(--k-rim-width) color-mix(in srgb,var(--k-line-hi) calc(var(--kl-l,0) * 100%),transparent)}
+.knobs-panel[data-gpu-active="true"] .knobs-lens{visibility:hidden}
 .knobs-panel .knobs-slider{height:var(--k-row);contain:layout style}
 .knobs-panel .knobs-row:where(:not(.knobs-slider,.knobs-x,.knobs-spring)){display:flex;align-items:center;justify-content:space-between;gap:8px;height:var(--k-row);padding:0 var(--k-inset);contain:layout style}
 .knobs-panel .knobs-row>span:first-child{color:var(--k-label);font-weight:var(--k-label-weight);min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
@@ -762,12 +1087,19 @@ ${POINTER_ROW} :is(.knobs-card>*,.knobs-sub,.knobs-x-head):not(:hover)::after{op
 .knobs-smear .knobs-fill{background:linear-gradient(to left,transparent,var(--k-fill-tint) calc(var(--k-smear) * 1px));transform:translateX(calc(var(--k-fill) - 100% + var(--k-smear) * .5px))}
 .knobs-smear .knobs-handle::before{scale:calc(1 + var(--k-smear) / 3) 1;opacity:calc(3 / (3 + var(--k-smear)))}
 .knobs-animate .knobs-fill,.knobs-animate .knobs-handle{transition:--k-fill ${SLIDE_T} ${DELAY},--k-fill-mix .15s,opacity .15s}
-.knobs-settle .knobs-fill,.knobs-settle .knobs-handle{transition:--k-fill .1s cubic-bezier(.25,1,.5,1),--k-fill-mix .12s,opacity .15s}
-/* The default: a short notch rising from the bottom edge, only while the row is in hand. */
+/* The default: a short notch rising from the bottom edge, only while the row is in hand. The
+   active preset's value hangs one from the top edge. */
 .knobs-marks>.knobs-notch{top:auto;bottom:0;width:1.5px;height:4px;border-radius:999px 999px 0 0;transform:translateX(-50%);background:var(--k-accent);opacity:0;transition:opacity .2s,height .15s var(--k-ease)}
+.knobs-marks>.knobs-base{top:0;bottom:auto;border-radius:0 0 999px 999px}
 .knobs-slider:is(:hover,.knobs-active,:has(:focus-visible)) .knobs-notch{opacity:.38}
-.knobs-slider.knobs-modified:is(:hover,.knobs-active,:has(:focus-visible)) .knobs-notch{opacity:.55}
-.knobs-magnet .knobs-notch{opacity:.95;height:6px}
+.knobs-slider.knobs-modified:is(:hover,.knobs-active,:has(:focus-visible)) .knobs-notch:not(.knobs-base){opacity:.55}
+.knobs-magnet .knobs-notch:not(.knobs-base),.knobs-held-base .knobs-base{opacity:.95;height:6px}
+/* Precision by distance: a fine ruler around the handle, a level for each halving of the rate,
+   each finer, shorter and fainter than the last. */
+.knobs-ruler{position:absolute;inset:0;pointer-events:none;--k-ruler-w:linear-gradient(to right,transparent calc(var(--k-fill) - ${RULER_FADE}px),#000 calc(var(--k-fill) - ${RULER_NEAR}px),#000 calc(var(--k-fill) + ${RULER_NEAR}px),transparent calc(var(--k-fill) + ${RULER_FADE}px));-webkit-mask:var(--k-ruler-w);mask:var(--k-ruler-w)}
+.knobs-ruler>i{position:absolute;left:0;right:0;top:50%;opacity:0;translate:-.5px 0;transition:opacity .18s var(--k-ease)}
+${RULER.map(([n, h, a], i) => `.knobs-ruler>i:nth-child(${i + 1}){height:${h}px;margin-top:${-h / 2}px;background:repeating-linear-gradient(to right,color-mix(in srgb,var(--k-accent) ${a * 100}%,transparent) 0 1px,transparent 1px calc(100% / ${n}))}`).join(`
+`)}
 /* The handle is a full-width layer moved by the fill (translate's % is its own width, the track's). */
 .knobs-handle{position:absolute;inset:0;pointer-events:none;transform:translateX(var(--k-fill));opacity:var(--k-handle-rest);transition:opacity .15s}
 .knobs-handle::before{content:"";position:absolute;left:0;top:50%;width:3px;height:calc(var(--k-row) - 12px);margin-top:calc(6px - var(--k-row) / 2);translate:calc(-50% - var(--k-handle-inset)) 0;border-radius:var(--k-round);background:var(--k-handle);
@@ -977,7 +1309,7 @@ ${POINTER_ROW} .knobs-slider.knobs-modified:not(:hover,.knobs-active) .knobs-val
 /* Rows as separate bars (--k-row-gap above 0): each row carries its own surface, no hairlines.
    A spring stacks its curve over its two sliders. */
 .knobs-panel[data-rows] .knobs-card{display:flex;flex-direction:column;gap:var(--k-row-gap);background:transparent;overflow:visible}
-.knobs-panel[data-rows] .knobs-card>*{background:var(--k-surface);border-radius:var(--k-radius);overflow:hidden}
+.knobs-panel[data-rows] .knobs-card>*{background:var(--k-surface);border-radius:var(--k-radius);overflow:hidden;--k-rt:1;--k-rb:1}
 .knobs-panel[data-rows] .knobs-card>:is(:hover,.knobs-active){background:color-mix(in srgb,var(--k-surface-hi) 50%,var(--k-surface))}
 .knobs-panel[data-rows] :is(.knobs-card>*,.knobs-sub)::before{display:none}
 .knobs-panel[data-rows] .knobs-card>.knobs-subhead{background:transparent}
@@ -1180,17 +1512,19 @@ ${POINTER_ROW} .knobs-slider.knobs-modified:not(:hover,.knobs-active) .knobs-val
 /* Hint mode: stable short codes, zero layout shift */
 .knobs-hinting .knobs-hint-miss{opacity:var(--k-disabled-opacity);transition:opacity .1s}
 .knobs-hint-layer{position:absolute;left:0;top:0;width:0;height:0;pointer-events:none;z-index:5;animation:knobs-in .1s var(--k-ease)}
-.knobs-hint{position:absolute;transform:translateY(-50%);display:inline-flex;align-items:center;height:15px;padding:0 4px;border-radius:var(--k-radius-sm);background:var(--k-accent);color:var(--k-bg);box-shadow:0 1px 3px rgba(0,0,0,calc(.35 * var(--k-lift)));
+/* The badges are <kbd>s, so they outrank the scoped reset's (0,1,1). */
+.knobs-panel .knobs-hint{position:absolute;transform:translateY(-50%);display:inline-flex;align-items:center;height:15px;padding:0 4px;border-radius:var(--k-radius-sm);background:var(--k-accent);color:var(--k-bg);box-shadow:0 1px 3px rgba(0,0,0,calc(.35 * var(--k-lift)));
   font:700 var(--k-text-cap)/1 var(--k-mono);letter-spacing:.04em;text-transform:uppercase;pointer-events:none}
+.knobs-panel .knobs-hint[hidden]{display:none}
 .knobs-hint-typed{opacity:var(--k-hint-typed-opacity)}
 .knobs-hint-rest{opacity:1}
 
 /* A focused row's options: tiny digits in hint mode's look, once focus settles (optkeys.ts). */
 .knobs-optkeys{position:absolute;left:0;top:0;width:0;height:0;pointer-events:none;z-index:5}
-.knobs-optkey{position:absolute;transform:translateY(-50%);display:inline-flex;align-items:center;height:12px;padding:0 3px;border-radius:var(--k-radius-sm);background:var(--k-accent);color:var(--k-bg);box-shadow:0 1px 3px rgba(0,0,0,calc(.35 * var(--k-lift)));
+.knobs-panel .knobs-optkey{position:absolute;transform:translateY(-50%);display:inline-flex;align-items:center;height:12px;padding:0 3px;border-radius:var(--k-radius-sm);background:var(--k-accent);color:var(--k-bg);box-shadow:0 1px 3px rgba(0,0,0,calc(.35 * var(--k-lift)));
   font:700 calc(var(--k-text-cap) * .85)/1 var(--k-mono);letter-spacing:.04em;pointer-events:none;opacity:0;transition:opacity .12s var(--k-ease)}
-.knobs-optkey-range{transform:translate(-100%,-50%)}
-.knobs-optkey[data-shown]{opacity:.85;transition-duration:.15s}
+.knobs-panel .knobs-optkey-range{transform:translate(-100%,-50%)}
+.knobs-panel .knobs-optkey[data-shown]{opacity:.85;transition-duration:.15s}
 
 /* Custom actions */
 .knobs-panel .knobs-custom-actions{display:grid;grid-template-columns:repeat(auto-fit,minmax(96px,1fr));gap:var(--k-gap);margin-top:var(--k-section-gap)}
@@ -1432,4 +1766,1054 @@ function injectStyles(doc) {
   style.dataset.knobsStyle = "", style.textContent = content, doc.head.append(style);
 }
 
-export { CHECK_POINTS, CHECK_PATH, iconPath, iconSvg, readSession, writeSession, rolling_css_default, presetCss, FILL, LEAD, trailScale, Edges, POP_MS, popScale, VelocityTracker, clamp, Roll, rollTarget, numeral, entranceOffset, FLASH_MS, flash, flashOf, DELAYED, injectPreset, injectStyles };
+// src/panel/sound.ts
+var click = (f, p, d = 0.005, q = 4, at = 0) => ({
+  f,
+  q,
+  a: 0.0008,
+  d,
+  p,
+  at
+}), thud = (f, p, d, at = 0) => ({
+  filter: "lowpass",
+  f,
+  q: 0.7,
+  a: 0.0015,
+  d,
+  p,
+  at
+}), air = (f, to, d, p, a = 0.012, at = 0) => ({
+  f,
+  to,
+  glide: a + d * 0.6,
+  q: 1.4,
+  a,
+  d,
+  p,
+  at
+}), knock = (f, d, p, at = 0) => ({
+  wave: "sine",
+  f: f * 1.6,
+  to: f,
+  glide: 0.018,
+  a: 0.001,
+  d,
+  p,
+  at
+}), glass = (f, d, p, at = 0) => [
+  [1, 1],
+  [2.76, 0.28],
+  [5.4, 0.08]
+].filter(([ratio]) => f * ratio <= 5000).map(([ratio, level]) => ({
+  wave: "sine",
+  f: f * ratio,
+  a: 0.002,
+  d: Math.max(0.028, d / ratio ** 0.75),
+  p: p * level,
+  at
+})), clamp3 = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+var cadence = (sinceMs) => clamp3((240 - sinceMs) / 170, 0, 1);
+function recipe(cue, detail = {}, speed = 0, random = Math.random) {
+  let dir = Math.sign(detail.direction ?? 0), light = 1 - 0.45 * speed, vary = (amount) => 1 + (random() * 2 - 1) * amount;
+  switch (cue) {
+    case "step": {
+      let k = 2 ** (clamp3(detail.position ?? 0.5, 0, 1) * 0.9 - 0.35), even = light / k ** 0.75, layers = [
+        click(3000 * k, 0.5 * even, 0.004, 5),
+        click(1300 * k, 0.22 * even, 0.01, 2.5)
+      ];
+      if (speed < 0.6)
+        layers.push({ wave: "sine", f: 1480 * k, a: 0.001, d: 0.05, p: 0.008 * light });
+      if (detail.strong)
+        layers.push(knock(240, 0.03, 0.05), click(2100, 0.3, 0.006, 3));
+      return { layers, gain: 1.8 };
+    }
+    case "limit":
+      return { layers: [thud(380, 0.9, 0.05), knock(115, 0.06, 0.07)], gain: 0.9 };
+    case "toggle":
+      return dir < 0 ? {
+        layers: [
+          click(2800, 0.14, 0.003, 3),
+          click(1450, 0.5, 0.013, 2, 0.012),
+          knock(250, 0.034, 0.06, 0.012)
+        ],
+        gain: 1.2
+      } : {
+        layers: [
+          click(3300, 0.14, 0.003, 3),
+          click(1850, 0.5, 0.012, 2, 0.013),
+          knock(330, 0.03, 0.06, 0.013)
+        ],
+        gain: 1.2
+      };
+    case "select": {
+      let k = 1 + 0.06 * dir;
+      return {
+        layers: [click(2700 * k, 0.4 * light, 0.006, 3), knock(430 * k, 0.02, 0.045 * light)],
+        gain: 1.5
+      };
+    }
+    case "preset":
+      return {
+        layers: [
+          click(2400, 0.3, 0.005, 3),
+          thud(1800, 0.08, 0.004),
+          ...glass(1046.5, 0.24, 0.016, 0.012),
+          ...glass(1568, 0.2, 0.01, 0.012)
+        ],
+        gain: 2.5,
+        room: 0.6
+      };
+    case "random":
+    case "mutate": {
+      let n = cue === "random" ? 5 : 2, layers = [], at = 0, gap = 0.044;
+      for (let i = 0;i < n; i++) {
+        let level = 0.8 ** i;
+        layers.push(click(1500 + 1900 * random(), 0.36 * level, 0.006, 3, at), knock(380 + 320 * random(), 0.018, 0.04 * level, at)), at += gap * vary(0.15), gap *= 0.78;
+      }
+      return { layers, gain: 1.6 };
+    }
+    case "reset":
+      return {
+        layers: [
+          { f: 2600, to: 750, glide: 0.09, q: 1.3, a: 0.07, d: 0.03, p: 0.18 },
+          click(2200, 0.3, 0.004, 3, 0.082),
+          knock(300, 0.02, 0.04, 0.082)
+        ],
+        gain: 1.1
+      };
+    case "copy":
+      return {
+        layers: [
+          thud(2200, 0.06, 0.003),
+          ...glass(1174.66, 0.2, 0.014),
+          { wave: "sine", f: 1178.5, a: 0.002, d: 0.18, p: 0.006 },
+          ...glass(1567.98, 0.24, 0.014, 0.06)
+        ],
+        gain: 2.6,
+        room: 1
+      };
+    case "undo":
+    case "redo": {
+      let back = cue === "undo";
+      return {
+        layers: [
+          air(back ? 1700 : 850, back ? 750 : 1800, 0.04, 0.14),
+          knock(back ? 330 : 420, 0.02, 0.04, 0.028)
+        ],
+        gain: 1.4
+      };
+    }
+    case "open":
+      return { layers: [click(2600, 0.16, 0.004, 3), air(700, 1600, 0.045, 0.14, 0.02)], gain: 1.7 };
+    case "close":
+      return {
+        layers: [
+          air(1500, 650, 0.04, 0.13, 0.015),
+          knock(240, 0.028, 0.06, 0.03),
+          click(1700, 0.2, 0.006, 3, 0.03)
+        ],
+        gain: 1.1
+      };
+    case "hint":
+      return {
+        layers: [air(1200, 2400, 0.05, 0.06, 0.02), ...glass(1568, 0.14, 0.01, 0.012)],
+        gain: 2.3,
+        room: 0.8
+      };
+    case "type": {
+      let k = vary(0.06);
+      return {
+        layers: [click(3600 * k, 0.16 * light, 0.003, 1), click(1600 * k, 0.3 * light, 0.008, 3)],
+        gain: 1.4
+      };
+    }
+    case "press":
+      return {
+        layers: [click(2650, 0.4, 0.004, 1.5), knock(380, 0.02, 0.05), thud(220, 0.25, 0.022)],
+        gain: 2
+      };
+    case "capture":
+      return {
+        layers: [
+          click(3000, 0.3, 0.003, 3),
+          click(2400, 0.22, 0.004, 3, 0.035),
+          ...glass(1318.5, 0.12, 0.012, 0.04)
+        ],
+        gain: 2.5,
+        room: 0.5
+      };
+  }
+}
+var themed = (layers, theme) => theme === "mech" ? layers.map((l) => l.wave ? { ...l, p: l.p * 0.5, d: l.d * 0.5 } : { ...l, d: l.d * 0.75, q: (l.q ?? 1) * 1.3, p: l.p * 1.1 }) : [...layers], GAPS = {
+  step: 24,
+  limit: 140,
+  toggle: 40,
+  select: 28,
+  preset: 80,
+  random: 120,
+  mutate: 120,
+  reset: 120,
+  copy: 200,
+  undo: 45,
+  redo: 45,
+  open: 60,
+  close: 60,
+  hint: 120,
+  type: 18,
+  press: 50,
+  capture: 120
+};
+function createLimiter(gaps = GAPS) {
+  let last = /* @__PURE__ */ new Map;
+  return (cue, now) => {
+    let since = now - (last.get(cue) ?? Number.NEGATIVE_INFINITY);
+    if (since < (gaps[cue] ?? 0))
+      return null;
+    return last.set(cue, now), cadence(since);
+  };
+}
+var FRESH_MS = 150, DETENTS2 = 24;
+function createDetents() {
+  let last = /* @__PURE__ */ new Map;
+  return (key, before, after, detents, now) => {
+    let since = now - (last.get(key) ?? Number.NEGATIVE_INFINITY);
+    if (last.set(key, now), since > FRESH_MS)
+      return !0;
+    let n = Math.max(1, Math.round(detents));
+    return Math.round(clamp3(before, 0, 1) * n) !== Math.round(clamp3(after, 0, 1) * n);
+  };
+}
+var numbers = (v) => typeof v === "number" ? [v] : v && typeof v === "object" ? Object.values(v).filter((n) => typeof n === "number") : [];
+function changeCue(field, before, after) {
+  if (field.kind === "toggle")
+    return { cue: "toggle", detail: { direction: after ? 1 : -1 }, detents: 1, at: 1, was: 0 };
+  if (field.kind === "choice") {
+    let options = field.options ?? [];
+    return { cue: "select", detail: { direction: options.indexOf(after) - options.indexOf(before) }, detents: 1, at: 1, was: 0 };
+  }
+  if (field.kind === "keybind")
+    return after ? { cue: "capture", detail: {}, detents: 1, at: 1, was: 0 } : { cue: "select", detail: { direction: -1 }, detents: 1, at: 1, was: 0 };
+  let { min, max, step } = field, a = numbers(before), b = numbers(after);
+  if (typeof min !== "number" || typeof max !== "number" || !(max > min) || !b.length)
+    return { cue: "step", detail: {}, detents: 1, at: 0.5, was: 0.5 };
+  let i = b.findIndex((n, j) => n !== a[j]);
+  if (i < 0)
+    i = 0;
+  let pos = (n) => clamp3(((n ?? min) - min) / (max - min), 0, 1), steps = typeof step === "number" && step > 0 ? (max - min) / step : Number.POSITIVE_INFINITY;
+  return {
+    cue: "step",
+    detail: { position: pos(b[i]), strong: same(after, field.value) && !same(before, field.value) },
+    detents: steps <= 10 ? steps : DETENTS2,
+    at: pos(b[i]),
+    was: pos(a[i])
+  };
+}
+var same = (x, y) => {
+  let a = numbers(x), b = numbers(y);
+  return a.length > 0 && a.length === b.length && a.every((n, i) => n === b[i]);
+};
+function resolveSound(option) {
+  if (!option)
+    return null;
+  if (option === !0)
+    return {};
+  return {
+    ...option.volume !== void 0 ? { volume: clamp3(Number(option.volume) || 0, 0, 1) } : {},
+    ...option.theme ? { theme: option.theme } : {}
+  };
+}
+var MAX_VOICES = 10, PAD = 0.04, FADE = 0.015, LEVEL = 0.5, browserEnv = () => {
+  let win = typeof window > "u" ? void 0 : window;
+  return {
+    AudioContext: win?.AudioContext ?? win?.webkitAudioContext,
+    activated: () => win?.navigator?.userActivation?.hasBeenActive !== !1,
+    now: () => performance.now()
+  };
+};
+function createSound(env = browserEnv()) {
+  let enabled = !0, volume = 1, theme = "glass", context = null, bus = null, voices = [], listeners = /* @__PURE__ */ new Set, limit = createLimiter(), now = env.now ?? (() => Date.now()), random = env.random ?? Math.random, notify = () => {
+    for (let f of listeners)
+      f();
+  }, ensure = () => {
+    if (context)
+      return context;
+    if (!env.AudioContext || env.activated?.() === !1)
+      return null;
+    try {
+      context = new env.AudioContext;
+    } catch {
+      return null;
+    }
+    return context;
+  }, wake = (ctx) => {
+    if (ctx.state === "suspended" && enabled)
+      try {
+        ctx.resume().catch(() => {});
+      } catch {}
+  }, build = (ctx) => {
+    if (bus)
+      return bus;
+    let input = ctx.createGain();
+    input.gain.value = enabled ? volume : 0;
+    let subsonic = ctx.createBiquadFilter();
+    subsonic.type = "highpass", subsonic.frequency.value = 45;
+    let squeeze = ctx.createDynamicsCompressor();
+    squeeze.threshold.value = -22, squeeze.knee.value = 12, squeeze.ratio.value = 3, squeeze.attack.value = 0.002, squeeze.release.value = 0.12, input.connect(subsonic).connect(squeeze).connect(ctx.destination);
+    let rate = ctx.sampleRate, noise = ctx.createBuffer(1, rate, rate), data = noise.getChannelData(0), s = 7;
+    for (let i = 0;i < data.length; i++)
+      s = s * 1664525 + 1013904223 >>> 0, data[i] = s / 2147483648 - 1;
+    let len = Math.floor(rate * 0.2), impulse = ctx.createBuffer(2, len, rate);
+    for (let c = 0;c < 2; c++) {
+      let ch = impulse.getChannelData(c);
+      for (let i = Math.floor(rate * 0.006);i < len; i++)
+        ch[i] = data[i * (c + 3) % data.length] * Math.exp(-6.9 * i / len) / 9;
+    }
+    let verb = ctx.createConvolver();
+    verb.normalize = !1, verb.buffer = impulse;
+    let walls = ctx.createBiquadFilter();
+    return walls.type = "lowpass", walls.frequency.value = 3800, walls.connect(verb).connect(input), bus = { input, room: walls, noise }, bus;
+  }, render = (ctx, layers, level, room) => {
+    let b = build(ctx), t0 = ctx.currentTime + 0.002;
+    for (let i = voices.length - 1;i >= 0; i--)
+      if (voices[i].end < t0)
+        voices.splice(i, 1);
+    while (voices.length >= MAX_VOICES) {
+      let old = voices.shift();
+      old.gain.gain.cancelScheduledValues(t0), old.gain.gain.setValueAtTime(old.gain.gain.value, t0), old.gain.gain.linearRampToValueAtTime(0, t0 + FADE);
+    }
+    let out = ctx.createGain();
+    out.gain.value = level, out.connect(b.input);
+    let send;
+    if (room > 0)
+      send = ctx.createGain(), send.gain.value = 0.1 * room, out.connect(send).connect(b.room);
+    let end = t0;
+    for (let l of layers) {
+      let t = t0 + (l.at ?? 0), stop = t + l.a + l.d + PAD;
+      end = Math.max(end, stop);
+      let g = ctx.createGain();
+      g.gain.setValueAtTime(0, t), g.gain.linearRampToValueAtTime(l.p, t + l.a), g.gain.setTargetAtTime(0, t + l.a, l.d / 6.9);
+      let source, param;
+      if (l.wave) {
+        let osc = ctx.createOscillator();
+        osc.type = l.wave, param = osc.frequency, osc.connect(g), source = osc;
+      } else {
+        let src = ctx.createBufferSource();
+        src.buffer = b.noise, src.loop = !0;
+        let filter = ctx.createBiquadFilter();
+        if (filter.type = l.filter ?? "bandpass", l.q !== void 0)
+          filter.Q.value = l.q;
+        param = filter.frequency, src.connect(filter).connect(g), source = src;
+      }
+      if (param.setValueAtTime(l.f, t), l.to !== void 0)
+        param.exponentialRampToValueAtTime(l.to, t + (l.glide ?? l.a + l.d));
+      if (g.connect(out), l.wave)
+        source.start(t);
+      else
+        source.start(t, random() * 0.9);
+      source.stop(stop);
+    }
+    voices.push({ gain: out, end }), setTimeout(() => {
+      out.disconnect(), send?.disconnect();
+    }, (end - ctx.currentTime + 0.1) * 1000);
+  };
+  return {
+    get enabled() {
+      return enabled;
+    },
+    enable(on = !0) {
+      if (on === enabled)
+        return;
+      if (enabled = on, context && bus) {
+        let t = context.currentTime, g = bus.input.gain;
+        g.cancelScheduledValues(t), g.setValueAtTime(g.value, t), g.linearRampToValueAtTime(on ? volume : 0, t + FADE * 2);
+      }
+      if (on && context)
+        wake(context);
+      notify();
+    },
+    get volume() {
+      return volume;
+    },
+    setVolume(next) {
+      let v = clamp3(Number(next) || 0, 0, 1);
+      if (v === volume)
+        return;
+      if (volume = v, context && bus && enabled)
+        bus.input.gain.setTargetAtTime(v, context.currentTime, 0.02);
+      notify();
+    },
+    get theme() {
+      return theme;
+    },
+    setTheme(next) {
+      if (next !== "glass" && next !== "mech")
+        return;
+      if (next === theme)
+        return;
+      theme = next, notify();
+    },
+    play(cue, detail = {}) {
+      if (!enabled || volume === 0)
+        return;
+      let level = LEVEL * clamp3(detail.volume ?? 1, 0, 1);
+      if (level === 0)
+        return;
+      let made;
+      if (typeof cue === "string") {
+        let speed = limit(cue, now());
+        if (speed === null)
+          return;
+        made = recipe(cue, detail, speed, random);
+      } else
+        made = { layers: cue };
+      let ctx = ensure();
+      if (!ctx)
+        return;
+      let gain = level * (made.gain ?? 1), layers = themed(made.layers, detail.theme ?? theme), room = (detail.theme ?? theme) === "mech" ? 0 : made.room ?? 0;
+      if (ctx.state === "running")
+        render(ctx, layers, gain, room);
+      else
+        try {
+          ctx.resume().then(() => {
+            if (enabled && ctx.state === "running")
+              render(ctx, layers, gain, room);
+          }).catch(() => {});
+        } catch {}
+    },
+    output() {
+      let ctx = ensure();
+      if (!ctx)
+        return null;
+      return wake(ctx), { context: ctx, destination: build(ctx).input };
+    },
+    prime(doc = typeof document > "u" ? void 0 : document) {
+      let win = doc?.defaultView;
+      if (!win || context)
+        return;
+      let kinds = ["pointerdown", "keydown", "touchend"], unlock = () => {
+        if (!enabled)
+          return;
+        let ctx = ensure();
+        if (!ctx)
+          return;
+        build(ctx), wake(ctx);
+        for (let k of kinds)
+          win.removeEventListener(k, unlock, !0);
+      };
+      for (let k of kinds)
+        win.addEventListener(k, unlock, !0);
+    },
+    subscribe(listener) {
+      return listeners.add(listener), () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+var sound = /* @__PURE__ */ createSound(), panels = /* @__PURE__ */ new WeakMap, SOUND_PREF = "knobs:sound:v1";
+function soundPanel(root, options) {
+  panels.set(root, options), sound.prime(root.ownerDocument);
+}
+var sounds = (from) => {
+  let root = from?.closest?.(".knobs-panel");
+  return Boolean(root && panels.has(root));
+}, detents = createDetents();
+function changed(from, key, field, before, after) {
+  if (!sounds(from))
+    return;
+  let c = changeCue(field, before, after);
+  if (!c)
+    return;
+  if (c.cue === "step" && !detents(key, c.was, c.at, c.detents, performance.now()))
+    return;
+  cue(from, c.cue, c.detail);
+}
+function cue(from, name, detail = {}) {
+  let root = from?.closest?.(".knobs-panel"), options = root && panels.get(root);
+  if (!options)
+    return;
+  sound.play(name, {
+    ...detail,
+    volume: (options.volume ?? 1) * (detail.volume ?? 1),
+    ...options.theme && !detail.theme ? { theme: options.theme } : {}
+  });
+}
+
+// src/panel/hints.ts
+function extractWords(text) {
+  return text.toLowerCase().match(/[a-z]+/g) ?? [];
+}
+function candidatePool(words) {
+  let flat = words.join(""), pool = [], push = (s) => {
+    if (s && /^[a-z]{1,3}$/.test(s) && !pool.includes(s))
+      pool.push(s);
+  };
+  if (words.length >= 2) {
+    let w0 = words[0], w1 = words[1], base2 = w0[0] + w1[0];
+    push(base2);
+    for (let i = 1;i < w1.length; i++)
+      push(w0[0] + w1[i]);
+    for (let i = 1;i < w0.length; i++)
+      push(w0[i] + w1[0]);
+    if (words.length >= 3)
+      push(base2 + words[2][0]);
+    if (w1.length >= 2)
+      push(base2 + w1[1]);
+    if (w0.length >= 2)
+      push(base2 + w0[1]);
+  } else if (flat.length > 0) {
+    for (let i = 1;i < flat.length; i++)
+      push(flat[0] + flat[i]);
+    if (flat.length >= 3)
+      push(flat.slice(0, 3));
+  }
+  let f0 = flat[0] || "x";
+  for (let c = 97;c <= 122; c++)
+    push(f0 + String.fromCharCode(c));
+  return pool;
+}
+function assignHintCodes(items) {
+  let n = items.length;
+  if (n === 0)
+    return [];
+  let displayCounts = /* @__PURE__ */ new Map;
+  for (let item of items) {
+    let d = item.display.toLowerCase();
+    displayCounts.set(d, (displayCounts.get(d) ?? 0) + 1);
+  }
+  let itemWords = items.map((item) => {
+    let d = item.display.toLowerCase(), useKey = (displayCounts.get(d) ?? 0) > 1 && d !== item.key.toLowerCase(), w = extractWords(useKey ? item.key : item.display);
+    return w.length > 0 ? w : extractWords(item.key);
+  }), pools = itemWords.map((w) => candidatePool(w)), base2Of = pools.map((p) => p[0] ?? "x"), firstLetterCounts = /* @__PURE__ */ new Map, base2Counts = /* @__PURE__ */ new Map;
+  for (let i = 0;i < n; i++) {
+    let b2 = base2Of[i], f1 = b2[0];
+    firstLetterCounts.set(f1, (firstLetterCounts.get(f1) ?? 0) + 1), base2Counts.set(b2, (base2Counts.get(b2) ?? 0) + 1);
+  }
+  let codes = Array(n).fill(""), used = /* @__PURE__ */ new Set;
+  for (let i = 0;i < n; i++) {
+    let words = itemWords[i], b2 = base2Of[i], f1 = b2[0];
+    if (words.length === 1 && firstLetterCounts.get(f1) === 1 && !used.has(f1))
+      codes[i] = f1, used.add(f1);
+    else if (base2Counts.get(b2) === 1 && !used.has(b2))
+      codes[i] = b2, used.add(b2);
+  }
+  for (let i = 0;i < n; i++) {
+    if (codes[i])
+      continue;
+    let pool = pools[i], chosen = pool.find((cand) => cand.length === 2 && !used.has(cand) && !used.has(cand[0])) ?? pool.find((cand) => !used.has(cand) && !used.has(cand[0])) ?? `x${i}`;
+    codes[i] = chosen, used.add(chosen);
+  }
+  return codes;
+}
+function resolveHintCodes(codes, rawQuery = "") {
+  let q = rawQuery.toLowerCase().replace(/[^a-z]/g, ""), matchIndices = [], badges = codes.map((code, i) => {
+    let match = q.length === 0 || code.startsWith(q);
+    if (match)
+      matchIndices.push(i);
+    let typedLen = match ? Math.min(code.length, q.length) : 0;
+    return {
+      match,
+      prefix: code,
+      typed: code.slice(0, typedLen),
+      rest: code.slice(typedLen)
+    };
+  }), uniqueMatchIndex = matchIndices.length === 1 && q.length > 0 ? matchIndices[0] : -1;
+  return {
+    badges,
+    matchIndices,
+    uniqueMatchIndex
+  };
+}
+function createHintController(doc, root, wakeGpu) {
+  let layer = doc.createElement("div");
+  layer.className = "knobs-hint-layer", layer.setAttribute("aria-hidden", "true");
+  let active = !1, local = !1, query = "", spots = [], targets = [], codes = [], badgeNodes = [];
+  function stop() {
+    if (!active)
+      return;
+    active = !1, local = !1, query = "", root.classList.remove("knobs-hinting");
+    for (let t of spots)
+      t.el.classList.remove("knobs-hint-match", "knobs-hint-miss");
+    spots = [], targets = [], codes = [], badgeNodes = [], layer.replaceChildren(), layer.remove(), wakeGpu();
+  }
+  function paint() {
+    if (!active)
+      return;
+    let resolution = resolveHintCodes(codes, query);
+    if (local && resolution.uniqueMatchIndex >= 0) {
+      let hit = targets[resolution.uniqueMatchIndex];
+      stop(), hit.activate();
+      return;
+    }
+    for (let i = 0;i < spots.length; i++) {
+      let t = spots[i], b = resolution.badges[i], node = badgeNodes[i];
+      if (t.el.classList.toggle("knobs-hint-match", b.match), t.el.classList.toggle("knobs-hint-miss", !b.match), !node)
+        continue;
+      if (node.tag.hidden = !b.match, b.match)
+        node.typedSpan.textContent = b.typed, node.restSpan.textContent = b.rest;
+    }
+    wakeGpu();
+  }
+  function show(nextSpots, nextCodes) {
+    if (stop(), nextSpots.length === 0)
+      return;
+    if (active = !0, query = "", spots = nextSpots, codes = nextCodes, root.classList.add("knobs-hinting"), !layer.isConnected)
+      root.append(layer);
+    cue(root, "hint");
+    let rootRect = root.getBoundingClientRect();
+    badgeNodes = spots.map((t) => {
+      let tag = doc.createElement("kbd");
+      tag.className = "knobs-hint";
+      let typedSpan = doc.createElement("span");
+      typedSpan.className = "knobs-hint-typed";
+      let restSpan = doc.createElement("span");
+      restSpan.className = "knobs-hint-rest", tag.append(typedSpan, restSpan);
+      let rect = t.el.getBoundingClientRect();
+      if (t.labelEl) {
+        let lRect = t.labelEl.getBoundingClientRect(), left = lRect.right - rootRect.left - root.clientLeft + root.scrollLeft + 6, top = lRect.top - rootRect.top - root.clientTop + root.scrollTop + lRect.height * 0.5;
+        tag.style.left = `${Math.round(left)}px`, tag.style.top = `${Math.round(top)}px`;
+      } else {
+        let left = rect.left - rootRect.left - root.clientLeft + root.scrollLeft + 1, top = rect.top - rootRect.top - root.clientTop + root.scrollTop + 1;
+        tag.style.left = `${Math.round(left)}px`, tag.style.top = `${Math.round(top)}px`;
+      }
+      return layer.append(tag), { tag, typedSpan, restSpan };
+    }), paint();
+  }
+  function start(nextTargets) {
+    if (show(nextTargets, assignHintCodes(nextTargets)), !active)
+      return;
+    local = !0, targets = nextTargets;
+  }
+  function narrow(next) {
+    if (next.length > query.length)
+      cue(root, "type");
+    query = next, paint();
+  }
+  function handleKey(event) {
+    if (!active || !local)
+      return !1;
+    if (event.preventDefault(), event.stopPropagation(), event.key === "Escape")
+      stop();
+    else if (event.key === "Backspace")
+      query = query.slice(0, -1), paint();
+    else if (event.key === "Enter") {
+      let resolution = resolveHintCodes(codes, query), first = targets[resolution.matchIndices[0] ?? -1];
+      stop(), first?.activate();
+    } else if (/^[a-zA-Z]$/.test(event.key))
+      cue(root, "type"), query += event.key.toLowerCase(), paint();
+    return !0;
+  }
+  return {
+    get isActive() {
+      return active;
+    },
+    start,
+    show,
+    narrow,
+    stop,
+    handleKey
+  };
+}
+
+// src/panel/page-hints.ts
+var HINT_LETTERS = "asdfghjkleruiowtyqpcvnmxzb", HOME_ROW = 9;
+function assignPageCodes(counts) {
+  let n = HINT_LETTERS.length, result = counts.map((c) => Array(c).fill("")), need = counts.map((c) => c > 0 ? Math.ceil(c / n) : 0), used = need.reduce((a, b) => a + b, 0);
+  if (used <= n) {
+    while (used < n) {
+      let best = -1, most = HOME_ROW;
+      if (counts.forEach((c, i) => {
+        let per = need[i] ? Math.ceil(c / need[i]) : 0;
+        if (per > most)
+          best = i, most = per;
+      }), best < 0)
+        break;
+      need[best]++, used++;
+    }
+    let letter = 0;
+    return counts.forEach((c, i) => {
+      let k = need[i], at = 0;
+      for (let chunk = 0;chunk < k; chunk++) {
+        let size = Math.floor(c / k) + (chunk < c % k ? 1 : 0), first = HINT_LETTERS[letter++];
+        for (let j = 0;j < size; j++)
+          result[i][at + j] = size === 1 ? first : first + HINT_LETTERS[j];
+        at += size;
+      }
+    }), result;
+  }
+  let slot = 0;
+  return counts.forEach((c, i) => {
+    for (let j = 0;j < c; j++, slot++) {
+      let first = Math.floor(slot / n);
+      if (first < n)
+        result[i][j] = HINT_LETTERS[first] + HINT_LETTERS[slot % n];
+    }
+  }), result;
+}
+var COLUMN = 200;
+function orderHintGroups(groups) {
+  return groups.map((g, i) => ({ g, i })).sort((a, b) => a.g.rank - b.g.rank || Math.floor(a.g.left / COLUMN) - Math.floor(b.g.left / COLUMN) || a.g.top - b.g.top || a.g.left - b.g.left || a.i - b.i).map((x) => x.i);
+}
+var PAGE_HINT_KEY = "s", KEY = Symbol.for("knobs.pageHints.v1");
+function pageHints(doc = document) {
+  let holder = doc, registry = holder[KEY] ?? createRegistry(doc);
+  return holder[KEY] = registry, registry;
+}
+var isTyping = isTypingTarget, PRESSABLE = "button,a[href],summary,[role=button],[role=tab],[role=radio],[role=switch],[role=checkbox],[role=menuitem],[role=option]";
+function activateElement(el) {
+  let pressable = el.matches(PRESSABLE) || el.tabIndex < 0 && !el.matches("input,select,textarea");
+  if (el.tabIndex >= 0 || el.matches("input,select,textarea"))
+    el.focus({ preventScroll: !0, focusVisible: !0 });
+  if (pressable)
+    el.click();
+}
+var labelOf = (el) => (el.dataset.hint || el.getAttribute("aria-label") || el.textContent || "").trim();
+function createRegistry(doc) {
+  let win = doc.defaultView, sources = [], session = null, listening = !1, onDocKey = (e) => {
+    if (session || e.defaultPrevented || e.repeat || e.isComposing)
+      return;
+    if (e.metaKey || e.ctrlKey || e.altKey || e.key !== PAGE_HINT_KEY)
+      return;
+    if (isTyping(e.target) || !wide())
+      return;
+    if (registry.start())
+      e.preventDefault();
+  }, wide = () => listening && (sources.length > 1 || [...doc.querySelectorAll("[data-hint]")].some((el) => !el.closest(".knobs-panel"))), relisten = () => {
+    let next = sources.some((s) => s.listen);
+    if (next === listening)
+      return;
+    if (listening = next, next)
+      doc.addEventListener("keydown", onDocKey);
+    else
+      doc.removeEventListener("keydown", onDocKey);
+  }, shown = (el) => {
+    if (!el.isConnected || el.disabled)
+      return !1;
+    if (el.closest("[hidden],[inert],[data-leaving]"))
+      return !1;
+    if (el.getClientRects().length === 0)
+      return !1;
+    let check = el.checkVisibility;
+    return check ? check.call(el, { visibilityProperty: !0 }) : !0;
+  }, collect = () => {
+    let seen = /* @__PURE__ */ new Set, take = (item) => {
+      let t = typeof item.nodeType === "number" ? { el: item } : item, el = t.el;
+      if (seen.has(el) || !shown(el))
+        return null;
+      let label = (t.label ?? labelOf(el)).trim();
+      return seen.add(el), {
+        el,
+        label: label || "x",
+        ...t.labelEl ? { labelEl: t.labelEl } : {},
+        activate: t.activate ?? (() => activateElement(el))
+      };
+    }, groups = [];
+    for (let source of [...sources].sort((a, b) => a.rank - b.rank)) {
+      let targets = [];
+      for (let item of source.targets()) {
+        let t = take(item);
+        if (t)
+          targets.push(t);
+      }
+      if (targets.length)
+        groups.push({ source, targets });
+    }
+    let byGroup = /* @__PURE__ */ new Map;
+    for (let el of doc.querySelectorAll("[data-hint]")) {
+      if (el.closest(".knobs-panel"))
+        continue;
+      let t = take(el);
+      if (!t)
+        continue;
+      let key = el.closest("[data-hint-group]"), list = byGroup.get(key);
+      if (list)
+        list.push(t);
+      else
+        byGroup.set(key, [t]);
+    }
+    for (let targets of byGroup.values())
+      groups.push({ targets });
+    return groups;
+  }, inView = (el, clips) => {
+    if (!win)
+      return !0;
+    let r = el.getBoundingClientRect(), y = r.top + Math.min(r.height / 2, 10), top = 0, left = 0, { innerWidth: right, innerHeight: bottom } = win;
+    for (let p = el.parentElement;p && p !== doc.body; p = p.parentElement) {
+      let clip = clips.get(p);
+      if (clip === void 0) {
+        let cs = win.getComputedStyle(p);
+        clip = cs.overflowX !== "visible" || cs.overflowY !== "visible" ? p.getBoundingClientRect() : null, clips.set(p, clip);
+      }
+      if (!clip)
+        continue;
+      top = Math.max(top, clip.top), left = Math.max(left, clip.left), right = Math.min(right, clip.right), bottom = Math.min(bottom, clip.bottom);
+    }
+    return y >= top && y <= bottom && r.right > left + 2 && r.left < right - 2;
+  }, registry = {
+    register(root, targets, options = {}) {
+      let source = {
+        root,
+        targets,
+        listen: options.listen !== !1,
+        rank: options.rank ?? 2,
+        ...options.paint ? { paint: options.paint } : {}
+      };
+      return sources.push(source), relisten(), () => {
+        let i = sources.indexOf(source);
+        if (i < 0)
+          return;
+        if (sources.splice(i, 1), session?.has(source))
+          registry.stop();
+        relisten();
+      };
+    },
+    start() {
+      registry.stop();
+      let groups = collect();
+      if (groups.length === 0)
+        return !1;
+      let codes;
+      if (groups.length === 1) {
+        let only = groups[0].targets;
+        codes = [assignHintCodes(only.map((t) => ({ key: t.label, display: t.label })))];
+      } else {
+        let clips = /* @__PURE__ */ new Map;
+        if (groups = groups.map((g) => ({ ...g, targets: g.targets.filter((t) => inView(t.el, clips)) })).filter((g) => g.targets.length > 0), groups.length === 0)
+          return !1;
+        groups = orderHintGroups(groups.map((g) => {
+          let left = 1 / 0, top = 1 / 0;
+          for (let t of g.targets) {
+            let r = t.el.getBoundingClientRect();
+            left = Math.min(left, r.left), top = Math.min(top, r.top);
+          }
+          return { rank: g.source?.rank ?? 2, left, top };
+        })).map((i) => groups[i]), codes = groups.length === 1 ? [assignHintCodes(groups[0].targets.map((t) => ({ key: t.label, display: t.label })))] : assignPageCodes(groups.map((g) => g.targets.length));
+      }
+      return session = createSession(doc, groups, codes, () => {
+        session = null;
+      }), !0;
+    },
+    stop() {
+      session?.stop(), session = null;
+    },
+    get active() {
+      return session !== null;
+    },
+    get listening() {
+      return wide();
+    }
+  };
+  return registry;
+}
+function createSession(doc, groups, codes, ended) {
+  let win = doc.defaultView, entries = [], painters = [], shared = { spots: [], codes: [] };
+  if (groups.forEach((g, i) => {
+    let spots = [], mine = [];
+    if (g.targets.forEach((t, j) => {
+      let code = codes[i][j];
+      if (!code)
+        return;
+      entries.push({ target: t, code }), spots.push(t), mine.push(code);
+    }), !spots.length)
+      return;
+    if (g.source?.paint)
+      painters.push(g.source.paint), g.source.paint.show(spots, mine);
+    else
+      shared.spots.push(...spots), shared.codes.push(...mine);
+  }), shared.spots.length) {
+    let layer = layerPainter(doc, groups);
+    painters.push(layer), layer.show(shared.spots, shared.codes);
+  }
+  let allCodes = entries.map((e) => e.code), query = "", over = !1, stop = () => {
+    if (over)
+      return;
+    over = !0;
+    for (let p of painters)
+      p.clear();
+    win?.removeEventListener("keydown", onKey, !0), doc.removeEventListener("scroll", onScroll, !0), doc.removeEventListener("pointerdown", onPointer, !0), win?.removeEventListener("resize", stop), win?.removeEventListener("blur", stop), ended();
+  }, finish = (i) => {
+    let hit = i === void 0 ? void 0 : entries[i];
+    stop(), hit?.target.activate();
+  }, narrow = () => {
+    let r = resolveHintCodes(allCodes, query);
+    if (r.uniqueMatchIndex >= 0)
+      return finish(r.uniqueMatchIndex);
+    for (let p of painters)
+      p.narrow(query);
+  }, onKey = (e) => {
+    if (e.isComposing || ["Shift", "Meta", "Control", "Alt", "CapsLock"].includes(e.key))
+      return;
+    if (e.preventDefault(), e.stopImmediatePropagation(), e.metaKey || e.ctrlKey)
+      return stop();
+    if (e.key === "Escape")
+      stop();
+    else if (e.key === "Backspace")
+      query = query.slice(0, -1), narrow();
+    else if (e.key === "Enter")
+      finish(resolveHintCodes(allCodes, query).matchIndices[0]);
+    else if (/^[a-zA-Z]$/.test(e.key))
+      query += e.key.toLowerCase(), narrow();
+  }, scrolled = /* @__PURE__ */ new Map, offset = (t) => t === doc ? (win?.scrollY ?? 0) + (win?.scrollX ?? 0) : t.scrollTop + t.scrollLeft, onScroll = (e) => {
+    let t = e.target;
+    if (!t)
+      return;
+    let at = offset(t), from = scrolled.get(t);
+    if (from === void 0)
+      scrolled.set(t, at);
+    else if (Math.abs(at - from) > 24)
+      stop();
+  }, onPointer = () => stop();
+  return win?.addEventListener("keydown", onKey, !0), doc.addEventListener("scroll", onScroll, !0), doc.addEventListener("pointerdown", onPointer, !0), win?.addEventListener("resize", stop), win?.addEventListener("blur", stop), {
+    has: (source) => groups.some((g) => g.source === source),
+    stop
+  };
+}
+var STYLE_ID = "knobs-page-hints-css", CSS = `
+.knobs-page-hints{position:fixed;left:0;top:0;width:0;height:0;pointer-events:none;z-index:2147483000}
+.knobs-page-hint{position:fixed;transform:translateY(-50%);display:inline-flex;align-items:center;height:15px;padding:0 4px;border-radius:var(--kh-radius);background:var(--kh-accent);color:var(--kh-bg);
+  box-shadow:0 1px 3px rgba(0,0,0,calc(.35 * var(--kh-lift)));font:700 var(--kh-size)/1 var(--kh-mono);letter-spacing:.04em;text-transform:uppercase;white-space:nowrap;pointer-events:none;
+  animation:knobs-page-hint-in .1s var(--kh-ease)}
+.knobs-page-hint[hidden]{display:none}
+.knobs-page-hint>.knobs-hint-typed{opacity:var(--kh-typed)}
+[data-knobs-hint-miss]{opacity:.32;transition:opacity .1s}
+@keyframes knobs-page-hint-in{from{opacity:0;transform:translateY(calc(4px - 50%)) scale(.985)}to{opacity:1;transform:translateY(-50%)}}
+@media(prefers-reduced-motion:reduce){@keyframes knobs-page-hint-in{from{opacity:0}to{opacity:1}}}
+`;
+function hintTokens(doc, groups) {
+  let win = doc.defaultView, read = (el, names) => {
+    if (!el || !win)
+      return "";
+    let cs = win.getComputedStyle(el);
+    for (let name of names) {
+      let v = cs.getPropertyValue(name).trim();
+      if (v)
+        return v;
+    }
+    return "";
+  }, panel = doc.querySelector(".knobs-panel"), piece = groups.find((g) => g.source && !g.source.paint)?.source?.root, pick = (k, fallback) => read(panel, [`--k-${k}`]) || read(piece, [`--ku-${k}`, `--k-${k}`]) || fallback;
+  return {
+    "--kh-accent": pick("accent", "#fff"),
+    "--kh-bg": pick("bg", "#1c1c1e"),
+    "--kh-mono": pick("mono", "ui-monospace,Menlo,monospace"),
+    "--kh-radius": read(panel, ["--k-radius-sm"]) || "4px",
+    "--kh-size": read(panel, ["--k-text-cap"]) || "10px",
+    "--kh-typed": read(panel, ["--k-hint-typed-opacity"]) || ".42",
+    "--kh-lift": read(panel, ["--k-lift"]) || "1",
+    "--kh-ease": read(panel, ["--k-ease"]) || "cubic-bezier(.2,.8,.2,1)"
+  };
+}
+function layerPainter(doc, groups) {
+  let layer = doc.createElement("div");
+  layer.className = "knobs-page-hints", layer.setAttribute("aria-hidden", "true");
+  let spots = [], codes = [], nodes = [];
+  return {
+    show(next, nextCodes) {
+      if (!doc.getElementById(STYLE_ID)) {
+        let style = doc.createElement("style");
+        style.id = STYLE_ID, style.textContent = CSS, doc.head.append(style);
+      }
+      spots = next, codes = nextCodes;
+      for (let [k, v] of Object.entries(hintTokens(doc, groups)))
+        layer.style.setProperty(k, v);
+      nodes = spots.map((t, i) => {
+        let tag = doc.createElement("kbd");
+        tag.className = "knobs-page-hint";
+        let typed = doc.createElement("span");
+        typed.className = "knobs-hint-typed";
+        let rest = doc.createElement("span");
+        rest.textContent = codes[i] ?? "", tag.append(typed, rest);
+        let r = (t.labelEl ?? t.el).getBoundingClientRect(), left = t.labelEl ? r.right + 6 : r.left + 1;
+        return tag.style.left = `${Math.round(left)}px`, tag.style.top = `${Math.round(r.top + r.height / 2)}px`, layer.append(tag), { tag, typed, rest };
+      }), doc.body.append(layer);
+    },
+    narrow(query) {
+      let r = resolveHintCodes(codes, query);
+      nodes.forEach((n, i) => {
+        let b = r.badges[i];
+        n.tag.hidden = !b.match, n.typed.textContent = b.typed, n.rest.textContent = b.rest, spots[i].el.toggleAttribute("data-knobs-hint-miss", !b.match);
+      });
+    },
+    clear() {
+      for (let t of spots)
+        t.el.removeAttribute("data-knobs-hint-miss");
+      layer.remove(), layer.replaceChildren(), spots = [], nodes = [];
+    }
+  };
+}
+
+// src/panel/toggle.ts
+function isToggleKey(event, key) {
+  if (!key || event.defaultPrevented || event.repeat || event.isComposing)
+    return !1;
+  if (event.ctrlKey || event.metaKey || event.altKey)
+    return !1;
+  if (isTypingTarget(event.target))
+    return !1;
+  if (event.key === key)
+    return !0;
+  return key === "`" && event.code === "Backquote" && !event.shiftKey;
+}
+var KEY2 = Symbol.for("knobs.toggle.v1"), memoryKey = (id) => storageKey(id, "shown");
+function toggleLayer(doc) {
+  let holder = doc;
+  return holder[KEY2] ??= createLayer(doc);
+}
+function createLayer(doc) {
+  let win = doc.defaultView, surfaces = /* @__PURE__ */ new Set, state = /* @__PURE__ */ new Map, pressed = /* @__PURE__ */ new Map, lastFocus, isShown = (s) => {
+    let on = state.get(s.id) ?? pressed.get(s.key);
+    if (on === void 0)
+      try {
+        on = s.storage()?.getItem(memoryKey(s.id)) !== "0";
+      } catch {
+        on = !0;
+      }
+    return state.set(s.id, on), on;
+  }, toggle = (key) => {
+    let mine = [...surfaces].filter((s) => s.key === key);
+    if (!mine.length)
+      return !1;
+    let next = !mine.some(isShown);
+    if (pressed.set(key, next), !next) {
+      let active = doc.activeElement;
+      if (active && mine.some((s) => s.root.contains(active)))
+        lastFocus = active, active.blur();
+      pageHints(doc).stop();
+    }
+    for (let s of mine) {
+      state.set(s.id, next);
+      try {
+        s.storage()?.setItem(memoryKey(s.id), next ? "1" : "0");
+      } catch {}
+    }
+    for (let s of mine)
+      s.show(next, !0);
+    if (next) {
+      let active = doc.activeElement;
+      if (lastFocus?.isConnected && (!active || active === doc.body))
+        lastFocus.focus({ preventScroll: !0 });
+      lastFocus = void 0;
+    }
+    return !0;
+  }, onKey = (event) => {
+    let keys = new Set([...surfaces].map((s) => s.key));
+    for (let key of keys)
+      if (isToggleKey(event, key))
+        return void toggle(key);
+  };
+  return {
+    register(surface) {
+      if (!surfaces.size)
+        win.addEventListener("keydown", onKey, !0);
+      return surfaces.add(surface), {
+        shown: isShown(surface),
+        dispose() {
+          if (surfaces.delete(surface), !surfaces.size)
+            win.removeEventListener("keydown", onKey, !0);
+        }
+      };
+    },
+    toggle
+  };
+}
+
+export { CHECK_POINTS, CHECK_PATH, iconPath, iconSvg, readSession, writeSession, rolling_css_default, presetCss, FILL, LEAD, trailScale, Edges, POP_MS, popScale, settleScale, VelocityTracker, clamp, Roll, rollTarget, numeral, entranceOffset, FLASH_MS, flash, flashOf, offRow, precisionRate, RULER, RULER_NEAR, RULER_FADE, rulerLevels, rulerAlpha, rulerDepth, THIN, THINNEST, thinOf, roundOf, stretchOf, stretchAt, giveRoom, detentScale, detentsOf, roundValues, unwarp, Notches, escapeTo, commandScope, scopeLabel, crumbTrail, escTarget, digitOption, digitHints, createCrumbs, DELAYED, injectPreset, injectStyles, resolveSound, sound, SOUND_PREF, soundPanel, changed, cue, createHintController, pageHints, toggleLayer };